diff --git a/src/trace_processor/export_json_unittest.cc b/src/trace_processor/export_json_unittest.cc
index ded2e75..02fe44d 100644
--- a/src/trace_processor/export_json_unittest.cc
+++ b/src/trace_processor/export_json_unittest.cc
@@ -119,11 +119,8 @@
   context_.args_tracker->Flush();  // Flush track args.
   StringId cat_id = context_.storage->InternString(base::StringView(kCategory));
   StringId name_id = context_.storage->InternString(base::StringView(kName));
-  StringId ref_type_id = context_.storage->InternString(
-      GetRefTypeStringMap()[static_cast<uint32_t>(RefType::kRefUtid)]);
-  context_.storage->mutable_slice_table()->Insert({kTimestamp, kDuration, track,
-                                                   utid, ref_type_id, cat_id,
-                                                   name_id, 0, 0, 0});
+  context_.storage->mutable_slice_table()->Insert(
+      {kTimestamp, kDuration, track, cat_id, name_id, 0, 0, 0});
   context_.storage->mutable_thread_slices()->AddThreadSlice(
       0, kThreadTimestamp, kThreadDuration, kThreadInstructionCount,
       kThreadInstructionDelta);
@@ -169,11 +166,8 @@
   context_.args_tracker->Flush();  // Flush track args.
   StringId cat_id = context_.storage->InternString(base::StringView(kCategory));
   StringId name_id = context_.storage->InternString(base::StringView(kName));
-  StringId ref_type_id = context_.storage->InternString(
-      GetRefTypeStringMap()[static_cast<uint32_t>(RefType::kRefUtid)]);
-  context_.storage->mutable_slice_table()->Insert({kTimestamp, kDuration, track,
-                                                   utid, ref_type_id, cat_id,
-                                                   name_id, 0, 0, 0});
+  context_.storage->mutable_slice_table()->Insert(
+      {kTimestamp, kDuration, track, cat_id, name_id, 0, 0, 0});
   context_.storage->mutable_thread_slices()->AddThreadSlice(
       0, kThreadTimestamp, kThreadDuration, kThreadInstructionCount,
       kThreadInstructionDelta);
@@ -234,10 +228,8 @@
 
   StringId cat_id = context_.storage->InternString("cat");
   StringId name_id = context_.storage->InternString("name");
-  StringId ref_type_id = context_.storage->InternString(
-      GetRefTypeStringMap()[static_cast<uint32_t>(RefType::kRefTrack)]);
   context_.storage->mutable_slice_table()->Insert(
-      {0, 0, track, track, ref_type_id, cat_id, name_id, 0, 0, 0});
+      {0, 0, track, cat_id, name_id, 0, 0, 0});
 
   base::TempFile temp_file = base::TempFile::Create();
   FILE* output = fopen(temp_file.path().c_str(), "w+");
@@ -408,10 +400,8 @@
   context_.args_tracker->Flush();  // Flush track args.
   StringId cat_id = context_.storage->InternString(base::StringView(kCategory));
   StringId name_id = context_.storage->InternString(base::StringView(kName));
-  StringId ref_type_id = context_.storage->InternString(
-      GetRefTypeStringMap()[static_cast<uint32_t>(RefType::kRefUtid)]);
   context_.storage->mutable_slice_table()->Insert(
-      {0, 0, track, utid, ref_type_id, cat_id, name_id, 0, 0, 0});
+      {0, 0, track, cat_id, name_id, 0, 0, 0});
 
   StringId arg_key_id = context_.storage->InternString(
       base::StringView("task.posted_from.file_name"));
@@ -455,12 +445,9 @@
   context_.args_tracker->Flush();  // Flush track args.
   StringId cat_id = storage->InternString(base::StringView(kCategory));
   StringId name_id = storage->InternString(base::StringView(kName));
-  StringId ref_type_id = context_.storage->InternString(
-      GetRefTypeStringMap()[static_cast<uint32_t>(RefType::kRefUtid)]);
   RowId row_id = TraceStorage::CreateRowId(
-      kNestableSlices,
-      storage->mutable_slice_table()->Insert(
-          {0, 0, track, utid, ref_type_id, cat_id, name_id, 0, 0, 0}));
+      kNestableSlices, storage->mutable_slice_table()->Insert(
+                           {0, 0, track, cat_id, name_id, 0, 0, 0}));
 
   auto add_arg = [&](const char* key, Variadic value) {
     StringId key_id = storage->InternString(key);
@@ -507,10 +494,8 @@
   context_.args_tracker->Flush();  // Flush track args.
   StringId cat_id = context_.storage->InternString(base::StringView(kCategory));
   StringId name_id = context_.storage->InternString(base::StringView(kName));
-  StringId ref_type_id = context_.storage->InternString(
-      GetRefTypeStringMap()[static_cast<uint32_t>(RefType::kRefUtid)]);
   context_.storage->mutable_slice_table()->Insert(
-      {0, 0, track, utid, ref_type_id, cat_id, name_id, 0, 0, 0});
+      {0, 0, track, cat_id, name_id, 0, 0, 0});
 
   StringId arg_flat_key_id = context_.storage->InternString(
       base::StringView("debug.draw_duration_ms"));
@@ -559,10 +544,8 @@
   context_.args_tracker->Flush();  // Flush track args.
   StringId cat_id = context_.storage->InternString(base::StringView(kCategory));
   StringId name_id = context_.storage->InternString(base::StringView(kName));
-  StringId ref_type_id = context_.storage->InternString(
-      GetRefTypeStringMap()[static_cast<uint32_t>(RefType::kRefUtid)]);
   context_.storage->mutable_slice_table()->Insert(
-      {0, 0, track, utid, ref_type_id, cat_id, name_id, 0, 0, 0});
+      {0, 0, track, cat_id, name_id, 0, 0, 0});
 
   StringId arg_key0_id =
       context_.storage->InternString(base::StringView("arg0"));
@@ -607,10 +590,8 @@
   context_.args_tracker->Flush();  // Flush track args.
   StringId cat_id = context_.storage->InternString(base::StringView(kCategory));
   StringId name_id = context_.storage->InternString(base::StringView(kName));
-  StringId ref_type_id = context_.storage->InternString(
-      GetRefTypeStringMap()[static_cast<uint32_t>(RefType::kRefUtid)]);
   context_.storage->mutable_slice_table()->Insert(
-      {0, 0, track, utid, ref_type_id, cat_id, name_id, 0, 0, 0});
+      {0, 0, track, cat_id, name_id, 0, 0, 0});
 
   StringId arg_flat_key_id =
       context_.storage->InternString(base::StringView("a.b"));
@@ -658,10 +639,8 @@
   context_.args_tracker->Flush();  // Flush track args.
   StringId cat_id = context_.storage->InternString(base::StringView(kCategory));
   StringId name_id = context_.storage->InternString(base::StringView(kName));
-  StringId ref_type_id = context_.storage->InternString(
-      GetRefTypeStringMap()[static_cast<uint32_t>(RefType::kRefUtid)]);
   context_.storage->mutable_slice_table()->Insert(
-      {0, 0, track, utid, ref_type_id, cat_id, name_id, 0, 0, 0});
+      {0, 0, track, cat_id, name_id, 0, 0, 0});
 
   StringId arg_flat_key_id =
       context_.storage->InternString(base::StringView("a"));
@@ -709,10 +688,8 @@
   context_.args_tracker->Flush();  // Flush track args.
   StringId cat_id = context_.storage->InternString(base::StringView(kCategory));
   StringId name_id = context_.storage->InternString(base::StringView(kName));
-  StringId ref_type_id = context_.storage->InternString(
-      GetRefTypeStringMap()[static_cast<uint32_t>(RefType::kRefUtid)]);
   context_.storage->mutable_slice_table()->Insert(
-      {0, 0, track, utid, ref_type_id, cat_id, name_id, 0, 0, 0});
+      {0, 0, track, cat_id, name_id, 0, 0, 0});
 
   StringId arg_key_id = context_.storage->InternString(base::StringView("a"));
   StringId arg_value_id =
@@ -749,9 +726,8 @@
   context_.args_tracker->Flush();  // Flush track args.
   StringId cat_id = context_.storage->InternString(base::StringView(kCategory));
   StringId name_id = context_.storage->InternString(base::StringView(kName));
-  StringId ref_type_id = context_.storage->InternString(base::StringView());
   context_.storage->mutable_slice_table()->Insert(
-      {kTimestamp, 0, track, 0, ref_type_id, cat_id, name_id, 0, 0, 0});
+      {kTimestamp, 0, track, cat_id, name_id, 0, 0, 0});
 
   base::TempFile temp_file = base::TempFile::Create();
   FILE* output = fopen(temp_file.path().c_str(), "w+");
@@ -782,10 +758,8 @@
   context_.args_tracker->Flush();  // Flush track args.
   StringId cat_id = context_.storage->InternString(base::StringView(kCategory));
   StringId name_id = context_.storage->InternString(base::StringView(kName));
