diff --git a/include/perfetto/ext/base/string_writer.h b/include/perfetto/ext/base/string_writer.h
index 10e92a0..6bc7fad 100644
--- a/include/perfetto/ext/base/string_writer.h
+++ b/include/perfetto/ext/base/string_writer.h
@@ -68,34 +68,20 @@
   // digits of the integer is less than |padding|.
   template <char padchar, uint64_t padding>
   void AppendPaddedInt(int64_t sign_value) {
-    // Need to add 2 to the number of digits to account for minus sign and
-    // rounding down of digits10.
-    constexpr auto kMaxDigits = std::numeric_limits<uint64_t>::digits10 + 2;
-    constexpr auto kSizeNeeded = kMaxDigits > padding ? kMaxDigits : padding;
-    PERFETTO_DCHECK(pos_ + kSizeNeeded <= size_);
-
-    char data[kSizeNeeded];
     const bool negate = signbit(static_cast<double>(sign_value));
-    uint64_t value = static_cast<uint64_t>(std::abs(sign_value));
+    uint64_t absolute_value = static_cast<uint64_t>(std::abs(sign_value));
+    AppendPaddedInt<padchar, padding>(absolute_value, negate);
+  }
 
-    size_t idx;
-    for (idx = kSizeNeeded - 1; value >= 10;) {
-      char digit = value % 10;
-      value /= 10;
-      data[idx--] = digit + '0';
-    }
-    data[idx--] = static_cast<char>(value) + '0';
+  void AppendUnsignedInt(uint64_t value) {
+    AppendPaddedUnsignedInt<'0', 0>(value);
+  }
 
-    if (padding > 0) {
-      size_t num_digits = kSizeNeeded - 1 - idx;
-      for (size_t i = num_digits; i < padding; i++) {
-        data[idx--] = padchar;
-      }
-    }
-
-    if (negate)
-      buffer_[pos_++] = '-';
-    AppendString(&data[idx + 1], kSizeNeeded - idx - 1);
+  // Appends an unsigned integer to the buffer, padding with |padchar| if the
+  // number of digits of the integer is less than |padding|.
+  template <char padchar, uint64_t padding>
+  void AppendPaddedUnsignedInt(uint64_t value) {
+    AppendPaddedInt<padchar, padding>(value, false);
   }
 
   // Appends a hex integer to the buffer.
@@ -118,6 +104,14 @@
     pos_ += res;
   }
 
+  void AppendBool(bool value) {
+    if (value) {
+      AppendLiteral("true");
+      return;
+    }
+    AppendLiteral("false");
+  }
+
   StringView GetStringView() {
     PERFETTO_DCHECK(pos_ <= size_);
     return StringView(buffer_, pos_);
@@ -137,6 +131,36 @@
   void reset() { pos_ = 0; }
 
  private:
+  template <char padchar, uint64_t padding>
+  void AppendPaddedInt(uint64_t absolute_value, bool negate) {
+    // Need to add 2 to the number of digits to account for minus sign and
+    // rounding down of digits10.
+    constexpr auto kMaxDigits = std::numeric_limits<uint64_t>::digits10 + 2;
+    constexpr auto kSizeNeeded = kMaxDigits > padding ? kMaxDigits : padding;
+    PERFETTO_DCHECK(pos_ + kSizeNeeded <= size_);
+
+    char data[kSizeNeeded];
+
+    size_t idx;
+    for (idx = kSizeNeeded - 1; absolute_value >= 10;) {
+      char digit = absolute_value % 10;
+      absolute_value /= 10;
+      data[idx--] = digit + '0';
+    }
+    data[idx--] = static_cast<char>(absolute_value) + '0';
+
+    if (padding > 0) {
+      size_t num_digits = kSizeNeeded - 1 - idx;
+      for (size_t i = num_digits; i < padding; i++) {
+        data[idx--] = padchar;
+      }
+    }
+
+    if (negate)
+      buffer_[pos_++] = '-';
+    AppendString(&data[idx + 1], kSizeNeeded - idx - 1);
+  }
+
   char* buffer_ = nullptr;
   size_t size_ = 0;
   size_t pos_ = 0;
diff --git a/src/base/string_writer_unittest.cc b/src/base/string_writer_unittest.cc
index 8d83dcc..12a7872 100644
--- a/src/base/string_writer_unittest.cc
+++ b/src/base/string_writer_unittest.cc
@@ -37,6 +37,11 @@
   }
   {
     base::StringWriter writer(buffer, sizeof(buffer));
+    writer.AppendUnsignedInt(523);
+    ASSERT_EQ(writer.GetStringView().ToStdString(), "523");
+  }
+  {
+    base::StringWriter writer(buffer, sizeof(buffer));
     writer.AppendPaddedInt<'0', 3>(0);
     ASSERT_EQ(writer.GetStringView().ToStdString(), "000");
   }
@@ -62,6 +67,11 @@
   }
   {
     base::StringWriter writer(buffer, sizeof(buffer));
+    writer.AppendPaddedUnsignedInt<' ', 5>(123);
+    ASSERT_EQ(writer.GetStringView().ToStdString(), "  123");
+  }
+  {
+    base::StringWriter writer(buffer, sizeof(buffer));
     writer.AppendDouble(123.25);
     ASSERT_EQ(writer.GetStringView().ToStdString(), "123.250000");
   }
@@ -75,6 +85,21 @@
     writer.AppendInt(std::numeric_limits<int64_t>::max());
     ASSERT_EQ(writer.GetStringView().ToStdString(), "9223372036854775807");
   }
