diff --git a/include/perfetto/ext/base/string_view.h b/include/perfetto/ext/base/string_view.h
index dce2fdc..4f16f90 100644
--- a/include/perfetto/ext/base/string_view.h
+++ b/include/perfetto/ext/base/string_view.h
@@ -119,7 +119,7 @@
   }
 
   std::string ToStdString() const {
-    return data_ == nullptr ? "" : std::string(data_, size_);
+    return size_ == 0 ? "" : std::string(data_, size_);
   }
 
   uint64_t Hash() const {
diff --git a/src/base/string_view_unittest.cc b/src/base/string_view_unittest.cc
index bb00035..5bda159 100644
--- a/src/base/string_view_unittest.cc
+++ b/src/base/string_view_unittest.cc
@@ -34,6 +34,8 @@
   EXPECT_EQ(StringView("ax", 1), StringView("ay", 1));
   EXPECT_EQ(StringView("ax", 1), StringView("a"));
   EXPECT_EQ(StringView("ax", 1), "a");
+  EXPECT_EQ(StringView(reinterpret_cast<const char*>(0x100), 0).ToStdString(),
+            std::string(""));
   EXPECT_EQ(StringView("foo|", 3).ToStdString(), std::string("foo"));
   EXPECT_TRUE(StringView("x") != StringView(""));
   EXPECT_TRUE(StringView("") != StringView("y"));
diff --git a/src/trace_processor/importers/json/json_trace_tokenizer.cc b/src/trace_processor/importers/json/json_trace_tokenizer.cc
index 695e692..aa2b259 100644
--- a/src/trace_processor/importers/json/json_trace_tokenizer.cc
+++ b/src/trace_processor/importers/json/json_trace_tokenizer.cc
@@ -33,8 +33,6 @@
 
 namespace {
 
-#if PERFETTO_BUILDFLAG(PERFETTO_TP_JSON)
-
 util::Status AppendUnescapedCharacter(char c,
                                       bool is_escaping,
                                       std::string* key) {
@@ -103,11 +101,8 @@
   return ReadStringRes::kNeedsMoreData;
 }
 
-#endif  // PERFETTO_BUILDFLAG(PERFETTO_TP_JSON)
-
 }  // namespace
 
-#if PERFETTO_BUILDFLAG(PERFETTO_TP_JSON)
 ReadDictRes ReadOneJsonDict(const char* start,
                             const char* end,
                             base::StringView* value,
@@ -365,7 +360,54 @@
   }
   return ReadSystemLineRes::kNeedsMoreData;
 }
-#endif  // PERFETTO_BUILDFLAG(PERFETTO_TP_JSON)
+
+base::Optional<json::TimeUnit> MaybeParseDisplayTimeUnit(
+    base::StringView buffer) {
+  size_t idx = buffer.find("\"displayTimeUnit\"");
+  if (idx == base::StringView::npos)
+    return base::nullopt;
+
+  base::StringView time_unit = buffer.substr(idx);
+  std::string key;
+  const char* value_start = nullptr;
+  ReadKeyRes res =
+      ReadOneJsonKey(time_unit.data(), time_unit.end(), &key, &value_start);
+
+  // If we didn't read the key successfully, it could have been that
+  // displayTimeUnit is used somewhere else in the dict (maybe as a value?) so
+  // just ignore it.
+  if (res == ReadKeyRes::kEndOfDictionary || res == ReadKeyRes::kFatalError ||
+      res == ReadKeyRes::kNeedsMoreData) {
+    return base::nullopt;
+  }
+
+  // Double check that we did actually get the displayTimeUnit key.
+  if (key != "displayTimeUnit")
+    return base::nullopt;
+
+  // If the value isn't a string, we can do little except bail.
+  if (value_start[0] != '"')
+    return base::nullopt;
+
+  std::string value;
+  const char* unused;
+  ReadStringRes value_res =
+      ReadOneJsonString(value_start + 1, time_unit.end(), &value, &unused);
+
+  // If we didn't read the value successfully, we could be in another key
+  // in a nested dictionary. Just ignore the error.
+  if (value_res == ReadStringRes::kFatalError ||
+      value_res == ReadStringRes::kNeedsMoreData) {
+    return base::nullopt;
+  }
+
+  if (value == "ns") {
+    return json::TimeUnit::kNs;
+  } else if (value == "ms") {
+    return json::TimeUnit::kMs;
+  }
+  return base::nullopt;
+}
 
 JsonTraceTokenizer::JsonTraceTokenizer(TraceProcessorContext* ctx)
     : context_(ctx) {}