-  StringId ref_type_id = context_.storage->InternString(
-      GetRefTypeStringMap()[static_cast<uint32_t>(RefType::kRefUtid)]);
   context_.storage->mutable_slice_table()->Insert(
-      {kTimestamp, 0, track, utid, ref_type_id, cat_id, name_id, 0, 0, 0});
+      {kTimestamp, 0, track, cat_id, name_id, 0, 0, 0});
 
   base::TempFile temp_file = base::TempFile::Create();
   FILE* output = fopen(temp_file.path().c_str(), "w+");
@@ -817,8 +791,6 @@
   UniquePid upid = context_.storage->AddEmptyProcess(kProcessID);
   StringId cat_id = context_.storage->InternString(base::StringView(kCategory));
   StringId name_id = context_.storage->InternString(base::StringView(kName));
-  StringId ref_type_id = context_.storage->InternString(
-      GetRefTypeStringMap()[static_cast<uint32_t>(RefType::kRefTrack)]);
 
   constexpr int64_t kSourceId = 235;
   TrackId track = context_.track_tracker->InternLegacyChromeAsyncTrack(
@@ -826,9 +798,8 @@
       /*source_scope=*/0);
   context_.args_tracker->Flush();  // Flush track args.
 
-  context_.storage->mutable_slice_table()->Insert({kTimestamp, kDuration, track,
-                                                   track, ref_type_id, cat_id,
-                                                   name_id, 0, 0, 0});
+  context_.storage->mutable_slice_table()->Insert(
+      {kTimestamp, kDuration, track, cat_id, name_id, 0, 0, 0});
   StringId arg_key_id =
       context_.storage->InternString(base::StringView(kArgName));
   TraceStorage::Args::Arg arg;
@@ -883,8 +854,6 @@
   UniquePid upid = context_.storage->AddEmptyProcess(kProcessID);
   StringId cat_id = context_.storage->InternString(base::StringView(kCategory));
   StringId name_id = context_.storage->InternString(base::StringView(kName));
-  StringId ref_type_id = context_.storage->InternString(
-      GetRefTypeStringMap()[static_cast<uint32_t>(RefType::kRefTrack)]);
 
   constexpr int64_t kSourceId = 235;
   TrackId track = context_.track_tracker->InternLegacyChromeAsyncTrack(
@@ -893,8 +862,7 @@
   context_.args_tracker->Flush();  // Flush track args.
 
   auto slice_id = context_.storage->mutable_slice_table()->Insert(
-      {kTimestamp, kDuration, track, track, ref_type_id, cat_id, name_id, 0, 0,
-       0});
+      {kTimestamp, kDuration, track, cat_id, name_id, 0, 0, 0});
   context_.storage->mutable_virtual_track_slices()->AddVirtualTrackSlice(
       slice_id, kThreadTimestamp, kThreadDuration, 0, 0);
 
@@ -941,8 +909,6 @@
   UniquePid upid = context_.storage->AddEmptyProcess(kProcessID);
   StringId cat_id = context_.storage->InternString(base::StringView(kCategory));
   StringId name_id = context_.storage->InternString(base::StringView(kName));
-  StringId ref_type_id = context_.storage->InternString(
-      GetRefTypeStringMap()[static_cast<uint32_t>(RefType::kRefTrack)]);
 
   constexpr int64_t kSourceId = 235;
   TrackId track = context_.track_tracker->InternLegacyChromeAsyncTrack(
@@ -951,8 +917,7 @@
   context_.args_tracker->Flush();  // Flush track args.
 
   auto slice_id = context_.storage->mutable_slice_table()->Insert(
-      {kTimestamp, kDuration, track, track, ref_type_id, cat_id, name_id, 0, 0,
-       0});
+      {kTimestamp, kDuration, track, cat_id, name_id, 0, 0, 0});
   context_.storage->mutable_virtual_track_slices()->AddVirtualTrackSlice(
       slice_id, kThreadTimestamp, kThreadDuration, 0, 0);
 
@@ -987,8 +952,6 @@
   UniquePid upid = context_.storage->AddEmptyProcess(kProcessID);
   StringId cat_id = context_.storage->InternString(base::StringView(kCategory));
   StringId name_id = context_.storage->InternString(base::StringView(kName));
-  StringId ref_type_id = context_.storage->InternString(
-      GetRefTypeStringMap()[static_cast<uint32_t>(RefType::kRefTrack)]);
 
   constexpr int64_t kSourceId = 235;
   TrackId track = context_.track_tracker->InternLegacyChromeAsyncTrack(
@@ -997,7 +960,7 @@
   context_.args_tracker->Flush();  // Flush track args.
 
   context_.storage->mutable_slice_table()->Insert(
-      {kTimestamp, 0, track, track, ref_type_id, cat_id, name_id, 0, 0, 0});
+      {kTimestamp, 0, track, cat_id, name_id, 0, 0, 0});
   StringId arg_key_id =
       context_.storage->InternString(base::StringView("arg_name"));
   TraceStorage::Args::Arg arg;
@@ -1250,15 +1213,12 @@
   StringId arg1_id = context_.storage->InternString(base::StringView("arg1"));
   StringId arg2_id = context_.storage->InternString(base::StringView("arg2"));
   StringId val_id = context_.storage->InternString(base::StringView("val"));