+  {
+    base::StringWriter writer(buffer, sizeof(buffer));
+    writer.AppendUnsignedInt(std::numeric_limits<uint64_t>::max());
+    ASSERT_EQ(writer.GetStringView().ToStdString(), "18446744073709551615");
+  }
+  {
+    base::StringWriter writer(buffer, sizeof(buffer));
+    writer.AppendBool(true);
+    ASSERT_EQ(writer.GetStringView().ToStdString(), "true");
+  }
+  {
+    base::StringWriter writer(buffer, sizeof(buffer));
+    writer.AppendBool(false);
+    ASSERT_EQ(writer.GetStringView().ToStdString(), "false");
+  }
 
   constexpr char kTestStr[] = "test";
   {
@@ -105,13 +130,16 @@
   base::StringWriter writer(buffer, sizeof(buffer));
   writer.AppendChar('0');
   writer.AppendInt(132545);
+  writer.AppendUnsignedInt(523);
   writer.AppendPaddedInt<'0', 0>(1);
   writer.AppendPaddedInt<'0', 3>(0);
   writer.AppendPaddedInt<'0', 1>(1);
   writer.AppendPaddedInt<'0', 2>(1);
   writer.AppendPaddedInt<'0', 3>(1);
   writer.AppendPaddedInt<' ', 5>(123);
+  writer.AppendPaddedUnsignedInt<' ', 5>(456);
   writer.AppendDouble(123.25);
+  writer.AppendBool(true);
 
   constexpr char kTestStr[] = "test";
   writer.AppendLiteral(kTestStr);
@@ -119,7 +147,7 @@
   writer.AppendString(kTestStr);
 
   ASSERT_EQ(writer.GetStringView().ToStdString(),
-            "01325451000101001  123123.250000testtesttest");
+            "01325455231000101001  123  456123.250000truetesttesttest");
 }
 
 }  // namespace
diff --git a/src/trace_processor/args_table.cc b/src/trace_processor/args_table.cc
index 8b781f2..bc89ef0 100644
--- a/src/trace_processor/args_table.cc
+++ b/src/trace_processor/args_table.cc
@@ -79,14 +79,30 @@
     case Variadic::Type::kInt:
       sqlite_utils::ReportSqliteResult(ctx, value.int_value);
       break;
-    case Variadic::Type::kReal:
-      sqlite_utils::ReportSqliteResult(ctx, value.real_value);
+    case Variadic::Type::kUint:
+      // BEWARE: uint64 is handled as signed int64 for SQLite operations.
+      sqlite_utils::ReportSqliteResult(ctx,
+                                       static_cast<int64_t>(value.uint_value));
       break;
     case Variadic::Type::kString: {
       const char* str = storage_->GetString(value.string_value).c_str();
       sqlite3_result_text(ctx, str, -1, sqlite_utils::kSqliteStatic);
       break;
     }
+    case Variadic::Type::kReal:
+      sqlite_utils::ReportSqliteResult(ctx, value.real_value);
+      break;
+    case Variadic::Type::kPointer:
+      // BEWARE: pointers are handled as signed int64 for SQLite operations.
+      sqlite_utils::ReportSqliteResult(
+          ctx, static_cast<int64_t>(value.pointer_value));
+      break;
+    case Variadic::Type::kBool:
+      sqlite_utils::ReportSqliteResult(ctx, value.bool_value);
+      break;
+    case Variadic::Type::kJson:
+      sqlite_utils::ReportSqliteResult(ctx, value.json_value);
+      break;
   }
 }
 
@@ -110,13 +126,16 @@
           });
       break;
     }
-    case Variadic::Type::kReal: {
+    case Variadic::Type::kUint: {
       bool op_is_null = sqlite_utils::IsOpIsNull(op);
-      auto predicate = sqlite_utils::CreateNumericPredicate<double>(op, value);
+      // BEWARE: uint64 is handled as signed int64 for SQLite operations.
+      auto predicate = sqlite_utils::CreateNumericPredicate<int64_t>(op, value);
       index->FilterRows(
           [this, predicate, op_is_null](uint32_t row) PERFETTO_ALWAYS_INLINE {
             const auto& arg = storage_->args().arg_values()[row];
-            return arg.type == type_ ? predicate(arg.real_value) : op_is_null;
+            return arg.type == type_
+                       ? predicate(static_cast<int64_t>(arg.uint_value))
+                       : op_is_null;
           });
       break;
     }
@@ -131,6 +150,50 @@
       });
       break;
     }
+    case Variadic::Type::kReal: {
+      bool op_is_null = sqlite_utils::IsOpIsNull(op);
+      auto predicate = sqlite_utils::CreateNumericPredicate<double>(op, value);
+      index->FilterRows(
+          [this, predicate, op_is_null](uint32_t row) PERFETTO_ALWAYS_INLINE {
+            const auto& arg = storage_->args().arg_values()[row];
+            return arg.type == type_ ? predicate(arg.real_value) : op_is_null;
+          });
+      break;
+    }
+    case Variadic::Type::kPointer: {
+      bool op_is_null = sqlite_utils::IsOpIsNull(op);
+      // BEWARE: pointers are handled as signed int64 for SQLite operations.
+      auto predicate = sqlite_utils::CreateNumericPredicate<int64_t>(op, value);
+      index->FilterRows(
+          [this, predicate, op_is_null](uint32_t row) PERFETTO_ALWAYS_INLINE {
+            const auto& arg = storage_->args().arg_values()[row];
+            return arg.type == type_
+                       ? predicate(static_cast<int64_t>(arg.pointer_value))
+                       : op_is_null;
+          });
+      break;
+    }
+    case Variadic::Type::kBool: {
+      bool op_is_null = sqlite_utils::IsOpIsNull(op);
+      auto predicate = sqlite_utils::CreateNumericPredicate<bool>(op, value);
+      index->FilterRows(
+          [this, predicate, op_is_null](uint32_t row) PERFETTO_ALWAYS_INLINE {
+            const auto& arg = storage_->args().arg_values()[row];
+            return arg.type == type_ ? predicate(arg.bool_value) : op_is_null;
+          });
+      break;
+    }
+    case Variadic::Type::kJson: {
+      auto predicate = sqlite_utils::CreateStringPredicate(op, value);
+      index->FilterRows([this,
+                         &predicate](uint32_t row) PERFETTO_ALWAYS_INLINE {
+        const auto& arg = storage_->args().arg_values()[row];
+        return arg.type == type_
+                   ? predicate(storage_->GetString(arg.json_value).c_str())
+                   : predicate(nullptr);
+      });
+      break;
+    }
   }
 }
 