@@ -375,28 +417,23 @@
                                        size_t size) {
   PERFETTO_DCHECK(json::IsJsonSupported());
 
-#if PERFETTO_BUILDFLAG(PERFETTO_TP_JSON)
   buffer_.insert(buffer_.end(), data.get(), data.get() + size);
   const char* buf = buffer_.data();
   const char* next = buf;
   const char* end = buf + buffer_.size();
 
-  JsonTracker* json_tracker = JsonTracker::GetOrCreate(context_);
-
-  // It's possible the displayTimeUnit key is at the end of the json
-  // file so to be correct we ought to parse the whole file looking
-  // for this key before parsing any events however this would require
-  // two passes on the file so for now we only handle displayTimeUnit
-  // correctly if it is at the beginning of the file.
-  const base::StringView view(buf, size);
-  if (view.find("\"displayTimeUnit\":\"ns\"") != base::StringView::npos) {
-    json_tracker->SetTimeUnit(json::TimeUnit::kNs);
-  } else if (view.find("\"displayTimeUnit\":\"ms\"") !=
-             base::StringView::npos) {
-    json_tracker->SetTimeUnit(json::TimeUnit::kMs);
-  }
-
   if (offset_ == 0) {
+    // It's possible the displayTimeUnit key is at the end of the json
+    // file so to be correct we ought to parse the whole file looking
+    // for this key before parsing any events however this would require
+    // two passes on the file so for now we only handle displayTimeUnit
+    // correctly if it is at the beginning of the file.
+    base::Optional<json::TimeUnit> timeunit =
+        MaybeParseDisplayTimeUnit(base::StringView(buf, size));
+    if (timeunit) {
+      JsonTracker::GetOrCreate(context_)->SetTimeUnit(*timeunit);
+    }
+
     // Strip leading whitespace.
     while (next != end && isspace(*next)) {
       next++;
@@ -436,18 +473,8 @@
   offset_ += static_cast<uint64_t>(next - buf);
   buffer_.erase(buffer_.begin(), buffer_.begin() + (next - buf));
   return util::OkStatus();
-#else
-  perfetto::base::ignore_result(data);
-  perfetto::base::ignore_result(size);
-  perfetto::base::ignore_result(context_);
-  perfetto::base::ignore_result(format_);
-  perfetto::base::ignore_result(position_);
-  perfetto::base::ignore_result(offset_);
-  return util::ErrStatus("Cannot parse JSON trace due to missing JSON support");
-#endif  // PERFETTO_BUILDFLAG(PERFETTO_TP_JSON)
 }
 
-#if PERFETTO_BUILDFLAG(PERFETTO_TP_JSON)
 util::Status JsonTraceTokenizer::ParseInternal(const char* start,
                                                const char* end,
                                                const char** out) {
@@ -491,6 +518,12 @@
           return util::ErrStatus("displayTimeUnit too large");
         if (time_unit != "ms" && time_unit != "ns")
           return util::ErrStatus("displayTimeUnit unknown");
+        // If the displayTimeUnit came after the first chunk, the increment the
+        // too late stat.
+        if (offset_ != 0) {
+          context_->storage->IncrementStats(
+              stats::json_display_time_unit_too_late);
+        }
         return ParseInternal(next, end, out);
       } else {
         // If we don't recognize the key, just ignore the rest of the trace and
@@ -595,7 +628,6 @@
   *out = next;
   return util::OkStatus();
 }
-#endif  // PERFETTO_BUILDFLAG(PERFETTO_TP_JSON)
 
 void JsonTraceTokenizer::NotifyEndOfFile() {}
 
diff --git a/src/trace_processor/importers/json/json_trace_tokenizer.h b/src/trace_processor/importers/json/json_trace_tokenizer.h
index 86f5731..4daf661 100644
--- a/src/trace_processor/importers/json/json_trace_tokenizer.h
+++ b/src/trace_processor/importers/json/json_trace_tokenizer.h
@@ -20,6 +20,7 @@
 #include <stdint.h>
 
 #include "src/trace_processor/importers/common/chunked_trace_reader.h"
+#include "src/trace_processor/importers/json/json_utils.h"
 #include "src/trace_processor/importers/systrace/systrace_line_tokenizer.h"
 #include "src/trace_processor/storage/trace_storage.h"
 
@@ -32,7 +33,6 @@
 
 class TraceProcessorContext;
 
-#if PERFETTO_BUILDFLAG(PERFETTO_TP_JSON)
 // Visible for testing.
 enum class ReadDictRes {
   kFoundDict,
@@ -93,7 +93,11 @@
                                          const char* end,
                                          std::string* line,
                                          const char** next);
-#endif
+
+// Parses the "displayTimeUnit" key from the given trace buffer
+// and returns the associated time unit if one exists.
+base::Optional<json::TimeUnit> MaybeParseDisplayTimeUnit(
+    base::StringView buffer);
 
 // Reads a JSON trace in chunks and extracts top level json objects.
 class JsonTraceTokenizer : public ChunkedTraceReader {
@@ -139,11 +143,9 @@
     kEof,
   };
 
-#if PERFETTO_BUILDFLAG(PERFETTO_TP_JSON)
   util::Status ParseInternal(const char* start,
                              const char* end,
                              const char** next);
-#endif
 
   TraceProcessorContext* const context_;
 
diff --git a/src/trace_processor/importers/json/json_trace_tokenizer_unittest.cc b/src/trace_processor/importers/json/json_trace_tokenizer_unittest.cc
index 051f52a..6a11a44 100644
--- a/src/trace_processor/importers/json/json_trace_tokenizer_unittest.cc
+++ b/src/trace_processor/importers/json/json_trace_tokenizer_unittest.cc
@@ -272,6 +272,58 @@
   ASSERT_EQ(*line, R"({"ts": 149029, "foo": "bar"})");
 }
 
+TEST(JsonTraceTokenizerTest, DisplayTimeUnit) {
+  ASSERT_EQ(MaybeParseDisplayTimeUnit(R"(
+    {
+    }
+  )"),
+            base::nullopt);
+  ASSERT_EQ(MaybeParseDisplayTimeUnit(R"(
+    {
+      "displayTimeUnit": 0
+    }
+  )"),
+            base::nullopt);
+  ASSERT_EQ(MaybeParseDisplayTimeUnit(R"(
+    {
+      "str": "displayTimeUnit"
+    }
+  )"),
+            base::nullopt);
+
+  ASSERT_EQ(MaybeParseDisplayTimeUnit(R"(
+    {
+      "traceEvents": [
+        {
+          "pid": 1, "tid": 1, "name": "test",
+          "ts": 1, "dur": 1000, "ph": "X", "cat": "fee"
+        }
+      ],
+      "displayTimeUnit": "ms"
+    }
+  )"),
+            json::TimeUnit::kMs);
+  ASSERT_EQ(MaybeParseDisplayTimeUnit(R"(
+    {
+      "traceEvents": [
+        {
+          "pid": 1, "tid": 1, "name": "test",
+          "ts": 1, "dur": 1000, "ph": "X", "cat": "fee"
+        }
+      ],
+      "displayTimeUnit": "ns"
+    }
+  )"),
+            json::TimeUnit::kNs);
+
+  ASSERT_EQ(MaybeParseDisplayTimeUnit(R"(
+    {
+      "displayTimeUnit":"ms"
+    }
+  )"),
+            json::TimeUnit::kMs);
+}
+
 }  // namespace
 }  // namespace trace_processor
 }  // namespace perfetto