-  StringId ref_type_id = context_.storage->InternString(
-      GetRefTypeStringMap()[static_cast<uint32_t>(RefType::kRefUtid)]);
 
   std::array<RowId, 3> slice_ids;
   for (size_t i = 0; i < name_ids.size(); i++) {
     slice_ids[i] = TraceStorage::CreateRowId(
-        kNestableSlices,
-        context_.storage->mutable_slice_table()->Insert(
-            {0, 0, track, utid, ref_type_id, cat_id, name_ids[i], 0, 0, 0}));
+        kNestableSlices, context_.storage->mutable_slice_table()->Insert(
+                             {0, 0, track, cat_id, name_ids[i], 0, 0, 0}));
   }
 
   for (RowId row : slice_ids) {
@@ -1358,15 +1318,11 @@
   context_.args_tracker->Flush();  // Flush track args.
   StringId cat_id = context_.storage->InternString(base::StringView(kCategory));
   StringId name_id = context_.storage->InternString(base::StringView(kName));
-  StringId ref_type_id = context_.storage->InternString(
-      GetRefTypeStringMap()[static_cast<uint32_t>(RefType::kRefUtid)]);
 
-  context_.storage->mutable_slice_table()->Insert({kTimestamp1, kDuration,
-                                                   track, utid, ref_type_id,
-                                                   cat_id, name_id, 0, 0, 0});
-  context_.storage->mutable_slice_table()->Insert({kTimestamp2, kDuration,
-                                                   track, utid, ref_type_id,
-                                                   cat_id, name_id, 0, 0, 0});
+  context_.storage->mutable_slice_table()->Insert(
+      {kTimestamp1, kDuration, track, cat_id, name_id, 0, 0, 0});
+  context_.storage->mutable_slice_table()->Insert(
+      {kTimestamp2, kDuration, track, cat_id, name_id, 0, 0, 0});
 
   auto label_filter = [](const char* label_name) {
     return strcmp(label_name, "traceEvents") == 0;
diff --git a/src/trace_processor/importers/fuchsia/fuchsia_trace_parser.cc b/src/trace_processor/importers/fuchsia/fuchsia_trace_parser.cc
index a362d8e..ad98daf 100644
--- a/src/trace_processor/importers/fuchsia/fuchsia_trace_parser.cc
+++ b/src/trace_processor/importers/fuchsia/fuchsia_trace_parser.cc
@@ -319,7 +319,7 @@
               procs->UpdateThread(static_cast<uint32_t>(tinfo.tid),
                                   static_cast<uint32_t>(tinfo.pid));
           TrackId track_id = context_->track_tracker->InternThreadTrack(utid);
-          slices->Begin(ts, track_id, utid, RefType::kRefUtid, cat, name);
+          slices->Begin(ts, track_id, cat, name);
           break;
         }
         case kDurationEnd: {
@@ -349,8 +349,7 @@
               procs->UpdateThread(static_cast<uint32_t>(tinfo.tid),
                                   static_cast<uint32_t>(tinfo.pid));
           TrackId track_id = context_->track_tracker->InternThreadTrack(utid);
-          slices->Scoped(ts, track_id, utid, RefType::kRefUtid, cat, name,
-                         duration);
+          slices->Scoped(ts, track_id, cat, name, duration);
           break;
         }
         case kAsyncBegin: {
@@ -361,7 +360,7 @@
           }
           TrackId track_id = context_->track_tracker->InternFuchsiaAsyncTrack(
               name, correlation_id);
-          slices->Begin(ts, track_id, track_id, RefType::kRefTrack, cat, name);
+          slices->Begin(ts, track_id, cat, name);
           break;
         }
         case kAsyncInstant: {
diff --git a/src/trace_processor/importers/json/json_trace_parser.cc b/src/trace_processor/importers/json/json_trace_parser.cc
index e4a7ea1..7a59c63 100644
--- a/src/trace_processor/importers/json/json_trace_parser.cc
+++ b/src/trace_processor/importers/json/json_trace_parser.cc
@@ -89,8 +89,7 @@
   switch (phase) {
     case 'B': {  // TRACE_EVENT_BEGIN.
       TrackId track_id = context_->track_tracker->InternThreadTrack(utid);
-      slice_tracker->Begin(timestamp, track_id, utid, RefType::kRefUtid, cat_id,
-                           name_id);
+      slice_tracker->Begin(timestamp, track_id, cat_id, name_id);
       break;
     }
     case 'E': {  // TRACE_EVENT_END.
@@ -104,8 +103,8 @@
       if (!opt_dur.has_value())
         return;
       TrackId track_id = context_->track_tracker->InternThreadTrack(utid);
-      slice_tracker->Scoped(timestamp, track_id, utid, RefType::kRefUtid,
-                            cat_id, name_id, opt_dur.value());
+      slice_tracker->Scoped(timestamp, track_id, cat_id, name_id,
+                            opt_dur.value());
       break;
     }
     case 'M': {  // Metadata events (process and thread names).
diff --git a/src/trace_processor/importers/proto/graphics_event_parser.cc b/src/trace_processor/importers/proto/graphics_event_parser.cc
index fff48ed..066f5d6 100644
--- a/src/trace_processor/importers/proto/graphics_event_parser.cc
+++ b/src/trace_processor/importers/proto/graphics_event_parser.cc
@@ -250,7 +250,7 @@
     TrackId track_id =
         gpu_hw_queue_ids_[static_cast<size_t>(event.hw_queue_id())];
     const auto slice_id = context_->slice_tracker->Scoped(
-        ts, track_id, track_id, RefType::kRefTrack, 0 /* cat */, stage_name,
+        ts, track_id, 0 /* cat */, stage_name,
         static_cast<int64_t>(event.duration()), args_callback);
 
     context_->storage->mutable_gpu_slice_table()->Insert(
@@ -326,8 +326,7 @@
   TrackId track_id = context_->track_tracker->InternGpuTrack(track);
 
   const auto slice_id = context_->slice_tracker->Scoped(
-      timestamp, track_id, track_id, RefType::kRefTrack, 0 /* cat */,
-      event_name_id, duration,
+      timestamp, track_id, 0 /* cat */, event_name_id, duration,
       [this, layer_name_id](ArgsTracker* args_tracker, RowId row_id) {
         args_tracker->AddArg(row_id, layer_name_key_id_, layer_name_key_id_,
                              Variadic::String(layer_name_id));
@@ -400,8 +399,7 @@
       present_event_name_id_ =
           context_->storage->InternString(present_frame_name_.GetStringView());
       const auto present_slice_id = context_->slice_tracker->Begin(
-          timestamp, present_track_id_, present_track_id_, RefType::kRefTrack,
-          0 /* cat */, present_event_name_id_);
+          timestamp, present_track_id_, 0 /* cat */, present_event_name_id_);
 
       if (present_slice_id) {
         tables::GpuSliceTable::Row row;
@@ -623,8 +621,7 @@
           ? log_severity_ids_[static_cast<size_t>(event.severity())]
           : log_severity_ids_[log_severity_ids_.size() - 1];
   const auto slice_id = context_->slice_tracker->Scoped(
-      ts, track_id, track_id, RefType::kRefTrack, 0 /* cat */, severity_id,
-      0 /* duration */, args_callback);
+      ts, track_id, 0 /* cat */, severity_id, 0 /* duration */, args_callback);
 
   tables::GpuSliceTable::Row row;
   row.slice_id = slice_id.value();
diff --git a/src/trace_processor/importers/proto/proto_trace_parser.cc b/src/trace_processor/importers/proto/proto_trace_parser.cc
index e6d3e35..29551e9 100644
--- a/src/trace_processor/importers/proto/proto_trace_parser.cc
+++ b/src/trace_processor/importers/proto/proto_trace_parser.cc
@@ -570,8 +570,8 @@
       name_id = context_->storage->InternString(fallback);
     }
     TrackId track_id = context_->track_tracker->InternThreadTrack(utid);
-    context_->slice_tracker->Scoped(ts, track_id, utid, RefType::kRefUtid,
-                                    cat_id, name_id, event.event_duration_ns());
+    context_->slice_tracker->Scoped(ts, track_id, cat_id, name_id,
+                                    event.event_duration_ns());
   } else if (event.has_counter_id()) {
     auto cid = event.counter_id();
     if (cid < metatrace::COUNTERS_MAX) {
diff --git a/src/trace_processor/importers/proto/proto_trace_parser_unittest.cc b/src/trace_processor/importers/proto/proto_trace_parser_unittest.cc
index 23a1f68..4d9150d 100644
--- a/src/trace_processor/importers/proto/proto_trace_parser_unittest.cc
+++ b/src/trace_processor/importers/proto/proto_trace_parser_unittest.cc
@@ -208,11 +208,9 @@
  public:
   MockSliceTracker(TraceProcessorContext* context) : SliceTracker(context) {}
 
-  MOCK_METHOD7(Begin,
+  MOCK_METHOD5(Begin,
                base::Optional<uint32_t>(int64_t timestamp,
                                         TrackId track_id,
-                                        int64_t ref,
-                                        RefType ref_type,
                                         StringId cat,
                                         StringId name,
                                         SetArgsCallback args_callback));
@@ -222,11 +220,9 @@
                                         StringId cat,
                                         StringId name,
                                         SetArgsCallback args_callback));
-  MOCK_METHOD8(Scoped,
+  MOCK_METHOD6(Scoped,
                base::Optional<uint32_t>(int64_t timestamp,
                                         TrackId track_id,
-                                        int64_t ref,
-                                        RefType ref_type,
                                         StringId cat,
                                         StringId name,
                                         int64_t duration,
@@ -816,16 +812,15 @@
 
   constexpr TrackId track = 0u;
   InSequence in_sequence;  // Below slices should be sorted by timestamp.
-  EXPECT_CALL(*slice_, Scoped(1005000, track, 1, RefType::kRefUtid,
-                              kNullStringId, kNullStringId, 23000, _))
+  EXPECT_CALL(*slice_,
+              Scoped(1005000, track, kNullStringId, kNullStringId, 23000, _))
       .WillOnce(DoAll(
-          InvokeArgument<7>(
+          InvokeArgument<5>(
               &args, TraceStorage::CreateRowId(TableId::kNestableSlices, 0u)),
           Return(0u)));
-  EXPECT_CALL(*slice_, Begin(1010000, track, 1, RefType::kRefUtid,
-                             kNullStringId, kNullStringId, _))
+  EXPECT_CALL(*slice_, Begin(1010000, track, kNullStringId, kNullStringId, _))
       .WillOnce(DoAll(
-          InvokeArgument<6>(
+          InvokeArgument<4>(
               &args, TraceStorage::CreateRowId(TableId::kNestableSlices, 1u)),
           Return(1u)));
   EXPECT_CALL(*slice_, End(1020000, track, kNullStringId, kNullStringId, _))
@@ -909,16 +904,15 @@
 
   constexpr TrackId track = 0u;
   InSequence in_sequence;  // Below slices should be sorted by timestamp.
-  EXPECT_CALL(*slice_, Begin(1010000, track, 1, RefType::kRefUtid,
-                             kNullStringId, kNullStringId, _))
+  EXPECT_CALL(*slice_, Begin(1010000, track, kNullStringId, kNullStringId, _))
       .WillOnce(DoAll(
-          InvokeArgument<6>(
+          InvokeArgument<4>(
               &args, TraceStorage::CreateRowId(TableId::kNestableSlices, 0u)),
           Return(0u)));
-  EXPECT_CALL(*slice_, Scoped(1015000, track, 1, RefType::kRefUtid,
-                              kNullStringId, kNullStringId, 0, _))
+  EXPECT_CALL(*slice_,
+              Scoped(1015000, track, kNullStringId, kNullStringId, 0, _))
       .WillOnce(DoAll(
-          InvokeArgument<7>(
+          InvokeArgument<5>(
               &args, TraceStorage::CreateRowId(TableId::kNestableSlices, 1u)),
           Return(1u)));
   EXPECT_CALL(*slice_, End(1020000, track, kNullStringId, kNullStringId, _))
@@ -1070,19 +1064,19 @@
 
   RowId first_slice_row_id =
       TraceStorage::CreateRowId(TableId::kNestableSlices, 0u);
-  EXPECT_CALL(*slice_, Scoped(1005000, thread_1_track, 1, RefType::kRefUtid,
-                              StringId(1), StringId(2), 23000, _))
+  EXPECT_CALL(*slice_, Scoped(1005000, thread_1_track, StringId(1), StringId(2),
+                              23000, _))
       .WillOnce(
-          DoAll(InvokeArgument<7>(&args, first_slice_row_id), Return(0u)));
+          DoAll(InvokeArgument<5>(&args, first_slice_row_id), Return(0u)));
   EXPECT_CALL(
       args, AddArg(first_slice_row_id, _, _, Variadic::UnsignedInteger(9999u)));
   EXPECT_CALL(args, AddArg(first_slice_row_id, _, _, Variadic::Boolean(true)));
   EXPECT_CALL(args, AddArg(first_slice_row_id, _, _, _));
 
-  EXPECT_CALL(*slice_, Begin(1010000, thread_1_track, 1, RefType::kRefUtid,
-                             StringId(3), StringId(4), _))
+  EXPECT_CALL(*slice_,
+              Begin(1010000, thread_1_track, StringId(3), StringId(4), _))
       .WillOnce(DoAll(
-          InvokeArgument<6>(
+          InvokeArgument<4>(
               &args, TraceStorage::CreateRowId(TableId::kNestableSlices, 1u)),
           Return(1u)));
 
@@ -1093,18 +1087,18 @@
               &args, TraceStorage::CreateRowId(TableId::kNestableSlices, 1u)),
           Return(1u)));
 
-  EXPECT_CALL(*slice_, Scoped(1040000, thread_1_track, 1, RefType::kRefUtid,
-                              StringId(3), StringId(4), 0, _))
+  EXPECT_CALL(*slice_,
+              Scoped(1040000, thread_1_track, StringId(3), StringId(4), 0, _))
       .WillOnce(DoAll(
-          InvokeArgument<7>(
+          InvokeArgument<5>(
               &args, TraceStorage::CreateRowId(TableId::kNestableSlices, 2u)),
           Return(2u)));
 
   RowId last_slice_row_id =
       TraceStorage::CreateRowId(TableId::kNestableSlices, 3u);
-  EXPECT_CALL(*slice_, Scoped(1050000, process_2_track, 2, RefType::kRefUpid,
-                              StringId(3), StringId(4), 0, _))
-      .WillOnce(DoAll(InvokeArgument<7>(&args, last_slice_row_id), Return(3u)));
+  EXPECT_CALL(*slice_,
+              Scoped(1050000, process_2_track, StringId(3), StringId(4), 0, _))
+      .WillOnce(DoAll(InvokeArgument<5>(&args, last_slice_row_id), Return(3u)));
   // Second slice should have a legacy_event.original_tid arg.
   EXPECT_CALL(args, AddArg(last_slice_row_id, _, _, Variadic::Integer(16)));
 
@@ -1249,17 +1243,13 @@
 
   InSequence in_sequence;  // Below slices should be sorted by timestamp.
 
-  EXPECT_CALL(*slice_, Begin(1010000, 1, 1, RefType::kRefTrack, StringId(1),
-                             StringId(2), _))
+  EXPECT_CALL(*slice_, Begin(1010000, 1, StringId(1), StringId(2), _))
       .WillOnce(Return(0u));
-  EXPECT_CALL(*slice_, Scoped(1015000, 1, 1, RefType::kRefTrack, StringId(1),
-                              StringId(4), 0, _));
-  EXPECT_CALL(*slice_, Scoped(1018000, 2, 2, RefType::kRefTrack, StringId(3),
-                              StringId(4), 0, _));
+  EXPECT_CALL(*slice_, Scoped(1015000, 1, StringId(1), StringId(4), 0, _));
+  EXPECT_CALL(*slice_, Scoped(1018000, 2, StringId(3), StringId(4), 0, _));
   EXPECT_CALL(*slice_, End(1020000, 1, StringId(1), StringId(2), _))
       .WillOnce(Return(0u));
-  EXPECT_CALL(*slice_, Scoped(1030000, 3, 3, RefType::kRefTrack, StringId(3),
-                              StringId(4), 0, _));
+  EXPECT_CALL(*slice_, Scoped(1030000, 3, StringId(3), StringId(4), 0, _));
 
   context_.sorter->ExtractEventsForced();
 
@@ -1443,24 +1433,21 @@
       .WillOnce(Return(1));
   EXPECT_CALL(*storage_, InternString(base::StringView("ev1")))
       .WillOnce(Return(2));
-  EXPECT_CALL(*slice_, Begin(1010000, 1, 1, RefType::kRefTrack, StringId(1),
-                             StringId(2), _))
+  EXPECT_CALL(*slice_, Begin(1010000, 1, StringId(1), StringId(2), _))
       .WillOnce(Return(0u));
 
   EXPECT_CALL(*storage_, InternString(base::StringView("cat2")))
       .WillOnce(Return(3));
   EXPECT_CALL(*storage_, InternString(base::StringView("ev2")))
       .WillOnce(Return(4));
-  EXPECT_CALL(*slice_, Scoped(1015000, 0, 1, RefType::kRefUtid, StringId(3),
-                              StringId(4), 0, _))
+  EXPECT_CALL(*slice_, Scoped(1015000, 0, StringId(3), StringId(4), 0, _))
       .WillOnce(Return(1u));
 
   EXPECT_CALL(*storage_, InternString(base::StringView("cat3")))
       .WillOnce(Return(5));
   EXPECT_CALL(*storage_, InternString(base::StringView("ev3")))
       .WillOnce(Return(6));
-  EXPECT_CALL(*slice_, Scoped(1016000, 2, 2, RefType::kRefUtid, StringId(5),
-                              StringId(6), 0, _))
+  EXPECT_CALL(*slice_, Scoped(1016000, 2, StringId(5), StringId(6), 0, _))
       .WillOnce(Return(2u));
 
   EXPECT_CALL(*slice_, End(1020000, 1, StringId(0), StringId(0), _))
@@ -1522,7 +1509,7 @@
 
   Tokenize();
 
-  EXPECT_CALL(*slice_, Begin(_, _, _, _, _, _, _)).Times(0);
+  EXPECT_CALL(*slice_, Begin(_, _, _, _, _)).Times(0);
   context_.sorter->ExtractEventsForced();
 }
 
@@ -1546,7 +1533,7 @@
 
   Tokenize();
 
-  EXPECT_CALL(*slice_, Begin(_, _, _, _, _, _, _)).Times(0);
+  EXPECT_CALL(*slice_, Begin(_, _, _, _, _)).Times(0);
   context_.sorter->ExtractEventsForced();
 }
 
@@ -1648,8 +1635,7 @@
 
   constexpr TrackId track = 0u;
   InSequence in_sequence;  // Below slices should be sorted by timestamp.
-  EXPECT_CALL(*slice_, Begin(1010000, track, 1, RefType::kRefUtid,
-                             kNullStringId, kNullStringId, _));
+  EXPECT_CALL(*slice_, Begin(1010000, track, kNullStringId, kNullStringId, _));
   EXPECT_CALL(*slice_, End(2010000, track, kNullStringId, kNullStringId, _));
 
   context_.sorter->ExtractEventsForced();
@@ -1772,10 +1758,10 @@
   constexpr TrackId thread_1_track = 1u;
   InSequence in_sequence;  // Below slices should be sorted by timestamp.
 
-  EXPECT_CALL(*slice_, Begin(1005000, thread_2_track, 2, RefType::kRefUtid,
-                             StringId(1), StringId(2), _));
-  EXPECT_CALL(*slice_, Begin(1010000, thread_1_track, 1, RefType::kRefUtid,
-                             StringId(1), StringId(3), _));
+  EXPECT_CALL(*slice_,
+              Begin(1005000, thread_2_track, StringId(1), StringId(2), _));
+  EXPECT_CALL(*slice_,
+              Begin(1010000, thread_1_track, StringId(1), StringId(3), _));
   EXPECT_CALL(*slice_,
               End(1015000, thread_2_track, StringId(1), StringId(2), _));
   EXPECT_CALL(*slice_,
@@ -1956,9 +1942,8 @@
   constexpr TrackId track = 0u;
   InSequence in_sequence;  // Below slices should be sorted by timestamp.
 
-  EXPECT_CALL(*slice_, Begin(1010000, track, 1, RefType::kRefUtid, StringId(1),
-                             StringId(2), _))
-      .WillOnce(DoAll(InvokeArgument<6>(&args, 1u), Return(1u)));
+  EXPECT_CALL(*slice_, Begin(1010000, track, StringId(1), StringId(2), _))
+      .WillOnce(DoAll(InvokeArgument<4>(&args, 1u), Return(1u)));
   EXPECT_CALL(args, AddArg(1u, StringId(3), StringId(3),
                            Variadic::UnsignedInteger(10u)));
 
@@ -2048,9 +2033,8 @@
       .WillOnce(Return(1));
   EXPECT_CALL(*storage_, InternString(base::StringView("ev1")))
       .WillOnce(Return(2));
-  EXPECT_CALL(*slice_, Begin(1010000, track, 1, RefType::kRefUtid, StringId(1),
-                             StringId(2), _))
-      .WillOnce(DoAll(InvokeArgument<6>(&args, 1u), Return(1u)));
+  EXPECT_CALL(*slice_, Begin(1010000, track, StringId(1), StringId(2), _))
+      .WillOnce(DoAll(InvokeArgument<4>(&args, 1u), Return(1u)));
   EXPECT_CALL(*storage_, InternString(base::StringView("file1")))
       .WillOnce(Return(3));
   EXPECT_CALL(*storage_, InternString(base::StringView("func1")))
@@ -2129,9 +2113,8 @@
   EXPECT_CALL(*storage_, InternString(base::StringView("ev1")))
       .WillOnce(Return(2));
 
-  EXPECT_CALL(*slice_, Scoped(1010000, track, 1, RefType::kRefUtid, StringId(1),
-                              StringId(2), 0, _))
-      .WillOnce(DoAll(InvokeArgument<7>(&args, 1u), Return(1u)));
+  EXPECT_CALL(*slice_, Scoped(1010000, track, StringId(1), StringId(2), 0, _))
+      .WillOnce(DoAll(InvokeArgument<5>(&args, 1u), Return(1u)));
 
   EXPECT_CALL(*storage_, InternString(base::StringView("body1")))
       .WillOnce(Return(3));
@@ -2306,8 +2289,7 @@
   InSequence in_sequence;  // Below slices should be sorted by timestamp.
 
   // Timestamp should be adjusted to trace time (BOOTTIME).
-  EXPECT_CALL(*slice_, Begin(10000, track, 1, RefType::kRefUtid, kNullStringId,
-                             kNullStringId, _));
+  EXPECT_CALL(*slice_, Begin(10000, track, kNullStringId, kNullStringId, _));
 
   context_.sorter->ExtractEventsForced();
 }
diff --git a/src/trace_processor/importers/proto/track_event_parser.cc b/src/trace_processor/importers/proto/track_event_parser.cc
index 9f0560f..85507b3 100644
--- a/src/trace_processor/importers/proto/track_event_parser.cc
+++ b/src/trace_processor/importers/proto/track_event_parser.cc
@@ -522,9 +522,8 @@
         return;
       }
 
-      auto opt_slice_id =
-          slice_tracker->Begin(ts, track_id, *utid, RefType::kRefUtid,
-                               category_id, name_id, args_callback);
+      auto opt_slice_id = slice_tracker->Begin(ts, track_id, category_id,
+                                               name_id, args_callback);
       if (opt_slice_id.has_value()) {
         auto* thread_slices = storage->mutable_thread_slices();
         PERFETTO_DCHECK(!thread_slices->slice_count() ||
@@ -563,8 +562,7 @@
       if (duration_ns < 0)
         return;
       auto opt_slice_id = slice_tracker->Scoped(
-          ts, track_id, *utid, RefType::kRefUtid, category_id, name_id,
-          duration_ns, args_callback);
+          ts, track_id, category_id, name_id, duration_ns, args_callback);
       if (opt_slice_id.has_value()) {
         auto* thread_slices = storage->mutable_thread_slices();
         PERFETTO_DCHECK(!thread_slices->slice_count() ||
@@ -587,10 +585,8 @@
       switch (legacy_event.instant_event_scope()) {
         case LegacyEvent::SCOPE_UNSPECIFIED:
         case LegacyEvent::SCOPE_THREAD: {
-          // TODO(lalitm): Associate thread slices with track instead.
           auto opt_slice_id = slice_tracker->Scoped(
-              ts, track_id, *utid, RefType::kRefUtid, category_id, name_id,
-              duration_ns, args_callback);
+              ts, track_id, category_id, name_id, duration_ns, args_callback);
           if (opt_slice_id.has_value()) {
             auto* thread_slices = storage->mutable_thread_slices();
             PERFETTO_DCHECK(!thread_slices->slice_count() ||
@@ -602,14 +598,12 @@
           break;
         }
         case LegacyEvent::SCOPE_GLOBAL: {
-          slice_tracker->Scoped(ts, track_id, /*ref=*/0, RefType::kRefNoRef,
-                                category_id, name_id, duration_ns,
+          slice_tracker->Scoped(ts, track_id, category_id, name_id, duration_ns,
                                 args_callback);
           break;
         }
         case LegacyEvent::SCOPE_PROCESS: {
-          slice_tracker->Scoped(ts, track_id, *upid, RefType::kRefUpid,
-                                category_id, name_id, duration_ns,
+          slice_tracker->Scoped(ts, track_id, category_id, name_id, duration_ns,
                                 args_callback);
           break;
         }
@@ -622,9 +616,8 @@
       break;
     }
     case 'b': {  // TRACE_EVENT_PHASE_NESTABLE_ASYNC_BEGIN
-      auto opt_slice_id =
-          slice_tracker->Begin(ts, track_id, track_id, RefType::kRefTrack,
-                               category_id, name_id, args_callback);
+      auto opt_slice_id = slice_tracker->Begin(ts, track_id, category_id,
+                                               name_id, args_callback);
       // For the time beeing, we only create vtrack slice rows if we need to
       // store thread timestamps/counters.
       if (legacy_event.use_async_tts() && opt_slice_id.has_value()) {
@@ -654,8 +647,7 @@
       int64_t duration_ns = 0;
       int64_t tidelta = 0;
       auto opt_slice_id = slice_tracker->Scoped(
-          ts, track_id, track_id, RefType::kRefTrack, category_id, name_id,
-          duration_ns, args_callback);
+          ts, track_id, category_id, name_id, duration_ns, args_callback);
       if (legacy_event.use_async_tts() && opt_slice_id.has_value()) {
         auto* vtrack_slices = storage->mutable_virtual_track_slices();
         PERFETTO_DCHECK(!vtrack_slices->slice_count() ||
diff --git a/src/trace_processor/importers/systrace/systrace_parser.cc b/src/trace_processor/importers/systrace/systrace_parser.cc
index 66dc3e7..3063411 100644
--- a/src/trace_processor/importers/systrace/systrace_parser.cc
+++ b/src/trace_processor/importers/systrace/systrace_parser.cc
@@ -103,8 +103,7 @@
       StringId name_id = context_->storage->InternString(point.name);
       UniqueTid utid = context_->process_tracker->UpdateThread(pid, point.tgid);
       TrackId track_id = context_->track_tracker->InternThreadTrack(utid);
-      context_->slice_tracker->Begin(ts, track_id, utid, RefType::kRefUtid,
-                                     0 /* cat */, name_id);
+      context_->slice_tracker->Begin(ts, track_id, 0 /* cat */, name_id);
       break;
     }
 
@@ -137,8 +136,7 @@
       TrackId track_id = context_->track_tracker->InternAndroidAsyncTrack(
           name_id, upid, cookie);
       if (point.phase == 'S') {
-        context_->slice_tracker->Begin(ts, track_id, track_id,
-                                       RefType::kRefTrack, 0, name_id);
+        context_->slice_tracker->Begin(ts, track_id, 0, name_id);
       } else {
         context_->slice_tracker->End(ts, track_id);
       }
diff --git a/src/trace_processor/metrics/android/android_startup.sql b/src/trace_processor/metrics/android/android_startup.sql
index f1484e4..142d142 100644
--- a/src/trace_processor/metrics/android/android_startup.sql
+++ b/src/trace_processor/metrics/android/android_startup.sql
@@ -22,20 +22,20 @@
 -- Slices for forked processes. Never present in hot starts.
 -- Prefer this over process start_ts, since the process might have
 -- been preforked.
-CREATE VIEW zygote_fork_slices AS
-SELECT slices.ts, slices.dur, STR_SPLIT(slices.name, ": ", 1) AS process_name
-FROM slices WHERE name LIKE 'Start proc: %';
+CREATE VIEW zygote_fork_slice AS
+SELECT slice.ts, slice.dur, STR_SPLIT(slice.name, ": ", 1) AS process_name
+FROM slice WHERE name LIKE 'Start proc: %';
 
 CREATE TABLE zygote_forks_by_id AS
 SELECT
   launches.id,
-  zygote_fork_slices.ts,
-  zygote_fork_slices.dur
-FROM zygote_fork_slices
+  zygote_fork_slice.ts,
+  zygote_fork_slice.dur
+FROM zygote_fork_slice
 JOIN launches
-ON (launches.ts < zygote_fork_slices.ts
-    AND zygote_fork_slices.ts + zygote_fork_slices.dur < launches.ts_end
-    AND zygote_fork_slices.process_name = launches.package
+ON (launches.ts < zygote_fork_slice.ts
+    AND zygote_fork_slice.ts + zygote_fork_slice.dur < launches.ts_end
+    AND zygote_fork_slice.process_name = launches.package
 );
 
 CREATE VIEW launch_main_threads AS
@@ -61,18 +61,19 @@
 GROUP BY 1, 2;
 
 -- Tracks all slices for the main process threads
-CREATE TABLE main_process_slices AS
+CREATE TABLE main_process_slice AS
 SELECT
   launches.id AS launch_id,
-  slices.name AS name,
-  AndroidStartupMetric_Slice('dur_ns', SUM(slices.dur)) AS slice_proto
+  slice.name AS name,
+  AndroidStartupMetric_Slice('dur_ns', SUM(slice.dur)) AS slice_proto
 FROM launches
 JOIN launch_processes ON (launches.id = launch_processes.launch_id)
 JOIN thread ON (launch_processes.upid = thread.upid)
-JOIN slices ON (
-  slices.utid = thread.utid
-  AND slices.ts BETWEEN launches.ts AND launches.ts + launches.dur)
-WHERE slices.name IN (
+JOIN thread_track USING (utid)
+JOIN slice ON (
+  slice.track_id = thread_track.id
+  AND slice.ts BETWEEN launches.ts AND launches.ts + launches.dur)
+WHERE slice.name IN (
   'ActivityThreadMain',
   'bindApplication',
   'activityStart',
@@ -135,23 +136,23 @@
         )
       ),
       'time_activity_thread_main', (
-        SELECT slice_proto FROM main_process_slices
+        SELECT slice_proto FROM main_process_slice
         WHERE launch_id = launches.id AND name = 'ActivityThreadMain'
       ),
       'time_bind_application', (
-        SELECT slice_proto FROM main_process_slices
+        SELECT slice_proto FROM main_process_slice
         WHERE launch_id = launches.id AND name = 'bindApplication'
       ),
       'time_activity_start', (
-        SELECT slice_proto FROM main_process_slices
+        SELECT slice_proto FROM main_process_slice
         WHERE launch_id = launches.id AND name = 'activityStart'
       ),
       'time_activity_resume', (
-        SELECT slice_proto FROM main_process_slices
+        SELECT slice_proto FROM main_process_slice
         WHERE launch_id = launches.id AND name = 'activityResume'
       ),
       'time_choreographer', (
-        SELECT slice_proto FROM main_process_slices
+        SELECT slice_proto FROM main_process_slice
         WHERE launch_id = launches.id AND name = 'Choreographer#doFrame'
       ),
       'time_before_start_process', (
diff --git a/src/trace_processor/metrics/android/android_startup_launches.sql b/src/trace_processor/metrics/android/android_startup_launches.sql
index e714d4c..63b38ac 100644
--- a/src/trace_processor/metrics/android/android_startup_launches.sql
+++ b/src/trace_processor/metrics/android/android_startup_launches.sql
@@ -24,7 +24,7 @@
 FROM args
 WHERE string_value LIKE '%|launching: %';
 
--- TODO: Replace with proper async slices once available
+-- TODO: Replace with proper async slice once available
 -- The start of the launching event corresponds to the end of the AM handling
 -- the startActivity intent, whereas the end corresponds to the first frame drawn.
 -- Only successful app launches have a launching event.
@@ -44,13 +44,13 @@
 -- Marks the beginning of the trace and is equivalent to when the statsd launch
 -- logging begins.
 CREATE VIEW activity_intent_received AS
-SELECT ts FROM slices
+SELECT ts FROM slice
 WHERE name = 'MetricsLogger:launchObserverNotifyIntentStarted';
 
 -- Successful activity launch. The end of the 'launching' event is not related
 -- to whether it actually succeeded or not.
 CREATE VIEW activity_intent_launch_successful AS
-SELECT ts FROM slices
+SELECT ts FROM slice
 WHERE name = 'MetricsLogger:launchObserverNotifyActivityLaunchFinished';
 
 -- We partition the trace into spans based on posted activity intents.
diff --git a/src/trace_processor/slice_tracker.cc b/src/trace_processor/slice_tracker.cc
index 39d4058..f811f04 100644
--- a/src/trace_processor/slice_tracker.cc
+++ b/src/trace_processor/slice_tracker.cc
@@ -40,8 +40,6 @@
 
 base::Optional<uint32_t> SliceTracker::Begin(int64_t timestamp,
                                              TrackId track_id,
-                                             int64_t ref,
-                                             RefType ref_type,
                                              StringId category,
                                              StringId name,
                                              SetArgsCallback args_callback) {
@@ -53,14 +51,12 @@
   prev_timestamp_ = timestamp;
 
   MaybeCloseStack(timestamp, &stacks_[track_id]);
-  return StartSlice(timestamp, kPendingDuration, track_id, ref, ref_type,
-                    category, name, args_callback);
+  return StartSlice(timestamp, kPendingDuration, track_id, category, name,
+                    args_callback);
 }
 
 base::Optional<uint32_t> SliceTracker::Scoped(int64_t timestamp,
                                               TrackId track_id,
-                                              int64_t ref,
-                                              RefType ref_type,
                                               StringId category,
                                               StringId name,
                                               int64_t duration,
@@ -74,16 +70,14 @@
 
   PERFETTO_DCHECK(duration >= 0);
   MaybeCloseStack(timestamp, &stacks_[track_id]);
-  return StartSlice(timestamp, duration, track_id, ref, ref_type, category,
-                    name, args_callback);
+  return StartSlice(timestamp, duration, track_id, category, name,
+                    args_callback);
 }
 
 base::Optional<uint32_t> SliceTracker::StartSlice(
     int64_t timestamp,
     int64_t duration,
     TrackId track_id,
-    int64_t ref,
-    RefType ref_type,
     StringId category,
     StringId name,
     SetArgsCallback args_callback) {
@@ -98,11 +92,8 @@
   int64_t parent_stack_id =
       depth == 0 ? 0 : slices->stack_id()[stack->back().first];
 
-  StringId ref_type_id = context_->storage->InternString(
-      GetRefTypeStringMap()[static_cast<uint32_t>(ref_type)]);
-
-  tables::SliceTable::Row row(timestamp, duration, track_id, ref, ref_type_id,
-                              category, name, depth, 0, parent_stack_id);
+  tables::SliceTable::Row row(timestamp, duration, track_id, category, name,
+                              depth, 0, parent_stack_id);
   uint32_t slice_idx = slices->Insert(row);
   stack->emplace_back(std::make_pair(slice_idx, ArgsTracker(context_)));
 
diff --git a/src/trace_processor/slice_tracker.h b/src/trace_processor/slice_tracker.h
index 2347aea..9ffd529 100644
--- a/src/trace_processor/slice_tracker.h
+++ b/src/trace_processor/slice_tracker.h
@@ -38,8 +38,6 @@
   virtual base::Optional<uint32_t> Begin(
       int64_t timestamp,
       TrackId track_id,
-      int64_t ref,
-      RefType ref_type,
       StringId category,
       StringId name,
       SetArgsCallback args_callback = SetArgsCallback());
@@ -48,8 +46,6 @@
   virtual base::Optional<uint32_t> Scoped(
       int64_t timestamp,
       TrackId track_id,
-      int64_t ref,
-      RefType ref_type,
       StringId category,
       StringId name,
       int64_t duration,
@@ -72,8 +68,6 @@
   base::Optional<uint32_t> StartSlice(int64_t timestamp,
                                       int64_t duration,
                                       TrackId track_id,
-                                      int64_t ref,
-                                      RefType ref_type,
                                       StringId category,
                                       StringId name,
                                       SetArgsCallback args_callback);
diff --git a/src/trace_processor/slice_tracker_unittest.cc b/src/trace_processor/slice_tracker_unittest.cc
index 3b709ce..f4f3c64 100644
--- a/src/trace_processor/slice_tracker_unittest.cc
+++ b/src/trace_processor/slice_tracker_unittest.cc
@@ -56,8 +56,7 @@
   SliceTracker tracker(&context);
 
   constexpr TrackId track = 22u;
-  tracker.Begin(2 /*ts*/, track, 42 /*ref*/, RefType::kRefUtid, 0 /*cat*/,
-                1 /*name*/);
+  tracker.Begin(2 /*ts*/, track, 0 /*cat*/, 1 /*name*/);
   tracker.End(10 /*ts*/, track, 0 /*cat*/, 1 /*name*/);
 
   const auto& slices = context.storage->slice_table();
@@ -67,9 +66,6 @@
   EXPECT_EQ(slices.track_id()[0], track);
   EXPECT_EQ(slices.category()[0], 0u);
   EXPECT_EQ(slices.name()[0], 1u);
-  EXPECT_EQ(slices.ref()[0], 42);
-  EXPECT_EQ(slices.ref_type().GetString(0),
-            GetRefTypeStringMap()[static_cast<uint32_t>(RefType::kRefUtid)]);
   EXPECT_EQ(slices.depth()[0], 0u);
   EXPECT_EQ(slices.arg_set_id()[0], kInvalidArgSetId);
 }
@@ -80,8 +76,8 @@
   SliceTracker tracker(&context);
 
   constexpr TrackId track = 22u;
-  tracker.Begin(2 /*ts*/, track, 42 /*ref*/, RefType::kRefUtid, 0 /*cat*/,
-                1 /*name*/, [](ArgsTracker* args_tracker, RowId row) {
+  tracker.Begin(2 /*ts*/, track, 0 /*cat*/, 1 /*name*/,
+                [](ArgsTracker* args_tracker, RowId row) {
                   args_tracker->AddArg(row, /*flat_key=*/1, /*key=*/2,
                                        /*value=*/Variadic::Integer(10));
                 });
@@ -98,9 +94,6 @@
   EXPECT_EQ(slices.track_id()[0], track);
   EXPECT_EQ(slices.category()[0], 0u);
   EXPECT_EQ(slices.name()[0], 1u);
-  EXPECT_EQ(slices.ref()[0], 42);
-  EXPECT_EQ(slices.ref_type().GetString(0),
-            GetRefTypeStringMap()[static_cast<uint32_t>(RefType::kRefUtid)]);
   EXPECT_EQ(slices.depth()[0], 0u);
   auto set_id = slices.arg_set_id()[0];
 
@@ -121,10 +114,8 @@
   SliceTracker tracker(&context);
 
   constexpr TrackId track = 22u;
-  tracker.Begin(2 /*ts*/, track, 42 /*ref*/, RefType::kRefUtid, 0 /*cat*/,
-                1 /*name*/);
-  tracker.Begin(3 /*ts*/, track, 42 /*ref*/, RefType::kRefUtid, 0 /*cat*/,
-                2 /*name*/);
+  tracker.Begin(2 /*ts*/, track, 0 /*cat*/, 1 /*name*/);
+  tracker.Begin(3 /*ts*/, track, 0 /*cat*/, 2 /*name*/);
   tracker.End(5 /*ts*/, track);
   tracker.End(10 /*ts*/, track);
 
@@ -138,9 +129,6 @@
   EXPECT_EQ(slices.track_id()[idx], track);
   EXPECT_EQ(slices.category()[idx], 0u);
   EXPECT_EQ(slices.name()[idx], 1u);
-  EXPECT_EQ(slices.ref()[idx], 42);
-  EXPECT_EQ(slices.ref_type().GetString(idx),
-            GetRefTypeStringMap()[static_cast<uint32_t>(RefType::kRefUtid)]);
   EXPECT_EQ(slices.depth()[idx++], 0u);
 
   EXPECT_EQ(slices.ts()[idx], 3);
@@ -148,9 +136,6 @@
   EXPECT_EQ(slices.track_id()[idx], track);
   EXPECT_EQ(slices.category()[idx], 0u);
   EXPECT_EQ(slices.name()[idx], 2u);
-  EXPECT_EQ(slices.ref()[idx], 42);
-  EXPECT_EQ(slices.ref_type().GetString(idx),
-            GetRefTypeStringMap()[static_cast<uint32_t>(RefType::kRefUtid)]);
   EXPECT_EQ(slices.depth()[idx], 1u);
 
   EXPECT_EQ(slices.parent_stack_id()[0], 0);
@@ -164,9 +149,9 @@
   SliceTracker tracker(&context);
 
   constexpr TrackId track = 22u;
-  tracker.Begin(0 /*ts*/, track, 42 /*ref*/, RefType::kRefUtid, 0, 0);
-  tracker.Begin(1 /*ts*/, track, 42 /*ref*/, RefType::kRefUtid, 0, 0);
-  tracker.Scoped(2 /*ts*/, track, 42 /*ref*/, RefType::kRefUtid, 0, 0, 6);
+  tracker.Begin(0 /*ts*/, track, 0, 0);
+  tracker.Begin(1 /*ts*/, track, 0, 0);
+  tracker.Scoped(2 /*ts*/, track, 0, 0, 6);
   tracker.End(9 /*ts*/, track);
   tracker.End(10 /*ts*/, track);
 
@@ -181,8 +166,7 @@
   SliceTracker tracker(&context);
 
   constexpr TrackId track = 22u;
-  tracker.Begin(2 /*ts*/, track, 42 /*ref*/, RefType::kRefUtid, 5 /*cat*/,
-                1 /*name*/);
+  tracker.Begin(2 /*ts*/, track, 5 /*cat*/, 1 /*name*/);
   tracker.End(3 /*ts*/, track, 1 /*cat*/, 1 /*name*/);
   tracker.End(4 /*ts*/, track, 0 /*cat*/, 2 /*name*/);
   tracker.End(5 /*ts*/, track, 5 /*cat*/, 1 /*name*/);
@@ -200,14 +184,10 @@
   // from being closed, leading to an inconsistency when we try to insert the
   // final slice and it doesn't intersect with the still pending first slice.
   constexpr TrackId track = 22u;
-  tracker.Scoped(2 /*ts*/, track, 42 /*ref*/, RefType::kRefUtid, 0 /*cat*/,
-                 1 /*name*/, 10 /* dur */);
-  tracker.Scoped(2 /*ts*/, track, 42 /*ref*/, RefType::kRefUtid, 0 /*cat*/,
-                 1 /*name*/, 0 /* dur */);
-  tracker.Scoped(12 /*ts*/, track, 42 /*ref*/, RefType::kRefUtid, 0 /*cat*/,
-                 1 /*name*/, 1 /* dur */);
-  tracker.Scoped(13 /*ts*/, track, 42 /*ref*/, RefType::kRefUtid, 0 /*cat*/,
-                 1 /*name*/, 1 /* dur */);
+  tracker.Scoped(2 /*ts*/, track, 0 /*cat*/, 1 /*name*/, 10 /* dur */);
+  tracker.Scoped(2 /*ts*/, track, 0 /*cat*/, 1 /*name*/, 0 /* dur */);
+  tracker.Scoped(12 /*ts*/, track, 0 /*cat*/, 1 /*name*/, 1 /* dur */);
+  tracker.Scoped(13 /*ts*/, track, 0 /*cat*/, 1 /*name*/, 1 /* dur */);
 
   auto slices = ToSliceInfo(context.storage->slice_table());
   EXPECT_THAT(slices, ElementsAre(SliceInfo{2, 10}, SliceInfo{2, 0},
@@ -221,9 +201,9 @@
 
   constexpr TrackId track_a = 22u;
   constexpr TrackId track_b = 23u;
-  tracker.Begin(0 /*ts*/, track_a, 42 /*ref*/, RefType::kRefUtid, 0, 0);
-  tracker.Scoped(2 /*ts*/, track_b, 42 /*ref*/, RefType::kRefUtid, 0, 0, 6);
-  tracker.Scoped(3 /*ts*/, track_b, 42 /*ref*/, RefType::kRefUtid, 0, 0, 4);
+  tracker.Begin(0 /*ts*/, track_a, 0, 0);
+  tracker.Scoped(2 /*ts*/, track_b, 0, 0, 6);
+  tracker.Scoped(3 /*ts*/, track_b, 0, 0, 4);
   tracker.End(10 /*ts*/, track_a);
   tracker.FlushPendingSlices();
 
@@ -245,28 +225,22 @@
   SliceTracker tracker(&context);
 
   constexpr TrackId track = 22u;
-  tracker.Scoped(50 /*ts*/, track, 42 /*ref*/, RefType::kRefUtid, 11 /*cat*/,
-                 21 /*name*/, 100 /*dur*/);
-  tracker.Begin(100 /*ts*/, track, 42 /*ref*/, RefType::kRefUtid, 12 /*cat*/,
-                22 /*name*/);
-  tracker.Scoped(450 /*ts*/, track, 42 /*ref*/, RefType::kRefUtid, 12 /*cat*/,
-                 22 /*name*/, 100 /*dur*/);
+  tracker.Scoped(50 /*ts*/, track, 11 /*cat*/, 21 /*name*/, 100 /*dur*/);
+  tracker.Begin(100 /*ts*/, track, 12 /*cat*/, 22 /*name*/);
+  tracker.Scoped(450 /*ts*/, track, 12 /*cat*/, 22 /*name*/, 100 /*dur*/);
   tracker.End(500 /*ts*/, track, 12 /*cat*/, 22 /*name*/);
 
   // This slice should now have depth 0.
-  tracker.Begin(800 /*ts*/, track, 42 /*ref*/, RefType::kRefUtid, 13 /*cat*/,
-                23 /*name*/);
+  tracker.Begin(800 /*ts*/, track, 13 /*cat*/, 23 /*name*/);
   // Null cat and name matches everything.
   tracker.End(1000 /*ts*/, track, 0 /*cat*/, 0 /*name*/);
 
   // Slice will not close if category is different.
-  tracker.Begin(1100 /*ts*/, track, 42 /*ref*/, RefType::kRefUtid, 11 /*cat*/,
-                21 /*name*/);
+  tracker.Begin(1100 /*ts*/, track, 11 /*cat*/, 21 /*name*/);
   tracker.End(1200 /*ts*/, track, 12 /*cat*/, 21 /*name*/);
 
   // Slice will not close if name is different.
-  tracker.Begin(1300 /*ts*/, track, 42 /*ref*/, RefType::kRefUtid, 11 /*cat*/,
-                21 /*name*/);
+  tracker.Begin(1300 /*ts*/, track, 11 /*cat*/, 21 /*name*/);
   tracker.End(1400 /*ts*/, track, 11 /*cat*/, 22 /*name*/);
 
   tracker.FlushPendingSlices();
diff --git a/src/trace_processor/syscall_tracker.h b/src/trace_processor/syscall_tracker.h
index f367309..09cf772 100644
--- a/src/trace_processor/syscall_tracker.h
+++ b/src/trace_processor/syscall_tracker.h
@@ -52,8 +52,7 @@
     StringId name = SyscallNumberToStringId(syscall_num);
     if (!name.is_null()) {
       TrackId track_id = context_->track_tracker->InternThreadTrack(utid);
-      context_->slice_tracker->Begin(ts, track_id, utid, RefType::kRefUtid,
-                                     0 /* cat */, name);
+      context_->slice_tracker->Begin(ts, track_id, 0 /* cat */, name);
     }
   }
 
diff --git a/src/trace_processor/syscall_tracker_unittest.cc b/src/trace_processor/syscall_tracker_unittest.cc
index 70bf075..a659a64 100644
--- a/src/trace_processor/syscall_tracker_unittest.cc
+++ b/src/trace_processor/syscall_tracker_unittest.cc
@@ -32,11 +32,9 @@
   MockSliceTracker(TraceProcessorContext* context) : SliceTracker(context) {}
   virtual ~MockSliceTracker() = default;
 
-  MOCK_METHOD7(Begin,
+  MOCK_METHOD5(Begin,
                base::Optional<uint32_t>(int64_t timestamp,
                                         TrackId track_id,
-                                        int64_t ref,
-                                        RefType ref_type,
                                         StringId cat,
                                         StringId name,
                                         SetArgsCallback args_callback));
@@ -69,9 +67,8 @@
   constexpr TrackId track = 0u;
   StringId begin_name = 0;
   StringId end_name = 0;
-  EXPECT_CALL(*slice_tracker,
-              Begin(100, track, 42, RefType::kRefUtid, kNullStringId, _, _))
-      .WillOnce(DoAll(SaveArg<5>(&begin_name), Return(base::nullopt)));
+  EXPECT_CALL(*slice_tracker, Begin(100, track, kNullStringId, _, _))
+      .WillOnce(DoAll(SaveArg<3>(&begin_name), Return(base::nullopt)));
   EXPECT_CALL(*slice_tracker, End(110, track, kNullStringId, _, _))
       .WillOnce(DoAll(SaveArg<3>(&end_name), Return(base::nullopt)));
 
@@ -83,7 +80,7 @@
 
 TEST_F(SyscallTrackerTest, IgnoreWriteSyscalls) {
   context.syscall_tracker->SetArchitecture(kAarch64);
-  EXPECT_CALL(*slice_tracker, Begin(_, _, _, _, _, _, _)).Times(0);
+  EXPECT_CALL(*slice_tracker, Begin(_, _, _, _, _)).Times(0);
   EXPECT_CALL(*slice_tracker, End(_, _, _, _, _)).Times(0);
 
   context.syscall_tracker->Enter(100 /*ts*/, 42 /*utid*/, 64 /*sys_write*/);
@@ -94,9 +91,8 @@
   constexpr TrackId track = 0u;
   StringId begin_name = 0;
   StringId end_name = 0;
-  EXPECT_CALL(*slice_tracker,
-              Begin(100, track, 42, RefType::kRefUtid, kNullStringId, _, _))
-      .WillOnce(DoAll(SaveArg<5>(&begin_name), Return(base::nullopt)));
+  EXPECT_CALL(*slice_tracker, Begin(100, track, kNullStringId, _, _))
+      .WillOnce(DoAll(SaveArg<3>(&begin_name), Return(base::nullopt)));
   EXPECT_CALL(*slice_tracker, End(110, track, kNullStringId, _, _))
       .WillOnce(DoAll(SaveArg<3>(&end_name), Return(base::nullopt)));
 
@@ -111,9 +107,8 @@
   constexpr TrackId track = 0u;
   StringId begin_name = 0;
   StringId end_name = 0;
-  EXPECT_CALL(*slice_tracker,
-              Begin(100, track, 42, RefType::kRefUtid, kNullStringId, _, _))
-      .WillOnce(DoAll(SaveArg<5>(&begin_name), Return(base::nullopt)));
+  EXPECT_CALL(*slice_tracker, Begin(100, track, kNullStringId, _, _))
+      .WillOnce(DoAll(SaveArg<3>(&begin_name), Return(base::nullopt)));
   EXPECT_CALL(*slice_tracker, End(110, track, kNullStringId, _, _))
       .WillOnce(DoAll(SaveArg<3>(&end_name), Return(base::nullopt)));
 
@@ -125,7 +120,7 @@
 }
 
 TEST_F(SyscallTrackerTest, SyscallNumberTooLarge) {
-  EXPECT_CALL(*slice_tracker, Begin(_, _, _, _, _, _, _)).Times(0);
+  EXPECT_CALL(*slice_tracker, Begin(_, _, _, _, _)).Times(0);
   EXPECT_CALL(*slice_tracker, End(_, _, _, _, _)).Times(0);
   context.syscall_tracker->SetArchitecture(kAarch64);
   context.syscall_tracker->Enter(100 /*ts*/, 42 /*utid*/, 9999);
diff --git a/src/trace_processor/tables/slice_tables.h b/src/trace_processor/tables/slice_tables.h
index d4485fb..4d2be49 100644
--- a/src/trace_processor/tables/slice_tables.h
+++ b/src/trace_processor/tables/slice_tables.h
@@ -29,8 +29,6 @@
   C(int64_t, ts, Column::Flag::kSorted)              \
   C(int64_t, dur)                                    \
   C(uint32_t, track_id)                              \
-  C(int64_t, ref)                                    \
-  C(StringPool::Id, ref_type)                        \
   C(StringPool::Id, category)                        \
   C(StringPool::Id, name)                            \
   C(uint32_t, depth)                                 \
diff --git a/src/trace_processor/trace_database_integrationtest.cc b/src/trace_processor/trace_database_integrationtest.cc
index b96e628..5fc550f 100644
--- a/src/trace_processor/trace_database_integrationtest.cc
+++ b/src/trace_processor/trace_database_integrationtest.cc
@@ -131,8 +131,10 @@
 #if PERFETTO_BUILDFLAG(PERFETTO_TP_JSON_IMPORT)
 TEST_F(TraceProcessorIntegrationTest, Sfgate) {
   ASSERT_TRUE(LoadTrace("sfgate.json", strlen("{\"traceEvents\":[")).ok());
-  auto it =
-      Query("select count(*), max(ts) - min(ts) from slices where utid != 0");
+  auto it = Query(
+      "select count(*), max(ts) - min(ts) "
+      "from slice s inner join thread_track t "
+      "on s.track_id = t.id where utid != 0");
   ASSERT_TRUE(it.Next());
   ASSERT_EQ(it.Get(0).type, SqlValue::kLong);
   ASSERT_EQ(it.Get(0).long_value, 39828);
@@ -144,7 +146,7 @@
 TEST_F(TraceProcessorIntegrationTest, UnsortedTrace) {
   ASSERT_TRUE(
       LoadTrace("unsorted_trace.json", strlen("{\"traceEvents\":[")).ok());
-  auto it = Query("select ts, depth from slices order by ts");
+  auto it = Query("select ts, depth from slice order by ts");
   ASSERT_TRUE(it.Next());
   ASSERT_EQ(it.Get(0).type, SqlValue::kLong);
   ASSERT_EQ(it.Get(0).long_value, 50000);
diff --git a/src/trace_processor/trace_processor_impl.cc b/src/trace_processor/trace_processor_impl.cc
index b0fe758..e47806d 100644
--- a/src/trace_processor/trace_processor_impl.cc
+++ b/src/trace_processor/trace_processor_impl.cc
@@ -178,11 +178,7 @@
                "SELECT "
                "  *, "
                "  category AS cat, "
-               "  id AS slice_id, "
-               "  CASE ref_type "
-               "    WHEN 'utid' THEN ref "
-               "    ELSE NULL "
-               "  END AS utid "
+               "  id AS slice_id "
                "FROM internal_slice;",
                0, 0, &error);
   if (error) {