@@ -150,14 +213,32 @@
     switch (type_) {
       case Variadic::Type::kInt:
         return sqlite_utils::CompareValuesAsc(arg_f.int_value, arg_s.int_value);
-      case Variadic::Type::kReal:
-        return sqlite_utils::CompareValuesAsc(arg_f.real_value,
-                                              arg_s.real_value);
+      case Variadic::Type::kUint:
+        // BEWARE: uint64 is handled as signed int64 for SQLite operations.
+        return sqlite_utils::CompareValuesAsc(
+            static_cast<int64_t>(arg_f.uint_value),
+            static_cast<int64_t>(arg_s.uint_value));
       case Variadic::Type::kString: {
         const auto& f_str = storage_->GetString(arg_f.string_value);
         const auto& s_str = storage_->GetString(arg_s.string_value);
         return sqlite_utils::CompareValuesAsc(f_str, s_str);
       }
+      case Variadic::Type::kReal:
+        return sqlite_utils::CompareValuesAsc(arg_f.real_value,
+                                              arg_s.real_value);
+      case Variadic::Type::kPointer:
+        // BEWARE: pointers are handled as signed int64 for SQLite operations.
+        return sqlite_utils::CompareValuesAsc(
+            static_cast<int64_t>(arg_f.pointer_value),
+            static_cast<int64_t>(arg_s.pointer_value));
+      case Variadic::Type::kBool:
+        return sqlite_utils::CompareValuesAsc(arg_f.bool_value,
+                                              arg_s.bool_value);
+      case Variadic::Type::kJson: {
+        const auto& f_str = storage_->GetString(arg_f.json_value);
+        const auto& s_str = storage_->GetString(arg_s.json_value);
+        return sqlite_utils::CompareValuesAsc(f_str, s_str);
+      }
     }
   } else if (arg_s.type == type_) {
     return -1;
diff --git a/src/trace_processor/args_table.h b/src/trace_processor/args_table.h
index 0d9fd4b..3327e57 100644
--- a/src/trace_processor/args_table.h
+++ b/src/trace_processor/args_table.h
@@ -56,9 +56,17 @@
       switch (type_) {
         case Variadic::Type::kInt:
           return Table::ColumnType::kLong;
+        case Variadic::Type::kUint:
+          return Table::ColumnType::kLong;
+        case Variadic::Type::kString:
+          return Table::ColumnType::kString;
         case Variadic::Type::kReal:
           return Table::ColumnType::kDouble;
-        case Variadic::Type::kString:
+        case Variadic::Type::kPointer:
+          return Table::ColumnType::kLong;
+        case Variadic::Type::kBool:
+          return Table::ColumnType::kBool;
+        case Variadic::Type::kJson:
           return Table::ColumnType::kString;
       }
       PERFETTO_FATAL("Not reached");  // For gcc
diff --git a/src/trace_processor/args_tracker.h b/src/trace_processor/args_tracker.h
index b966dc9..7eb27d7 100644
--- a/src/trace_processor/args_tracker.h
+++ b/src/trace_processor/args_tracker.h
@@ -32,10 +32,12 @@
   virtual ~ArgsTracker();
 
   // Adds a arg for this row id with the given key and value.
-  void AddArg(RowId row_id, StringId flat_key, StringId key, Variadic);
+  // Virtual for testing.
+  virtual void AddArg(RowId row_id, StringId flat_key, StringId key, Variadic);
 
   // Commits the added args to storage.
-  void Flush();
+  // Virtual for testing.
+  virtual void Flush();
 
  private:
   std::vector<TraceStorage::Args::Arg> args_;
diff --git a/src/trace_processor/proto_incremental_state.h b/src/trace_processor/proto_incremental_state.h
index 38f4abd..b2dc1de 100644
--- a/src/trace_processor/proto_incremental_state.h
+++ b/src/trace_processor/proto_incremental_state.h
@@ -77,7 +77,7 @@
   struct InternedDataView {
     InternedDataView(TraceBlobView msg) : message(std::move(msg)) {}
 
-    typename MessageType::Decoder CreateDecoder() {
+    typename MessageType::Decoder CreateDecoder() const {
       return typename MessageType::Decoder(message.data(), message.length());
     }
 
diff --git a/src/trace_processor/proto_trace_parser.cc b/src/trace_processor/proto_trace_parser.cc
index ae94745..3355766 100644
--- a/src/trace_processor/proto_trace_parser.cc
+++ b/src/trace_processor/proto_trace_parser.cc
@@ -118,7 +118,11 @@
       oom_score_adj_id_(context->storage->InternString("oom_score_adj")),
       ion_total_unknown_id_(context->storage->InternString("mem.ion.unknown")),
       ion_change_unknown_id_(
-          context->storage->InternString("mem.ion_change.unknown")) {
+          context->storage->InternString("mem.ion_change.unknown")),
+      task_file_name_args_key_id_(
+          context->storage->InternString("task.posted_from.file_name")),
+      task_function_name_args_key_id_(
+          context->storage->InternString("task.posted_from.function_name")) {
   for (const auto& name : BuildMeminfoCounterNames()) {
     meminfo_strs_id_.emplace_back(context->storage->InternString(name));
   }
@@ -1436,21 +1440,35 @@
   // TODO(eseckler): Handle thread timestamp/duration, debug annotations, task
   // souce locations, legacy event attributes, ...
 
+  auto args_callback = [this, &event, &sequence_state](
+                           ArgsTracker* args_tracker, RowId row) {
+    for (auto it = event.debug_annotations(); it; ++it) {
+      ParseDebugAnnotationArgs(it->as_bytes(), sequence_state, args_tracker,
+                               row);
+    }
+
+    if (event.has_task_execution()) {
+      ParseTaskExecutionArgs(event.task_execution(), sequence_state,
+                             args_tracker, row);
+    }
+  };
+
   int32_t phase = legacy_event.phase();
   switch (static_cast<char>(phase)) {
     case 'B': {  // TRACE_EVENT_PHASE_BEGIN.
-      slice_tracker->Begin(ts, utid, category_id, name_id);
+      slice_tracker->Begin(ts, utid, category_id, name_id, args_callback);
       break;
     }
     case 'E': {  // TRACE_EVENT_PHASE_END.
-      slice_tracker->End(ts, utid, category_id, name_id);
+      slice_tracker->End(ts, utid, category_id, name_id, args_callback);
       break;
     }
     case 'X': {  // TRACE_EVENT_PHASE_COMPLETE.
       auto duration_ns = legacy_event.duration_us() * 1000;
       if (duration_ns < 0)
         return;
-      slice_tracker->Scoped(ts, utid, category_id, name_id, duration_ns);
+      slice_tracker->Scoped(ts, utid, category_id, name_id, duration_ns,
+                            args_callback);
       break;
     }
     case 'M': {  // TRACE_EVENT_PHASE_METADATA (process and thread names).
@@ -1486,6 +1504,176 @@
   }
 }
 
+void ProtoTraceParser::ParseDebugAnnotationArgs(
+    ConstBytes debug_annotation,
+    ProtoIncrementalState::PacketSequenceState* sequence_state,
+    ArgsTracker* args_tracker,
+    RowId row) {
+  protos::pbzero::DebugAnnotation::Decoder annotation(debug_annotation.data,
+                                                      debug_annotation.size);
+  uint32_t iid = annotation.name_iid();
+  if (!iid)
+    return;
+
+  auto* map =
+      sequence_state->GetInternedDataMap<protos::pbzero::DebugAnnotationName>();
+  auto name_view_it = map->find(iid);
+  if (name_view_it == map->end()) {
+    PERFETTO_ELOG(
+        "Could not find debug annotation name interning entry for ID %u", iid);
+    return;
+  }
+
+  TraceStorage* storage = context_->storage.get();
+
+  StringId name_id = 0;
+
+  // If the name is already in the pool, no need to decode it again.
+  if (name_view_it->second.storage_refs) {
+    name_id = name_view_it->second.storage_refs->name_id;
+  } else {
+    auto name = name_view_it->second.CreateDecoder();
+    std::string name_prefixed = "debug." + name.name().ToStdString();
+    name_id = storage->InternString(base::StringView(name_prefixed));
+    // Avoid having to decode & look up the name again in the future.
+    name_view_it->second.storage_refs =
+        ProtoIncrementalState::StorageReferences<
+            protos::pbzero::DebugAnnotationName>{name_id};
+  }
+
+  if (annotation.has_bool_value()) {
+    args_tracker->AddArg(row, name_id, name_id,
+                         Variadic::Boolean(annotation.bool_value()));
+  } else if (annotation.has_uint_value()) {
+    args_tracker->AddArg(row, name_id, name_id,
+                         Variadic::UnsignedInteger(annotation.uint_value()));
+  } else if (annotation.has_int_value()) {
+    args_tracker->AddArg(row, name_id, name_id,
+                         Variadic::Integer(annotation.int_value()));
+  } else if (annotation.has_double_value()) {
+    args_tracker->AddArg(row, name_id, name_id,
+                         Variadic::Real(annotation.double_value()));
+  } else if (annotation.has_string_value()) {
+    args_tracker->AddArg(
+        row, name_id, name_id,
+        Variadic::String(storage->InternString(annotation.string_value())));
+  } else if (annotation.has_pointer_value()) {
+    args_tracker->AddArg(row, name_id, name_id,
+                         Variadic::Pointer(annotation.pointer_value()));
+  } else if (annotation.has_legacy_json_value()) {
+    args_tracker->AddArg(row, name_id, name_id,
+                         Variadic::String(storage->InternString(
+                             annotation.legacy_json_value())));
+  } else if (annotation.has_nested_value()) {
+    auto name = storage->GetString(name_id);
+    ParseNestedValueArgs(annotation.nested_value(), name, name, args_tracker,
+                         row);
+  }
+}
+
+void ProtoTraceParser::ParseNestedValueArgs(ConstBytes nested_value,
+                                            base::StringView flat_key,
+                                            base::StringView key,
+                                            ArgsTracker* args_tracker,
+                                            RowId row) {
+  protos::pbzero::DebugAnnotation::NestedValue::Decoder value(
+      nested_value.data, nested_value.size);
+  switch (value.nested_type()) {
+    case protos::pbzero::DebugAnnotation::NestedValue::UNSPECIFIED: {
+      auto flat_key_id = context_->storage->InternString(flat_key);
+      auto key_id = context_->storage->InternString(key);
+      // Leaf value.
+      if (value.has_bool_value()) {
+        args_tracker->AddArg(row, flat_key_id, key_id,
+                             Variadic::Boolean(value.bool_value()));
+      } else if (value.has_int_value()) {
+        args_tracker->AddArg(row, flat_key_id, key_id,
+                             Variadic::Integer(value.int_value()));
+      } else if (value.has_double_value()) {
+        args_tracker->AddArg(row, flat_key_id, key_id,
+                             Variadic::Real(value.double_value()));
+      } else if (value.has_string_value()) {
+        args_tracker->AddArg(row, flat_key_id, key_id,
+                             Variadic::String(context_->storage->InternString(
+                                 value.string_value())));
+      }
+      break;
+    }
+    case protos::pbzero::DebugAnnotation::NestedValue::DICT: {
+      auto key_it = value.dict_keys();
+      auto value_it = value.dict_values();
+      for (; key_it && value_it; ++key_it, ++value_it) {
+        std::string child_name = key_it->as_std_string();
+        std::string child_flat_key = flat_key.ToStdString() + "." + child_name;
+        std::string child_key = key.ToStdString() + "." + child_name;
+        ParseNestedValueArgs(value_it->as_bytes(),
+                             base::StringView(child_flat_key),
+                             base::StringView(child_key), args_tracker, row);
+      }
+      break;
+    }
+    case protos::pbzero::DebugAnnotation::NestedValue::ARRAY: {
+      int child_index = 0;
+      std::string child_flat_key = flat_key.ToStdString();
+      for (auto value_it = value.array_values(); value_it;
+           ++value_it, ++child_index) {
+        std::string child_key =
+            key.ToStdString() + "[" + std::to_string(child_index) + "]";
+        ParseNestedValueArgs(value_it->as_bytes(),
+                             base::StringView(child_flat_key),
+                             base::StringView(child_key), args_tracker, row);
+      }
+      break;
+    }
+  }
+}
+
+void ProtoTraceParser::ParseTaskExecutionArgs(
+    ConstBytes task_execution,
+    ProtoIncrementalState::PacketSequenceState* sequence_state,
+    ArgsTracker* args_tracker,
+    RowId row) {
+  protos::pbzero::TaskExecution::Decoder task(task_execution.data,
+                                              task_execution.size);
+  uint32_t iid = task.posted_from_iid();
+  if (!iid)
+    return;
+
+  auto* map =
+      sequence_state->GetInternedDataMap<protos::pbzero::SourceLocation>();
+  auto location_view_it = map->find(iid);
+  if (location_view_it == map->end()) {
+    PERFETTO_ELOG("Could not find source location interning entry for ID %u",
+                  iid);
+    return;
+  }
+
+  StringId file_name_id = 0;
+  StringId function_name_id = 0;
+
+  // If the names are already in the pool, no need to decode them again.
+  if (location_view_it->second.storage_refs) {
+    file_name_id = location_view_it->second.storage_refs->file_name_id;
+    function_name_id = location_view_it->second.storage_refs->function_name_id;
+  } else {
+    TraceStorage* storage = context_->storage.get();
+    auto location = location_view_it->second.CreateDecoder();
+    file_name_id = storage->InternString(location.file_name());
+    function_name_id = storage->InternString(location.function_name());
+    // Avoid having to decode & look up the names again in the future.
+    location_view_it->second.storage_refs =
+        ProtoIncrementalState::StorageReferences<
+            protos::pbzero::SourceLocation>{file_name_id, function_name_id};
+  }
+
+  args_tracker->AddArg(row, task_file_name_args_key_id_,
+                       task_file_name_args_key_id_,
+                       Variadic::String(file_name_id));
+  args_tracker->AddArg(row, task_function_name_args_key_id_,
+                       task_function_name_args_key_id_,
+                       Variadic::String(function_name_id));
+}
+
 void ProtoTraceParser::ParseChromeBenchmarkMetadata(ConstBytes blob) {
   TraceStorage* storage = context_->storage.get();
   protos::pbzero::ChromeBenchmarkMetadata::Decoder packet(blob.data, blob.size);
diff --git a/src/trace_processor/proto_trace_parser.h b/src/trace_processor/proto_trace_parser.h
index a66573d..0fbe329 100644
--- a/src/trace_processor/proto_trace_parser.h
+++ b/src/trace_processor/proto_trace_parser.h
@@ -33,6 +33,7 @@
 namespace perfetto {
 namespace trace_processor {
 
+class ArgsTracker;
 class TraceProcessorContext;
 
 class ProtoTraceParser : public TraceParser {
@@ -92,6 +93,21 @@
                        int64_t tts,
                        ProtoIncrementalState::PacketSequenceState*,
                        ConstBytes);
+  void ParseDebugAnnotationArgs(
+      ConstBytes debug_annotation,
+      ProtoIncrementalState::PacketSequenceState* sequence_state,
+      ArgsTracker* args_tracker,
+      RowId row);
+  void ParseNestedValueArgs(ConstBytes nested_value,
+                            base::StringView flat_key,
+                            base::StringView key,
+                            ArgsTracker* args_tracker,
+                            RowId row);
+  void ParseTaskExecutionArgs(
+      ConstBytes task_execution,
+      ProtoIncrementalState::PacketSequenceState* sequence_state,
+      ArgsTracker* args_tracker,
+      RowId row);
   void ParseChromeBenchmarkMetadata(ConstBytes);
 
  private:
@@ -123,6 +139,8 @@
   const StringId oom_score_adj_id_;
   const StringId ion_total_unknown_id_;
   const StringId ion_change_unknown_id_;
+  const StringId task_file_name_args_key_id_;
+  const StringId task_function_name_args_key_id_;
   std::vector<StringId> meminfo_strs_id_;
   std::vector<StringId> vmstat_strs_id_;
   std::vector<StringId> rss_members_;
diff --git a/src/trace_processor/proto_trace_parser_unittest.cc b/src/trace_processor/proto_trace_parser_unittest.cc
index 6107f4f..a40868d 100644
--- a/src/trace_processor/proto_trace_parser_unittest.cc
+++ b/src/trace_processor/proto_trace_parser_unittest.cc
@@ -104,6 +104,7 @@
   MockTraceStorage() : TraceStorage() {}
 
   MOCK_METHOD1(InternString, StringId(base::StringView));
+  MOCK_CONST_METHOD1(GetString, NullTermStringView(StringId));
   MOCK_METHOD2(SetMetadata, void(size_t, Variadic));
   MOCK_METHOD2(AppendMetadata, void(size_t, Variadic));
 };
@@ -147,8 +148,7 @@
   ProtoTraceParserTest() {
     nice_storage_ = new NiceMock<MockTraceStorage>();
     context_.storage.reset(nice_storage_);
-    args_ = new MockArgsTracker(&context_);
-    context_.args_tracker.reset(args_);
+    context_.args_tracker.reset(new ArgsTracker(&context_));
     event_ = new MockEventTracker(&context_);
     context_.event_tracker.reset(event_);
     process_ = new MockProcessTracker(&context_);
@@ -189,7 +189,6 @@
   std::unique_ptr<protozero::ScatteredStreamWriter> stream_writer_;
   protos::pbzero::Trace trace_;
   TraceProcessorContext context_;
-  MockArgsTracker* args_;
   MockEventTracker* event_;
   MockProcessTracker* process_;
   MockSliceTracker* slice_;
@@ -976,6 +975,264 @@
   context_.sorter->ExtractEventsForced();
 }
 
+TEST_F(ProtoTraceParserTest, TrackEventWithDebugAnnotations) {
+  InitStorage();
+  context_.sorter.reset(new TraceSorter(
+      &context_, std::numeric_limits<int64_t>::max() /*window size*/));
+  MockArgsTracker args(&context_);
+
+  {
+    auto* packet = trace_.add_packet();
+    packet->set_trusted_packet_sequence_id(1);
+    packet->set_incremental_state_cleared(true);
+    auto* thread_desc = packet->set_thread_descriptor();
+    thread_desc->set_pid(15);
+    thread_desc->set_tid(16);
+    thread_desc->set_reference_timestamp_us(1000);
+    thread_desc->set_reference_thread_time_us(2000);
+  }
+  {
+    auto* packet = trace_.add_packet();
+    packet->set_trusted_packet_sequence_id(1);
+    auto* event = packet->set_track_event();
+    event->set_timestamp_delta_us(10);   // absolute: 1010.
+    event->set_thread_time_delta_us(5);  // absolute: 2005.
+    event->add_category_iids(1);
+    auto* annotation1 = event->add_debug_annotations();
+    annotation1->set_name_iid(1);
+    annotation1->set_uint_value(10u);
+    auto* annotation2 = event->add_debug_annotations();
+    annotation2->set_name_iid(2);
+    auto* nested = annotation2->set_nested_value();
+    nested->set_nested_type(protos::pbzero::DebugAnnotation::NestedValue::DICT);
+    nested->add_dict_keys("child1");
+    nested->add_dict_keys("child2");
+    auto* child1 = nested->add_dict_values();
+    child1->set_nested_type(
+        protos::pbzero::DebugAnnotation::NestedValue::UNSPECIFIED);
+    child1->set_bool_value(true);
+    auto* child2 = nested->add_dict_values();
+    child2->set_nested_type(
+        protos::pbzero::DebugAnnotation::NestedValue::ARRAY);
+    auto* child21 = child2->add_array_values();
+    child21->set_nested_type(
+        protos::pbzero::DebugAnnotation::NestedValue::UNSPECIFIED);
+    child21->set_string_value("child21");
+    auto* child22 = child2->add_array_values();
+    child22->set_nested_type(
+        protos::pbzero::DebugAnnotation::NestedValue::UNSPECIFIED);
+    child22->set_double_value(2.2);
+    auto* child23 = child2->add_array_values();
+    child23->set_nested_type(
+        protos::pbzero::DebugAnnotation::NestedValue::UNSPECIFIED);
+    child23->set_int_value(23);
+    auto* legacy_event = event->set_legacy_event();
+    legacy_event->set_name_iid(1);
+    legacy_event->set_phase('B');
+
+    auto* interned_data = packet->set_interned_data();
+    auto cat1 = interned_data->add_event_categories();
+    cat1->set_iid(1);
+    cat1->set_name("cat1");
+    auto ev1 = interned_data->add_legacy_event_names();
+    ev1->set_iid(1);
+    ev1->set_name("ev1");
+    auto an1 = interned_data->add_debug_annotation_names();
+    an1->set_iid(1);
+    an1->set_name("an1");
+    auto an2 = interned_data->add_debug_annotation_names();
+    an2->set_iid(2);
+    an2->set_name("an2");
+  }
+  {
+    auto* packet = trace_.add_packet();
+    packet->set_trusted_packet_sequence_id(1);
+    auto* event = packet->set_track_event();
+    event->set_timestamp_delta_us(10);   // absolute: 1020.
+    event->set_thread_time_delta_us(5);  // absolute: 2010.
+    event->add_category_iids(1);
+    auto* annotation3 = event->add_debug_annotations();
+    annotation3->set_name_iid(3);
+    annotation3->set_int_value(-3);
+    auto* annotation4 = event->add_debug_annotations();
+    annotation4->set_name_iid(4);
+    annotation4->set_bool_value(true);
+    auto* annotation5 = event->add_debug_annotations();
+    annotation5->set_name_iid(5);
+    annotation5->set_double_value(-5.5);
+    auto* annotation6 = event->add_debug_annotations();
+    annotation6->set_name_iid(6);
+    annotation6->set_pointer_value(20u);
+    auto* annotation7 = event->add_debug_annotations();
+    annotation7->set_name_iid(7);
+    annotation7->set_string_value("val7");
+    auto* annotation8 = event->add_debug_annotations();
+    annotation8->set_name_iid(8);
+    annotation8->set_legacy_json_value("val8");
+    auto* legacy_event = event->set_legacy_event();
+    legacy_event->set_name_iid(1);
+    legacy_event->set_phase('E');
+
+    auto* interned_data = packet->set_interned_data();
+    auto an3 = interned_data->add_debug_annotation_names();
+    an3->set_iid(3);
+    an3->set_name("an3");
+    auto an4 = interned_data->add_debug_annotation_names();
+    an4->set_iid(4);
+    an4->set_name("an4");
+    auto an5 = interned_data->add_debug_annotation_names();
+    an5->set_iid(5);
+    an5->set_name("an5");
+    auto an6 = interned_data->add_debug_annotation_names();
+    an6->set_iid(6);
+    an6->set_name("an6");
+    auto an7 = interned_data->add_debug_annotation_names();
+    an7->set_iid(7);
+    an7->set_name("an7");
+    auto an8 = interned_data->add_debug_annotation_names();
+    an8->set_iid(8);
+    an8->set_name("an8");
+  }
+
+  Tokenize();
+
+  EXPECT_CALL(*process_, UpdateThread(16, 15))
+      .Times(2)
+      .WillRepeatedly(Return(1));
+
+  InSequence in_sequence;  // Below slices should be sorted by timestamp.
+
+  EXPECT_CALL(*storage_, InternString(base::StringView("cat1")))
+      .WillOnce(Return(1));
+  EXPECT_CALL(*storage_, InternString(base::StringView("ev1")))
+      .WillOnce(Return(2));
+  EXPECT_CALL(*slice_, Begin(1010000, 1, 1, 2, _))
+      .WillOnce(testing::InvokeArgument<4>(&args, 1u));
+  EXPECT_CALL(*storage_, InternString(base::StringView("debug.an1")))
+      .WillOnce(Return(3));
+  EXPECT_CALL(args, AddArg(1u, 3, 3, Variadic::UnsignedInteger(10u)));
+
+  EXPECT_CALL(*storage_, InternString(base::StringView("debug.an2")))
+      .WillOnce(Return(4));
+  EXPECT_CALL(*storage_, GetString(4)).WillOnce(Return("debug.an2"));
+  EXPECT_CALL(*storage_, InternString(base::StringView("debug.an2.child1")))
+      .Times(2)
+      .WillRepeatedly(Return(5));
+  EXPECT_CALL(args, AddArg(1u, 5, 5, Variadic::Boolean(true)));
+
+  EXPECT_CALL(*storage_, InternString(base::StringView("debug.an2.child2")))
+      .WillOnce(Return(6));
+  EXPECT_CALL(*storage_, InternString(base::StringView("debug.an2.child2[0]")))
+      .WillOnce(Return(7));
+  EXPECT_CALL(*storage_, InternString(base::StringView("child21")))
+      .WillOnce(Return(8));
+  EXPECT_CALL(args, AddArg(1u, 6, 7, Variadic::String(8)));
+
+  EXPECT_CALL(*storage_, InternString(base::StringView("debug.an2.child2")))
+      .WillOnce(Return(6));
+  EXPECT_CALL(*storage_, InternString(base::StringView("debug.an2.child2[1]")))
+      .WillOnce(Return(9));
+  EXPECT_CALL(args, AddArg(1u, 6, 9, Variadic::Real(2.2)));
+
+  EXPECT_CALL(*storage_, InternString(base::StringView("debug.an2.child2")))
+      .WillOnce(Return(6));
+  EXPECT_CALL(*storage_, InternString(base::StringView("debug.an2.child2[2]")))
+      .WillOnce(Return(10));
+  EXPECT_CALL(args, AddArg(1u, 6, 10, Variadic::Integer(23)));
+
+  EXPECT_CALL(*slice_, End(1020000, 1, 1, 2, _))
+      .WillOnce(testing::InvokeArgument<4>(&args, 1u));
+
+  EXPECT_CALL(*storage_, InternString(base::StringView("debug.an3")))
+      .WillOnce(Return(11));
+  EXPECT_CALL(args, AddArg(1u, 11, 11, Variadic::Integer(-3)));
+  EXPECT_CALL(*storage_, InternString(base::StringView("debug.an4")))
+      .WillOnce(Return(12));
+  EXPECT_CALL(args, AddArg(1u, 12, 12, Variadic::Boolean(true)));
+  EXPECT_CALL(*storage_, InternString(base::StringView("debug.an5")))
+      .WillOnce(Return(13));
+  EXPECT_CALL(args, AddArg(1u, 13, 13, Variadic::Real(-5.5)));
+  EXPECT_CALL(*storage_, InternString(base::StringView("debug.an6")))
+      .WillOnce(Return(14));
+  EXPECT_CALL(args, AddArg(1u, 14, 14, Variadic::Pointer(20u)));
+  EXPECT_CALL(*storage_, InternString(base::StringView("debug.an7")))
+      .WillOnce(Return(15));
+  EXPECT_CALL(*storage_, InternString(base::StringView("val7")))
+      .WillOnce(Return(16));
+  EXPECT_CALL(args, AddArg(1u, 15, 15, Variadic::String(16)));
+  EXPECT_CALL(*storage_, InternString(base::StringView("debug.an8")))
+      .WillOnce(Return(17));
+  EXPECT_CALL(*storage_, InternString(base::StringView("val8")))
+      .WillOnce(Return(18));
+  EXPECT_CALL(args, AddArg(1u, 17, 17, Variadic::String(18)));
+
+  context_.sorter->ExtractEventsForced();
+}
+
+TEST_F(ProtoTraceParserTest, TrackEventWithTaskExecution) {
+  InitStorage();
+  context_.sorter.reset(new TraceSorter(
+      &context_, std::numeric_limits<int64_t>::max() /*window size*/));
+  MockArgsTracker args(&context_);
+
+  {
+    auto* packet = trace_.add_packet();
+    packet->set_trusted_packet_sequence_id(1);
+    packet->set_incremental_state_cleared(true);
+    auto* thread_desc = packet->set_thread_descriptor();
+    thread_desc->set_pid(15);
+    thread_desc->set_tid(16);
+    thread_desc->set_reference_timestamp_us(1000);
+    thread_desc->set_reference_thread_time_us(2000);
+  }
+  {
+    auto* packet = trace_.add_packet();
+    packet->set_trusted_packet_sequence_id(1);
+    auto* event = packet->set_track_event();
+    event->set_timestamp_delta_us(10);   // absolute: 1010.
+    event->set_thread_time_delta_us(5);  // absolute: 2005.
+    event->add_category_iids(1);
+    auto* task_execution = event->set_task_execution();
+    task_execution->set_posted_from_iid(1);
+    auto* legacy_event = event->set_legacy_event();
+    legacy_event->set_name_iid(1);
+    legacy_event->set_phase('B');
+
+    auto* interned_data = packet->set_interned_data();
+    auto cat1 = interned_data->add_event_categories();
+    cat1->set_iid(1);
+    cat1->set_name("cat1");
+    auto ev1 = interned_data->add_legacy_event_names();
+    ev1->set_iid(1);
+    ev1->set_name("ev1");
+    auto loc1 = interned_data->add_source_locations();
+    loc1->set_iid(1);
+    loc1->set_file_name("file1");
+    loc1->set_function_name("func1");
+  }
+
+  Tokenize();
+
+  EXPECT_CALL(*process_, UpdateThread(16, 15)).WillOnce(Return(1));
+
+  InSequence in_sequence;  // Below slices should be sorted by timestamp.
+
+  EXPECT_CALL(*storage_, InternString(base::StringView("cat1")))
+      .WillOnce(Return(1));
+  EXPECT_CALL(*storage_, InternString(base::StringView("ev1")))
+      .WillOnce(Return(2));
+  EXPECT_CALL(*slice_, Begin(1010000, 1, 1, 2, _))
+      .WillOnce(testing::InvokeArgument<4>(&args, 1u));
+  EXPECT_CALL(*storage_, InternString(base::StringView("file1")))
+      .WillOnce(Return(3));
+  EXPECT_CALL(*storage_, InternString(base::StringView("func1")))
+      .WillOnce(Return(4));
+  EXPECT_CALL(args, AddArg(1u, _, _, Variadic::String(3)));
+  EXPECT_CALL(args, AddArg(1u, _, _, Variadic::String(4)));
+
+  context_.sorter->ExtractEventsForced();
+}
+
 TEST_F(ProtoTraceParserTest, LoadChromeBenchmarkMetadata) {
   static const char kName[] = "name";
   static const char kTag2[] = "tag1";
diff --git a/src/trace_processor/raw_table.cc b/src/trace_processor/raw_table.cc
index 1f9196e..d7dcffe 100644
--- a/src/trace_processor/raw_table.cc
+++ b/src/trace_processor/raw_table.cc
@@ -90,12 +90,27 @@
       case Variadic::kInt:
         writer->AppendInt(value.int_value);
         break;
-      case Variadic::kReal:
-        writer->AppendDouble(value.real_value);
+      case Variadic::kUint:
+        writer->AppendUnsignedInt(value.uint_value);
         break;
       case Variadic::kString: {
         const auto& str = storage_->GetString(value.string_value);
         writer->AppendString(str.c_str(), str.size());
+        break;
+      }
+      case Variadic::kReal:
+        writer->AppendDouble(value.real_value);
+        break;
+      case Variadic::kPointer:
+        writer->AppendUnsignedInt(value.pointer_value);
+        break;
+      case Variadic::kBool:
+        writer->AppendBool(value.bool_value);
+        break;
+      case Variadic::kJson: {
+        const auto& str = storage_->GetString(value.json_value);
+        writer->AppendString(str.c_str(), str.size());
+        break;
       }
     }
   };
diff --git a/src/trace_processor/sqlite_utils.h b/src/trace_processor/sqlite_utils.h
index 60d095f..64ad4fb 100644
--- a/src/trace_processor/sqlite_utils.h
+++ b/src/trace_processor/sqlite_utils.h
@@ -132,6 +132,13 @@
   return sqlite3_value_double(value);
 }
 
+template <>
+inline bool ExtractSqliteValue(sqlite3_value* value) {
+  auto type = sqlite3_value_type(value);
+  PERFETTO_DCHECK(type == SQLITE_INTEGER);
+  return static_cast<bool>(sqlite3_value_int(value));
+}
+
 // Do not add a uint64_t version of ExtractSqliteValue. You should not be using
 // uint64_t at all given that SQLite doesn't support it.
 
@@ -362,6 +369,11 @@
 }
 
 template <>
+inline void ReportSqliteResult(sqlite3_context* ctx, bool value) {
+  sqlite3_result_int(ctx, value);
+}
+
+template <>
 inline void ReportSqliteResult(sqlite3_context* ctx, double value) {
   sqlite3_result_double(ctx, value);
 }
@@ -430,6 +442,8 @@
       type = Table::ColumnType::kString;
     } else if (strcmp(raw_type, "DOUBLE") == 0) {
       type = Table::ColumnType::kDouble;
+    } else if (strcmp(raw_type, "BOOLEAN") == 0) {
+      type = Table::ColumnType::kBool;
     } else if (!*raw_type) {
       PERFETTO_DLOG("Unknown column type for %s %s", raw_table_name.c_str(),
                     name);
diff --git a/src/trace_processor/table.cc b/src/trace_processor/table.cc
index 1218b5a..1110d6f 100644
--- a/src/trace_processor/table.cc
+++ b/src/trace_processor/table.cc
@@ -39,6 +39,8 @@
       return "INT";
     case Table::ColumnType::kDouble:
       return "DOUBLE";
+    case Table::ColumnType::kBool:
+      return "BOOLEAN";
     case Table::ColumnType::kUnknown:
       PERFETTO_FATAL("Cannot map unknown column type");
   }
diff --git a/src/trace_processor/table.h b/src/trace_processor/table.h
index 0c8e638..c89f002 100644
--- a/src/trace_processor/table.h
+++ b/src/trace_processor/table.h
@@ -49,7 +49,8 @@
     kLong = 3,
     kInt = 4,
     kDouble = 5,
-    kUnknown = 6,
+    kBool = 6,
+    kUnknown = 7,
   };
 
   // Describes a column of this table.
diff --git a/src/trace_processor/trace_storage.h b/src/trace_processor/trace_storage.h
index 45ffed3..de4dfa5 100644
--- a/src/trace_processor/trace_storage.h
+++ b/src/trace_processor/trace_storage.h
@@ -131,12 +131,24 @@
           case Variadic::Type::kInt:
             hash.Update(arg.value.int_value);
             break;
+          case Variadic::Type::kUint:
+            hash.Update(arg.value.uint_value);
+            break;
           case Variadic::Type::kString:
             hash.Update(arg.value.string_value);
             break;
           case Variadic::Type::kReal:
             hash.Update(arg.value.real_value);
             break;
+          case Variadic::Type::kPointer:
+            hash.Update(arg.value.pointer_value);
+            break;
+          case Variadic::Type::kBool:
+            hash.Update(arg.value.bool_value);
+            break;
+          case Variadic::Type::kJson:
+            hash.Update(arg.value.json_value);
+            break;
         }
         return hash.digest();
       }