diff --git a/src/trace_processor/importers/json/json_tracker.h b/src/trace_processor/importers/json/json_tracker.h
index d786bf1..167881e 100644
--- a/src/trace_processor/importers/json/json_tracker.h
+++ b/src/trace_processor/importers/json/json_tracker.h
@@ -47,6 +47,9 @@
   base::Optional<int64_t> CoerceToTs(const Json::Value& value) {
     return json::CoerceToTs(time_unit_, value);
   }
+  base::Optional<int64_t> CoerceToTs(const std::string& value) {
+    return json::CoerceToTs(time_unit_, value);
+  }
 
  private:
   json::TimeUnit time_unit_ = json::TimeUnit::kUs;
diff --git a/src/trace_processor/importers/json/json_utils.cc b/src/trace_processor/importers/json/json_utils.cc
index 5d0b2d1..c44efa1 100644
--- a/src/trace_processor/importers/json/json_utils.cc
+++ b/src/trace_processor/importers/json/json_utils.cc
@@ -57,22 +57,8 @@
     case Json::uintValue:
     case Json::intValue:
       return value.asInt64() * TimeUnitToNs(unit);
-    case Json::stringValue: {
-      std::string s = value.asString();
-      size_t lhs_end = std::min<size_t>(s.find('.'), s.size());
-      size_t rhs_start = std::min<size_t>(lhs_end + 1, s.size());
-      base::Optional<int64_t> lhs = base::StringToInt64(s.substr(0, lhs_end));
-      base::Optional<double> rhs =
-          base::StringToDouble("0." + s.substr(rhs_start, std::string::npos));
-      if ((!lhs.has_value() && lhs_end > 0) ||
-          (!rhs.has_value() && rhs_start < s.size())) {
-        return base::nullopt;
-      }
-      int64_t factor = TimeUnitToNs(unit);
-      return lhs.value_or(0) * factor +
-             static_cast<int64_t>(rhs.value_or(0) *
-                                  static_cast<double>(factor));
-    }
+    case Json::stringValue:
+      return CoerceToTs(unit, value.asString());
     default:
       return base::nullopt;
   }
@@ -83,6 +69,29 @@
 #endif
 }
 