@@ -832,7 +844,8 @@
   }
 
   // Reading methods.
-  NullTermStringView GetString(StringId id) const {
+  // Virtual for testing.
+  virtual NullTermStringView GetString(StringId id) const {
     return string_pool_.Get(id);
   }
 
diff --git a/src/trace_processor/variadic.h b/src/trace_processor/variadic.h
index 761aea3..6df011e 100644
--- a/src/trace_processor/variadic.h
+++ b/src/trace_processor/variadic.h
@@ -24,7 +24,7 @@
 
 // Variadic type representing value of different possible types.
 struct Variadic {
-  enum Type { kInt, kString, kReal };
+  enum Type { kInt, kUint, kString, kReal, kPointer, kBool, kJson };
 
   static Variadic Integer(int64_t int_value) {
     Variadic variadic;
@@ -33,6 +33,17 @@
     return variadic;
   }
 
+  // BEWARE: Unsigned 64-bit integers will be handled as signed integers by
+  // SQLite for built-in SQL operators. This variadic type is used to
+  // distinguish between int64 and uint64 for correct JSON export of TrackEvent
+  // arguments.
+  static Variadic UnsignedInteger(uint64_t uint_value) {
+    Variadic variadic;
+    variadic.type = Type::kUint;
+    variadic.uint_value = uint_value;
+    return variadic;
+  }
+
   static Variadic String(StringPool::Id string_id) {
     Variadic variadic;
     variadic.type = Type::kString;
@@ -47,16 +58,49 @@
     return variadic;
   }
 
+  // This variadic type is used to distinguish between integers and pointer
+  // values for correct JSON export of TrackEvent arguments.
+  static Variadic Pointer(uint64_t pointer_value) {
+    Variadic variadic;
+    variadic.type = Type::kPointer;
+    variadic.pointer_value = pointer_value;
+    return variadic;
+  }
+
+  static Variadic Boolean(bool bool_value) {
+    Variadic variadic;
+    variadic.type = Type::kBool;
+    variadic.bool_value = bool_value;
+    return variadic;
+  }
+
+  // This variadic type is used to distinguish between regular string and JSON
+  // string values for correct JSON export of TrackEvent arguments.
+  static Variadic Json(StringPool::Id json_value) {
+    Variadic variadic;
+    variadic.type = Type::kJson;
+    variadic.json_value = json_value;
+    return variadic;
+  }
+
   // Used in tests.
   bool operator==(const Variadic& other) const {
     if (type == other.type) {
       switch (type) {
         case kInt:
           return int_value == other.int_value;
+        case kUint:
+          return uint_value == other.uint_value;
         case kString:
           return string_value == other.string_value;
         case kReal:
           return std::equal_to<double>()(real_value, other.real_value);
+        case kPointer:
+          return pointer_value == other.pointer_value;
+        case kBool:
+          return bool_value == other.bool_value;
+        case kJson:
+          return json_value == other.json_value;
       }
     }
     return false;
@@ -65,8 +109,12 @@
   Type type;
   union {
     int64_t int_value;
+    uint64_t uint_value;
     StringPool::Id string_value;
     double real_value;
+    uint64_t pointer_value;
+    bool bool_value;
+    StringPool::Id json_value;
   };
 };