+base::Optional<int64_t> CoerceToTs(TimeUnit unit, const std::string& s) {
+  PERFETTO_DCHECK(IsJsonSupported());
+
+#if PERFETTO_BUILDFLAG(PERFETTO_TP_JSON)
+  size_t lhs_end = std::min<size_t>(s.find('.'), s.size());
+  size_t rhs_start = std::min<size_t>(lhs_end + 1, s.size());
+  base::Optional<int64_t> lhs = base::StringToInt64(s.substr(0, lhs_end));
+  base::Optional<double> rhs =
+      base::StringToDouble("0." + s.substr(rhs_start, std::string::npos));
+  if ((!lhs.has_value() && lhs_end > 0) ||
+      (!rhs.has_value() && rhs_start < s.size())) {
+    return base::nullopt;
+  }
+  int64_t factor = TimeUnitToNs(unit);
+  return lhs.value_or(0) * factor +
+         static_cast<int64_t>(rhs.value_or(0) * static_cast<double>(factor));
+#else
+  perfetto::base::ignore_result(unit);
+  perfetto::base::ignore_result(s);
+  return base::nullopt;
+#endif
+}
+
 base::Optional<int64_t> CoerceToInt64(const Json::Value& value) {
   PERFETTO_DCHECK(IsJsonSupported());
 
diff --git a/src/trace_processor/importers/json/json_utils.h b/src/trace_processor/importers/json/json_utils.h
index f4a70b3..74a2c3a 100644
--- a/src/trace_processor/importers/json/json_utils.h
+++ b/src/trace_processor/importers/json/json_utils.h
@@ -42,6 +42,7 @@
 
 enum class TimeUnit { kNs = 1, kUs = 1000, kMs = 1000000 };
 base::Optional<int64_t> CoerceToTs(TimeUnit unit, const Json::Value& value);
+base::Optional<int64_t> CoerceToTs(TimeUnit unit, const std::string& value);
 base::Optional<int64_t> CoerceToInt64(const Json::Value& value);
 base::Optional<uint32_t> CoerceToUint32(const Json::Value& value);
 
diff --git a/src/trace_processor/importers/systrace/systrace_parser.cc b/src/trace_processor/importers/systrace/systrace_parser.cc
index 607b2ba..b9655d4 100644
--- a/src/trace_processor/importers/systrace/systrace_parser.cc
+++ b/src/trace_processor/importers/systrace/systrace_parser.cc
@@ -59,7 +59,7 @@
                                     int64_t value) {
   systrace_utils::SystraceTracePoint point{};
   point.name = name;
-  point.value = static_cast<double>(value);
+  point.value = value;
 
   // Hardcode the tgid to 0 (i.e. no tgid available) because zero events can
   // come from kernel threads and as we group kernel threads into the kthreadd
@@ -108,7 +108,7 @@
   // the UI.
   point.tgid = 0;
 
-  point.value = static_cast<double>(value);
+  point.value = value;
   // Some versions of this trace point fill trace_type with one of (B/E/C),
   // others use the trace_begin boolean and only support begin/end events:
   if (trace_type == 0) {
@@ -164,7 +164,7 @@
     case 'S':
     case 'F': {
       StringId name_id = context_->storage->InternString(point.name);
-      int64_t cookie = static_cast<int64_t>(point.value);
+      int64_t cookie = point.value;
       UniquePid upid =
           context_->process_tracker->GetOrCreateProcess(point.tgid);
 
@@ -223,7 +223,8 @@
         // Promote ScreenState to its own top level counter.
         TrackId track =
             context_->track_tracker->InternGlobalCounterTrack(screen_state_id_);
-        context_->event_tracker->PushCounter(ts, point.value, track);
+        context_->event_tracker->PushCounter(
+            ts, static_cast<double>(point.value), track);
         return;
       }
 
@@ -243,7 +244,8 @@
         track_id =
             context_->track_tracker->InternProcessCounterTrack(name_id, upid);
       }
-      context_->event_tracker->PushCounter(ts, point.value, track_id);
+      context_->event_tracker->PushCounter(ts, static_cast<double>(point.value),
+                                           track_id);
     }
   }
 }
diff --git a/src/trace_processor/importers/systrace/systrace_parser.h b/src/trace_processor/importers/systrace/systrace_parser.h
index 1c0b9e2..a369af9 100644
--- a/src/trace_processor/importers/systrace/systrace_parser.h
+++ b/src/trace_processor/importers/systrace/systrace_parser.h
@@ -48,30 +48,24 @@
 
   static SystraceTracePoint C(uint32_t tgid,
                               base::StringView name,
-                              double value,
-                              base::StringView category_group = "") {
-    return SystraceTracePoint('C', tgid, std::move(name), value,
-                              category_group);
+                              int64_t value) {
+    return SystraceTracePoint('C', tgid, std::move(name), value);
   }
 
   static SystraceTracePoint S(uint32_t tgid,
                               base::StringView name,
-                              double value) {
-    return SystraceTracePoint('S', tgid, std::move(name), value);
+                              int64_t cookie) {
+    return SystraceTracePoint('S', tgid, std::move(name), cookie);
   }
 
   static SystraceTracePoint F(uint32_t tgid,
                               base::StringView name,
-                              double value) {
-    return SystraceTracePoint('F', tgid, std::move(name), value);
+                              int64_t cookie) {
+    return SystraceTracePoint('F', tgid, std::move(name), cookie);
   }
 
-  SystraceTracePoint(char p,
-                     uint32_t tg,
-                     base::StringView n,
-                     double v,
-                     base::StringView c = "")
-      : phase(p), tgid(tg), name(std::move(n)), value(v), category_group(c) {}
+  SystraceTracePoint(char p, uint32_t tg, base::StringView n, int64_t v)
+      : phase(p), tgid(tg), name(std::move(n)), value(v) {}
 
   // Phase can be one of B, E, C, S, F.
   char phase = '\0';
@@ -81,11 +75,8 @@
   // For phase = 'B' and phase = 'C' only.
   base::StringView name;
 
-  // For phase = 'C' only.
-  double value = 0;
-
-  // For phase = 'C' only (from Chrome).
-  base::StringView category_group;
+  // For phase = 'C' (counter value) and 'B', 'F' (async cookie).
+  int64_t value = 0;
 
   // Visible for unittesting.
   friend std::ostream& operator<<(std::ostream& os,
@@ -103,112 +94,94 @@
 // 4. C|1636|wq:monitor|0
 // 5. S|1636|frame_capture|123
 // 6. F|1636|frame_capture|456
+// Counters emitted by chromium can have a further "category group" appended
+// ("Blob" in the example below). We ignore the category group.
 // 7. C|3209|TransfersBytesPendingOnDisk-value|0|Blob
-// Visible for unittesting.
-inline SystraceParseResult ParseSystraceTracePoint(base::StringView str,
-                                                   SystraceTracePoint* out) {
-  const char* s = str.data();
-  size_t len = str.size();
+inline SystraceParseResult ParseSystraceTracePoint(
+    base::StringView str_untrimmed,
+    SystraceTracePoint* out) {
   *out = {};
 
-  // We don't support empty events.
-  if (len == 0)
-    return SystraceParseResult::kFailure;
-
-  constexpr const char* kClockSyncPrefix = "trace_event_clock_sync:";
-  if (len >= strlen(kClockSyncPrefix) &&
-      strncmp(kClockSyncPrefix, s, strlen(kClockSyncPrefix)) == 0)
-    return SystraceParseResult::kUnsupported;
-
-  char ph = s[0];
-  if (ph != 'B' && ph != 'E' && ph != 'C' && ph != 'S' && ph != 'F')
-    return SystraceParseResult::kFailure;
-
-  out->phase = ph;
-
-  // We only support E events with no arguments.
-  if (len == 1 && ph != 'E')
-    return SystraceParseResult::kFailure;
-
-  // If str matches '[BEC]\|[0-9]+[\|\n]?' set tgid_length to the length of
-  // the number. Otherwise return kFailure.
-  if (len >= 2 && s[1] != '|' && s[1] != '\n')
-    return SystraceParseResult::kFailure;
-
-  size_t tgid_length = 0;
-  for (size_t i = 2; i < len; i++) {
-    if (s[i] == '|' || s[i] == '\n') {
+  // Strip trailing \n and \0. StringViews are not null-terminated, but the
+  // writer could have appended a stray \0 depending on where the trace comes
+  // from.
+  size_t len = str_untrimmed.size();
+  for (; len > 0; --len) {
+    char last_char = str_untrimmed.at(len - 1);
+    if (last_char != '\n' && last_char != '\0')
       break;
-    }
-    if (s[i] < '0' || s[i] > '9')
-      return SystraceParseResult::kFailure;
-    tgid_length++;
   }
+  base::StringView str = str_untrimmed.substr(0, len);
 
-  // If len == 1, tgid_length will be 0 which will ensure we don't do
-  // an out of bounds read.
-  std::string tgid_str(s + 2, tgid_length);
-  out->tgid = base::StringToUInt32(tgid_str).value_or(0);
+  size_t off = 0;
 
-  switch (ph) {
-    case 'B': {
-      size_t name_index = 2 + tgid_length + 1;
-      if (name_index > len || s[name_index - 1] != '|')
+  // This function reads the next field up to the next '|', '\0' or end(). It
+  // advances |off| as it goes through fields.
+  auto read_next_field = [&off, &str, len]() {
+    for (size_t field_start = off;; ++off) {
+      char c = off >= len ? '\0' : str.at(off);
+      if (c == '|' || c == '\0') {
+        auto res = str.substr(field_start, off - field_start);
+        ++off;  // Eat the separator.
+        return res;
+      }
+    }
+  };
+
+  auto f0_phase = read_next_field();
+  if (PERFETTO_UNLIKELY(f0_phase.empty()))
+    return SystraceParseResult::kFailure;
+  out->phase = f0_phase.at(0);
+
+  auto f1_tgid = read_next_field();
+  auto opt_tgid = base::StringToUInt32(f1_tgid.ToStdString());
+  out->tgid = opt_tgid.value_or(0);
+  const bool has_tgid = opt_tgid.has_value();
+
+  switch (out->phase) {
+    case 'B': {  // Begin thread-scoped synchronous slice.
+      if (!has_tgid)
         return SystraceParseResult::kFailure;
-      out->name = base::StringView(
-          s + name_index, len - name_index - (s[len - 1] == '\n' ? 1 : 0));
-      if (out->name.empty()) {
-        static const char kEmptySliceName[] = "[empty slice name]";
-        out->name = base::StringView(kEmptySliceName);
+      auto f2_name = str.substr(off);  // It's fine even if |off| >= end().
+      if (f2_name.empty()) {
+        out->name = base::StringView("[empty slice name]");
+      } else {
+        out->name = f2_name;
       }
       return SystraceParseResult::kSuccess;
     }
-    case 'E': {
+    case 'E':  // End thread-scoped synchronous slice.
+      // Some non-Android traces (Flutter) use just "E" (aosp/1244409). Allow
+      // empty TGID on end slices. By design they are thread-scoped anyways.
+      return SystraceParseResult::kSuccess;
+    case 'S':    // Begin of async slice.
+    case 'F': {  // End of async slice.
+      auto f2_name = read_next_field();
+      auto f3_cookie = read_next_field();
+      auto maybe_cookie = base::StringToInt64(f3_cookie.ToStdString());
+      if (PERFETTO_UNLIKELY(!has_tgid || f2_name.empty() || f3_cookie.empty() ||
+                            !maybe_cookie)) {
+        return SystraceParseResult::kFailure;
+      }
+      out->name = f2_name;
+      out->value = *maybe_cookie;
       return SystraceParseResult::kSuccess;
     }
-    case 'S':
-    case 'F':
-    case 'C': {
-      size_t name_index = 2 + tgid_length + 1;
-      base::Optional<size_t> name_length;
-      for (size_t i = name_index; i < len; i++) {
-        if (s[i] == '|') {
-          name_length = i - name_index;
-          break;
-        }
-      }
-      if (!name_length.has_value())
-        return SystraceParseResult::kFailure;
-      out->name = base::StringView(s + name_index, name_length.value());
-
-      size_t value_index = name_index + name_length.value() + 1;
-      size_t value_pipe = str.find('|', value_index);
-      size_t value_len = value_pipe == base::StringView::npos
-                             ? len - value_index
-                             : value_pipe - value_index;
-      if (value_len == 0)
-        return SystraceParseResult::kFailure;
-      if (s[value_index + value_len - 1] == '\n')
-        value_len--;
-      std::string value_str(s + value_index, value_len);
-      base::Optional<double> maybe_value = base::StringToDouble(value_str);
-      if (!maybe_value.has_value()) {
+    case 'C': {  // Counter.
+      auto f2_name = read_next_field();
+      auto f3_value = read_next_field();
+      auto maybe_value = base::StringToInt64(f3_value.ToStdString());
+      if (PERFETTO_UNLIKELY(!has_tgid || f2_name.empty() || f3_value.empty() ||
+                            !maybe_value)) {
         return SystraceParseResult::kFailure;
       }
-      out->value = maybe_value.value();
-
-      if (value_pipe != base::StringView::npos) {
-        size_t group_len = len - value_pipe - 1;
-        if (group_len == 0)
-          return SystraceParseResult::kFailure;
-        if (s[len - 1] == '\n')
-          group_len--;
-        out->category_group = base::StringView(s + value_pipe + 1, group_len);
-      }
-
+      out->name = f2_name;
+      out->value = *maybe_value;
       return SystraceParseResult::kSuccess;
     }
     default:
+      if (str.find("trace_event_clock_sync:") == 0)
+        return SystraceParseResult::kUnsupported;
       return SystraceParseResult::kFailure;
   }
 }
diff --git a/src/trace_processor/importers/systrace/systrace_parser_unittest.cc b/src/trace_processor/importers/systrace/systrace_parser_unittest.cc
index 563df7f..d0c89cf 100644
--- a/src/trace_processor/importers/systrace/systrace_parser_unittest.cc
+++ b/src/trace_processor/importers/systrace/systrace_parser_unittest.cc
@@ -39,6 +39,9 @@
   ASSERT_EQ(ParseSystraceTracePoint("||\n", &result), Result::kFailure);
   ASSERT_EQ(ParseSystraceTracePoint("B", &result), Result::kFailure);
   ASSERT_EQ(ParseSystraceTracePoint("B\n", &result), Result::kFailure);
+  ASSERT_EQ(ParseSystraceTracePoint("C\n", &result), Result::kFailure);
+  ASSERT_EQ(ParseSystraceTracePoint("S\n", &result), Result::kFailure);
+  ASSERT_EQ(ParseSystraceTracePoint("F\n", &result), Result::kFailure);
   ASSERT_EQ(ParseSystraceTracePoint("C", &result), Result::kFailure);
   ASSERT_EQ(ParseSystraceTracePoint("S", &result), Result::kFailure);
   ASSERT_EQ(ParseSystraceTracePoint("F", &result), Result::kFailure);
@@ -64,14 +67,13 @@
   ASSERT_EQ(ParseSystraceTracePoint("E|42", &result), Result::kSuccess);
   EXPECT_EQ(result, SystraceTracePoint::E(42));
 
-  ASSERT_EQ(ParseSystraceTracePoint("C|543|foo|", &result), Result::kFailure);
   ASSERT_EQ(ParseSystraceTracePoint("C|543|foo|8", &result), Result::kSuccess);
   EXPECT_EQ(result, SystraceTracePoint::C(543, "foo", 8));
 
-  ASSERT_EQ(ParseSystraceTracePoint("C|543|foo|8|", &result), Result::kFailure);
-  ASSERT_EQ(ParseSystraceTracePoint("C|543|foo|8|group", &result),
-            Result::kSuccess);
-  EXPECT_EQ(result, SystraceTracePoint::C(543, "foo", 8, "group"));
+  ASSERT_EQ(
+      ParseSystraceTracePoint("C|543|foo|8|chromium_group_ignored", &result),
+      Result::kSuccess);
+  EXPECT_EQ(result, SystraceTracePoint::C(543, "foo", 8));
 
   ASSERT_EQ(ParseSystraceTracePoint("S|", &result), Result::kFailure);
 
diff --git a/src/trace_processor/storage/stats.h b/src/trace_processor/storage/stats.h
index bc44fef..4a05a74 100644
--- a/src/trace_processor/storage/stats.h
+++ b/src/trace_processor/storage/stats.h
@@ -124,6 +124,10 @@
   F(process_tracker_errors,             kSingle,  kError,    kAnalysis, ""),   \
   F(json_tokenizer_failure,             kSingle,  kError,    kTrace,    ""),   \
   F(json_parser_failure,                kSingle,  kError,    kTrace,    ""),   \
+  F(json_display_time_unit_too_late,    kSingle,  kError,    kTrace,           \
+      "The displayTimeUnit key came too late in the JSON trace so was "        \
+      "ignored. Trace processor only supports displayTimeUnit appearing "      \
+      "at the start of JSON traces"),                                          \
   F(heap_graph_invalid_string_id,       kIndexed, kError,    kTrace,    ""),   \
   F(heap_graph_non_finalized_graph,     kSingle,  kError,    kTrace,    ""),   \
   F(heap_graph_malformed_packet,        kIndexed, kError,    kTrace,    ""),   \
diff --git a/ui/src/common/proto_ring_buffer.ts b/ui/src/common/proto_ring_buffer.ts
new file mode 100644
index 0000000..b03c1c9
--- /dev/null
+++ b/ui/src/common/proto_ring_buffer.ts
@@ -0,0 +1,156 @@
+// Copyright (C) 2021 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import {assertTrue} from '../base/logging';
+
+// This class is the TypeScript equivalent of the identically-named C++ class in
+// //protozero/proto_ring_buffer.h. See comments in that header for a detailed
+// description. The architecture is identical.
+
+const kGrowBytes = 128 * 1024;
+const kMaxMsgSize = 64 * 1024 * 1024;
+
+export class ProtoRingBuffer {
+  private buf = new Uint8Array(kGrowBytes);
+  private fastpath?: Uint8Array;
+  private rd = 0;
+  private wr = 0;
+
+  // The caller must call ReadMessage() after each append() call.
+  // The |data| might be either copied in the internal ring buffer or returned
+  // (% subarray()) to the next ReadMessage() call.
+  append(data: Uint8Array) {
+    assertTrue(this.wr <= this.buf.length);
+    assertTrue(this.rd <= this.wr);
+
+    // If the last call to ReadMessage() consumed all the data in the buffer and
+    // there are no incomplete messages pending, restart from the beginning
+    // rather than keep ringing. This is the most common case.
+    if (this.rd === this.wr) {
+      this.rd = this.wr = 0;
+    }
+
+    // The caller is expected to issue a ReadMessage() after each append().
+    const dataLen = data.length;
+    if (dataLen === 0) return;
+    assertTrue(this.fastpath === undefined);
+    if (this.rd === this.wr) {
+      const msg = ProtoRingBuffer.tryReadMessage(data, 0, dataLen);
+      if (msg !== undefined &&
+          ((msg.byteOffset + msg.length) === (data.byteOffset + dataLen))) {
+        // Fastpath: in many cases, the underlying stream will effectively
+        // preserve the atomicity of messages for most small messages.
+        // In this case we can avoid the extra buffer roundtrip and return the
+        // original array (actually a subarray that skips the proto header).
+        // The next call to ReadMessage() will return this.
+        this.fastpath = msg;
+        return;
+      }
+    }
+
+    let avail = this.buf.length - this.wr;
+    if (dataLen > avail) {
+      // This whole section should be hit extremely rarely.
+
+      // Try first just recompacting the buffer by moving everything to the
+      // left. This can happen if we received "a message and a bit" on each
+      // append() call.
+      this.buf.copyWithin(0, this.rd, this.wr);
+      avail += this.rd;
+      this.wr -= this.rd;
+      this.rd = 0;
+      if (dataLen > avail) {
+        // Still not enough, expand the buffer.
+        let newSize = this.buf.length;
+        while (dataLen > newSize - this.wr) {
+          newSize += kGrowBytes;
+        }
+        assertTrue(newSize <= kMaxMsgSize * 2);
+        const newBuf = new Uint8Array(newSize);
+        newBuf.set(this.buf);
+        this.buf = newBuf;
+        // No need to touch rd / wr.
+      }
+    }
+
+    // Append the received data at the end of the ring buffer.
+    this.buf.set(data, this.wr);
+    this.wr += dataLen;
+  }
+
+  // Tries to extract a message from the ring buffer. If there is no message,
+  // or if the current message is still incomplete, returns undefined.
+  // The caller is expected to call this in a loop until it returns undefined.
+  // Note that a single write to Append() can yield more than one message
+  // (see ProtoRingBufferTest.CoalescingStream in the unittest).
+  readMessage(): Uint8Array|undefined {
+    if (this.fastpath !== undefined) {
+      assertTrue(this.rd === this.wr);
+      const msg = this.fastpath;
+      this.fastpath = undefined;
+      return msg;
+    }
+    assertTrue(this.rd <= this.wr);
+    if (this.rd >= this.wr) {
+      return undefined;  // Completely empty.
+    }
+    const msg = ProtoRingBuffer.tryReadMessage(this.buf, this.rd, this.wr);
+    if (msg === undefined) return undefined;
+    assertTrue(msg.buffer === this.buf.buffer);
+    assertTrue(this.buf.byteOffset === 0);
+    this.rd = msg.byteOffset + msg.length;
+
+    // Deliberately returning a copy of the data with slice(). In various cases
+    // (streaming query response) the caller will hold onto the returned buffer.
+    // If we get to this point, |msg| is a view of the circular buffer that we
+    // will overwrite on the next calls to append().
+    return msg.slice();
+  }
+
+  private static tryReadMessage(
+      data: Uint8Array, dataStart: number, dataEnd: number): Uint8Array
+      |undefined {
+    assertTrue(dataEnd <= data.length);
+    let pos = dataStart;
+    if (pos >= dataEnd) return undefined;
+    const tag = data[pos++];  // Assume one-byte tag.
+    if (tag >= 0x80 || (tag & 0x07) !== 2 /* len delimited */) {
+      throw new Error(
+          `RPC framing error, unexpected tag ${tag} @ offset ${pos - 1}`);
+    }
+
+    let len = 0;
+    for (let shift = 0;; shift += 7) {
+      if (pos >= dataEnd) {
+        return undefined;  // Not enough data to read varint.
+      }
+      const val = data[pos++];
+      len |= ((val & 0x7f) << shift) >>> 0;
+      if (val < 0x80) break;
+    }
+
+    if (len >= kMaxMsgSize) {
+      throw new Error(
+          `RPC framing error, message too large (${len} > ${kMaxMsgSize}`);
+    }
+    const end = pos + len;
+    if (end > dataEnd) return undefined;
+
+    // This is a subarray() and not a slice() because in the |fastpath| case
+    // we want to just return the original buffer pushed by append().
+    // In the slow-path (ring-buffer) case, the readMessage() above will create
+    // a copy via slice() before returning it.
+    return data.subarray(pos, end);
+  }
+}
diff --git a/ui/src/common/proto_ring_buffer_unittest.ts b/ui/src/common/proto_ring_buffer_unittest.ts
new file mode 100644
index 0000000..6c06ae0
--- /dev/null
+++ b/ui/src/common/proto_ring_buffer_unittest.ts
@@ -0,0 +1,140 @@
+// Copyright (C) 2021 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import * as protobuf from 'protobufjs/minimal';
+import {assertTrue} from '../base/logging';
+
+import {ProtoRingBuffer} from './proto_ring_buffer';
+
+let seed = 1;
+
+// For reproducibility.
+function Rnd(max: number) {
+  seed = seed * 16807 % 2147483647;
+  return seed % max;
+}
+
+function MakeProtoMessage(fieldId: number, len: number) {
+  const writer = protobuf.Writer.create();
+  const tag = (fieldId << 3) | 2 /*length-delimited*/;
+  assertTrue(tag < 0x80 && (tag & 7) === 2);
+  writer.uint32(tag);
+  const data = new Uint8Array(len);
+  for (let i = 0; i < len; i++) {
+    data[i] = 48 + ((fieldId + i) % 73);
+  }
+  writer.bytes(data);
+  const res = writer.finish();
+  // For whatever reason the object returned by protobufjs' Writer cannot be
+  // directly .toEqual()-ed with Uint8Arrays.
+  const buf = new Uint8Array(res.length);
+  buf.set(res);
+  return buf;
+}
+
+test('ProtoRingBufferTest.Fastpath', () => {
+  const buf = new ProtoRingBuffer();
+
+  for (let rep = 0; rep < 3; rep++) {
+    let inputBuf = MakeProtoMessage(1, 32);
+    buf.append(inputBuf);
+    let msg = buf.readMessage();
+    expect(msg).toBeDefined();
+    expect(msg).toBeInstanceOf(Uint8Array);
+    expect(msg!.length).toBe(32);
+
+    // subarray(2) is to strip the proto preamble. The returned buffer starts at
+    // the start of the payload.
+    expect(msg).toEqual(inputBuf.subarray(2));
+
+    // When we hit the fastpath, the returned message should be a subarray of
+    // the same ArrayBuffer passed to append.
+    expect(msg!.buffer).toBe(inputBuf.buffer);
+
+    inputBuf = MakeProtoMessage(2, 32);
+    buf.append(inputBuf.subarray(0, 13));
+    expect(buf.readMessage()).toBeUndefined();
+    buf.append(inputBuf.subarray(13));
+    msg = buf.readMessage();
+    expect(msg).toBeDefined();
+    expect(msg).toBeInstanceOf(Uint8Array);
+    expect(msg).toEqual(inputBuf.subarray(2));
+    expect(msg!.buffer !== inputBuf.buffer).toBeTruthy();
+  }
+});
+
+test('ProtoRingBufferTest.CoalescingStream', () => {
+  const buf = new ProtoRingBuffer();
+
+  const mergedBuf = new Uint8Array(612);
+  const expected = new Array<Uint8Array>();
+  for (let i = 1, pos = 0; i <= 6; i++) {
+    const msg = MakeProtoMessage(i, 100);
+    expected.push(msg);
+    mergedBuf.set(msg, pos);
+    pos += msg.length;
+  }
+
+  const fragLens = [120, 20, 471, 1];
+  let fragSum = 0;
+  fragLens.map(fragLen => {
+    buf.append(mergedBuf.subarray(fragSum, fragSum + fragLen));
+    fragSum += fragLen;
+    for (;;) {
+      const msg = buf.readMessage();
+      if (msg === undefined) break;
+      const exp = expected.shift();
+      expect(exp).toBeDefined();
+      expect(msg).toEqual(exp!.subarray(-1 * msg.length));
+    }
+  });
+  expect(expected.length).toEqual(0);
+});
+
+
+test('ProtoRingBufferTest.RandomSizes', () => {
+  const buf = new ProtoRingBuffer();
+  const kNumMsg = 100;
+  const mergedBuf = new Uint8Array(1024 * 1024 * 32);
+  const expectedLengths = [];
+  let mergedLen = 0;
+  for (let i = 0; i < kNumMsg; i++) {
+    const fieldId = 1 + Rnd(15);  // We support only one byte tag.
+    const rndVal = Rnd(1024);
+    let len = 1 + rndVal;
+    if ((rndVal % 100) < 5) {
+      len *= 1000;
+    }
+    const msg = MakeProtoMessage(fieldId, len);
+    assertTrue(mergedBuf.length >= mergedLen + msg.length);
+    expectedLengths.push(len);
+    mergedBuf.set(msg, mergedLen);
+    mergedLen += msg.length;
+  }
+
+  for (let fragSum = 0; fragSum < mergedLen;) {
+      let fragLen = 1 + Rnd(1024 * 32);
+      fragLen = Math.min(fragLen, mergedLen - fragSum);
+      buf.append(mergedBuf.subarray(fragSum, fragSum + fragLen));
+      fragSum += fragLen;
+      for (;;) {
+        const msg = buf.readMessage();
+        if (msg === undefined) break;
+        const expLen = expectedLengths.shift();
+        expect(expLen).toBeDefined();
+        expect(msg.length).toEqual(expLen);
+      }
+    }
+  expect(expectedLengths.length).toEqual(0);
+});