diff --git a/base/debug/task_annotator.cc b/base/debug/task_annotator.cc
index 2197b85..def2d7a 100644
--- a/base/debug/task_annotator.cc
+++ b/base/debug/task_annotator.cc
@@ -11,7 +11,6 @@
 #include "base/no_destructor.h"
 #include "base/pending_task.h"
 #include "base/threading/thread_local.h"
-#include "base/trace_event/trace_event.h"
 
 namespace base {
 namespace debug {
@@ -37,13 +36,6 @@
 
 void TaskAnnotator::DidQueueTask(const char* queue_function,
                                  const PendingTask& pending_task) {
-  if (queue_function) {
-    TRACE_EVENT_WITH_FLOW0(TRACE_DISABLED_BY_DEFAULT("toplevel.flow"),
-                           queue_function,
-                           TRACE_ID_MANGLE(GetTaskTraceID(pending_task)),
-                           TRACE_EVENT_FLAG_FLOW_OUT);
-  }
-
   // TODO(https://crbug.com/826902): Fix callers that invoke DidQueueTask()
   // twice for the same PendingTask.
   // DCHECK(!pending_task.task_backtrace[0])
@@ -64,13 +56,6 @@
                             PendingTask* pending_task) {
   ScopedTaskRunActivity task_activity(*pending_task);
 
-  if (queue_function) {
-    TRACE_EVENT_WITH_FLOW0(TRACE_DISABLED_BY_DEFAULT("toplevel.flow"),
-                           queue_function,
-                           TRACE_ID_MANGLE(GetTaskTraceID(*pending_task)),
-                           TRACE_EVENT_FLAG_FLOW_IN);
-  }
-
   // Before running the task, store the task backtrace with the chain of
   // PostTasks that resulted in this call and deliberately alias it to ensure
   // it is on the stack if the task crashes. Be careful not to assume that the
diff --git a/base/files/file_path_watcher_linux.cc b/base/files/file_path_watcher_linux.cc
index c58d686..75677d4 100644
--- a/base/files/file_path_watcher_linux.cc
+++ b/base/files/file_path_watcher_linux.cc
@@ -36,7 +36,6 @@
 #include "base/synchronization/lock.h"
 #include "base/threading/platform_thread.h"
 #include "base/threading/sequenced_task_runner_handle.h"
-#include "base/trace_event/trace_event.h"
 
 namespace base {
 
diff --git a/base/memory/memory_pressure_listener.cc b/base/memory/memory_pressure_listener.cc
index 669fb17..3768283 100644
--- a/base/memory/memory_pressure_listener.cc
+++ b/base/memory/memory_pressure_listener.cc
@@ -5,7 +5,6 @@
 #include "base/memory/memory_pressure_listener.h"
 
 #include "base/observer_list_threadsafe.h"
-#include "base/trace_event/trace_event.h"
 
 namespace base {
 
diff --git a/base/memory/shared_memory_posix.cc b/base/memory/shared_memory_posix.cc
index 6b53551..f868eb2 100644
--- a/base/memory/shared_memory_posix.cc
+++ b/base/memory/shared_memory_posix.cc
@@ -23,7 +23,6 @@
 #include "base/scoped_generic.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread_restrictions.h"
-#include "base/trace_event/trace_event.h"
 #include "base/unguessable_token.h"
 #include "build_config.h"
 
diff --git a/base/memory/shared_memory_tracker.cc b/base/memory/shared_memory_tracker.cc
index 5ca7c84..ee2b490 100644
--- a/base/memory/shared_memory_tracker.cc
+++ b/base/memory/shared_memory_tracker.cc
@@ -6,9 +6,6 @@
 
 #include "base/memory/shared_memory.h"
 #include "base/strings/string_number_conversions.h"
-#include "base/trace_event/memory_allocator_dump_guid.h"
-#include "base/trace_event/memory_dump_manager.h"
-#include "base/trace_event/process_memory_dump.h"
 
 namespace base {
 
@@ -27,32 +24,6 @@
   return std::string(kDumpRootName) + "/" + id.ToString();
 }
 
-// static
-trace_event::MemoryAllocatorDumpGuid
-SharedMemoryTracker::GetGlobalDumpIdForTracing(const UnguessableToken& id) {
-  std::string dump_name = GetDumpNameForTracing(id);
-  return trace_event::MemoryAllocatorDumpGuid(dump_name);
-}
-
-// static
-const trace_event::MemoryAllocatorDump*
-SharedMemoryTracker::GetOrCreateSharedMemoryDump(
-    const SharedMemory* shared_memory,
-    trace_event::ProcessMemoryDump* pmd) {
-  return GetOrCreateSharedMemoryDumpInternal(shared_memory->memory(),
-                                             shared_memory->mapped_size(),
-                                             shared_memory->mapped_id(), pmd);
-}
-
-const trace_event::MemoryAllocatorDump*
-SharedMemoryTracker::GetOrCreateSharedMemoryDump(
-    const SharedMemoryMapping& shared_memory,
-    trace_event::ProcessMemoryDump* pmd) {
-  return GetOrCreateSharedMemoryDumpInternal(shared_memory.raw_memory_ptr(),
-                                             shared_memory.mapped_size(),
-                                             shared_memory.guid(), pmd);
-}
-
 void SharedMemoryTracker::IncrementMemoryUsage(
     const SharedMemory& shared_memory) {
   AutoLock hold(usages_lock_);
@@ -84,64 +55,8 @@
 }
 
 SharedMemoryTracker::SharedMemoryTracker() {
-  trace_event::MemoryDumpManager::GetInstance()->RegisterDumpProvider(
-      this, "SharedMemoryTracker", nullptr);
 }
 
 SharedMemoryTracker::~SharedMemoryTracker() = default;
 
-bool SharedMemoryTracker::OnMemoryDump(const trace_event::MemoryDumpArgs& args,
-                                       trace_event::ProcessMemoryDump* pmd) {
-  AutoLock hold(usages_lock_);
-  for (const auto& usage : usages_) {
-    const trace_event::MemoryAllocatorDump* dump =
-        GetOrCreateSharedMemoryDumpInternal(
-            usage.first, usage.second.mapped_size, usage.second.mapped_id, pmd);
-    DCHECK(dump);
-  }
-  return true;
-}
-
-// static
-const trace_event::MemoryAllocatorDump*
-SharedMemoryTracker::GetOrCreateSharedMemoryDumpInternal(
-    void* mapped_memory,
-    size_t mapped_size,
-    const UnguessableToken& mapped_id,
-    trace_event::ProcessMemoryDump* pmd) {
-  const std::string dump_name = GetDumpNameForTracing(mapped_id);
-  trace_event::MemoryAllocatorDump* local_dump =
-      pmd->GetAllocatorDump(dump_name);
-  if (local_dump)
-    return local_dump;
-
-  size_t virtual_size = mapped_size;
-  // If resident size is not available, a virtual size is used as fallback.
-  size_t size = virtual_size;
-#if defined(COUNT_RESIDENT_BYTES_SUPPORTED)
-  base::Optional<size_t> resident_size =
-      trace_event::ProcessMemoryDump::CountResidentBytesInSharedMemory(
-          mapped_memory, mapped_size);
-  if (resident_size.has_value())
-    size = resident_size.value();
-#endif
-
-  local_dump = pmd->CreateAllocatorDump(dump_name);
-  local_dump->AddScalar(trace_event::MemoryAllocatorDump::kNameSize,
-                        trace_event::MemoryAllocatorDump::kUnitsBytes, size);
-  local_dump->AddScalar("virtual_size",
-                        trace_event::MemoryAllocatorDump::kUnitsBytes,
-                        virtual_size);
-  auto global_dump_guid = GetGlobalDumpIdForTracing(mapped_id);
-  trace_event::MemoryAllocatorDump* global_dump =
-      pmd->CreateSharedGlobalAllocatorDump(global_dump_guid);
-  global_dump->AddScalar(trace_event::MemoryAllocatorDump::kNameSize,
-                         trace_event::MemoryAllocatorDump::kUnitsBytes, size);
-
-  // The edges will be overriden by the clients with correct importance.
-  pmd->AddOverridableOwnershipEdge(local_dump->guid(), global_dump->guid(),
-                                   0 /* importance */);
-  return local_dump;
-}
-
 }  // namespace
diff --git a/base/memory/shared_memory_tracker.h b/base/memory/shared_memory_tracker.h
index 499b172..72c7b7a 100644
--- a/base/memory/shared_memory_tracker.h
+++ b/base/memory/shared_memory_tracker.h
@@ -11,39 +11,17 @@
 #include "base/memory/shared_memory.h"
 #include "base/memory/shared_memory_mapping.h"
 #include "base/synchronization/lock.h"
-#include "base/trace_event/memory_dump_provider.h"
 
 namespace base {
 
-namespace trace_event {
-class MemoryAllocatorDump;
-class MemoryAllocatorDumpGuid;
-class ProcessMemoryDump;
-}
-
 // SharedMemoryTracker tracks shared memory usage.
-class BASE_EXPORT SharedMemoryTracker : public trace_event::MemoryDumpProvider {
+class BASE_EXPORT SharedMemoryTracker {
  public:
   // Returns a singleton instance.
   static SharedMemoryTracker* GetInstance();
 
   static std::string GetDumpNameForTracing(const UnguessableToken& id);
 
-  static trace_event::MemoryAllocatorDumpGuid GetGlobalDumpIdForTracing(
-      const UnguessableToken& id);
-
-  // Gets or creates if non-existant, a memory dump for the |shared_memory|
-  // inside the given |pmd|. Also adds the necessary edges for the dump when
-  // creating the dump.
-  static const trace_event::MemoryAllocatorDump* GetOrCreateSharedMemoryDump(
-      const SharedMemory* shared_memory,
-      trace_event::ProcessMemoryDump* pmd);
-  // We're in the middle of a refactor https://crbug.com/795291. Eventually, the
-  // first call will go away.
-  static const trace_event::MemoryAllocatorDump* GetOrCreateSharedMemoryDump(
-      const SharedMemoryMapping& shared_memory,
-      trace_event::ProcessMemoryDump* pmd);
-
   // Records shared memory usage on valid mapping.
   void IncrementMemoryUsage(const SharedMemory& shared_memory);
   void IncrementMemoryUsage(const SharedMemoryMapping& mapping);
@@ -57,17 +35,7 @@
 
  private:
   SharedMemoryTracker();
-  ~SharedMemoryTracker() override;
-
-  // trace_event::MemoryDumpProvider implementation.
-  bool OnMemoryDump(const trace_event::MemoryDumpArgs& args,
-                    trace_event::ProcessMemoryDump* pmd) override;
-
-  static const trace_event::MemoryAllocatorDump*
-  GetOrCreateSharedMemoryDumpInternal(void* mapped_memory,
-                                      size_t mapped_size,
-                                      const UnguessableToken& mapped_id,
-                                      trace_event::ProcessMemoryDump* pmd);
+  ~SharedMemoryTracker();
 
   // Information associated with each mapped address.
   struct UsageInfo {
diff --git a/base/message_loop/message_loop.cc b/base/message_loop/message_loop.cc
index a7c3f25..0953aaf 100644
--- a/base/message_loop/message_loop.cc
+++ b/base/message_loop/message_loop.cc
@@ -18,7 +18,6 @@
 #include "base/third_party/dynamic_annotations/dynamic_annotations.h"
 #include "base/threading/thread_id_name_manager.h"
 #include "base/threading/thread_task_runner_handle.h"
-#include "base/trace_event/trace_event.h"
 
 #if defined(OS_MACOSX)
 #include "base/message_loop/message_pump_mac.h"
@@ -312,8 +311,6 @@
   // Execute the task and assume the worst: It is probably not reentrant.
   task_execution_allowed_ = false;
 
-  TRACE_TASK_EXECUTION("MessageLoop::RunTask", *pending_task);
-
   for (auto& observer : task_observers_)
     observer.WillProcessTask(*pending_task);
   incoming_task_queue_->RunTask(pending_task);
diff --git a/base/message_loop/message_pump_libevent.cc b/base/message_loop/message_pump_libevent.cc
index a8efd27..2b47681 100644
--- a/base/message_loop/message_pump_libevent.cc
+++ b/base/message_loop/message_pump_libevent.cc
@@ -16,7 +16,6 @@
 #include "base/posix/eintr_wrapper.h"
 #include "base/third_party/libevent/event.h"
 #include "base/time/time.h"
-#include "base/trace_event/trace_event.h"
 #include "build_config.h"
 
 #if defined(OS_MACOSX)
@@ -306,11 +305,6 @@
                                                  void* context) {
   FdWatchController* controller = static_cast<FdWatchController*>(context);
   DCHECK(controller);
-  TRACE_EVENT2("toplevel", "MessagePumpLibevent::OnLibeventNotification",
-               "src_file", controller->created_from_location().file_name(),
-               "src_func", controller->created_from_location().function_name());
-  TRACE_HEAP_PROFILER_API_SCOPED_TASK_EXECUTION heap_profiler_scope(
-      controller->created_from_location().file_name());
 
   MessagePumpLibevent* pump = controller->pump();
   pump->processed_io_events_ = true;
diff --git a/base/message_loop/message_pump_win.cc b/base/message_loop/message_pump_win.cc
index 8e6f1f4..47cf477 100644
--- a/base/message_loop/message_pump_win.cc
+++ b/base/message_loop/message_pump_win.cc
@@ -13,7 +13,6 @@
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/stringprintf.h"
-#include "base/trace_event/trace_event.h"
 #include "base/win/current_module.h"
 #include "base/win/wrapped_window_proc.h"
 
@@ -347,8 +346,6 @@
 }
 
 bool MessagePumpForUI::ProcessMessageHelper(const MSG& msg) {
-  TRACE_EVENT1("base", "MessagePumpForUI::ProcessMessageHelper",
-               "message", msg.message);
   if (WM_QUIT == msg.message) {
     // WM_QUIT is the standard way to exit a GetMessage() loop. Our MessageLoop
     // has its own quit mechanism, so WM_QUIT is unexpected and should be
diff --git a/base/process/launch_posix.cc b/base/process/launch_posix.cc
index d1690bc..1004012 100644
--- a/base/process/launch_posix.cc
+++ b/base/process/launch_posix.cc
@@ -42,7 +42,6 @@
 #include "base/threading/platform_thread.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/time/time.h"
-#include "base/trace_event/trace_event.h"
 #include "build_config.h"
 
 #if defined(OS_LINUX) || defined(OS_AIX)
diff --git a/base/task_scheduler/scheduler_worker.cc b/base/task_scheduler/scheduler_worker.cc
index d3b8c0c..33b400a 100644
--- a/base/task_scheduler/scheduler_worker.cc
+++ b/base/task_scheduler/scheduler_worker.cc
@@ -13,7 +13,6 @@
 #include "base/logging.h"
 #include "base/task_scheduler/scheduler_worker_observer.h"
 #include "base/task_scheduler/task_tracker.h"
-#include "base/trace_event/trace_event.h"
 
 #if defined(OS_MACOSX)
 #include "base/mac/scoped_nsautorelease_pool.h"
@@ -274,7 +273,6 @@
 
 void SchedulerWorker::RunWorker() {
   DCHECK_EQ(self_, this);
-  TRACE_EVENT_BEGIN0("task_scheduler", "SchedulerWorkerThread active");
 
   if (scheduler_worker_observer_)
     scheduler_worker_observer_->OnSchedulerWorkerMainEntry();
@@ -283,9 +281,7 @@
 
   // A SchedulerWorker starts out waiting for work.
   {
-    TRACE_EVENT_END0("task_scheduler", "SchedulerWorkerThread active");
     delegate_->WaitForWork(&wake_up_event_);
-    TRACE_EVENT_BEGIN0("task_scheduler", "SchedulerWorkerThread active");
   }
 
 // When defined(COM_INIT_CHECK_HOOK_ENABLED), ignore
@@ -311,9 +307,7 @@
       if (ShouldExit())
         break;
 
-      TRACE_EVENT_END0("task_scheduler", "SchedulerWorkerThread active");
       delegate_->WaitForWork(&wake_up_event_);
-      TRACE_EVENT_BEGIN0("task_scheduler", "SchedulerWorkerThread active");
       continue;
     }
 
@@ -345,8 +339,6 @@
   // Release the self-reference to |this|. This can result in deleting |this|
   // and as such no more member accesses should be made after this point.
   self_ = nullptr;
-
-  TRACE_EVENT_END0("task_scheduler", "SchedulerWorkerThread active");
 }
 
 }  // namespace internal
diff --git a/base/task_scheduler/task_tracker.cc b/base/task_scheduler/task_tracker.cc
index 5c98b5c..4fd2356 100644
--- a/base/task_scheduler/task_tracker.cc
+++ b/base/task_scheduler/task_tracker.cc
@@ -15,6 +15,7 @@
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/sequence_token.h"
+#include "base/strings/string_util.h"
 #include "base/synchronization/condition_variable.h"
 #include "base/task_scheduler/scoped_set_task_priority_for_current_thread.h"
 #include "base/threading/sequence_local_storage_map.h"
@@ -22,7 +23,6 @@
 #include "base/threading/thread_restrictions.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
-#include "base/trace_event/trace_event.h"
 #include "base/values.h"
 
 namespace base {
@@ -35,7 +35,7 @@
 constexpr char kSingleThreadExecutionMode[] = "single thread";
 
 // An immutable copy of a scheduler task's info required by tracing.
-class TaskTracingInfo : public trace_event::ConvertableToTraceFormat {
+class TaskTracingInfo {
  public:
   TaskTracingInfo(const TaskTraits& task_traits,
                   const char* execution_mode,
@@ -44,9 +44,6 @@
         execution_mode_(execution_mode),
         sequence_token_(sequence_token) {}
 
-  // trace_event::ConvertableToTraceFormat implementation.
-  void AppendAsTraceFormat(std::string* out) const override;
-
  private:
   const TaskTraits task_traits_;
   const char* const execution_mode_;
@@ -55,28 +52,11 @@
   DISALLOW_COPY_AND_ASSIGN(TaskTracingInfo);
 };
 
-void TaskTracingInfo::AppendAsTraceFormat(std::string* out) const {
-  DictionaryValue dict;
-
-  dict.SetString("task_priority",
-                 base::TaskPriorityToString(task_traits_.priority()));
-  dict.SetString("execution_mode", execution_mode_);
-  if (execution_mode_ != kParallelExecutionMode)
-    dict.SetInteger("sequence_token", sequence_token_.ToInternalValue());
-
-  std::string tmp;
-  JSONWriter::Write(dict, &tmp);
-  out->append(tmp);
-}
-
 // These name conveys that a Task is posted to/run by the task scheduler without
 // revealing its implementation details.
 constexpr char kQueueFunctionName[] = "TaskScheduler PostTask";
 constexpr char kRunFunctionName[] = "TaskScheduler RunTask";
 
-constexpr char kTaskSchedulerFlowTracingCategory[] =
-    TRACE_DISABLED_BY_DEFAULT("task_scheduler.flow");
-
 // Constructs a histogram to track latency which is logging to
 // "TaskScheduler.{histogram_name}.{histogram_label}.{task_type_suffix}".
 HistogramBase* GetLatencyHistogram(StringPiece histogram_name,
@@ -347,13 +327,6 @@
   if (task.delayed_run_time.is_null())
     subtle::NoBarrier_AtomicIncrement(&num_incomplete_undelayed_tasks_, 1);
 
-  {
-    TRACE_EVENT_WITH_FLOW0(
-        kTaskSchedulerFlowTracingCategory, kQueueFunctionName,
-        TRACE_ID_MANGLE(task_annotator_.GetTaskTraceID(task)),
-        TRACE_EVENT_FLAG_FLOW_OUT);
-  }
-
   task_annotator_.DidQueueTask(nullptr, task);
 
   return true;
@@ -496,29 +469,6 @@
     }
 
     if (can_run_task) {
-      TRACE_TASK_EXECUTION(kRunFunctionName, task);
-
-      const char* const execution_mode =
-          task.single_thread_task_runner_ref
-              ? kSingleThreadExecutionMode
-              : (task.sequenced_task_runner_ref ? kSequencedExecutionMode
-                                                : kParallelExecutionMode);
-      // TODO(gab): In a better world this would be tacked on as an extra arg
-      // to the trace event generated above. This is not possible however until
-      // http://crbug.com/652692 is resolved.
-      TRACE_EVENT1("task_scheduler", "TaskTracker::RunTask", "task_info",
-                   std::make_unique<TaskTracingInfo>(
-                       task.traits, execution_mode, sequence_token));
-
-      {
-        // Put this in its own scope so it preceeds rather than overlaps with
-        // RunTask() in the trace view.
-        TRACE_EVENT_WITH_FLOW0(
-            kTaskSchedulerFlowTracingCategory, kQueueFunctionName,
-            TRACE_ID_MANGLE(task_annotator_.GetTaskTraceID(task)),
-            TRACE_EVENT_FLAG_FLOW_IN);
-      }
-
       task_annotator_.RunTask(nullptr, &task);
     }
 
diff --git a/base/test/test_mock_time_task_runner.h b/base/test/test_mock_time_task_runner.h
index 23dbb2f..993db05 100644
--- a/base/test/test_mock_time_task_runner.h
+++ b/base/test/test_mock_time_task_runner.h
@@ -17,6 +17,7 @@
 #include "base/macros.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
+#include "base/synchronization/condition_variable.h"
 #include "base/synchronization/lock.h"
 #include "base/test/test_pending_task.h"
 #include "base/threading/thread_checker_impl.h"
diff --git a/base/test/test_pending_task.cc b/base/test/test_pending_task.cc
index f9cfa8e..bb81eaa 100644
--- a/base/test/test_pending_task.cc
+++ b/base/test/test_pending_task.cc
@@ -38,44 +38,4 @@
 
 TestPendingTask::~TestPendingTask() = default;
 
-void TestPendingTask::AsValueInto(base::trace_event::TracedValue* state) const {
-  state->SetInteger("run_at", GetTimeToRun().ToInternalValue());
-  state->SetString("posting_function", location.ToString());
-  state->SetInteger("post_time", post_time.ToInternalValue());
-  state->SetInteger("delay", delay.ToInternalValue());
-  switch (nestability) {
-    case NESTABLE:
-      state->SetString("nestability", "NESTABLE");
-      break;
-    case NON_NESTABLE:
-      state->SetString("nestability", "NON_NESTABLE");
-      break;
-  }
-  state->SetInteger("delay", delay.ToInternalValue());
-}
-
-std::unique_ptr<base::trace_event::ConvertableToTraceFormat>
-TestPendingTask::AsValue() const {
-  std::unique_ptr<base::trace_event::TracedValue> state(
-      new base::trace_event::TracedValue());
-  AsValueInto(state.get());
-  return std::move(state);
-}
-
-std::string TestPendingTask::ToString() const {
-  std::string output("TestPendingTask(");
-  AsValue()->AppendAsTraceFormat(&output);
-  output += ")";
-  return output;
-}
-
-std::ostream& operator<<(std::ostream& os, const TestPendingTask& task) {
-  PrintTo(task, &os);
-  return os;
-}
-
-void PrintTo(const TestPendingTask& task, std::ostream* os) {
-  *os << task.ToString();
-}
-
 }  // namespace base
diff --git a/base/test/test_pending_task.h b/base/test/test_pending_task.h
index 460de0e..5e607ac 100644
--- a/base/test/test_pending_task.h
+++ b/base/test/test_pending_task.h
@@ -10,7 +10,6 @@
 #include "base/callback.h"
 #include "base/location.h"
 #include "base/time/time.h"
-#include "base/trace_event/trace_event_argument.h"
 
 namespace base {
 
@@ -58,21 +57,10 @@
   TimeDelta delay;
   TestNestability nestability;
 
-  // Functions for using test pending task with tracing, useful in unit
-  // testing.
-  void AsValueInto(base::trace_event::TracedValue* state) const;
-  std::unique_ptr<base::trace_event::ConvertableToTraceFormat> AsValue() const;
-  std::string ToString() const;
-
  private:
   DISALLOW_COPY_AND_ASSIGN(TestPendingTask);
 };
 
-// gtest helpers which allow pretty printing of the tasks, very useful in unit
-// testing.
-std::ostream& operator<<(std::ostream& os, const TestPendingTask& task);
-void PrintTo(const TestPendingTask& task, std::ostream* os);
-
 }  // namespace base
 
 #endif  // BASE_TEST_TEST_PENDING_TASK_H_
diff --git a/base/test/trace_event_analyzer.cc b/base/test/trace_event_analyzer.cc
deleted file mode 100644
index cab2899..0000000
--- a/base/test/trace_event_analyzer.cc
+++ /dev/null
@@ -1,1069 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/test/trace_event_analyzer.h"
-
-#include <math.h>
-
-#include <algorithm>
-#include <set>
-
-#include "base/json/json_reader.h"
-#include "base/memory/ptr_util.h"
-#include "base/memory/ref_counted_memory.h"
-#include "base/run_loop.h"
-#include "base/strings/pattern.h"
-#include "base/trace_event/trace_buffer.h"
-#include "base/trace_event/trace_config.h"
-#include "base/trace_event/trace_log.h"
-#include "base/values.h"
-
-namespace {
-void OnTraceDataCollected(base::OnceClosure quit_closure,
-                          base::trace_event::TraceResultBuffer* buffer,
-                          const scoped_refptr<base::RefCountedString>& json,
-                          bool has_more_events) {
-  buffer->AddFragment(json->data());
-  if (!has_more_events)
-    std::move(quit_closure).Run();
-}
-}  // namespace
-
-namespace trace_analyzer {
-
-// TraceEvent
-
-TraceEvent::TraceEvent()
-    : thread(0, 0),
-      timestamp(0),
-      duration(0),
-      phase(TRACE_EVENT_PHASE_BEGIN),
-      other_event(nullptr) {}
-
-TraceEvent::TraceEvent(TraceEvent&& other) = default;
-
-TraceEvent::~TraceEvent() = default;
-
-TraceEvent& TraceEvent::operator=(TraceEvent&& rhs) = default;
-
-bool TraceEvent::SetFromJSON(const base::Value* event_value) {
-  if (event_value->type() != base::Value::Type::DICTIONARY) {
-    LOG(ERROR) << "Value must be Type::DICTIONARY";
-    return false;
-  }
-  const base::DictionaryValue* dictionary =
-      static_cast<const base::DictionaryValue*>(event_value);
-
-  std::string phase_str;
-  const base::DictionaryValue* args = nullptr;
-
-  if (!dictionary->GetString("ph", &phase_str)) {
-    LOG(ERROR) << "ph is missing from TraceEvent JSON";
-    return false;
-  }
-
-  phase = *phase_str.data();
-
-  bool may_have_duration = (phase == TRACE_EVENT_PHASE_COMPLETE);
-  bool require_origin = (phase != TRACE_EVENT_PHASE_METADATA);
-  bool require_id = (phase == TRACE_EVENT_PHASE_ASYNC_BEGIN ||
-                     phase == TRACE_EVENT_PHASE_ASYNC_STEP_INTO ||
-                     phase == TRACE_EVENT_PHASE_ASYNC_STEP_PAST ||
-                     phase == TRACE_EVENT_PHASE_MEMORY_DUMP ||
-                     phase == TRACE_EVENT_PHASE_ENTER_CONTEXT ||
-                     phase == TRACE_EVENT_PHASE_LEAVE_CONTEXT ||
-                     phase == TRACE_EVENT_PHASE_CREATE_OBJECT ||
-                     phase == TRACE_EVENT_PHASE_DELETE_OBJECT ||
-                     phase == TRACE_EVENT_PHASE_SNAPSHOT_OBJECT ||
-                     phase == TRACE_EVENT_PHASE_ASYNC_END);
-
-  if (require_origin && !dictionary->GetInteger("pid", &thread.process_id)) {
-    LOG(ERROR) << "pid is missing from TraceEvent JSON";
-    return false;
-  }
-  if (require_origin && !dictionary->GetInteger("tid", &thread.thread_id)) {
-    LOG(ERROR) << "tid is missing from TraceEvent JSON";
-    return false;
-  }
-  if (require_origin && !dictionary->GetDouble("ts", &timestamp)) {
-    LOG(ERROR) << "ts is missing from TraceEvent JSON";
-    return false;
-  }
-  if (may_have_duration) {
-    dictionary->GetDouble("dur", &duration);
-  }
-  if (!dictionary->GetString("cat", &category)) {
-    LOG(ERROR) << "cat is missing from TraceEvent JSON";
-    return false;
-  }
-  if (!dictionary->GetString("name", &name)) {
-    LOG(ERROR) << "name is missing from TraceEvent JSON";
-    return false;
-  }
-  if (!dictionary->GetDictionary("args", &args)) {
-    LOG(ERROR) << "args is missing from TraceEvent JSON";
-    return false;
-  }
-  if (require_id && !dictionary->GetString("id", &id)) {
-    LOG(ERROR) << "id is missing from ASYNC_BEGIN/ASYNC_END TraceEvent JSON";
-    return false;
-  }
-
-  dictionary->GetDouble("tdur", &thread_duration);
-  dictionary->GetDouble("tts", &thread_timestamp);
-  dictionary->GetString("scope", &scope);
-  dictionary->GetString("bind_id", &bind_id);
-  dictionary->GetBoolean("flow_out", &flow_out);
-  dictionary->GetBoolean("flow_in", &flow_in);
-
-  const base::DictionaryValue* id2;
-  if (dictionary->GetDictionary("id2", &id2)) {
-    id2->GetString("global", &global_id2);
-    id2->GetString("local", &local_id2);
-  }
-
-  // For each argument, copy the type and create a trace_analyzer::TraceValue.
-  for (base::DictionaryValue::Iterator it(*args); !it.IsAtEnd();
-       it.Advance()) {
-    std::string str;
-    bool boolean = false;
-    int int_num = 0;
-    double double_num = 0.0;
-    if (it.value().GetAsString(&str)) {
-      arg_strings[it.key()] = str;
-    } else if (it.value().GetAsInteger(&int_num)) {
-      arg_numbers[it.key()] = static_cast<double>(int_num);
-    } else if (it.value().GetAsBoolean(&boolean)) {
-      arg_numbers[it.key()] = static_cast<double>(boolean ? 1 : 0);
-    } else if (it.value().GetAsDouble(&double_num)) {
-      arg_numbers[it.key()] = double_num;
-    }
-    // Record all arguments as values.
-    arg_values[it.key()] = it.value().CreateDeepCopy();
-  }
-
-  return true;
-}
-
-double TraceEvent::GetAbsTimeToOtherEvent() const {
-  return fabs(other_event->timestamp - timestamp);
-}
-
-bool TraceEvent::GetArgAsString(const std::string& name,
-                                std::string* arg) const {
-  const auto it = arg_strings.find(name);
-  if (it != arg_strings.end()) {
-    *arg = it->second;
-    return true;
-  }
-  return false;
-}
-
-bool TraceEvent::GetArgAsNumber(const std::string& name,
-                                double* arg) const {
-  const auto it = arg_numbers.find(name);
-  if (it != arg_numbers.end()) {
-    *arg = it->second;
-    return true;
-  }
-  return false;
-}
-
-bool TraceEvent::GetArgAsValue(const std::string& name,
-                               std::unique_ptr<base::Value>* arg) const {
-  const auto it = arg_values.find(name);
-  if (it != arg_values.end()) {
-    *arg = it->second->CreateDeepCopy();
-    return true;
-  }
-  return false;
-}
-
-bool TraceEvent::HasStringArg(const std::string& name) const {
-  return (arg_strings.find(name) != arg_strings.end());
-}
-
-bool TraceEvent::HasNumberArg(const std::string& name) const {
-  return (arg_numbers.find(name) != arg_numbers.end());
-}
-
-bool TraceEvent::HasArg(const std::string& name) const {
-  return (arg_values.find(name) != arg_values.end());
-}
-
-std::string TraceEvent::GetKnownArgAsString(const std::string& name) const {
-  std::string arg_string;
-  bool result = GetArgAsString(name, &arg_string);
-  DCHECK(result);
-  return arg_string;
-}
-
-double TraceEvent::GetKnownArgAsDouble(const std::string& name) const {
-  double arg_double = 0;
-  bool result = GetArgAsNumber(name, &arg_double);
-  DCHECK(result);
-  return arg_double;
-}
-
-int TraceEvent::GetKnownArgAsInt(const std::string& name) const {
-  double arg_double = 0;
-  bool result = GetArgAsNumber(name, &arg_double);
-  DCHECK(result);
-  return static_cast<int>(arg_double);
-}
-
-bool TraceEvent::GetKnownArgAsBool(const std::string& name) const {
-  double arg_double = 0;
-  bool result = GetArgAsNumber(name, &arg_double);
-  DCHECK(result);
-  return (arg_double != 0.0);
-}
-
-std::unique_ptr<base::Value> TraceEvent::GetKnownArgAsValue(
-    const std::string& name) const {
-  std::unique_ptr<base::Value> arg_value;
-  bool result = GetArgAsValue(name, &arg_value);
-  DCHECK(result);
-  return arg_value;
-}
-
-// QueryNode
-
-QueryNode::QueryNode(const Query& query) : query_(query) {
-}
-
-QueryNode::~QueryNode() = default;
-
-// Query
-
-Query::Query(TraceEventMember member)
-    : type_(QUERY_EVENT_MEMBER),
-      operator_(OP_INVALID),
-      member_(member),
-      number_(0),
-      is_pattern_(false) {
-}
-
-Query::Query(TraceEventMember member, const std::string& arg_name)
-    : type_(QUERY_EVENT_MEMBER),
-      operator_(OP_INVALID),
-      member_(member),
-      number_(0),
-      string_(arg_name),
-      is_pattern_(false) {
-}
-
-Query::Query(const Query& query) = default;
-
-Query::~Query() = default;
-
-Query Query::String(const std::string& str) {
-  return Query(str);
-}
-
-Query Query::Double(double num) {
-  return Query(num);
-}
-
-Query Query::Int(int32_t num) {
-  return Query(static_cast<double>(num));
-}
-
-Query Query::Uint(uint32_t num) {
-  return Query(static_cast<double>(num));
-}
-
-Query Query::Bool(bool boolean) {
-  return Query(boolean ? 1.0 : 0.0);
-}
-
-Query Query::Phase(char phase) {
-  return Query(static_cast<double>(phase));
-}
-
-Query Query::Pattern(const std::string& pattern) {
-  Query query(pattern);
-  query.is_pattern_ = true;
-  return query;
-}
-
-bool Query::Evaluate(const TraceEvent& event) const {
-  // First check for values that can convert to bool.
-
-  // double is true if != 0:
-  double bool_value = 0.0;
-  bool is_bool = GetAsDouble(event, &bool_value);
-  if (is_bool)
-    return (bool_value != 0.0);
-
-  // string is true if it is non-empty:
-  std::string str_value;
-  bool is_str = GetAsString(event, &str_value);
-  if (is_str)
-    return !str_value.empty();
-
-  DCHECK_EQ(QUERY_BOOLEAN_OPERATOR, type_)
-      << "Invalid query: missing boolean expression";
-  DCHECK(left_.get());
-  DCHECK(right_.get() || is_unary_operator());
-
-  if (is_comparison_operator()) {
-    DCHECK(left().is_value() && right().is_value())
-        << "Invalid query: comparison operator used between event member and "
-           "value.";
-    bool compare_result = false;
-    if (CompareAsDouble(event, &compare_result))
-      return compare_result;
-    if (CompareAsString(event, &compare_result))
-      return compare_result;
-    return false;
-  }
-  // It's a logical operator.
-  switch (operator_) {
-    case OP_AND:
-      return left().Evaluate(event) && right().Evaluate(event);
-    case OP_OR:
-      return left().Evaluate(event) || right().Evaluate(event);
-    case OP_NOT:
-      return !left().Evaluate(event);
-    default:
-      NOTREACHED();
-      return false;
-  }
-}
-
-bool Query::CompareAsDouble(const TraceEvent& event, bool* result) const {
-  double lhs, rhs;
-  if (!left().GetAsDouble(event, &lhs) || !right().GetAsDouble(event, &rhs))
-    return false;
-  switch (operator_) {
-    case OP_EQ:
-      *result = (lhs == rhs);
-      return true;
-    case OP_NE:
-      *result = (lhs != rhs);
-      return true;
-    case OP_LT:
-      *result = (lhs < rhs);
-      return true;
-    case OP_LE:
-      *result = (lhs <= rhs);
-      return true;
-    case OP_GT:
-      *result = (lhs > rhs);
-      return true;
-    case OP_GE:
-      *result = (lhs >= rhs);
-      return true;
-    default:
-      NOTREACHED();
-      return false;
-  }
-}
-
-bool Query::CompareAsString(const TraceEvent& event, bool* result) const {
-  std::string lhs, rhs;
-  if (!left().GetAsString(event, &lhs) || !right().GetAsString(event, &rhs))
-    return false;
-  switch (operator_) {
-    case OP_EQ:
-      if (right().is_pattern_)
-        *result = base::MatchPattern(lhs, rhs);
-      else if (left().is_pattern_)
-        *result = base::MatchPattern(rhs, lhs);
-      else
-        *result = (lhs == rhs);
-      return true;
-    case OP_NE:
-      if (right().is_pattern_)
-        *result = !base::MatchPattern(lhs, rhs);
-      else if (left().is_pattern_)
-        *result = !base::MatchPattern(rhs, lhs);
-      else
-        *result = (lhs != rhs);
-      return true;
-    case OP_LT:
-      *result = (lhs < rhs);
-      return true;
-    case OP_LE:
-      *result = (lhs <= rhs);
-      return true;
-    case OP_GT:
-      *result = (lhs > rhs);
-      return true;
-    case OP_GE:
-      *result = (lhs >= rhs);
-      return true;
-    default:
-      NOTREACHED();
-      return false;
-  }
-}
-
-bool Query::EvaluateArithmeticOperator(const TraceEvent& event,
-                                       double* num) const {
-  DCHECK_EQ(QUERY_ARITHMETIC_OPERATOR, type_);
-  DCHECK(left_.get());
-  DCHECK(right_.get() || is_unary_operator());
-
-  double lhs = 0, rhs = 0;
-  if (!left().GetAsDouble(event, &lhs))
-    return false;
-  if (!is_unary_operator() && !right().GetAsDouble(event, &rhs))
-    return false;
-
-  switch (operator_) {
-    case OP_ADD:
-      *num = lhs + rhs;
-      return true;
-    case OP_SUB:
-      *num = lhs - rhs;
-      return true;
-    case OP_MUL:
-      *num = lhs * rhs;
-      return true;
-    case OP_DIV:
-      *num = lhs / rhs;
-      return true;
-    case OP_MOD:
-      *num = static_cast<double>(static_cast<int64_t>(lhs) %
-                                 static_cast<int64_t>(rhs));
-      return true;
-    case OP_NEGATE:
-      *num = -lhs;
-      return true;
-    default:
-      NOTREACHED();
-      return false;
-  }
-}
-
-bool Query::GetAsDouble(const TraceEvent& event, double* num) const {
-  switch (type_) {
-    case QUERY_ARITHMETIC_OPERATOR:
-      return EvaluateArithmeticOperator(event, num);
-    case QUERY_EVENT_MEMBER:
-      return GetMemberValueAsDouble(event, num);
-    case QUERY_NUMBER:
-      *num = number_;
-      return true;
-    default:
-      return false;
-  }
-}
-
-bool Query::GetAsString(const TraceEvent& event, std::string* str) const {
-  switch (type_) {
-    case QUERY_EVENT_MEMBER:
-      return GetMemberValueAsString(event, str);
-    case QUERY_STRING:
-      *str = string_;
-      return true;
-    default:
-      return false;
-  }
-}
-
-const TraceEvent* Query::SelectTargetEvent(const TraceEvent* event,
-                                           TraceEventMember member) {
-  if (member >= OTHER_FIRST_MEMBER && member <= OTHER_LAST_MEMBER) {
-    return event->other_event;
-  } else if (member >= PREV_FIRST_MEMBER && member <= PREV_LAST_MEMBER) {
-    return event->prev_event;
-  } else {
-    return event;
-  }
-}
-
-bool Query::GetMemberValueAsDouble(const TraceEvent& event,
-                                   double* num) const {
-  DCHECK_EQ(QUERY_EVENT_MEMBER, type_);
-
-  // This could be a request for a member of |event| or a member of |event|'s
-  // associated previous or next event. Store the target event in the_event:
-  const TraceEvent* the_event = SelectTargetEvent(&event, member_);
-
-  // Request for member of associated event, but there is no associated event.
-  if (!the_event)
-    return false;
-
-  switch (member_) {
-    case EVENT_PID:
-    case OTHER_PID:
-    case PREV_PID:
-      *num = static_cast<double>(the_event->thread.process_id);
-      return true;
-    case EVENT_TID:
-    case OTHER_TID:
-    case PREV_TID:
-      *num = static_cast<double>(the_event->thread.thread_id);
-      return true;
-    case EVENT_TIME:
-    case OTHER_TIME:
-    case PREV_TIME:
-      *num = the_event->timestamp;
-      return true;
-    case EVENT_DURATION:
-      if (!the_event->has_other_event())
-        return false;
-      *num = the_event->GetAbsTimeToOtherEvent();
-      return true;
-    case EVENT_COMPLETE_DURATION:
-      if (the_event->phase != TRACE_EVENT_PHASE_COMPLETE)
-        return false;
-      *num = the_event->duration;
-      return true;
-    case EVENT_PHASE:
-    case OTHER_PHASE:
-    case PREV_PHASE:
-      *num = static_cast<double>(the_event->phase);
-      return true;
-    case EVENT_HAS_STRING_ARG:
-    case OTHER_HAS_STRING_ARG:
-    case PREV_HAS_STRING_ARG:
-      *num = (the_event->HasStringArg(string_) ? 1.0 : 0.0);
-      return true;
-    case EVENT_HAS_NUMBER_ARG:
-    case OTHER_HAS_NUMBER_ARG:
-    case PREV_HAS_NUMBER_ARG:
-      *num = (the_event->HasNumberArg(string_) ? 1.0 : 0.0);
-      return true;
-    case EVENT_ARG:
-    case OTHER_ARG:
-    case PREV_ARG: {
-      // Search for the argument name and return its value if found.
-      std::map<std::string, double>::const_iterator num_i =
-          the_event->arg_numbers.find(string_);
-      if (num_i == the_event->arg_numbers.end())
-        return false;
-      *num = num_i->second;
-      return true;
-    }
-    case EVENT_HAS_OTHER:
-      // return 1.0 (true) if the other event exists
-      *num = event.other_event ? 1.0 : 0.0;
-      return true;
-    case EVENT_HAS_PREV:
-      *num = event.prev_event ? 1.0 : 0.0;
-      return true;
-    default:
-      return false;
-  }
-}
-
-bool Query::GetMemberValueAsString(const TraceEvent& event,
-                                   std::string* str) const {
-  DCHECK_EQ(QUERY_EVENT_MEMBER, type_);
-
-  // This could be a request for a member of |event| or a member of |event|'s
-  // associated previous or next event. Store the target event in the_event:
-  const TraceEvent* the_event = SelectTargetEvent(&event, member_);
-
-  // Request for member of associated event, but there is no associated event.
-  if (!the_event)
-    return false;
-
-  switch (member_) {
-    case EVENT_CATEGORY:
-    case OTHER_CATEGORY:
-    case PREV_CATEGORY:
-      *str = the_event->category;
-      return true;
-    case EVENT_NAME:
-    case OTHER_NAME:
-    case PREV_NAME:
-      *str = the_event->name;
-      return true;
-    case EVENT_ID:
-    case OTHER_ID:
-    case PREV_ID:
-      *str = the_event->id;
-      return true;
-    case EVENT_ARG:
-    case OTHER_ARG:
-    case PREV_ARG: {
-      // Search for the argument name and return its value if found.
-      std::map<std::string, std::string>::const_iterator str_i =
-          the_event->arg_strings.find(string_);
-      if (str_i == the_event->arg_strings.end())
-        return false;
-      *str = str_i->second;
-      return true;
-    }
-    default:
-      return false;
-  }
-}
-
-Query::Query(const std::string& str)
-    : type_(QUERY_STRING),
-      operator_(OP_INVALID),
-      member_(EVENT_INVALID),
-      number_(0),
-      string_(str),
-      is_pattern_(false) {
-}
-
-Query::Query(double num)
-    : type_(QUERY_NUMBER),
-      operator_(OP_INVALID),
-      member_(EVENT_INVALID),
-      number_(num),
-      is_pattern_(false) {
-}
-const Query& Query::left() const {
-  return left_->query();
-}
-
-const Query& Query::right() const {
-  return right_->query();
-}
-
-Query Query::operator==(const Query& rhs) const {
-  return Query(*this, rhs, OP_EQ);
-}
-
-Query Query::operator!=(const Query& rhs) const {
-  return Query(*this, rhs, OP_NE);
-}
-
-Query Query::operator<(const Query& rhs) const {
-  return Query(*this, rhs, OP_LT);
-}
-
-Query Query::operator<=(const Query& rhs) const {
-  return Query(*this, rhs, OP_LE);
-}
-
-Query Query::operator>(const Query& rhs) const {
-  return Query(*this, rhs, OP_GT);
-}
-
-Query Query::operator>=(const Query& rhs) const {
-  return Query(*this, rhs, OP_GE);
-}
-
-Query Query::operator&&(const Query& rhs) const {
-  return Query(*this, rhs, OP_AND);
-}
-
-Query Query::operator||(const Query& rhs) const {
-  return Query(*this, rhs, OP_OR);
-}
-
-Query Query::operator!() const {
-  return Query(*this, OP_NOT);
-}
-
-Query Query::operator+(const Query& rhs) const {
-  return Query(*this, rhs, OP_ADD);
-}
-
-Query Query::operator-(const Query& rhs) const {
-  return Query(*this, rhs, OP_SUB);
-}
-
-Query Query::operator*(const Query& rhs) const {
-  return Query(*this, rhs, OP_MUL);
-}
-
-Query Query::operator/(const Query& rhs) const {
-  return Query(*this, rhs, OP_DIV);
-}
-
-Query Query::operator%(const Query& rhs) const {
-  return Query(*this, rhs, OP_MOD);
-}
-
-Query Query::operator-() const {
-  return Query(*this, OP_NEGATE);
-}
-
-
-Query::Query(const Query& left, const Query& right, Operator binary_op)
-    : operator_(binary_op),
-      left_(new QueryNode(left)),
-      right_(new QueryNode(right)),
-      member_(EVENT_INVALID),
-      number_(0) {
-  type_ = (binary_op < OP_ADD ?
-           QUERY_BOOLEAN_OPERATOR : QUERY_ARITHMETIC_OPERATOR);
-}
-
-Query::Query(const Query& left, Operator unary_op)
-    : operator_(unary_op),
-      left_(new QueryNode(left)),
-      member_(EVENT_INVALID),
-      number_(0) {
-  type_ = (unary_op < OP_ADD ?
-           QUERY_BOOLEAN_OPERATOR : QUERY_ARITHMETIC_OPERATOR);
-}
-
-namespace {
-
-// Search |events| for |query| and add matches to |output|.
-size_t FindMatchingEvents(const std::vector<TraceEvent>& events,
-                          const Query& query,
-                          TraceEventVector* output,
-                          bool ignore_metadata_events) {
-  for (size_t i = 0; i < events.size(); ++i) {
-    if (ignore_metadata_events && events[i].phase == TRACE_EVENT_PHASE_METADATA)
-      continue;
-    if (query.Evaluate(events[i]))
-      output->push_back(&events[i]);
-  }
-  return output->size();
-}
-
-bool ParseEventsFromJson(const std::string& json,
-                         std::vector<TraceEvent>* output) {
-  std::unique_ptr<base::Value> root = base::JSONReader::Read(json);
-
-  base::ListValue* root_list = nullptr;
-  if (!root.get() || !root->GetAsList(&root_list))
-    return false;
-
-  for (size_t i = 0; i < root_list->GetSize(); ++i) {
-    base::Value* item = nullptr;
-    if (root_list->Get(i, &item)) {
-      TraceEvent event;
-      if (event.SetFromJSON(item))
-        output->push_back(std::move(event));
-      else
-        return false;
-    }
-  }
-
-  return true;
-}
-
-}  // namespace
-
-// TraceAnalyzer
-
-TraceAnalyzer::TraceAnalyzer()
-    : ignore_metadata_events_(false), allow_association_changes_(true) {}
-
-TraceAnalyzer::~TraceAnalyzer() = default;
-
-// static
-TraceAnalyzer* TraceAnalyzer::Create(const std::string& json_events) {
-  std::unique_ptr<TraceAnalyzer> analyzer(new TraceAnalyzer());
-  if (analyzer->SetEvents(json_events))
-    return analyzer.release();
-  return nullptr;
-}
-
-bool TraceAnalyzer::SetEvents(const std::string& json_events) {
-  raw_events_.clear();
-  if (!ParseEventsFromJson(json_events, &raw_events_))
-    return false;
-  std::stable_sort(raw_events_.begin(), raw_events_.end());
-  ParseMetadata();
-  return true;
-}
-
-void TraceAnalyzer::AssociateBeginEndEvents() {
-  using trace_analyzer::Query;
-
-  Query begin(Query::EventPhaseIs(TRACE_EVENT_PHASE_BEGIN));
-  Query end(Query::EventPhaseIs(TRACE_EVENT_PHASE_END));
-  Query match(Query::EventName() == Query::OtherName() &&
-              Query::EventCategory() == Query::OtherCategory() &&
-              Query::EventTid() == Query::OtherTid() &&
-              Query::EventPid() == Query::OtherPid());
-
-  AssociateEvents(begin, end, match);
-}
-
-void TraceAnalyzer::AssociateAsyncBeginEndEvents(bool match_pid) {
-  using trace_analyzer::Query;
-
-  Query begin(
-      Query::EventPhaseIs(TRACE_EVENT_PHASE_ASYNC_BEGIN) ||
-      Query::EventPhaseIs(TRACE_EVENT_PHASE_ASYNC_STEP_INTO) ||
-      Query::EventPhaseIs(TRACE_EVENT_PHASE_ASYNC_STEP_PAST));
-  Query end(Query::EventPhaseIs(TRACE_EVENT_PHASE_ASYNC_END) ||
-            Query::EventPhaseIs(TRACE_EVENT_PHASE_ASYNC_STEP_INTO) ||
-            Query::EventPhaseIs(TRACE_EVENT_PHASE_ASYNC_STEP_PAST));
-  Query match(Query::EventCategory() == Query::OtherCategory() &&
-              Query::EventId() == Query::OtherId());
-
-  if (match_pid) {
-    match = match && Query::EventPid() == Query::OtherPid();
-  }
-
-  AssociateEvents(begin, end, match);
-}
-
-void TraceAnalyzer::AssociateEvents(const Query& first,
-                                    const Query& second,
-                                    const Query& match) {
-  DCHECK(allow_association_changes_)
-      << "AssociateEvents not allowed after FindEvents";
-
-  // Search for matching begin/end event pairs. When a matching end is found,
-  // it is associated with the begin event.
-  std::vector<TraceEvent*> begin_stack;
-  for (size_t event_index = 0; event_index < raw_events_.size();
-       ++event_index) {
-
-    TraceEvent& this_event = raw_events_[event_index];
-
-    if (second.Evaluate(this_event)) {
-      // Search stack for matching begin, starting from end.
-      for (int stack_index = static_cast<int>(begin_stack.size()) - 1;
-           stack_index >= 0; --stack_index) {
-        TraceEvent& begin_event = *begin_stack[stack_index];
-
-        // Temporarily set other to test against the match query.
-        const TraceEvent* other_backup = begin_event.other_event;
-        begin_event.other_event = &this_event;
-        if (match.Evaluate(begin_event)) {
-          // Found a matching begin/end pair.
-          // Set the associated previous event
-          this_event.prev_event = &begin_event;
-          // Erase the matching begin event index from the stack.
-          begin_stack.erase(begin_stack.begin() + stack_index);
-          break;
-        }
-
-        // Not a match, restore original other and continue.
-        begin_event.other_event = other_backup;
-      }
-    }
-    // Even if this_event is a |second| event that has matched an earlier
-    // |first| event, it can still also be a |first| event and be associated
-    // with a later |second| event.
-    if (first.Evaluate(this_event)) {
-      begin_stack.push_back(&this_event);
-    }
-  }
-}
-
-void TraceAnalyzer::MergeAssociatedEventArgs() {
-  for (size_t i = 0; i < raw_events_.size(); ++i) {
-    // Merge all associated events with the first event.
-    const TraceEvent* other = raw_events_[i].other_event;
-    // Avoid looping by keeping set of encountered TraceEvents.
-    std::set<const TraceEvent*> encounters;
-    encounters.insert(&raw_events_[i]);
-    while (other && encounters.find(other) == encounters.end()) {
-      encounters.insert(other);
-      raw_events_[i].arg_numbers.insert(
-          other->arg_numbers.begin(),
-          other->arg_numbers.end());
-      raw_events_[i].arg_strings.insert(
-          other->arg_strings.begin(),
-          other->arg_strings.end());
-      other = other->other_event;
-    }
-  }
-}
-
-size_t TraceAnalyzer::FindEvents(const Query& query, TraceEventVector* output) {
-  allow_association_changes_ = false;
-  output->clear();
-  return FindMatchingEvents(
-      raw_events_, query, output, ignore_metadata_events_);
-}
-
-const TraceEvent* TraceAnalyzer::FindFirstOf(const Query& query) {
-  TraceEventVector output;
-  if (FindEvents(query, &output) > 0)
-    return output.front();
-  return nullptr;
-}
-
-const TraceEvent* TraceAnalyzer::FindLastOf(const Query& query) {
-  TraceEventVector output;
-  if (FindEvents(query, &output) > 0)
-    return output.back();
-  return nullptr;
-}
-
-const std::string& TraceAnalyzer::GetThreadName(
-    const TraceEvent::ProcessThreadID& thread) {
-  // If thread is not found, just add and return empty string.
-  return thread_names_[thread];
-}
-
-void TraceAnalyzer::ParseMetadata() {
-  for (size_t i = 0; i < raw_events_.size(); ++i) {
-    TraceEvent& this_event = raw_events_[i];
-    // Check for thread name metadata.
-    if (this_event.phase != TRACE_EVENT_PHASE_METADATA ||
-        this_event.name != "thread_name")
-      continue;
-    std::map<std::string, std::string>::const_iterator string_it =
-        this_event.arg_strings.find("name");
-    if (string_it != this_event.arg_strings.end())
-      thread_names_[this_event.thread] = string_it->second;
-  }
-}
-
-// Utility functions for collecting process-local traces and creating a
-// |TraceAnalyzer| from the result.
-
-void Start(const std::string& category_filter_string) {
-  DCHECK(!base::trace_event::TraceLog::GetInstance()->IsEnabled());
-  base::trace_event::TraceLog::GetInstance()->SetEnabled(
-      base::trace_event::TraceConfig(category_filter_string, ""),
-      base::trace_event::TraceLog::RECORDING_MODE);
-}
-
-std::unique_ptr<TraceAnalyzer> Stop() {
-  DCHECK(base::trace_event::TraceLog::GetInstance()->IsEnabled());
-  base::trace_event::TraceLog::GetInstance()->SetDisabled();
-
-  base::trace_event::TraceResultBuffer buffer;
-  base::trace_event::TraceResultBuffer::SimpleOutput trace_output;
-  buffer.SetOutputCallback(trace_output.GetCallback());
-  base::RunLoop run_loop;
-  buffer.Start();
-  base::trace_event::TraceLog::GetInstance()->Flush(
-      base::BindRepeating(&OnTraceDataCollected, run_loop.QuitClosure(),
-                          base::Unretained(&buffer)));
-  run_loop.Run();
-  buffer.Finish();
-
-  return base::WrapUnique(TraceAnalyzer::Create(trace_output.json_output));
-}
-
-// TraceEventVector utility functions.
-
-bool GetRateStats(const TraceEventVector& events,
-                  RateStats* stats,
-                  const RateStatsOptions* options) {
-  DCHECK(stats);
-  // Need at least 3 events to calculate rate stats.
-  const size_t kMinEvents = 3;
-  if (events.size() < kMinEvents) {
-    LOG(ERROR) << "Not enough events: " << events.size();
-    return false;
-  }
-
-  std::vector<double> deltas;
-  size_t num_deltas = events.size() - 1;
-  for (size_t i = 0; i < num_deltas; ++i) {
-    double delta = events.at(i + 1)->timestamp - events.at(i)->timestamp;
-    if (delta < 0.0) {
-      LOG(ERROR) << "Events are out of order";
-      return false;
-    }
-    deltas.push_back(delta);
-  }
-
-  std::sort(deltas.begin(), deltas.end());
-
-  if (options) {
-    if (options->trim_min + options->trim_max > events.size() - kMinEvents) {
-      LOG(ERROR) << "Attempt to trim too many events";
-      return false;
-    }
-    deltas.erase(deltas.begin(), deltas.begin() + options->trim_min);
-    deltas.erase(deltas.end() - options->trim_max, deltas.end());
-  }
-
-  num_deltas = deltas.size();
-  double delta_sum = 0.0;
-  for (size_t i = 0; i < num_deltas; ++i)
-    delta_sum += deltas[i];
-
-  stats->min_us = *std::min_element(deltas.begin(), deltas.end());
-  stats->max_us = *std::max_element(deltas.begin(), deltas.end());
-  stats->mean_us = delta_sum / static_cast<double>(num_deltas);
-
-  double sum_mean_offsets_squared = 0.0;
-  for (size_t i = 0; i < num_deltas; ++i) {
-    double offset = fabs(deltas[i] - stats->mean_us);
-    sum_mean_offsets_squared += offset * offset;
-  }
-  stats->standard_deviation_us =
-      sqrt(sum_mean_offsets_squared / static_cast<double>(num_deltas - 1));
-
-  return true;
-}
-
-bool FindFirstOf(const TraceEventVector& events,
-                 const Query& query,
-                 size_t position,
-                 size_t* return_index) {
-  DCHECK(return_index);
-  for (size_t i = position; i < events.size(); ++i) {
-    if (query.Evaluate(*events[i])) {
-      *return_index = i;
-      return true;
-    }
-  }
-  return false;
-}
-
-bool FindLastOf(const TraceEventVector& events,
-                const Query& query,
-                size_t position,
-                size_t* return_index) {
-  DCHECK(return_index);
-  for (size_t i = std::min(position + 1, events.size()); i != 0; --i) {
-    if (query.Evaluate(*events[i - 1])) {
-      *return_index = i - 1;
-      return true;
-    }
-  }
-  return false;
-}
-
-bool FindClosest(const TraceEventVector& events,
-                 const Query& query,
-                 size_t position,
-                 size_t* return_closest,
-                 size_t* return_second_closest) {
-  DCHECK(return_closest);
-  if (events.empty() || position >= events.size())
-    return false;
-  size_t closest = events.size();
-  size_t second_closest = events.size();
-  for (size_t i = 0; i < events.size(); ++i) {
-    if (!query.Evaluate(*events.at(i)))
-      continue;
-    if (closest == events.size()) {
-      closest = i;
-      continue;
-    }
-    if (fabs(events.at(i)->timestamp - events.at(position)->timestamp) <
-        fabs(events.at(closest)->timestamp - events.at(position)->timestamp)) {
-      second_closest = closest;
-      closest = i;
-    } else if (second_closest == events.size()) {
-      second_closest = i;
-    }
-  }
-
-  if (closest < events.size() &&
-      (!return_second_closest || second_closest < events.size())) {
-    *return_closest = closest;
-    if (return_second_closest)
-      *return_second_closest = second_closest;
-    return true;
-  }
-
-  return false;
-}
-
-size_t CountMatches(const TraceEventVector& events,
-                    const Query& query,
-                    size_t begin_position,
-                    size_t end_position) {
-  if (begin_position >= events.size())
-    return 0u;
-  end_position = (end_position < events.size()) ? end_position : events.size();
-  size_t count = 0u;
-  for (size_t i = begin_position; i < end_position; ++i) {
-    if (query.Evaluate(*events.at(i)))
-      ++count;
-  }
-  return count;
-}
-
-}  // namespace trace_analyzer
diff --git a/base/test/trace_event_analyzer.h b/base/test/trace_event_analyzer.h
deleted file mode 100644
index dcdd2e4..0000000
--- a/base/test/trace_event_analyzer.h
+++ /dev/null
@@ -1,842 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-// Use trace_analyzer::Query and trace_analyzer::TraceAnalyzer to search for
-// specific trace events that were generated by the trace_event.h API.
-//
-// Basic procedure:
-// - Get trace events JSON string from base::trace_event::TraceLog.
-// - Create TraceAnalyzer with JSON string.
-// - Call TraceAnalyzer::AssociateBeginEndEvents (optional).
-// - Call TraceAnalyzer::AssociateEvents (zero or more times).
-// - Call TraceAnalyzer::FindEvents with queries to find specific events.
-//
-// A Query is a boolean expression tree that evaluates to true or false for a
-// given trace event. Queries can be combined into a tree using boolean,
-// arithmetic and comparison operators that refer to data of an individual trace
-// event.
-//
-// The events are returned as trace_analyzer::TraceEvent objects.
-// TraceEvent contains a single trace event's data, as well as a pointer to
-// a related trace event. The related trace event is typically the matching end
-// of a begin event or the matching begin of an end event.
-//
-// The following examples use this basic setup code to construct TraceAnalyzer
-// with the json trace string retrieved from TraceLog and construct an event
-// vector for retrieving events:
-//
-// TraceAnalyzer analyzer(json_events);
-// TraceEventVector events;
-//
-// EXAMPLE 1: Find events named "my_event".
-//
-// analyzer.FindEvents(Query(EVENT_NAME) == "my_event", &events);
-//
-// EXAMPLE 2: Find begin events named "my_event" with duration > 1 second.
-//
-// Query q = (Query(EVENT_NAME) == Query::String("my_event") &&
-//            Query(EVENT_PHASE) == Query::Phase(TRACE_EVENT_PHASE_BEGIN) &&
-//            Query(EVENT_DURATION) > Query::Double(1000000.0));
-// analyzer.FindEvents(q, &events);
-//
-// EXAMPLE 3: Associating event pairs across threads.
-//
-// If the test needs to analyze something that starts and ends on different
-// threads, the test needs to use INSTANT events. The typical procedure is to
-// specify the same unique ID as a TRACE_EVENT argument on both the start and
-// finish INSTANT events. Then use the following procedure to associate those
-// events.
-//
-// Step 1: instrument code with custom begin/end trace events.
-//   [Thread 1 tracing code]
-//   TRACE_EVENT_INSTANT1("test_latency", "timing1_begin", "id", 3);
-//   [Thread 2 tracing code]
-//   TRACE_EVENT_INSTANT1("test_latency", "timing1_end", "id", 3);
-//
-// Step 2: associate these custom begin/end pairs.
-//   Query begin(Query(EVENT_NAME) == Query::String("timing1_begin"));
-//   Query end(Query(EVENT_NAME) == Query::String("timing1_end"));
-//   Query match(Query(EVENT_ARG, "id") == Query(OTHER_ARG, "id"));
-//   analyzer.AssociateEvents(begin, end, match);
-//
-// Step 3: search for "timing1_begin" events with existing other event.
-//   Query q = (Query(EVENT_NAME) == Query::String("timing1_begin") &&
-//              Query(EVENT_HAS_OTHER));
-//   analyzer.FindEvents(q, &events);
-//
-// Step 4: analyze events, such as checking durations.
-//   for (size_t i = 0; i < events.size(); ++i) {
-//     double duration;
-//     EXPECT_TRUE(events[i].GetAbsTimeToOtherEvent(&duration));
-//     EXPECT_LT(duration, 1000000.0/60.0); // expect less than 1/60 second.
-//   }
-//
-// There are two helper functions, Start(category_filter_string) and Stop(), for
-// facilitating the collection of process-local traces and building a
-// TraceAnalyzer from them. A typical test, that uses the helper functions,
-// looks like the following:
-//
-// TEST_F(...) {
-//   Start("*");
-//   [Invoke the functions you want to test their traces]
-//   auto analyzer = Stop();
-//
-//   [Use the analyzer to verify produced traces, as explained above]
-// }
-//
-// Note: The Stop() function needs a SingleThreadTaskRunner.
-
-#ifndef BASE_TEST_TRACE_EVENT_ANALYZER_H_
-#define BASE_TEST_TRACE_EVENT_ANALYZER_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-#include <map>
-#include <memory>
-#include <string>
-#include <vector>
-
-#include "base/macros.h"
-#include "base/memory/ref_counted.h"
-#include "base/trace_event/trace_event.h"
-
-namespace base {
-class Value;
-}
-
-namespace trace_analyzer {
-class QueryNode;
-
-// trace_analyzer::TraceEvent is a more convenient form of the
-// base::trace_event::TraceEvent class to make tracing-based tests easier to
-// write.
-struct TraceEvent {
-  // ProcessThreadID contains a Process ID and Thread ID.
-  struct ProcessThreadID {
-    ProcessThreadID() : process_id(0), thread_id(0) {}
-    ProcessThreadID(int process_id, int thread_id)
-        : process_id(process_id), thread_id(thread_id) {}
-    bool operator< (const ProcessThreadID& rhs) const {
-      if (process_id != rhs.process_id)
-        return process_id < rhs.process_id;
-      return thread_id < rhs.thread_id;
-    }
-    int process_id;
-    int thread_id;
-  };
-
-  TraceEvent();
-  TraceEvent(TraceEvent&& other);
-  ~TraceEvent();
-
-  bool SetFromJSON(const base::Value* event_value) WARN_UNUSED_RESULT;
-
-  bool operator< (const TraceEvent& rhs) const {
-    return timestamp < rhs.timestamp;
-  }
-
-  TraceEvent& operator=(TraceEvent&& rhs);
-
-  bool has_other_event() const { return other_event; }
-
-  // Returns absolute duration in microseconds between this event and other
-  // event. Must have already verified that other_event exists by
-  // Query(EVENT_HAS_OTHER) or by calling has_other_event().
-  double GetAbsTimeToOtherEvent() const;
-
-  // Return the argument value if it exists and it is a string.
-  bool GetArgAsString(const std::string& name, std::string* arg) const;
-  // Return the argument value if it exists and it is a number.
-  bool GetArgAsNumber(const std::string& name, double* arg) const;
-  // Return the argument value if it exists.
-  bool GetArgAsValue(const std::string& name,
-                     std::unique_ptr<base::Value>* arg) const;
-
-  // Check if argument exists and is string.
-  bool HasStringArg(const std::string& name) const;
-  // Check if argument exists and is number (double, int or bool).
-  bool HasNumberArg(const std::string& name) const;
-  // Check if argument exists.
-  bool HasArg(const std::string& name) const;
-
-  // Get known existing arguments as specific types.
-  // Useful when you have already queried the argument with
-  // Query(HAS_NUMBER_ARG) or Query(HAS_STRING_ARG).
-  std::string GetKnownArgAsString(const std::string& name) const;
-  double GetKnownArgAsDouble(const std::string& name) const;
-  int GetKnownArgAsInt(const std::string& name) const;
-  bool GetKnownArgAsBool(const std::string& name) const;
-  std::unique_ptr<base::Value> GetKnownArgAsValue(
-      const std::string& name) const;
-
-  // Process ID and Thread ID.
-  ProcessThreadID thread;
-
-  // Time since epoch in microseconds.
-  // Stored as double to match its JSON representation.
-  double timestamp;
-  double duration;
-  char phase;
-  std::string category;
-  std::string name;
-  std::string id;
-  double thread_duration = 0.0;
-  double thread_timestamp = 0.0;
-  std::string scope;
-  std::string bind_id;
-  bool flow_out = false;
-  bool flow_in = false;
-  std::string global_id2;
-  std::string local_id2;
-
-  // All numbers and bool values from TraceEvent args are cast to double.
-  // bool becomes 1.0 (true) or 0.0 (false).
-  std::map<std::string, double> arg_numbers;
-  std::map<std::string, std::string> arg_strings;
-  std::map<std::string, std::unique_ptr<base::Value>> arg_values;
-
-  // The other event associated with this event (or NULL).
-  const TraceEvent* other_event;
-
-  // A back-link for |other_event|. That is, if other_event is not null, then
-  // |event->other_event->prev_event == event| is always true.
-  const TraceEvent* prev_event;
-};
-
-typedef std::vector<const TraceEvent*> TraceEventVector;
-
-class Query {
- public:
-  Query(const Query& query);
-
-  ~Query();
-
-  ////////////////////////////////////////////////////////////////
-  // Query literal values
-
-  // Compare with the given string.
-  static Query String(const std::string& str);
-
-  // Compare with the given number.
-  static Query Double(double num);
-  static Query Int(int32_t num);
-  static Query Uint(uint32_t num);
-
-  // Compare with the given bool.
-  static Query Bool(bool boolean);
-
-  // Compare with the given phase.
-  static Query Phase(char phase);
-
-  // Compare with the given string pattern. Only works with == and != operators.
-  // Example: Query(EVENT_NAME) == Query::Pattern("MyEvent*")
-  static Query Pattern(const std::string& pattern);
-
-  ////////////////////////////////////////////////////////////////
-  // Query event members
-
-  static Query EventPid() { return Query(EVENT_PID); }
-
-  static Query EventTid() { return Query(EVENT_TID); }
-
-  // Return the timestamp of the event in microseconds since epoch.
-  static Query EventTime() { return Query(EVENT_TIME); }
-
-  // Return the absolute time between event and other event in microseconds.
-  // Only works if Query::EventHasOther() == true.
-  static Query EventDuration() { return Query(EVENT_DURATION); }
-
-  // Return the duration of a COMPLETE event.
-  static Query EventCompleteDuration() {
-    return Query(EVENT_COMPLETE_DURATION);
-  }
-
-  static Query EventPhase() { return Query(EVENT_PHASE); }
-
-  static Query EventCategory() { return Query(EVENT_CATEGORY); }
-
-  static Query EventName() { return Query(EVENT_NAME); }
-
-  static Query EventId() { return Query(EVENT_ID); }
-
-  static Query EventPidIs(int process_id) {
-    return Query(EVENT_PID) == Query::Int(process_id);
-  }
-
-  static Query EventTidIs(int thread_id) {
-    return Query(EVENT_TID) == Query::Int(thread_id);
-  }
-
-  static Query EventThreadIs(const TraceEvent::ProcessThreadID& thread) {
-    return EventPidIs(thread.process_id) && EventTidIs(thread.thread_id);
-  }
-
-  static Query EventTimeIs(double timestamp) {
-    return Query(EVENT_TIME) == Query::Double(timestamp);
-  }
-
-  static Query EventDurationIs(double duration) {
-    return Query(EVENT_DURATION) == Query::Double(duration);
-  }
-
-  static Query EventPhaseIs(char phase) {
-    return Query(EVENT_PHASE) == Query::Phase(phase);
-  }
-
-  static Query EventCategoryIs(const std::string& category) {
-    return Query(EVENT_CATEGORY) == Query::String(category);
-  }
-
-  static Query EventNameIs(const std::string& name) {
-    return Query(EVENT_NAME) == Query::String(name);
-  }
-
-  static Query EventIdIs(const std::string& id) {
-    return Query(EVENT_ID) == Query::String(id);
-  }
-
-  // Evaluates to true if arg exists and is a string.
-  static Query EventHasStringArg(const std::string& arg_name) {
-    return Query(EVENT_HAS_STRING_ARG, arg_name);
-  }
-
-  // Evaluates to true if arg exists and is a number.
-  // Number arguments include types double, int and bool.
-  static Query EventHasNumberArg(const std::string& arg_name) {
-    return Query(EVENT_HAS_NUMBER_ARG, arg_name);
-  }
-
-  // Evaluates to arg value (string or number).
-  static Query EventArg(const std::string& arg_name) {
-    return Query(EVENT_ARG, arg_name);
-  }
-
-  // Return true if associated event exists.
-  static Query EventHasOther() { return Query(EVENT_HAS_OTHER); }
-
-  // Access the associated other_event's members:
-
-  static Query OtherPid() { return Query(OTHER_PID); }
-
-  static Query OtherTid() { return Query(OTHER_TID); }
-
-  static Query OtherTime() { return Query(OTHER_TIME); }
-
-  static Query OtherPhase() { return Query(OTHER_PHASE); }
-
-  static Query OtherCategory() { return Query(OTHER_CATEGORY); }
-
-  static Query OtherName() { return Query(OTHER_NAME); }
-
-  static Query OtherId() { return Query(OTHER_ID); }
-
-  static Query OtherPidIs(int process_id) {
-    return Query(OTHER_PID) == Query::Int(process_id);
-  }
-
-  static Query OtherTidIs(int thread_id) {
-    return Query(OTHER_TID) == Query::Int(thread_id);
-  }
-
-  static Query OtherThreadIs(const TraceEvent::ProcessThreadID& thread) {
-    return OtherPidIs(thread.process_id) && OtherTidIs(thread.thread_id);
-  }
-
-  static Query OtherTimeIs(double timestamp) {
-    return Query(OTHER_TIME) == Query::Double(timestamp);
-  }
-
-  static Query OtherPhaseIs(char phase) {
-    return Query(OTHER_PHASE) == Query::Phase(phase);
-  }
-
-  static Query OtherCategoryIs(const std::string& category) {
-    return Query(OTHER_CATEGORY) == Query::String(category);
-  }
-
-  static Query OtherNameIs(const std::string& name) {
-    return Query(OTHER_NAME) == Query::String(name);
-  }
-
-  static Query OtherIdIs(const std::string& id) {
-    return Query(OTHER_ID) == Query::String(id);
-  }
-
-  // Evaluates to true if arg exists and is a string.
-  static Query OtherHasStringArg(const std::string& arg_name) {
-    return Query(OTHER_HAS_STRING_ARG, arg_name);
-  }
-
-  // Evaluates to true if arg exists and is a number.
-  // Number arguments include types double, int and bool.
-  static Query OtherHasNumberArg(const std::string& arg_name) {
-    return Query(OTHER_HAS_NUMBER_ARG, arg_name);
-  }
-
-  // Evaluates to arg value (string or number).
-  static Query OtherArg(const std::string& arg_name) {
-    return Query(OTHER_ARG, arg_name);
-  }
-
-  // Access the associated prev_event's members:
-
-  static Query PrevPid() { return Query(PREV_PID); }
-
-  static Query PrevTid() { return Query(PREV_TID); }
-
-  static Query PrevTime() { return Query(PREV_TIME); }
-
-  static Query PrevPhase() { return Query(PREV_PHASE); }
-
-  static Query PrevCategory() { return Query(PREV_CATEGORY); }
-
-  static Query PrevName() { return Query(PREV_NAME); }
-
-  static Query PrevId() { return Query(PREV_ID); }
-
-  static Query PrevPidIs(int process_id) {
-    return Query(PREV_PID) == Query::Int(process_id);
-  }
-
-  static Query PrevTidIs(int thread_id) {
-    return Query(PREV_TID) == Query::Int(thread_id);
-  }
-
-  static Query PrevThreadIs(const TraceEvent::ProcessThreadID& thread) {
-    return PrevPidIs(thread.process_id) && PrevTidIs(thread.thread_id);
-  }
-
-  static Query PrevTimeIs(double timestamp) {
-    return Query(PREV_TIME) == Query::Double(timestamp);
-  }
-
-  static Query PrevPhaseIs(char phase) {
-    return Query(PREV_PHASE) == Query::Phase(phase);
-  }
-
-  static Query PrevCategoryIs(const std::string& category) {
-    return Query(PREV_CATEGORY) == Query::String(category);
-  }
-
-  static Query PrevNameIs(const std::string& name) {
-    return Query(PREV_NAME) == Query::String(name);
-  }
-
-  static Query PrevIdIs(const std::string& id) {
-    return Query(PREV_ID) == Query::String(id);
-  }
-
-  // Evaluates to true if arg exists and is a string.
-  static Query PrevHasStringArg(const std::string& arg_name) {
-    return Query(PREV_HAS_STRING_ARG, arg_name);
-  }
-
-  // Evaluates to true if arg exists and is a number.
-  // Number arguments include types double, int and bool.
-  static Query PrevHasNumberArg(const std::string& arg_name) {
-    return Query(PREV_HAS_NUMBER_ARG, arg_name);
-  }
-
-  // Evaluates to arg value (string or number).
-  static Query PrevArg(const std::string& arg_name) {
-    return Query(PREV_ARG, arg_name);
-  }
-
-  ////////////////////////////////////////////////////////////////
-  // Common queries:
-
-  // Find BEGIN events that have a corresponding END event.
-  static Query MatchBeginWithEnd() {
-    return (Query(EVENT_PHASE) == Query::Phase(TRACE_EVENT_PHASE_BEGIN)) &&
-           Query(EVENT_HAS_OTHER);
-  }
-
-  // Find COMPLETE events.
-  static Query MatchComplete() {
-    return (Query(EVENT_PHASE) == Query::Phase(TRACE_EVENT_PHASE_COMPLETE));
-  }
-
-  // Find ASYNC_BEGIN events that have a corresponding ASYNC_END event.
-  static Query MatchAsyncBeginWithNext() {
-    return (Query(EVENT_PHASE) ==
-            Query::Phase(TRACE_EVENT_PHASE_ASYNC_BEGIN)) &&
-           Query(EVENT_HAS_OTHER);
-  }
-
-  // Find BEGIN events of given |name| which also have associated END events.
-  static Query MatchBeginName(const std::string& name) {
-    return (Query(EVENT_NAME) == Query(name)) && MatchBeginWithEnd();
-  }
-
-  // Find COMPLETE events of given |name|.
-  static Query MatchCompleteName(const std::string& name) {
-    return (Query(EVENT_NAME) == Query(name)) && MatchComplete();
-  }
-
-  // Match given Process ID and Thread ID.
-  static Query MatchThread(const TraceEvent::ProcessThreadID& thread) {
-    return (Query(EVENT_PID) == Query::Int(thread.process_id)) &&
-           (Query(EVENT_TID) == Query::Int(thread.thread_id));
-  }
-
-  // Match event pair that spans multiple threads.
-  static Query MatchCrossThread() {
-    return (Query(EVENT_PID) != Query(OTHER_PID)) ||
-           (Query(EVENT_TID) != Query(OTHER_TID));
-  }
-
-  ////////////////////////////////////////////////////////////////
-  // Operators:
-
-  // Boolean operators:
-  Query operator==(const Query& rhs) const;
-  Query operator!=(const Query& rhs) const;
-  Query operator< (const Query& rhs) const;
-  Query operator<=(const Query& rhs) const;
-  Query operator> (const Query& rhs) const;
-  Query operator>=(const Query& rhs) const;
-  Query operator&&(const Query& rhs) const;
-  Query operator||(const Query& rhs) const;
-  Query operator!() const;
-
-  // Arithmetic operators:
-  // Following operators are applied to double arguments:
-  Query operator+(const Query& rhs) const;
-  Query operator-(const Query& rhs) const;
-  Query operator*(const Query& rhs) const;
-  Query operator/(const Query& rhs) const;
-  Query operator-() const;
-  // Mod operates on int64_t args (doubles are casted to int64_t beforehand):
-  Query operator%(const Query& rhs) const;
-
-  // Return true if the given event matches this query tree.
-  // This is a recursive method that walks the query tree.
-  bool Evaluate(const TraceEvent& event) const;
-
-  enum TraceEventMember {
-    EVENT_INVALID,
-    EVENT_PID,
-    EVENT_TID,
-    EVENT_TIME,
-    EVENT_DURATION,
-    EVENT_COMPLETE_DURATION,
-    EVENT_PHASE,
-    EVENT_CATEGORY,
-    EVENT_NAME,
-    EVENT_ID,
-    EVENT_HAS_STRING_ARG,
-    EVENT_HAS_NUMBER_ARG,
-    EVENT_ARG,
-    EVENT_HAS_OTHER,
-    EVENT_HAS_PREV,
-
-    OTHER_PID,
-    OTHER_TID,
-    OTHER_TIME,
-    OTHER_PHASE,
-    OTHER_CATEGORY,
-    OTHER_NAME,
-    OTHER_ID,
-    OTHER_HAS_STRING_ARG,
-    OTHER_HAS_NUMBER_ARG,
-    OTHER_ARG,
-
-    PREV_PID,
-    PREV_TID,
-    PREV_TIME,
-    PREV_PHASE,
-    PREV_CATEGORY,
-    PREV_NAME,
-    PREV_ID,
-    PREV_HAS_STRING_ARG,
-    PREV_HAS_NUMBER_ARG,
-    PREV_ARG,
-
-    OTHER_FIRST_MEMBER = OTHER_PID,
-    OTHER_LAST_MEMBER = OTHER_ARG,
-
-    PREV_FIRST_MEMBER = PREV_PID,
-    PREV_LAST_MEMBER = PREV_ARG,
-  };
-
-  enum Operator {
-    OP_INVALID,
-    // Boolean operators:
-    OP_EQ,
-    OP_NE,
-    OP_LT,
-    OP_LE,
-    OP_GT,
-    OP_GE,
-    OP_AND,
-    OP_OR,
-    OP_NOT,
-    // Arithmetic operators:
-    OP_ADD,
-    OP_SUB,
-    OP_MUL,
-    OP_DIV,
-    OP_MOD,
-    OP_NEGATE
-  };
-
-  enum QueryType {
-    QUERY_BOOLEAN_OPERATOR,
-    QUERY_ARITHMETIC_OPERATOR,
-    QUERY_EVENT_MEMBER,
-    QUERY_NUMBER,
-    QUERY_STRING
-  };
-
-  // Compare with the given member.
-  explicit Query(TraceEventMember member);
-
-  // Compare with the given member argument value.
-  Query(TraceEventMember member, const std::string& arg_name);
-
-  // Compare with the given string.
-  explicit Query(const std::string& str);
-
-  // Compare with the given number.
-  explicit Query(double num);
-
-  // Construct a boolean Query that returns (left <binary_op> right).
-  Query(const Query& left, const Query& right, Operator binary_op);
-
-  // Construct a boolean Query that returns (<binary_op> left).
-  Query(const Query& left, Operator unary_op);
-
-  // Try to compare left_ against right_ based on operator_.
-  // If either left or right does not convert to double, false is returned.
-  // Otherwise, true is returned and |result| is set to the comparison result.
-  bool CompareAsDouble(const TraceEvent& event, bool* result) const;
-
-  // Try to compare left_ against right_ based on operator_.
-  // If either left or right does not convert to string, false is returned.
-  // Otherwise, true is returned and |result| is set to the comparison result.
-  bool CompareAsString(const TraceEvent& event, bool* result) const;
-
-  // Attempt to convert this Query to a double. On success, true is returned
-  // and the double value is stored in |num|.
-  bool GetAsDouble(const TraceEvent& event, double* num) const;
-
-  // Attempt to convert this Query to a string. On success, true is returned
-  // and the string value is stored in |str|.
-  bool GetAsString(const TraceEvent& event, std::string* str) const;
-
-  // Evaluate this Query as an arithmetic operator on left_ and right_.
-  bool EvaluateArithmeticOperator(const TraceEvent& event,
-                                  double* num) const;
-
-  // For QUERY_EVENT_MEMBER Query: attempt to get the double value of the Query.
-  bool GetMemberValueAsDouble(const TraceEvent& event, double* num) const;
-
-  // For QUERY_EVENT_MEMBER Query: attempt to get the string value of the Query.
-  bool GetMemberValueAsString(const TraceEvent& event, std::string* num) const;
-
-  // Does this Query represent a value?
-  bool is_value() const { return type_ != QUERY_BOOLEAN_OPERATOR; }
-
-  bool is_unary_operator() const {
-    return operator_ == OP_NOT || operator_ == OP_NEGATE;
-  }
-
-  bool is_comparison_operator() const {
-    return operator_ != OP_INVALID && operator_ < OP_AND;
-  }
-
-  static const TraceEvent* SelectTargetEvent(const TraceEvent* ev,
-                                             TraceEventMember member);
-
-  const Query& left() const;
-  const Query& right() const;
-
- private:
-  QueryType type_;
-  Operator operator_;
-  scoped_refptr<QueryNode> left_;
-  scoped_refptr<QueryNode> right_;
-  TraceEventMember member_;
-  double number_;
-  std::string string_;
-  bool is_pattern_;
-};
-
-// Implementation detail:
-// QueryNode allows Query to store a ref-counted query tree.
-class QueryNode : public base::RefCounted<QueryNode> {
- public:
-  explicit QueryNode(const Query& query);
-  const Query& query() const { return query_; }
-
- private:
-  friend class base::RefCounted<QueryNode>;
-  ~QueryNode();
-
-  Query query_;
-};
-
-// TraceAnalyzer helps tests search for trace events.
-class TraceAnalyzer {
- public:
-  ~TraceAnalyzer();
-
-  // Use trace events from JSON string generated by tracing API.
-  // Returns non-NULL if the JSON is successfully parsed.
-  static TraceAnalyzer* Create(const std::string& json_events)
-                               WARN_UNUSED_RESULT;
-
-  void SetIgnoreMetadataEvents(bool ignore) {
-    ignore_metadata_events_ = ignore;
-  }
-
-  // Associate BEGIN and END events with each other. This allows Query(OTHER_*)
-  // to access the associated event and enables Query(EVENT_DURATION).
-  // An end event will match the most recent begin event with the same name,
-  // category, process ID and thread ID. This matches what is shown in
-  // about:tracing. After association, the BEGIN event will point to the
-  // matching END event, but the END event will not point to the BEGIN event.
-  void AssociateBeginEndEvents();
-
-  // Associate ASYNC_BEGIN, ASYNC_STEP and ASYNC_END events with each other.
-  // An ASYNC_END event will match the most recent ASYNC_BEGIN or ASYNC_STEP
-  // event with the same name, category, and ID. This creates a singly linked
-  // list of ASYNC_BEGIN->ASYNC_STEP...->ASYNC_END.
-  // |match_pid| - If true, will only match async events which are running
-  //               under the same process ID, otherwise will allow linking
-  //               async events from different processes.
-  void AssociateAsyncBeginEndEvents(bool match_pid = true);
-
-  // AssociateEvents can be used to customize event associations by setting the
-  // other_event member of TraceEvent. This should be used to associate two
-  // INSTANT events.
-  //
-  // The assumptions are:
-  // - |first| events occur before |second| events.
-  // - the closest matching |second| event is the correct match.
-  //
-  // |first|  - Eligible |first| events match this query.
-  // |second| - Eligible |second| events match this query.
-  // |match|  - This query is run on the |first| event. The OTHER_* EventMember
-  //            queries will point to an eligible |second| event. The query
-  //            should evaluate to true if the |first|/|second| pair is a match.
-  //
-  // When a match is found, the pair will be associated by having the first
-  // event's other_event member point to the other. AssociateEvents does not
-  // clear previous associations, so it is possible to associate multiple pairs
-  // of events by calling AssociateEvents more than once with different queries.
-  //
-  // NOTE: AssociateEvents will overwrite existing other_event associations if
-  // the queries pass for events that already had a previous association.
-  //
-  // After calling any Find* method, it is not allowed to call AssociateEvents
-  // again.
-  void AssociateEvents(const Query& first,
-                       const Query& second,
-                       const Query& match);
-
-  // For each event, copy its arguments to the other_event argument map. If
-  // argument name already exists, it will not be overwritten.
-  void MergeAssociatedEventArgs();
-
-  // Find all events that match query and replace output vector.
-  size_t FindEvents(const Query& query, TraceEventVector* output);
-
-  // Find first event that matches query or NULL if not found.
-  const TraceEvent* FindFirstOf(const Query& query);
-
-  // Find last event that matches query or NULL if not found.
-  const TraceEvent* FindLastOf(const Query& query);
-
-  const std::string& GetThreadName(const TraceEvent::ProcessThreadID& thread);
-
- private:
-  TraceAnalyzer();
-
-  bool SetEvents(const std::string& json_events) WARN_UNUSED_RESULT;
-
-  // Read metadata (thread names, etc) from events.
-  void ParseMetadata();
-
-  std::map<TraceEvent::ProcessThreadID, std::string> thread_names_;
-  std::vector<TraceEvent> raw_events_;
-  bool ignore_metadata_events_;
-  bool allow_association_changes_;
-
-  DISALLOW_COPY_AND_ASSIGN(TraceAnalyzer);
-};
-
-// Utility functions for collecting process-local traces and creating a
-// |TraceAnalyzer| from the result. Please see comments in trace_config.h to
-// understand how the |category_filter_string| works. Use "*" to enable all
-// default categories.
-void Start(const std::string& category_filter_string);
-std::unique_ptr<TraceAnalyzer> Stop();
-
-// Utility functions for TraceEventVector.
-
-struct RateStats {
-  double min_us;
-  double max_us;
-  double mean_us;
-  double standard_deviation_us;
-};
-
-struct RateStatsOptions {
-  RateStatsOptions() : trim_min(0u), trim_max(0u) {}
-  // After the times between events are sorted, the number of specified elements
-  // will be trimmed before calculating the RateStats. This is useful in cases
-  // where extreme outliers are tolerable and should not skew the overall
-  // average.
-  size_t trim_min;  // Trim this many minimum times.
-  size_t trim_max;  // Trim this many maximum times.
-};
-
-// Calculate min/max/mean and standard deviation from the times between
-// adjacent events.
-bool GetRateStats(const TraceEventVector& events,
-                  RateStats* stats,
-                  const RateStatsOptions* options);
-
-// Starting from |position|, find the first event that matches |query|.
-// Returns true if found, false otherwise.
-bool FindFirstOf(const TraceEventVector& events,
-                 const Query& query,
-                 size_t position,
-                 size_t* return_index);
-
-// Starting from |position|, find the last event that matches |query|.
-// Returns true if found, false otherwise.
-bool FindLastOf(const TraceEventVector& events,
-                const Query& query,
-                size_t position,
-                size_t* return_index);
-
-// Find the closest events to |position| in time that match |query|.
-// return_second_closest may be NULL. Closeness is determined by comparing
-// with the event timestamp.
-// Returns true if found, false otherwise. If both return parameters are
-// requested, both must be found for a successful result.
-bool FindClosest(const TraceEventVector& events,
-                 const Query& query,
-                 size_t position,
-                 size_t* return_closest,
-                 size_t* return_second_closest);
-
-// Count matches, inclusive of |begin_position|, exclusive of |end_position|.
-size_t CountMatches(const TraceEventVector& events,
-                    const Query& query,
-                    size_t begin_position,
-                    size_t end_position);
-
-// Count all matches.
-static inline size_t CountMatches(const TraceEventVector& events,
-                                  const Query& query) {
-  return CountMatches(events, query, 0u, events.size());
-}
-
-}  // namespace trace_analyzer
-
-#endif  // BASE_TEST_TRACE_EVENT_ANALYZER_H_
diff --git a/base/threading/thread_id_name_manager.cc b/base/threading/thread_id_name_manager.cc
index ca1979d..101b57d 100644
--- a/base/threading/thread_id_name_manager.cc
+++ b/base/threading/thread_id_name_manager.cc
@@ -12,7 +12,6 @@
 #include "base/no_destructor.h"
 #include "base/strings/string_util.h"
 #include "base/threading/thread_local.h"
-#include "base/trace_event/heap_profiler_allocation_context_tracker.h"
 
 namespace base {
 namespace {
@@ -88,14 +87,6 @@
     }
     thread_handle_to_interned_name_[id_to_handle_iter->second] = leaked_str;
   }
-
-  // Add the leaked thread name to heap profiler context tracker. The name added
-  // is valid for the lifetime of the process. AllocationContextTracker cannot
-  // call GetName(which holds a lock) during the first allocation because it can
-  // cause a deadlock when the first allocation happens in the
-  // ThreadIdNameManager itself when holding the lock.
-  trace_event::AllocationContextTracker::SetCurrentThreadName(
-      leaked_str->c_str());
 }
 
 const char* ThreadIdNameManager::GetName(PlatformThreadId id) {
diff --git a/base/trace_event/OWNERS b/base/trace_event/OWNERS
deleted file mode 100644
index 24a0bd2..0000000
--- a/base/trace_event/OWNERS
+++ /dev/null
@@ -1,15 +0,0 @@
-chiniforooshan@chromium.org
-oysteine@chromium.org
-primiano@chromium.org
-per-file trace_event_android.cc=wangxianzhu@chromium.org
-
-# For memory-infra related changes
-ssid@chromium.org
-
-# Emeritus:
-dsinclair@chromium.org
-nduca@chromium.org
-simonhatch@chromium.org
-
-# TEAM: tracing@chromium.org
-# COMPONENT: Speed>Tracing
diff --git a/base/trace_event/auto_open_close_event.cc b/base/trace_event/auto_open_close_event.cc
deleted file mode 100644
index 1879700..0000000
--- a/base/trace_event/auto_open_close_event.cc
+++ /dev/null
@@ -1,52 +0,0 @@
-// Copyright 2016 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/trace_event/auto_open_close_event.h"
-
-#include "base/macros.h"
-#include "base/time/time.h"
-#include "base/trace_event/trace_event.h"
-
-namespace base {
-namespace trace_event {
-
-AutoOpenCloseEvent::AutoOpenCloseEvent(AutoOpenCloseEvent::Type type,
-  const char* category, const char* event_name):
-  category_(category),
-  event_name_(event_name),
-  weak_factory_(this) {
-  base::trace_event::TraceLog::GetInstance()->AddAsyncEnabledStateObserver(
-      weak_factory_.GetWeakPtr());
-}
-
-AutoOpenCloseEvent::~AutoOpenCloseEvent() {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  base::trace_event::TraceLog::GetInstance()->RemoveAsyncEnabledStateObserver(
-      this);
-}
-
-void AutoOpenCloseEvent::Begin() {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  start_time_ = TRACE_TIME_TICKS_NOW();
-  TRACE_EVENT_ASYNC_BEGIN_WITH_TIMESTAMP0(
-      category_, event_name_, static_cast<void*>(this), start_time_);
-}
-
-void AutoOpenCloseEvent::End() {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  TRACE_EVENT_ASYNC_END0(category_, event_name_, static_cast<void*>(this));
-  start_time_ = base::TimeTicks();
-}
-
-void AutoOpenCloseEvent::OnTraceLogEnabled() {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  if (start_time_.ToInternalValue() != 0)
-    TRACE_EVENT_ASYNC_BEGIN_WITH_TIMESTAMP0(
-        category_, event_name_, static_cast<void*>(this), start_time_);
-}
-
-void AutoOpenCloseEvent::OnTraceLogDisabled() {}
-
-}  // namespace trace_event
-}  // namespace base
diff --git a/base/trace_event/auto_open_close_event.h b/base/trace_event/auto_open_close_event.h
deleted file mode 100644
index 795a494..0000000
--- a/base/trace_event/auto_open_close_event.h
+++ /dev/null
@@ -1,57 +0,0 @@
-// Copyright 2016 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_AUTO_OPEN_CLOSE_EVENT_H_
-#define BASE_AUTO_OPEN_CLOSE_EVENT_H_
-
-#include "base/macros.h"
-#include "base/memory/weak_ptr.h"
-#include "base/threading/thread_checker.h"
-#include "base/time/time.h"
-#include "base/trace_event/trace_event.h"
-
-namespace base {
-namespace trace_event {
-
-// Class for tracing events that support "auto-opening" and "auto-closing".
-// "auto-opening" = if the trace event is started (call Begin() before
-// tracing is started,the trace event will be opened, with the start time
-// being the time that the trace event was actually started.
-// "auto-closing" = if the trace event is started but not ended by the time
-// tracing ends, then the trace event will be automatically closed at the
-// end of tracing.
-class BASE_EXPORT AutoOpenCloseEvent
-    : public TraceLog::AsyncEnabledStateObserver {
- public:
-  enum Type {
-    ASYNC
-  };
-
-  // As in the rest of the tracing macros, the const char* arguments here
-  // must be pointers to indefinitely lived strings (e.g. hard-coded string
-  // literals are okay, but not strings created by c_str())
-  AutoOpenCloseEvent(Type type, const char* category, const char* event_name);
-  ~AutoOpenCloseEvent() override;
-
-  void Begin();
-  void End();
-
-  // AsyncEnabledStateObserver implementation
-  void OnTraceLogEnabled() override;
-  void OnTraceLogDisabled() override;
-
- private:
-  const char* const category_;
-  const char* const event_name_;
-  base::TimeTicks start_time_;
-  base::ThreadChecker thread_checker_;
-  WeakPtrFactory<AutoOpenCloseEvent> weak_factory_;
-
-  DISALLOW_COPY_AND_ASSIGN(AutoOpenCloseEvent);
-};
-
-}  // namespace trace_event
-}  // namespace base
-
-#endif  // BASE_AUTO_OPEN_CLOSE_EVENT_H_
\ No newline at end of file
diff --git a/base/trace_event/blame_context.cc b/base/trace_event/blame_context.cc
deleted file mode 100644
index ae0b718..0000000
--- a/base/trace_event/blame_context.cc
+++ /dev/null
@@ -1,111 +0,0 @@
-// Copyright 2016 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/trace_event/blame_context.h"
-
-#include "base/strings/stringprintf.h"
-#include "base/trace_event/trace_event.h"
-#include "base/trace_event/trace_event_argument.h"
-
-namespace base {
-namespace trace_event {
-
-BlameContext::BlameContext(const char* category,
-                           const char* name,
-                           const char* type,
-                           const char* scope,
-                           int64_t id,
-                           const BlameContext* parent_context)
-    : category_(category),
-      name_(name),
-      type_(type),
-      scope_(scope),
-      id_(id),
-      parent_scope_(parent_context ? parent_context->scope() : nullptr),
-      parent_id_(parent_context ? parent_context->id() : 0),
-      category_group_enabled_(nullptr),
-      weak_factory_(this) {
-  DCHECK(!parent_context || !std::strcmp(name_, parent_context->name()))
-      << "Parent blame context must have the same name";
-}
-
-BlameContext::~BlameContext() {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  DCHECK(WasInitialized());
-  TRACE_EVENT_API_ADD_TRACE_EVENT(
-      TRACE_EVENT_PHASE_DELETE_OBJECT, category_group_enabled_, type_, scope_,
-      id_, 0, nullptr, nullptr, nullptr, nullptr, TRACE_EVENT_FLAG_HAS_ID);
-  trace_event::TraceLog::GetInstance()->RemoveAsyncEnabledStateObserver(this);
-}
-
-void BlameContext::Enter() {
-  DCHECK(WasInitialized());
-  TRACE_EVENT_API_ADD_TRACE_EVENT(TRACE_EVENT_PHASE_ENTER_CONTEXT,
-                                  category_group_enabled_, name_, scope_, id_,
-                                  0 /* num_args */, nullptr, nullptr, nullptr,
-                                  nullptr, TRACE_EVENT_FLAG_HAS_ID);
-}
-
-void BlameContext::Leave() {
-  DCHECK(WasInitialized());
-  TRACE_EVENT_API_ADD_TRACE_EVENT(TRACE_EVENT_PHASE_LEAVE_CONTEXT,
-                                  category_group_enabled_, name_, scope_, id_,
-                                  0 /* num_args */, nullptr, nullptr, nullptr,
-                                  nullptr, TRACE_EVENT_FLAG_HAS_ID);
-}
-
-void BlameContext::TakeSnapshot() {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  DCHECK(WasInitialized());
-  if (!*category_group_enabled_)
-    return;
-  std::unique_ptr<trace_event::TracedValue> snapshot(
-      new trace_event::TracedValue);
-  AsValueInto(snapshot.get());
-  static const char* const kArgName = "snapshot";
-  const int kNumArgs = 1;
-  unsigned char arg_types[1] = {TRACE_VALUE_TYPE_CONVERTABLE};
-  std::unique_ptr<trace_event::ConvertableToTraceFormat> arg_values[1] = {
-      std::move(snapshot)};
-  TRACE_EVENT_API_ADD_TRACE_EVENT(TRACE_EVENT_PHASE_SNAPSHOT_OBJECT,
-                                  category_group_enabled_, type_, scope_, id_,
-                                  kNumArgs, &kArgName, arg_types, nullptr,
-                                  arg_values, TRACE_EVENT_FLAG_HAS_ID);
-}
-
-void BlameContext::OnTraceLogEnabled() {
-  DCHECK(WasInitialized());
-  TakeSnapshot();
-}
-
-void BlameContext::OnTraceLogDisabled() {}
-
-void BlameContext::AsValueInto(trace_event::TracedValue* state) {
-  DCHECK(WasInitialized());
-  if (!parent_id_)
-    return;
-  state->BeginDictionary("parent");
-  state->SetString("id_ref", StringPrintf("0x%" PRIx64, parent_id_));
-  state->SetString("scope", parent_scope_);
-  state->EndDictionary();
-}
-
-void BlameContext::Initialize() {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  category_group_enabled_ =
-      TRACE_EVENT_API_GET_CATEGORY_GROUP_ENABLED(category_);
-  TRACE_EVENT_API_ADD_TRACE_EVENT(
-      TRACE_EVENT_PHASE_CREATE_OBJECT, category_group_enabled_, type_, scope_,
-      id_, 0, nullptr, nullptr, nullptr, nullptr, TRACE_EVENT_FLAG_HAS_ID);
-  trace_event::TraceLog::GetInstance()->AddAsyncEnabledStateObserver(
-      weak_factory_.GetWeakPtr());
-  TakeSnapshot();
-}
-
-bool BlameContext::WasInitialized() const {
-  return category_group_enabled_ != nullptr;
-}
-
-}  // namespace trace_event
-}  // namespace base
diff --git a/base/trace_event/blame_context.h b/base/trace_event/blame_context.h
deleted file mode 100644
index a973a28..0000000
--- a/base/trace_event/blame_context.h
+++ /dev/null
@@ -1,138 +0,0 @@
-// Copyright 2016 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_TRACE_EVENT_BLAME_CONTEXT_H_
-#define BASE_TRACE_EVENT_BLAME_CONTEXT_H_
-
-#include <inttypes.h>
-
-#include "base/base_export.h"
-#include "base/macros.h"
-#include "base/threading/thread_checker.h"
-#include "base/trace_event/trace_log.h"
-
-namespace base {
-namespace trace_event {
-class TracedValue;
-}
-
-namespace trace_event {
-
-// A blame context represents a logical unit to which we want to attribute
-// different costs (e.g., CPU, network, or memory usage). An example of a blame
-// context is an <iframe> element on a web page. Different subsystems can
-// "enter" and "leave" blame contexts to indicate that they are doing work which
-// should be accounted against this blame context.
-//
-// A blame context can optionally have a parent context, forming a blame context
-// tree. When work is attributed to a particular blame context, it is considered
-// to count against all of that context's children too. This is useful when work
-// cannot be exactly attributed into a more specific context. For example,
-// Javascript garbage collection generally needs to inspect all objects on a
-// page instead looking at each <iframe> individually. In this case the work
-// should be attributed to a blame context which is the parent of all <iframe>
-// blame contexts.
-class BASE_EXPORT BlameContext
-    : public trace_event::TraceLog::AsyncEnabledStateObserver {
- public:
-  // Construct a blame context belonging to the blame context tree |name|, using
-  // the tracing category |category|, identified by |id| from the |scope|
-  // namespace. |type| identifies the type of this object snapshot in the blame
-  // context tree. |parent_context| is the parent of this blame context or
-  // null. Note that all strings must have application lifetime.
-  //
-  // For example, a blame context which represents a specific <iframe> in a
-  // browser frame tree could be specified with:
-  //
-  //   category="blink",
-  //   name="FrameTree",
-  //   type="IFrame",
-  //   scope="IFrameIdentifier",
-  //   id=1234.
-  //
-  // Each <iframe> blame context could have another <iframe> context as a
-  // parent, or a top-level context which represents the entire browser:
-  //
-  //   category="blink",
-  //   name="FrameTree",
-  //   type="Browser",
-  //   scope="BrowserIdentifier",
-  //   id=1.
-  //
-  // Note that the |name| property is identical, signifying that both context
-  // types are part of the same tree.
-  //
-  BlameContext(const char* category,
-               const char* name,
-               const char* type,
-               const char* scope,
-               int64_t id,
-               const BlameContext* parent_context);
-  ~BlameContext() override;
-
-  // Initialize the blame context, automatically taking a snapshot if tracing is
-  // enabled. Must be called before any other methods on this class.
-  void Initialize();
-
-  // Indicate that the current thread is now doing work which should count
-  // against this blame context.  This function is allowed to be called in a
-  // thread different from where the blame context was created; However, any
-  // client doing that must be fully responsible for ensuring thready safety.
-  void Enter();
-
-  // Leave and stop doing work for a previously entered blame context. If
-  // another blame context belonging to the same tree was entered prior to this
-  // one, it becomes the active blame context for this thread again.  Similar
-  // to Enter(), this function can be called in a thread different from where
-  // the blame context was created, and the same requirement on thread safety
-  // must be satisfied.
-  void Leave();
-
-  // Record a snapshot of the blame context. This is normally only needed if a
-  // blame context subclass defines custom properties (see AsValueInto) and one
-  // or more of those properties have changed.
-  void TakeSnapshot();
-
-  const char* category() const { return category_; }
-  const char* name() const { return name_; }
-  const char* type() const { return type_; }
-  const char* scope() const { return scope_; }
-  int64_t id() const { return id_; }
-
-  // trace_event::TraceLog::EnabledStateObserver implementation:
-  void OnTraceLogEnabled() override;
-  void OnTraceLogDisabled() override;
-
- protected:
-  // Serialize the properties of this blame context into |state|. Subclasses can
-  // override this method to record additional properties (e.g, the URL for an
-  // <iframe> blame context). Note that an overridden implementation must still
-  // call this base method.
-  virtual void AsValueInto(trace_event::TracedValue* state);
-
- private:
-  bool WasInitialized() const;
-
-  // The following string pointers have application lifetime.
-  const char* category_;
-  const char* name_;
-  const char* type_;
-  const char* scope_;
-  const int64_t id_;
-
-  const char* parent_scope_;
-  const int64_t parent_id_;
-
-  const unsigned char* category_group_enabled_;
-
-  ThreadChecker thread_checker_;
-  WeakPtrFactory<BlameContext> weak_factory_;
-
-  DISALLOW_COPY_AND_ASSIGN(BlameContext);
-};
-
-}  // namespace trace_event
-}  // namespace base
-
-#endif  // BASE_TRACE_EVENT_BLAME_CONTEXT_H_
diff --git a/base/trace_event/category_registry.cc b/base/trace_event/category_registry.cc
deleted file mode 100644
index e7c1460..0000000
--- a/base/trace_event/category_registry.cc
+++ /dev/null
@@ -1,156 +0,0 @@
-// Copyright 2016 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/trace_event/category_registry.h"
-
-#include <string.h>
-
-#include <type_traits>
-
-#include "base/atomicops.h"
-#include "base/debug/leak_annotations.h"
-#include "base/logging.h"
-#include "base/third_party/dynamic_annotations/dynamic_annotations.h"
-#include "base/trace_event/trace_category.h"
-
-namespace base {
-namespace trace_event {
-
-namespace {
-
-constexpr size_t kMaxCategories = 200;
-const int kNumBuiltinCategories = 4;
-
-// |g_categories| might end up causing creating dynamic initializers if not POD.
-static_assert(std::is_pod<TraceCategory>::value, "TraceCategory must be POD");
-
-// These entries must be kept consistent with the kCategory* consts below.
-TraceCategory g_categories[kMaxCategories] = {
-    {0, 0, "tracing categories exhausted; must increase kMaxCategories"},
-    {0, 0, "tracing already shutdown"},  // See kCategoryAlreadyShutdown below.
-    {0, 0, "__metadata"},                // See kCategoryMetadata below.
-    {0, 0, "toplevel"},                  // Warmup the toplevel category.
-};
-
-base::subtle::AtomicWord g_category_index = kNumBuiltinCategories;
-
-bool IsValidCategoryPtr(const TraceCategory* category) {
-  // If any of these are hit, something has cached a corrupt category pointer.
-  uintptr_t ptr = reinterpret_cast<uintptr_t>(category);
-  return ptr % sizeof(void*) == 0 &&
-         ptr >= reinterpret_cast<uintptr_t>(&g_categories[0]) &&
-         ptr <= reinterpret_cast<uintptr_t>(&g_categories[kMaxCategories - 1]);
-}
-
-}  // namespace
-
-// static
-TraceCategory* const CategoryRegistry::kCategoryExhausted = &g_categories[0];
-TraceCategory* const CategoryRegistry::kCategoryAlreadyShutdown =
-    &g_categories[1];
-TraceCategory* const CategoryRegistry::kCategoryMetadata = &g_categories[2];
-
-// static
-void CategoryRegistry::Initialize() {
-  // Trace is enabled or disabled on one thread while other threads are
-  // accessing the enabled flag. We don't care whether edge-case events are
-  // traced or not, so we allow races on the enabled flag to keep the trace
-  // macros fast.
-  for (size_t i = 0; i < kMaxCategories; ++i) {
-    ANNOTATE_BENIGN_RACE(g_categories[i].state_ptr(),
-                         "trace_event category enabled");
-    // If this DCHECK is hit in a test it means that ResetForTesting() is not
-    // called and the categories state leaks between test fixtures.
-    DCHECK(!g_categories[i].is_enabled());
-  }
-}
-
-// static
-void CategoryRegistry::ResetForTesting() {
-  // reset_for_testing clears up only the enabled state and filters. The
-  // categories themselves cannot be cleared up because the static pointers
-  // injected by the macros still point to them and cannot be reset.
-  for (size_t i = 0; i < kMaxCategories; ++i)
-    g_categories[i].reset_for_testing();
-}
-
-// static
-TraceCategory* CategoryRegistry::GetCategoryByName(const char* category_name) {
-  DCHECK(!strchr(category_name, '"'))
-      << "Category names may not contain double quote";
-
-  // The g_categories is append only, avoid using a lock for the fast path.
-  size_t category_index = base::subtle::Acquire_Load(&g_category_index);
-
-  // Search for pre-existing category group.
-  for (size_t i = 0; i < category_index; ++i) {
-    if (strcmp(g_categories[i].name(), category_name) == 0) {
-      return &g_categories[i];
-    }
-  }
-  return nullptr;
-}
-
-bool CategoryRegistry::GetOrCreateCategoryLocked(
-    const char* category_name,
-    CategoryInitializerFn category_initializer_fn,
-    TraceCategory** category) {
-  // This is the slow path: the lock is not held in the fastpath
-  // (GetCategoryByName), so more than one thread could have reached here trying
-  // to add the same category.
-  *category = GetCategoryByName(category_name);
-  if (*category)
-    return false;
-
-  // Create a new category.
-  size_t category_index = base::subtle::Acquire_Load(&g_category_index);
-  if (category_index >= kMaxCategories) {
-    NOTREACHED() << "must increase kMaxCategories";
-    *category = kCategoryExhausted;
-    return false;
-  }
-
-  // TODO(primiano): this strdup should be removed. The only documented reason
-  // for it was TraceWatchEvent, which is gone. However, something might have
-  // ended up relying on this. Needs some auditing before removal.
-  const char* category_name_copy = strdup(category_name);
-  ANNOTATE_LEAKING_OBJECT_PTR(category_name_copy);
-
-  *category = &g_categories[category_index];
-  DCHECK(!(*category)->is_valid());
-  DCHECK(!(*category)->is_enabled());
-  (*category)->set_name(category_name_copy);
-  category_initializer_fn(*category);
-
-  // Update the max index now.
-  base::subtle::Release_Store(&g_category_index, category_index + 1);
-  return true;
-}
-
-// static
-const TraceCategory* CategoryRegistry::GetCategoryByStatePtr(
-    const uint8_t* category_state) {
-  const TraceCategory* category = TraceCategory::FromStatePtr(category_state);
-  DCHECK(IsValidCategoryPtr(category));
-  return category;
-}
-
-// static
-bool CategoryRegistry::IsBuiltinCategory(const TraceCategory* category) {
-  DCHECK(IsValidCategoryPtr(category));
-  return category < &g_categories[kNumBuiltinCategories];
-}
-
-// static
-CategoryRegistry::Range CategoryRegistry::GetAllCategories() {
-  // The |g_categories| array is append only. We have to only guarantee to
-  // not return an index to a category which is being initialized by
-  // GetOrCreateCategoryByName().
-  size_t category_index = base::subtle::Acquire_Load(&g_category_index);
-  return CategoryRegistry::Range(&g_categories[0],
-                                 &g_categories[category_index]);
-}
-
-}  // namespace trace_event
-}  // namespace base
diff --git a/base/trace_event/category_registry.h b/base/trace_event/category_registry.h
deleted file mode 100644
index 9c08efa..0000000
--- a/base/trace_event/category_registry.h
+++ /dev/null
@@ -1,93 +0,0 @@
-// Copyright 2016 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_TRACE_EVENT_CATEGORY_REGISTRY_H_
-#define BASE_TRACE_EVENT_CATEGORY_REGISTRY_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-#include "base/base_export.h"
-#include "base/logging.h"
-
-namespace base {
-namespace trace_event {
-
-struct TraceCategory;
-class TraceCategoryTest;
-class TraceLog;
-
-// Allows fast and thread-safe acces to the state of all tracing categories.
-// All the methods in this class can be concurrently called on multiple threads,
-// unless otherwise noted (e.g., GetOrCreateCategoryLocked).
-// The reason why this is a fully static class with global state is to allow to
-// statically define known categories as global linker-initialized structs,
-// without requiring static initializers.
-class BASE_EXPORT CategoryRegistry {
- public:
-  // Allows for-each iterations over a slice of the categories array.
-  class Range {
-   public:
-    Range(TraceCategory* begin, TraceCategory* end) : begin_(begin), end_(end) {
-      DCHECK_LE(begin, end);
-    }
-    TraceCategory* begin() const { return begin_; }
-    TraceCategory* end() const { return end_; }
-
-   private:
-    TraceCategory* const begin_;
-    TraceCategory* const end_;
-  };
-
-  // Known categories.
-  static TraceCategory* const kCategoryExhausted;
-  static TraceCategory* const kCategoryMetadata;
-  static TraceCategory* const kCategoryAlreadyShutdown;
-
-  // Returns a category entry from the Category.state_ptr() pointer.
-  // TODO(primiano): trace macros should just keep a pointer to the entire
-  // TraceCategory, not just the enabled state pointer. That would remove the
-  // need for this function and make everything cleaner at no extra cost (as
-  // long as the |state_| is the first field of the struct, which can be
-  // guaranteed via static_assert, see TraceCategory ctor).
-  static const TraceCategory* GetCategoryByStatePtr(
-      const uint8_t* category_state);
-
-  // Returns a category from its name or nullptr if not found.
-  // The output |category| argument is an undefinitely lived pointer to the
-  // TraceCategory owned by the registry. TRACE_EVENTx macros will cache this
-  // pointer and use it for checks in their fast-paths.
-  static TraceCategory* GetCategoryByName(const char* category_name);
-
-  static bool IsBuiltinCategory(const TraceCategory*);
-
- private:
-  friend class TraceCategoryTest;
-  friend class TraceLog;
-  using CategoryInitializerFn = void (*)(TraceCategory*);
-
-  // Only for debugging/testing purposes, is a no-op on release builds.
-  static void Initialize();
-
-  // Resets the state of all categories, to clear up the state between tests.
-  static void ResetForTesting();
-
-  // Used to get/create a category in the slow-path. If the category exists
-  // already, this has the same effect of GetCategoryByName and returns false.
-  // If not, a new category is created and the CategoryInitializerFn is invoked
-  // before retuning true. The caller must guarantee serialization: either call
-  // this method from a single thread or hold a lock when calling this.
-  static bool GetOrCreateCategoryLocked(const char* category_name,
-                                        CategoryInitializerFn,
-                                        TraceCategory**);
-
-  // Allows to iterate over the valid categories in a for-each loop.
-  // This includes builtin categories such as __metadata.
-  static Range GetAllCategories();
-};
-
-}  // namespace trace_event
-}  // namespace base
-
-#endif  // BASE_TRACE_EVENT_CATEGORY_REGISTRY_H_
diff --git a/base/trace_event/common/trace_event_common.h b/base/trace_event/common/trace_event_common.h
deleted file mode 100644
index e2a5ca0..0000000
--- a/base/trace_event/common/trace_event_common.h
+++ /dev/null
@@ -1,1114 +0,0 @@
-// Copyright 2015 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_TRACE_EVENT_COMMON_TRACE_EVENT_COMMON_H_
-#define BASE_TRACE_EVENT_COMMON_TRACE_EVENT_COMMON_H_
-
-// This header file defines the set of trace_event macros without specifying
-// how the events actually get collected and stored. If you need to expose trace
-// events to some other universe, you can copy-and-paste this file as well as
-// trace_event.h, modifying the macros contained there as necessary for the
-// target platform. The end result is that multiple libraries can funnel events
-// through to a shared trace event collector.
-
-// IMPORTANT: To avoid conflicts, if you need to modify this file for a library,
-// land your change in base/ first, and then copy-and-paste it.
-
-// Trace events are for tracking application performance and resource usage.
-// Macros are provided to track:
-//    Begin and end of function calls
-//    Counters
-//
-// Events are issued against categories. Whereas LOG's
-// categories are statically defined, TRACE categories are created
-// implicitly with a string. For example:
-//   TRACE_EVENT_INSTANT0("MY_SUBSYSTEM", "SomeImportantEvent",
-//                        TRACE_EVENT_SCOPE_THREAD)
-//
-// It is often the case that one trace may belong in multiple categories at the
-// same time. The first argument to the trace can be a comma-separated list of
-// categories, forming a category group, like:
-//
-// TRACE_EVENT_INSTANT0("input,views", "OnMouseOver", TRACE_EVENT_SCOPE_THREAD)
-//
-// We can enable/disable tracing of OnMouseOver by enabling/disabling either
-// category.
-//
-// Events can be INSTANT, or can be pairs of BEGIN and END in the same scope:
-//   TRACE_EVENT_BEGIN0("MY_SUBSYSTEM", "SomethingCostly")
-//   doSomethingCostly()
-//   TRACE_EVENT_END0("MY_SUBSYSTEM", "SomethingCostly")
-// Note: our tools can't always determine the correct BEGIN/END pairs unless
-// these are used in the same scope. Use ASYNC_BEGIN/ASYNC_END macros if you
-// need them to be in separate scopes.
-//
-// A common use case is to trace entire function scopes. This
-// issues a trace BEGIN and END automatically:
-//   void doSomethingCostly() {
-//     TRACE_EVENT0("MY_SUBSYSTEM", "doSomethingCostly");
-//     ...
-//   }
-//
-// Additional parameters can be associated with an event:
-//   void doSomethingCostly2(int howMuch) {
-//     TRACE_EVENT1("MY_SUBSYSTEM", "doSomethingCostly",
-//         "howMuch", howMuch);
-//     ...
-//   }
-//
-// The trace system will automatically add to this information the
-// current process id, thread id, and a timestamp in microseconds.
-//
-// To trace an asynchronous procedure such as an IPC send/receive, use
-// ASYNC_BEGIN and ASYNC_END:
-//   [single threaded sender code]
-//     static int send_count = 0;
-//     ++send_count;
-//     TRACE_EVENT_ASYNC_BEGIN0("ipc", "message", send_count);
-//     Send(new MyMessage(send_count));
-//   [receive code]
-//     void OnMyMessage(send_count) {
-//       TRACE_EVENT_ASYNC_END0("ipc", "message", send_count);
-//     }
-// The third parameter is a unique ID to match ASYNC_BEGIN/ASYNC_END pairs.
-// ASYNC_BEGIN and ASYNC_END can occur on any thread of any traced process.
-// Pointers can be used for the ID parameter, and they will be mangled
-// internally so that the same pointer on two different processes will not
-// match. For example:
-//   class MyTracedClass {
-//    public:
-//     MyTracedClass() {
-//       TRACE_EVENT_ASYNC_BEGIN0("category", "MyTracedClass", this);
-//     }
-//     ~MyTracedClass() {
-//       TRACE_EVENT_ASYNC_END0("category", "MyTracedClass", this);
-//     }
-//   }
-//
-// Trace event also supports counters, which is a way to track a quantity
-// as it varies over time. Counters are created with the following macro:
-//   TRACE_COUNTER1("MY_SUBSYSTEM", "myCounter", g_myCounterValue);
-//
-// Counters are process-specific. The macro itself can be issued from any
-// thread, however.
-//
-// Sometimes, you want to track two counters at once. You can do this with two
-// counter macros:
-//   TRACE_COUNTER1("MY_SUBSYSTEM", "myCounter0", g_myCounterValue[0]);
-//   TRACE_COUNTER1("MY_SUBSYSTEM", "myCounter1", g_myCounterValue[1]);
-// Or you can do it with a combined macro:
-//   TRACE_COUNTER2("MY_SUBSYSTEM", "myCounter",
-//       "bytesPinned", g_myCounterValue[0],
-//       "bytesAllocated", g_myCounterValue[1]);
-// This indicates to the tracing UI that these counters should be displayed
-// in a single graph, as a summed area chart.
-//
-// Since counters are in a global namespace, you may want to disambiguate with a
-// unique ID, by using the TRACE_COUNTER_ID* variations.
-//
-// By default, trace collection is compiled in, but turned off at runtime.
-// Collecting trace data is the responsibility of the embedding
-// application. In Chrome's case, navigating to about:tracing will turn on
-// tracing and display data collected across all active processes.
-//
-//
-// Memory scoping note:
-// Tracing copies the pointers, not the string content, of the strings passed
-// in for category_group, name, and arg_names.  Thus, the following code will
-// cause problems:
-//     char* str = strdup("importantName");
-//     TRACE_EVENT_INSTANT0("SUBSYSTEM", str);  // BAD!
-//     free(str);                   // Trace system now has dangling pointer
-//
-// To avoid this issue with the |name| and |arg_name| parameters, use the
-// TRACE_EVENT_COPY_XXX overloads of the macros at additional runtime overhead.
-// Notes: The category must always be in a long-lived char* (i.e. static const).
-//        The |arg_values|, when used, are always deep copied with the _COPY
-//        macros.
-//
-// When are string argument values copied:
-// const char* arg_values are only referenced by default:
-//     TRACE_EVENT1("category", "name",
-//                  "arg1", "literal string is only referenced");
-// Use TRACE_STR_COPY to force copying of a const char*:
-//     TRACE_EVENT1("category", "name",
-//                  "arg1", TRACE_STR_COPY("string will be copied"));
-// std::string arg_values are always copied:
-//     TRACE_EVENT1("category", "name",
-//                  "arg1", std::string("string will be copied"));
-//
-//
-// Convertable notes:
-// Converting a large data type to a string can be costly. To help with this,
-// the trace framework provides an interface ConvertableToTraceFormat. If you
-// inherit from it and implement the AppendAsTraceFormat method the trace
-// framework will call back to your object to convert a trace output time. This
-// means, if the category for the event is disabled, the conversion will not
-// happen.
-//
-//   class MyData : public base::trace_event::ConvertableToTraceFormat {
-//    public:
-//     MyData() {}
-//     void AppendAsTraceFormat(std::string* out) const override {
-//       out->append("{\"foo\":1}");
-//     }
-//    private:
-//     ~MyData() override {}
-//     DISALLOW_COPY_AND_ASSIGN(MyData);
-//   };
-//
-//   TRACE_EVENT1("foo", "bar", "data",
-//                std::unique_ptr<ConvertableToTraceFormat>(new MyData()));
-//
-// The trace framework will take ownership if the passed pointer and it will
-// be free'd when the trace buffer is flushed.
-//
-// Note, we only do the conversion when the buffer is flushed, so the provided
-// data object should not be modified after it's passed to the trace framework.
-//
-//
-// Thread Safety:
-// A thread safe singleton and mutex are used for thread safety. Category
-// enabled flags are used to limit the performance impact when the system
-// is not enabled.
-//
-// TRACE_EVENT macros first cache a pointer to a category. The categories are
-// statically allocated and safe at all times, even after exit. Fetching a
-// category is protected by the TraceLog::lock_. Multiple threads initializing
-// the static variable is safe, as they will be serialized by the lock and
-// multiple calls will return the same pointer to the category.
-//
-// Then the category_group_enabled flag is checked. This is a unsigned char, and
-// not intended to be multithread safe. It optimizes access to AddTraceEvent
-// which is threadsafe internally via TraceLog::lock_. The enabled flag may
-// cause some threads to incorrectly call or skip calling AddTraceEvent near
-// the time of the system being enabled or disabled. This is acceptable as
-// we tolerate some data loss while the system is being enabled/disabled and
-// because AddTraceEvent is threadsafe internally and checks the enabled state
-// again under lock.
-//
-// Without the use of these static category pointers and enabled flags all
-// trace points would carry a significant performance cost of acquiring a lock
-// and resolving the category.
-
-// Check that nobody includes this file directly.  Clients are supposed to
-// include the surrounding "trace_event.h" of their project instead.
-#if defined(TRACE_EVENT0)
-#error "Another copy of this file has already been included."
-#endif
-
-// This will mark the trace event as disabled by default. The user will need
-// to explicitly enable the event.
-#define TRACE_DISABLED_BY_DEFAULT(name) "disabled-by-default-" name
-
-// Records a pair of begin and end events called "name" for the current
-// scope, with 0, 1 or 2 associated arguments. If the category is not
-// enabled, then this does nothing.
-// - category and name strings must have application lifetime (statics or
-//   literals). They may not include " chars.
-#define TRACE_EVENT0(category_group, name)    \
-  INTERNAL_TRACE_EVENT_ADD_SCOPED(category_group, name)
-#define TRACE_EVENT_WITH_FLOW0(category_group, name, bind_id, flow_flags)  \
-  INTERNAL_TRACE_EVENT_ADD_SCOPED_WITH_FLOW(category_group, name, bind_id, \
-                                            flow_flags)
-#define TRACE_EVENT1(category_group, name, arg1_name, arg1_val) \
-  INTERNAL_TRACE_EVENT_ADD_SCOPED(category_group, name, arg1_name, arg1_val)
-#define TRACE_EVENT_WITH_FLOW1(category_group, name, bind_id, flow_flags,  \
-                               arg1_name, arg1_val)                        \
-  INTERNAL_TRACE_EVENT_ADD_SCOPED_WITH_FLOW(category_group, name, bind_id, \
-                                            flow_flags, arg1_name, arg1_val)
-#define TRACE_EVENT2(category_group, name, arg1_name, arg1_val, arg2_name,   \
-                     arg2_val)                                               \
-  INTERNAL_TRACE_EVENT_ADD_SCOPED(category_group, name, arg1_name, arg1_val, \
-                                  arg2_name, arg2_val)
-#define TRACE_EVENT_WITH_FLOW2(category_group, name, bind_id, flow_flags,    \
-                               arg1_name, arg1_val, arg2_name, arg2_val)     \
-  INTERNAL_TRACE_EVENT_ADD_SCOPED_WITH_FLOW(category_group, name, bind_id,   \
-                                            flow_flags, arg1_name, arg1_val, \
-                                            arg2_name, arg2_val)
-
-// Records a single event called "name" immediately, with 0, 1 or 2
-// associated arguments. If the category is not enabled, then this
-// does nothing.
-// - category and name strings must have application lifetime (statics or
-//   literals). They may not include " chars.
-#define TRACE_EVENT_INSTANT0(category_group, name, scope)                   \
-  INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_INSTANT, category_group, name, \
-                           TRACE_EVENT_FLAG_NONE | scope)
-#define TRACE_EVENT_INSTANT1(category_group, name, scope, arg1_name, arg1_val) \
-  INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_INSTANT, category_group, name,    \
-                           TRACE_EVENT_FLAG_NONE | scope, arg1_name, arg1_val)
-#define TRACE_EVENT_INSTANT2(category_group, name, scope, arg1_name, arg1_val, \
-                             arg2_name, arg2_val)                              \
-  INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_INSTANT, category_group, name,    \
-                           TRACE_EVENT_FLAG_NONE | scope, arg1_name, arg1_val, \
-                           arg2_name, arg2_val)
-#define TRACE_EVENT_COPY_INSTANT0(category_group, name, scope)              \
-  INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_INSTANT, category_group, name, \
-                           TRACE_EVENT_FLAG_COPY | scope)
-#define TRACE_EVENT_COPY_INSTANT1(category_group, name, scope, arg1_name,   \
-                                  arg1_val)                                 \
-  INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_INSTANT, category_group, name, \
-                           TRACE_EVENT_FLAG_COPY | scope, arg1_name, arg1_val)
-#define TRACE_EVENT_COPY_INSTANT2(category_group, name, scope, arg1_name,      \
-                                  arg1_val, arg2_name, arg2_val)               \
-  INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_INSTANT, category_group, name,    \
-                           TRACE_EVENT_FLAG_COPY | scope, arg1_name, arg1_val, \
-                           arg2_name, arg2_val)
-
-#define TRACE_EVENT_INSTANT_WITH_TIMESTAMP0(category_group, name, scope, \
-                                            timestamp)                   \
-  INTERNAL_TRACE_EVENT_ADD_WITH_TIMESTAMP(                               \
-      TRACE_EVENT_PHASE_INSTANT, category_group, name, timestamp,        \
-      TRACE_EVENT_FLAG_NONE | scope)
-
-#define TRACE_EVENT_INSTANT_WITH_TIMESTAMP1(category_group, name, scope,  \
-                                            timestamp, arg_name, arg_val) \
-  INTERNAL_TRACE_EVENT_ADD_WITH_TIMESTAMP(                                \
-      TRACE_EVENT_PHASE_INSTANT, category_group, name, timestamp,         \
-      TRACE_EVENT_FLAG_NONE | scope, arg_name, arg_val)
-
-// Records a single BEGIN event called "name" immediately, with 0, 1 or 2
-// associated arguments. If the category is not enabled, then this
-// does nothing.
-// - category and name strings must have application lifetime (statics or
-//   literals). They may not include " chars.
-#define TRACE_EVENT_BEGIN0(category_group, name)                          \
-  INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_BEGIN, category_group, name, \
-                           TRACE_EVENT_FLAG_NONE)
-#define TRACE_EVENT_BEGIN1(category_group, name, arg1_name, arg1_val)     \
-  INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_BEGIN, category_group, name, \
-                           TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val)
-#define TRACE_EVENT_BEGIN2(category_group, name, arg1_name, arg1_val,     \
-                           arg2_name, arg2_val)                           \
-  INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_BEGIN, category_group, name, \
-                           TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val,    \
-                           arg2_name, arg2_val)
-#define TRACE_EVENT_COPY_BEGIN0(category_group, name)                     \
-  INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_BEGIN, category_group, name, \
-                           TRACE_EVENT_FLAG_COPY)
-#define TRACE_EVENT_COPY_BEGIN1(category_group, name, arg1_name, arg1_val) \
-  INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_BEGIN, category_group, name,  \
-                           TRACE_EVENT_FLAG_COPY, arg1_name, arg1_val)
-#define TRACE_EVENT_COPY_BEGIN2(category_group, name, arg1_name, arg1_val, \
-                                arg2_name, arg2_val)                       \
-  INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_BEGIN, category_group, name,  \
-                           TRACE_EVENT_FLAG_COPY, arg1_name, arg1_val,     \
-                           arg2_name, arg2_val)
-
-// Similar to TRACE_EVENT_BEGINx but with a custom |at| timestamp provided.
-// - |id| is used to match the _BEGIN event with the _END event.
-//   Events are considered to match if their category_group, name and id values
-//   all match. |id| must either be a pointer or an integer value up to 64 bits.
-//   If it's a pointer, the bits will be xored with a hash of the process ID so
-//   that the same pointer on two different processes will not collide.
-#define TRACE_EVENT_BEGIN_WITH_ID_TID_AND_TIMESTAMP0(category_group, name, id, \
-                                                     thread_id, timestamp)     \
-  INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP(                          \
-      TRACE_EVENT_PHASE_ASYNC_BEGIN, category_group, name, id, thread_id,      \
-      timestamp, TRACE_EVENT_FLAG_NONE)
-#define TRACE_EVENT_COPY_BEGIN_WITH_ID_TID_AND_TIMESTAMP0(                \
-    category_group, name, id, thread_id, timestamp)                       \
-  INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP(                     \
-      TRACE_EVENT_PHASE_ASYNC_BEGIN, category_group, name, id, thread_id, \
-      timestamp, TRACE_EVENT_FLAG_COPY)
-#define TRACE_EVENT_COPY_BEGIN_WITH_ID_TID_AND_TIMESTAMP1(                \
-    category_group, name, id, thread_id, timestamp, arg1_name, arg1_val)  \
-  INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP(                     \
-      TRACE_EVENT_PHASE_ASYNC_BEGIN, category_group, name, id, thread_id, \
-      timestamp, TRACE_EVENT_FLAG_COPY, arg1_name, arg1_val)
-#define TRACE_EVENT_COPY_BEGIN_WITH_ID_TID_AND_TIMESTAMP2(                \
-    category_group, name, id, thread_id, timestamp, arg1_name, arg1_val,  \
-    arg2_name, arg2_val)                                                  \
-  INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP(                     \
-      TRACE_EVENT_PHASE_ASYNC_BEGIN, category_group, name, id, thread_id, \
-      timestamp, TRACE_EVENT_FLAG_COPY, arg1_name, arg1_val, arg2_name,   \
-      arg2_val)
-
-// Records a single END event for "name" immediately. If the category
-// is not enabled, then this does nothing.
-// - category and name strings must have application lifetime (statics or
-//   literals). They may not include " chars.
-#define TRACE_EVENT_END0(category_group, name)                          \
-  INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_END, category_group, name, \
-                           TRACE_EVENT_FLAG_NONE)
-#define TRACE_EVENT_END1(category_group, name, arg1_name, arg1_val)     \
-  INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_END, category_group, name, \
-                           TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val)
-#define TRACE_EVENT_END2(category_group, name, arg1_name, arg1_val, arg2_name, \
-                         arg2_val)                                             \
-  INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_END, category_group, name,        \
-                           TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val,         \
-                           arg2_name, arg2_val)
-#define TRACE_EVENT_COPY_END0(category_group, name)                     \
-  INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_END, category_group, name, \
-                           TRACE_EVENT_FLAG_COPY)
-#define TRACE_EVENT_COPY_END1(category_group, name, arg1_name, arg1_val) \
-  INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_END, category_group, name,  \
-                           TRACE_EVENT_FLAG_COPY, arg1_name, arg1_val)
-#define TRACE_EVENT_COPY_END2(category_group, name, arg1_name, arg1_val, \
-                              arg2_name, arg2_val)                       \
-  INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_END, category_group, name,  \
-                           TRACE_EVENT_FLAG_COPY, arg1_name, arg1_val,   \
-                           arg2_name, arg2_val)
-
-#define TRACE_EVENT_MARK_WITH_TIMESTAMP0(category_group, name, timestamp) \
-  INTERNAL_TRACE_EVENT_ADD_WITH_TIMESTAMP(                                \
-      TRACE_EVENT_PHASE_MARK, category_group, name, timestamp,            \
-      TRACE_EVENT_FLAG_NONE)
-
-#define TRACE_EVENT_MARK_WITH_TIMESTAMP1(category_group, name, timestamp, \
-                                         arg1_name, arg1_val)             \
-  INTERNAL_TRACE_EVENT_ADD_WITH_TIMESTAMP(                                \
-      TRACE_EVENT_PHASE_MARK, category_group, name, timestamp,            \
-      TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val)
-
-#define TRACE_EVENT_MARK_WITH_TIMESTAMP2(                                      \
-    category_group, name, timestamp, arg1_name, arg1_val, arg2_name, arg2_val) \
-  INTERNAL_TRACE_EVENT_ADD_WITH_TIMESTAMP(                                     \
-      TRACE_EVENT_PHASE_MARK, category_group, name, timestamp,                 \
-      TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val, arg2_name, arg2_val)
-
-#define TRACE_EVENT_COPY_MARK(category_group, name)                      \
-  INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_MARK, category_group, name, \
-                           TRACE_EVENT_FLAG_COPY)
-
-#define TRACE_EVENT_COPY_MARK_WITH_TIMESTAMP(category_group, name, timestamp) \
-  INTERNAL_TRACE_EVENT_ADD_WITH_TIMESTAMP(                                    \
-      TRACE_EVENT_PHASE_MARK, category_group, name, timestamp,                \
-      TRACE_EVENT_FLAG_COPY)
-
-// Similar to TRACE_EVENT_ENDx but with a custom |at| timestamp provided.
-// - |id| is used to match the _BEGIN event with the _END event.
-//   Events are considered to match if their category_group, name and id values
-//   all match. |id| must either be a pointer or an integer value up to 64 bits.
-//   If it's a pointer, the bits will be xored with a hash of the process ID so
-//   that the same pointer on two different processes will not collide.
-#define TRACE_EVENT_END_WITH_ID_TID_AND_TIMESTAMP0(category_group, name, id, \
-                                                   thread_id, timestamp)     \
-  INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP(                        \
-      TRACE_EVENT_PHASE_ASYNC_END, category_group, name, id, thread_id,      \
-      timestamp, TRACE_EVENT_FLAG_NONE)
-#define TRACE_EVENT_COPY_END_WITH_ID_TID_AND_TIMESTAMP0(                \
-    category_group, name, id, thread_id, timestamp)                     \
-  INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP(                   \
-      TRACE_EVENT_PHASE_ASYNC_END, category_group, name, id, thread_id, \
-      timestamp, TRACE_EVENT_FLAG_COPY)
-#define TRACE_EVENT_COPY_END_WITH_ID_TID_AND_TIMESTAMP1(                 \
-    category_group, name, id, thread_id, timestamp, arg1_name, arg1_val) \
-  INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP(                    \
-      TRACE_EVENT_PHASE_ASYNC_END, category_group, name, id, thread_id,  \
-      timestamp, TRACE_EVENT_FLAG_COPY, arg1_name, arg1_val)
-#define TRACE_EVENT_COPY_END_WITH_ID_TID_AND_TIMESTAMP2(                 \
-    category_group, name, id, thread_id, timestamp, arg1_name, arg1_val, \
-    arg2_name, arg2_val)                                                 \
-  INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP(                    \
-      TRACE_EVENT_PHASE_ASYNC_END, category_group, name, id, thread_id,  \
-      timestamp, TRACE_EVENT_FLAG_COPY, arg1_name, arg1_val, arg2_name,  \
-      arg2_val)
-
-// Records the value of a counter called "name" immediately. Value
-// must be representable as a 32 bit integer.
-// - category and name strings must have application lifetime (statics or
-//   literals). They may not include " chars.
-#define TRACE_COUNTER1(category_group, name, value)                         \
-  INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_COUNTER, category_group, name, \
-                           TRACE_EVENT_FLAG_NONE, "value",                  \
-                           static_cast<int>(value))
-#define TRACE_COPY_COUNTER1(category_group, name, value)                    \
-  INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_COUNTER, category_group, name, \
-                           TRACE_EVENT_FLAG_COPY, "value",                  \
-                           static_cast<int>(value))
-
-// Records the values of a multi-parted counter called "name" immediately.
-// The UI will treat value1 and value2 as parts of a whole, displaying their
-// values as a stacked-bar chart.
-// - category and name strings must have application lifetime (statics or
-//   literals). They may not include " chars.
-#define TRACE_COUNTER2(category_group, name, value1_name, value1_val,       \
-                       value2_name, value2_val)                             \
-  INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_COUNTER, category_group, name, \
-                           TRACE_EVENT_FLAG_NONE, value1_name,              \
-                           static_cast<int>(value1_val), value2_name,       \
-                           static_cast<int>(value2_val))
-#define TRACE_COPY_COUNTER2(category_group, name, value1_name, value1_val,  \
-                            value2_name, value2_val)                        \
-  INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_COUNTER, category_group, name, \
-                           TRACE_EVENT_FLAG_COPY, value1_name,              \
-                           static_cast<int>(value1_val), value2_name,       \
-                           static_cast<int>(value2_val))
-
-// Similar to TRACE_COUNTERx, but with a custom |timestamp| provided.
-#define TRACE_COUNTER_WITH_TIMESTAMP1(category_group, name, timestamp, value) \
-  INTERNAL_TRACE_EVENT_ADD_WITH_TIMESTAMP(                                    \
-      TRACE_EVENT_PHASE_COUNTER, category_group, name, timestamp,             \
-      TRACE_EVENT_FLAG_NONE, "value", static_cast<int>(value))
-
-#define TRACE_COUNTER_WITH_TIMESTAMP2(category_group, name, timestamp,      \
-                                      value1_name, value1_val, value2_name, \
-                                      value2_val)                           \
-  INTERNAL_TRACE_EVENT_ADD_WITH_TIMESTAMP(                                  \
-      TRACE_EVENT_PHASE_COUNTER, category_group, name, timestamp,           \
-      TRACE_EVENT_FLAG_NONE, value1_name, static_cast<int>(value1_val),     \
-      value2_name, static_cast<int>(value2_val))
-
-// Records the value of a counter called "name" immediately. Value
-// must be representable as a 32 bit integer.
-// - category and name strings must have application lifetime (statics or
-//   literals). They may not include " chars.
-// - |id| is used to disambiguate counters with the same name. It must either
-//   be a pointer or an integer value up to 64 bits. If it's a pointer, the bits
-//   will be xored with a hash of the process ID so that the same pointer on
-//   two different processes will not collide.
-#define TRACE_COUNTER_ID1(category_group, name, id, value)                    \
-  INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_COUNTER, category_group, \
-                                   name, id, TRACE_EVENT_FLAG_NONE, "value",  \
-                                   static_cast<int>(value))
-#define TRACE_COPY_COUNTER_ID1(category_group, name, id, value)               \
-  INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_COUNTER, category_group, \
-                                   name, id, TRACE_EVENT_FLAG_COPY, "value",  \
-                                   static_cast<int>(value))
-
-// Records the values of a multi-parted counter called "name" immediately.
-// The UI will treat value1 and value2 as parts of a whole, displaying their
-// values as a stacked-bar chart.
-// - category and name strings must have application lifetime (statics or
-//   literals). They may not include " chars.
-// - |id| is used to disambiguate counters with the same name. It must either
-//   be a pointer or an integer value up to 64 bits. If it's a pointer, the bits
-//   will be xored with a hash of the process ID so that the same pointer on
-//   two different processes will not collide.
-#define TRACE_COUNTER_ID2(category_group, name, id, value1_name, value1_val,  \
-                          value2_name, value2_val)                            \
-  INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_COUNTER, category_group, \
-                                   name, id, TRACE_EVENT_FLAG_NONE,           \
-                                   value1_name, static_cast<int>(value1_val), \
-                                   value2_name, static_cast<int>(value2_val))
-#define TRACE_COPY_COUNTER_ID2(category_group, name, id, value1_name,         \
-                               value1_val, value2_name, value2_val)           \
-  INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_COUNTER, category_group, \
-                                   name, id, TRACE_EVENT_FLAG_COPY,           \
-                                   value1_name, static_cast<int>(value1_val), \
-                                   value2_name, static_cast<int>(value2_val))
-
-// TRACE_EVENT_SAMPLE_* events are injected by the sampling profiler.
-#define TRACE_EVENT_SAMPLE_WITH_TID_AND_TIMESTAMP0(category_group, name,       \
-                                                   thread_id, timestamp)       \
-  INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP(                          \
-      TRACE_EVENT_PHASE_SAMPLE, category_group, name, 0, thread_id, timestamp, \
-      TRACE_EVENT_FLAG_NONE)
-
-#define TRACE_EVENT_SAMPLE_WITH_TID_AND_TIMESTAMP1(                            \
-    category_group, name, thread_id, timestamp, arg1_name, arg1_val)           \
-  INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP(                          \
-      TRACE_EVENT_PHASE_SAMPLE, category_group, name, 0, thread_id, timestamp, \
-      TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val)
-
-#define TRACE_EVENT_SAMPLE_WITH_TID_AND_TIMESTAMP2(category_group, name,       \
-                                                   thread_id, timestamp,       \
-                                                   arg1_name, arg1_val,        \
-                                                   arg2_name, arg2_val)        \
-  INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP(                          \
-      TRACE_EVENT_PHASE_SAMPLE, category_group, name, 0, thread_id, timestamp, \
-      TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val, arg2_name, arg2_val)
-
-#define TRACE_EVENT_SAMPLE_WITH_ID1(category_group, name, id, arg1_name,       \
-                                    arg1_val)                                  \
-  INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_SAMPLE, category_group,   \
-                                   name, id, TRACE_EVENT_FLAG_NONE, arg1_name, \
-                                   arg1_val)
-
-// ASYNC_STEP_* APIs should be only used by legacy code. New code should
-// consider using NESTABLE_ASYNC_* APIs to describe substeps within an async
-// event.
-// Records a single ASYNC_BEGIN event called "name" immediately, with 0, 1 or 2
-// associated arguments. If the category is not enabled, then this
-// does nothing.
-// - category and name strings must have application lifetime (statics or
-//   literals). They may not include " chars.
-// - |id| is used to match the ASYNC_BEGIN event with the ASYNC_END event. ASYNC
-//   events are considered to match if their category_group, name and id values
-//   all match. |id| must either be a pointer or an integer value up to 64 bits.
-//   If it's a pointer, the bits will be xored with a hash of the process ID so
-//   that the same pointer on two different processes will not collide.
-//
-// An asynchronous operation can consist of multiple phases. The first phase is
-// defined by the ASYNC_BEGIN calls. Additional phases can be defined using the
-// ASYNC_STEP_INTO or ASYNC_STEP_PAST macros. The ASYNC_STEP_INTO macro will
-// annotate the block following the call. The ASYNC_STEP_PAST macro will
-// annotate the block prior to the call. Note that any particular event must use
-// only STEP_INTO or STEP_PAST macros; they can not mix and match. When the
-// operation completes, call ASYNC_END.
-//
-// An ASYNC trace typically occurs on a single thread (if not, they will only be
-// drawn on the thread defined in the ASYNC_BEGIN event), but all events in that
-// operation must use the same |name| and |id|. Each step can have its own
-// args.
-#define TRACE_EVENT_ASYNC_BEGIN0(category_group, name, id)        \
-  INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_ASYNC_BEGIN, \
-                                   category_group, name, id,      \
-                                   TRACE_EVENT_FLAG_NONE)
-#define TRACE_EVENT_ASYNC_BEGIN1(category_group, name, id, arg1_name, \
-                                 arg1_val)                            \
-  INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_ASYNC_BEGIN,     \
-                                   category_group, name, id,          \
-                                   TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val)
-#define TRACE_EVENT_ASYNC_BEGIN2(category_group, name, id, arg1_name, \
-                                 arg1_val, arg2_name, arg2_val)       \
-  INTERNAL_TRACE_EVENT_ADD_WITH_ID(                                   \
-      TRACE_EVENT_PHASE_ASYNC_BEGIN, category_group, name, id,        \
-      TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val, arg2_name, arg2_val)
-#define TRACE_EVENT_COPY_ASYNC_BEGIN0(category_group, name, id)   \
-  INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_ASYNC_BEGIN, \
-                                   category_group, name, id,      \
-                                   TRACE_EVENT_FLAG_COPY)
-#define TRACE_EVENT_COPY_ASYNC_BEGIN1(category_group, name, id, arg1_name, \
-                                      arg1_val)                            \
-  INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_ASYNC_BEGIN,          \
-                                   category_group, name, id,               \
-                                   TRACE_EVENT_FLAG_COPY, arg1_name, arg1_val)
-#define TRACE_EVENT_COPY_ASYNC_BEGIN2(category_group, name, id, arg1_name, \
-                                      arg1_val, arg2_name, arg2_val)       \
-  INTERNAL_TRACE_EVENT_ADD_WITH_ID(                                        \
-      TRACE_EVENT_PHASE_ASYNC_BEGIN, category_group, name, id,             \
-      TRACE_EVENT_FLAG_COPY, arg1_name, arg1_val, arg2_name, arg2_val)
-
-// Similar to TRACE_EVENT_ASYNC_BEGINx but with a custom |at| timestamp
-// provided.
-#define TRACE_EVENT_ASYNC_BEGIN_WITH_TIMESTAMP0(category_group, name, id, \
-                                                timestamp)                \
-  INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP(                     \
-      TRACE_EVENT_PHASE_ASYNC_BEGIN, category_group, name, id,            \
-      TRACE_EVENT_API_CURRENT_THREAD_ID, timestamp, TRACE_EVENT_FLAG_NONE)
-#define TRACE_EVENT_ASYNC_BEGIN_WITH_TIMESTAMP1(                           \
-    category_group, name, id, timestamp, arg1_name, arg1_val)              \
-  INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP(                      \
-      TRACE_EVENT_PHASE_ASYNC_BEGIN, category_group, name, id,             \
-      TRACE_EVENT_API_CURRENT_THREAD_ID, timestamp, TRACE_EVENT_FLAG_NONE, \
-      arg1_name, arg1_val)
-#define TRACE_EVENT_ASYNC_BEGIN_WITH_TIMESTAMP2(category_group, name, id,      \
-                                                timestamp, arg1_name,          \
-                                                arg1_val, arg2_name, arg2_val) \
-  INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP(                          \
-      TRACE_EVENT_PHASE_ASYNC_BEGIN, category_group, name, id,                 \
-      TRACE_EVENT_API_CURRENT_THREAD_ID, timestamp, TRACE_EVENT_FLAG_NONE,     \
-      arg1_name, arg1_val, arg2_name, arg2_val)
-#define TRACE_EVENT_COPY_ASYNC_BEGIN_WITH_TIMESTAMP0(category_group, name, id, \
-                                                     timestamp)                \
-  INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP(                          \
-      TRACE_EVENT_PHASE_ASYNC_BEGIN, category_group, name, id,                 \
-      TRACE_EVENT_API_CURRENT_THREAD_ID, timestamp, TRACE_EVENT_FLAG_COPY)
-
-// Records a single ASYNC_STEP_INTO event for |step| immediately. If the
-// category is not enabled, then this does nothing. The |name| and |id| must
-// match the ASYNC_BEGIN event above. The |step| param identifies this step
-// within the async event. This should be called at the beginning of the next
-// phase of an asynchronous operation. The ASYNC_BEGIN event must not have any
-// ASYNC_STEP_PAST events.
-#define TRACE_EVENT_ASYNC_STEP_INTO0(category_group, name, id, step)  \
-  INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_ASYNC_STEP_INTO, \
-                                   category_group, name, id,          \
-                                   TRACE_EVENT_FLAG_NONE, "step", step)
-#define TRACE_EVENT_ASYNC_STEP_INTO1(category_group, name, id, step, \
-                                     arg1_name, arg1_val)            \
-  INTERNAL_TRACE_EVENT_ADD_WITH_ID(                                  \
-      TRACE_EVENT_PHASE_ASYNC_STEP_INTO, category_group, name, id,   \
-      TRACE_EVENT_FLAG_NONE, "step", step, arg1_name, arg1_val)
-
-// Similar to TRACE_EVENT_ASYNC_STEP_INTOx but with a custom |at| timestamp
-// provided.
-#define TRACE_EVENT_ASYNC_STEP_INTO_WITH_TIMESTAMP0(category_group, name, id, \
-                                                    step, timestamp)          \
-  INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP(                         \
-      TRACE_EVENT_PHASE_ASYNC_STEP_INTO, category_group, name, id,            \
-      TRACE_EVENT_API_CURRENT_THREAD_ID, timestamp, TRACE_EVENT_FLAG_NONE,    \
-      "step", step)
-
-// Records a single ASYNC_STEP_PAST event for |step| immediately. If the
-// category is not enabled, then this does nothing. The |name| and |id| must
-// match the ASYNC_BEGIN event above. The |step| param identifies this step
-// within the async event. This should be called at the beginning of the next
-// phase of an asynchronous operation. The ASYNC_BEGIN event must not have any
-// ASYNC_STEP_INTO events.
-#define TRACE_EVENT_ASYNC_STEP_PAST0(category_group, name, id, step)  \
-  INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_ASYNC_STEP_PAST, \
-                                   category_group, name, id,          \
-                                   TRACE_EVENT_FLAG_NONE, "step", step)
-#define TRACE_EVENT_ASYNC_STEP_PAST1(category_group, name, id, step, \
-                                     arg1_name, arg1_val)            \
-  INTERNAL_TRACE_EVENT_ADD_WITH_ID(                                  \
-      TRACE_EVENT_PHASE_ASYNC_STEP_PAST, category_group, name, id,   \
-      TRACE_EVENT_FLAG_NONE, "step", step, arg1_name, arg1_val)
-
-// Records a single ASYNC_END event for "name" immediately. If the category
-// is not enabled, then this does nothing.
-#define TRACE_EVENT_ASYNC_END0(category_group, name, id)        \
-  INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_ASYNC_END, \
-                                   category_group, name, id,    \
-                                   TRACE_EVENT_FLAG_NONE)
-#define TRACE_EVENT_ASYNC_END1(category_group, name, id, arg1_name, arg1_val) \
-  INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_ASYNC_END,               \
-                                   category_group, name, id,                  \
-                                   TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val)
-#define TRACE_EVENT_ASYNC_END2(category_group, name, id, arg1_name, arg1_val, \
-                               arg2_name, arg2_val)                           \
-  INTERNAL_TRACE_EVENT_ADD_WITH_ID(                                           \
-      TRACE_EVENT_PHASE_ASYNC_END, category_group, name, id,                  \
-      TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val, arg2_name, arg2_val)
-#define TRACE_EVENT_COPY_ASYNC_END0(category_group, name, id)   \
-  INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_ASYNC_END, \
-                                   category_group, name, id,    \
-                                   TRACE_EVENT_FLAG_COPY)
-#define TRACE_EVENT_COPY_ASYNC_END1(category_group, name, id, arg1_name, \
-                                    arg1_val)                            \
-  INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_ASYNC_END,          \
-                                   category_group, name, id,             \
-                                   TRACE_EVENT_FLAG_COPY, arg1_name, arg1_val)
-#define TRACE_EVENT_COPY_ASYNC_END2(category_group, name, id, arg1_name, \
-                                    arg1_val, arg2_name, arg2_val)       \
-  INTERNAL_TRACE_EVENT_ADD_WITH_ID(                                      \
-      TRACE_EVENT_PHASE_ASYNC_END, category_group, name, id,             \
-      TRACE_EVENT_FLAG_COPY, arg1_name, arg1_val, arg2_name, arg2_val)
-
-// Similar to TRACE_EVENT_ASYNC_ENDx but with a custom |at| timestamp provided.
-#define TRACE_EVENT_ASYNC_END_WITH_TIMESTAMP0(category_group, name, id, \
-                                              timestamp)                \
-  INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP(                   \
-      TRACE_EVENT_PHASE_ASYNC_END, category_group, name, id,            \
-      TRACE_EVENT_API_CURRENT_THREAD_ID, timestamp, TRACE_EVENT_FLAG_NONE)
-#define TRACE_EVENT_ASYNC_END_WITH_TIMESTAMP1(category_group, name, id,       \
-                                              timestamp, arg1_name, arg1_val) \
-  INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP(                         \
-      TRACE_EVENT_PHASE_ASYNC_END, category_group, name, id,                  \
-      TRACE_EVENT_API_CURRENT_THREAD_ID, timestamp, TRACE_EVENT_FLAG_NONE,    \
-      arg1_name, arg1_val)
-#define TRACE_EVENT_ASYNC_END_WITH_TIMESTAMP2(category_group, name, id,       \
-                                              timestamp, arg1_name, arg1_val, \
-                                              arg2_name, arg2_val)            \
-  INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP(                         \
-      TRACE_EVENT_PHASE_ASYNC_END, category_group, name, id,                  \
-      TRACE_EVENT_API_CURRENT_THREAD_ID, timestamp, TRACE_EVENT_FLAG_NONE,    \
-      arg1_name, arg1_val, arg2_name, arg2_val)
-#define TRACE_EVENT_COPY_ASYNC_END_WITH_TIMESTAMP0(category_group, name, id, \
-                                                   timestamp)                \
-  INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP(                        \
-      TRACE_EVENT_PHASE_ASYNC_END, category_group, name, id,                 \
-      TRACE_EVENT_API_CURRENT_THREAD_ID, timestamp, TRACE_EVENT_FLAG_COPY)
-
-// NESTABLE_ASYNC_* APIs are used to describe an async operation, which can
-// be nested within a NESTABLE_ASYNC event and/or have inner NESTABLE_ASYNC
-// events.
-// - category and name strings must have application lifetime (statics or
-//   literals). They may not include " chars.
-// - A pair of NESTABLE_ASYNC_BEGIN event and NESTABLE_ASYNC_END event is
-//   considered as a match if their category_group, name and id all match.
-// - |id| must either be a pointer or an integer value up to 64 bits.
-//   If it's a pointer, the bits will be xored with a hash of the process ID so
-//   that the same pointer on two different processes will not collide.
-// - |id| is used to match a child NESTABLE_ASYNC event with its parent
-//   NESTABLE_ASYNC event. Therefore, events in the same nested event tree must
-//   be logged using the same id and category_group.
-//
-// Unmatched NESTABLE_ASYNC_END event will be parsed as an event that starts
-// at the first NESTABLE_ASYNC event of that id, and unmatched
-// NESTABLE_ASYNC_BEGIN event will be parsed as an event that ends at the last
-// NESTABLE_ASYNC event of that id. Corresponding warning messages for
-// unmatched events will be shown in the analysis view.
-
-// Records a single NESTABLE_ASYNC_BEGIN event called "name" immediately, with
-// 0, 1 or 2 associated arguments. If the category is not enabled, then this
-// does nothing.
-#define TRACE_EVENT_NESTABLE_ASYNC_BEGIN0(category_group, name, id)        \
-  INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_NESTABLE_ASYNC_BEGIN, \
-                                   category_group, name, id,               \
-                                   TRACE_EVENT_FLAG_NONE)
-#define TRACE_EVENT_NESTABLE_ASYNC_BEGIN1(category_group, name, id, arg1_name, \
-                                          arg1_val)                            \
-  INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_NESTABLE_ASYNC_BEGIN,     \
-                                   category_group, name, id,                   \
-                                   TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val)
-#define TRACE_EVENT_NESTABLE_ASYNC_BEGIN2(category_group, name, id, arg1_name, \
-                                          arg1_val, arg2_name, arg2_val)       \
-  INTERNAL_TRACE_EVENT_ADD_WITH_ID(                                            \
-      TRACE_EVENT_PHASE_NESTABLE_ASYNC_BEGIN, category_group, name, id,        \
-      TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val, arg2_name, arg2_val)
-// Records a single NESTABLE_ASYNC_END event called "name" immediately, with 0
-// or 2 associated arguments. If the category is not enabled, then this does
-// nothing.
-#define TRACE_EVENT_NESTABLE_ASYNC_END0(category_group, name, id)        \
-  INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_NESTABLE_ASYNC_END, \
-                                   category_group, name, id,             \
-                                   TRACE_EVENT_FLAG_NONE)
-// Records a single NESTABLE_ASYNC_END event called "name" immediately, with 1
-// associated argument. If the category is not enabled, then this does nothing.
-#define TRACE_EVENT_NESTABLE_ASYNC_END1(category_group, name, id, arg1_name, \
-                                        arg1_val)                            \
-  INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_NESTABLE_ASYNC_END,     \
-                                   category_group, name, id,                 \
-                                   TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val)
-#define TRACE_EVENT_NESTABLE_ASYNC_END2(category_group, name, id, arg1_name, \
-                                        arg1_val, arg2_name, arg2_val)       \
-  INTERNAL_TRACE_EVENT_ADD_WITH_ID(                                          \
-      TRACE_EVENT_PHASE_NESTABLE_ASYNC_END, category_group, name, id,        \
-      TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val, arg2_name, arg2_val)
-
-// Records a single NESTABLE_ASYNC_INSTANT event called "name" immediately,
-// with none, one or two associated argument. If the category is not enabled,
-// then this does nothing.
-#define TRACE_EVENT_NESTABLE_ASYNC_INSTANT0(category_group, name, id)        \
-  INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_NESTABLE_ASYNC_INSTANT, \
-                                   category_group, name, id,                 \
-                                   TRACE_EVENT_FLAG_NONE)
-
-#define TRACE_EVENT_NESTABLE_ASYNC_INSTANT1(category_group, name, id,        \
-                                            arg1_name, arg1_val)             \
-  INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_NESTABLE_ASYNC_INSTANT, \
-                                   category_group, name, id,                 \
-                                   TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val)
-
-#define TRACE_EVENT_NESTABLE_ASYNC_INSTANT2(                              \
-    category_group, name, id, arg1_name, arg1_val, arg2_name, arg2_val)   \
-  INTERNAL_TRACE_EVENT_ADD_WITH_ID(                                       \
-      TRACE_EVENT_PHASE_NESTABLE_ASYNC_INSTANT, category_group, name, id, \
-      TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val, arg2_name, arg2_val)
-
-#define TRACE_EVENT_COPY_NESTABLE_ASYNC_BEGIN_WITH_TTS2(                       \
-    category_group, name, id, arg1_name, arg1_val, arg2_name, arg2_val)        \
-  INTERNAL_TRACE_EVENT_ADD_WITH_ID(                                            \
-      TRACE_EVENT_PHASE_NESTABLE_ASYNC_BEGIN, category_group, name, id,        \
-      TRACE_EVENT_FLAG_ASYNC_TTS | TRACE_EVENT_FLAG_COPY, arg1_name, arg1_val, \
-      arg2_name, arg2_val)
-#define TRACE_EVENT_COPY_NESTABLE_ASYNC_END_WITH_TTS2(                         \
-    category_group, name, id, arg1_name, arg1_val, arg2_name, arg2_val)        \
-  INTERNAL_TRACE_EVENT_ADD_WITH_ID(                                            \
-      TRACE_EVENT_PHASE_NESTABLE_ASYNC_END, category_group, name, id,          \
-      TRACE_EVENT_FLAG_ASYNC_TTS | TRACE_EVENT_FLAG_COPY, arg1_name, arg1_val, \
-      arg2_name, arg2_val)
-
-// Similar to TRACE_EVENT_NESTABLE_ASYNC_{BEGIN,END}x but with a custom
-// |timestamp| provided.
-#define TRACE_EVENT_NESTABLE_ASYNC_BEGIN_WITH_TIMESTAMP0(category_group, name, \
-                                                         id, timestamp)        \
-  INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP(                          \
-      TRACE_EVENT_PHASE_NESTABLE_ASYNC_BEGIN, category_group, name, id,        \
-      TRACE_EVENT_API_CURRENT_THREAD_ID, timestamp, TRACE_EVENT_FLAG_NONE)
-#define TRACE_EVENT_NESTABLE_ASYNC_END_WITH_TIMESTAMP0(category_group, name, \
-                                                       id, timestamp)        \
-  INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP(                        \
-      TRACE_EVENT_PHASE_NESTABLE_ASYNC_END, category_group, name, id,        \
-      TRACE_EVENT_API_CURRENT_THREAD_ID, timestamp, TRACE_EVENT_FLAG_NONE)
-#define TRACE_EVENT_NESTABLE_ASYNC_END_WITH_TIMESTAMP1(                    \
-    category_group, name, id, timestamp, arg1_name, arg1_val)              \
-  INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP(                      \
-      TRACE_EVENT_PHASE_NESTABLE_ASYNC_END, category_group, name, id,      \
-      TRACE_EVENT_API_CURRENT_THREAD_ID, timestamp, TRACE_EVENT_FLAG_NONE, \
-      arg1_name, arg1_val)
-#define TRACE_EVENT_NESTABLE_ASYNC_INSTANT_WITH_TIMESTAMP0(               \
-    category_group, name, id, timestamp)                                  \
-  INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP(                     \
-      TRACE_EVENT_PHASE_NESTABLE_ASYNC_INSTANT, category_group, name, id, \
-      TRACE_EVENT_API_CURRENT_THREAD_ID, timestamp, TRACE_EVENT_FLAG_NONE)
-#define TRACE_EVENT_COPY_NESTABLE_ASYNC_BEGIN_WITH_TIMESTAMP0(          \
-    category_group, name, id, timestamp)                                \
-  INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP(                   \
-      TRACE_EVENT_PHASE_NESTABLE_ASYNC_BEGIN, category_group, name, id, \
-      TRACE_EVENT_API_CURRENT_THREAD_ID, timestamp, TRACE_EVENT_FLAG_COPY)
-#define TRACE_EVENT_COPY_NESTABLE_ASYNC_END_WITH_TIMESTAMP0(          \
-    category_group, name, id, timestamp)                              \
-  INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP(                 \
-      TRACE_EVENT_PHASE_NESTABLE_ASYNC_END, category_group, name, id, \
-      TRACE_EVENT_API_CURRENT_THREAD_ID, timestamp, TRACE_EVENT_FLAG_COPY)
-
-// Records a single FLOW_BEGIN event called "name" immediately, with 0, 1 or 2
-// associated arguments. If the category is not enabled, then this
-// does nothing.
-// - category and name strings must have application lifetime (statics or
-//   literals). They may not include " chars.
-// - |id| is used to match the FLOW_BEGIN event with the FLOW_END event. FLOW
-//   events are considered to match if their category_group, name and id values
-//   all match. |id| must either be a pointer or an integer value up to 64 bits.
-//   If it's a pointer, the bits will be xored with a hash of the process ID so
-//   that the same pointer on two different processes will not collide.
-// FLOW events are different from ASYNC events in how they are drawn by the
-// tracing UI. A FLOW defines asynchronous data flow, such as posting a task
-// (FLOW_BEGIN) and later executing that task (FLOW_END). Expect FLOWs to be
-// drawn as lines or arrows from FLOW_BEGIN scopes to FLOW_END scopes. Similar
-// to ASYNC, a FLOW can consist of multiple phases. The first phase is defined
-// by the FLOW_BEGIN calls. Additional phases can be defined using the FLOW_STEP
-// macros. When the operation completes, call FLOW_END. An async operation can
-// span threads and processes, but all events in that operation must use the
-// same |name| and |id|. Each event can have its own args.
-#define TRACE_EVENT_FLOW_BEGIN0(category_group, name, id)        \
-  INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_FLOW_BEGIN, \
-                                   category_group, name, id,     \
-                                   TRACE_EVENT_FLAG_NONE)
-#define TRACE_EVENT_FLOW_BEGIN1(category_group, name, id, arg1_name, arg1_val) \
-  INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_FLOW_BEGIN,               \
-                                   category_group, name, id,                   \
-                                   TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val)
-#define TRACE_EVENT_FLOW_BEGIN2(category_group, name, id, arg1_name, arg1_val, \
-                                arg2_name, arg2_val)                           \
-  INTERNAL_TRACE_EVENT_ADD_WITH_ID(                                            \
-      TRACE_EVENT_PHASE_FLOW_BEGIN, category_group, name, id,                  \
-      TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val, arg2_name, arg2_val)
-#define TRACE_EVENT_COPY_FLOW_BEGIN0(category_group, name, id)   \
-  INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_FLOW_BEGIN, \
-                                   category_group, name, id,     \
-                                   TRACE_EVENT_FLAG_COPY)
-#define TRACE_EVENT_COPY_FLOW_BEGIN1(category_group, name, id, arg1_name, \
-                                     arg1_val)                            \
-  INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_FLOW_BEGIN,          \
-                                   category_group, name, id,              \
-                                   TRACE_EVENT_FLAG_COPY, arg1_name, arg1_val)
-#define TRACE_EVENT_COPY_FLOW_BEGIN2(category_group, name, id, arg1_name, \
-                                     arg1_val, arg2_name, arg2_val)       \
-  INTERNAL_TRACE_EVENT_ADD_WITH_ID(                                       \
-      TRACE_EVENT_PHASE_FLOW_BEGIN, category_group, name, id,             \
-      TRACE_EVENT_FLAG_COPY, arg1_name, arg1_val, arg2_name, arg2_val)
-
-// Records a single FLOW_STEP event for |step| immediately. If the category
-// is not enabled, then this does nothing. The |name| and |id| must match the
-// FLOW_BEGIN event above. The |step| param identifies this step within the
-// async event. This should be called at the beginning of the next phase of an
-// asynchronous operation.
-#define TRACE_EVENT_FLOW_STEP0(category_group, name, id, step)  \
-  INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_FLOW_STEP, \
-                                   category_group, name, id,    \
-                                   TRACE_EVENT_FLAG_NONE, "step", step)
-#define TRACE_EVENT_FLOW_STEP1(category_group, name, id, step, arg1_name, \
-                               arg1_val)                                  \
-  INTERNAL_TRACE_EVENT_ADD_WITH_ID(                                       \
-      TRACE_EVENT_PHASE_FLOW_STEP, category_group, name, id,              \
-      TRACE_EVENT_FLAG_NONE, "step", step, arg1_name, arg1_val)
-#define TRACE_EVENT_COPY_FLOW_STEP0(category_group, name, id, step) \
-  INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_FLOW_STEP,     \
-                                   category_group, name, id,        \
-                                   TRACE_EVENT_FLAG_COPY, "step", step)
-#define TRACE_EVENT_COPY_FLOW_STEP1(category_group, name, id, step, arg1_name, \
-                                    arg1_val)                                  \
-  INTERNAL_TRACE_EVENT_ADD_WITH_ID(                                            \
-      TRACE_EVENT_PHASE_FLOW_STEP, category_group, name, id,                   \
-      TRACE_EVENT_FLAG_COPY, "step", step, arg1_name, arg1_val)
-
-// Records a single FLOW_END event for "name" immediately. If the category
-// is not enabled, then this does nothing.
-#define TRACE_EVENT_FLOW_END0(category_group, name, id)                        \
-  INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_FLOW_END, category_group, \
-                                   name, id, TRACE_EVENT_FLAG_NONE)
-#define TRACE_EVENT_FLOW_END_BIND_TO_ENCLOSING0(category_group, name, id)      \
-  INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_FLOW_END, category_group, \
-                                   name, id,                                   \
-                                   TRACE_EVENT_FLAG_BIND_TO_ENCLOSING)
-#define TRACE_EVENT_FLOW_END1(category_group, name, id, arg1_name, arg1_val)   \
-  INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_FLOW_END, category_group, \
-                                   name, id, TRACE_EVENT_FLAG_NONE, arg1_name, \
-                                   arg1_val)
-#define TRACE_EVENT_FLOW_END2(category_group, name, id, arg1_name, arg1_val,   \
-                              arg2_name, arg2_val)                             \
-  INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_FLOW_END, category_group, \
-                                   name, id, TRACE_EVENT_FLAG_NONE, arg1_name, \
-                                   arg1_val, arg2_name, arg2_val)
-#define TRACE_EVENT_COPY_FLOW_END0(category_group, name, id)                   \
-  INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_FLOW_END, category_group, \
-                                   name, id, TRACE_EVENT_FLAG_COPY)
-#define TRACE_EVENT_COPY_FLOW_END1(category_group, name, id, arg1_name,        \
-                                   arg1_val)                                   \
-  INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_FLOW_END, category_group, \
-                                   name, id, TRACE_EVENT_FLAG_COPY, arg1_name, \
-                                   arg1_val)
-#define TRACE_EVENT_COPY_FLOW_END2(category_group, name, id, arg1_name,        \
-                                   arg1_val, arg2_name, arg2_val)              \
-  INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_FLOW_END, category_group, \
-                                   name, id, TRACE_EVENT_FLAG_COPY, arg1_name, \
-                                   arg1_val, arg2_name, arg2_val)
-
-// Special trace event macro to trace task execution with the location where it
-// was posted from.
-#define TRACE_TASK_EXECUTION(run_function, task) \
-  INTERNAL_TRACE_TASK_EXECUTION(run_function, task)
-
-// TRACE_EVENT_METADATA* events are information related to other
-// injected events, not events in their own right.
-#define TRACE_EVENT_METADATA1(category_group, name, arg1_name, arg1_val) \
-  INTERNAL_TRACE_EVENT_METADATA_ADD(category_group, name, arg1_name, arg1_val)
-
-// Records a clock sync event.
-#define TRACE_EVENT_CLOCK_SYNC_RECEIVER(sync_id)                               \
-  INTERNAL_TRACE_EVENT_ADD(                                                    \
-      TRACE_EVENT_PHASE_CLOCK_SYNC, "__metadata", "clock_sync",                \
-      TRACE_EVENT_FLAG_NONE, "sync_id", sync_id)
-#define TRACE_EVENT_CLOCK_SYNC_ISSUER(sync_id, issue_ts, issue_end_ts)         \
-  INTERNAL_TRACE_EVENT_ADD_WITH_TIMESTAMP(                                     \
-      TRACE_EVENT_PHASE_CLOCK_SYNC, "__metadata", "clock_sync",                \
-      issue_end_ts, TRACE_EVENT_FLAG_NONE,                                     \
-      "sync_id", sync_id, "issue_ts", issue_ts)
-
-// Macros to track the life time and value of arbitrary client objects.
-// See also TraceTrackableObject.
-#define TRACE_EVENT_OBJECT_CREATED_WITH_ID(category_group, name, id) \
-  INTERNAL_TRACE_EVENT_ADD_WITH_ID(                                  \
-      TRACE_EVENT_PHASE_CREATE_OBJECT, category_group, name, id,     \
-      TRACE_EVENT_FLAG_NONE)
-
-#define TRACE_EVENT_OBJECT_SNAPSHOT_WITH_ID(category_group, name, id, \
-                                            snapshot)                 \
-  INTERNAL_TRACE_EVENT_ADD_WITH_ID(                                   \
-      TRACE_EVENT_PHASE_SNAPSHOT_OBJECT, category_group, name,        \
-      id, TRACE_EVENT_FLAG_NONE, "snapshot", snapshot)
-
-#define TRACE_EVENT_OBJECT_SNAPSHOT_WITH_ID_AND_TIMESTAMP(                     \
-    category_group, name, id, timestamp, snapshot)                             \
-  INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP(                          \
-      TRACE_EVENT_PHASE_SNAPSHOT_OBJECT, category_group, name,                 \
-      id, TRACE_EVENT_API_CURRENT_THREAD_ID, timestamp, TRACE_EVENT_FLAG_NONE, \
-      "snapshot", snapshot)
-
-#define TRACE_EVENT_OBJECT_DELETED_WITH_ID(category_group, name, id) \
-  INTERNAL_TRACE_EVENT_ADD_WITH_ID(                                  \
-      TRACE_EVENT_PHASE_DELETE_OBJECT, category_group, name, id,     \
-      TRACE_EVENT_FLAG_NONE)
-
-// Records entering and leaving trace event contexts. |category_group| and
-// |name| specify the context category and type. |context| is a
-// snapshotted context object id.
-#define TRACE_EVENT_ENTER_CONTEXT(category_group, name, context)      \
-  INTERNAL_TRACE_EVENT_ADD_WITH_ID(                                   \
-      TRACE_EVENT_PHASE_ENTER_CONTEXT, category_group, name, context, \
-      TRACE_EVENT_FLAG_NONE)
-#define TRACE_EVENT_LEAVE_CONTEXT(category_group, name, context)      \
-  INTERNAL_TRACE_EVENT_ADD_WITH_ID(                                   \
-      TRACE_EVENT_PHASE_LEAVE_CONTEXT, category_group, name, context, \
-      TRACE_EVENT_FLAG_NONE)
-#define TRACE_EVENT_SCOPED_CONTEXT(category_group, name, context) \
-  INTERNAL_TRACE_EVENT_SCOPED_CONTEXT(category_group, name, context)
-
-// Macro to specify that two trace IDs are identical. For example,
-// TRACE_LINK_IDS(
-//     "category", "name",
-//     TRACE_ID_WITH_SCOPE("net::URLRequest", 0x1000),
-//     TRACE_ID_WITH_SCOPE("blink::ResourceFetcher::FetchRequest", 0x2000))
-// tells the trace consumer that events with ID ("net::URLRequest", 0x1000) from
-// the current process have the same ID as events with ID
-// ("blink::ResourceFetcher::FetchRequest", 0x2000).
-#define TRACE_LINK_IDS(category_group, name, id, linked_id) \
-  INTERNAL_TRACE_EVENT_ADD_LINK_IDS(category_group, name, id, linked_id);
-
-// Macro to efficiently determine if a given category group is enabled.
-#define TRACE_EVENT_CATEGORY_GROUP_ENABLED(category_group, ret)             \
-  do {                                                                      \
-    INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO(category_group);                 \
-    if (INTERNAL_TRACE_EVENT_CATEGORY_GROUP_ENABLED_FOR_RECORDING_MODE()) { \
-      *ret = true;                                                          \
-    } else {                                                                \
-      *ret = false;                                                         \
-    }                                                                       \
-  } while (0)
-
-// Macro to explicitly warm up a given category group. This could be useful in
-// cases where we want to initialize a category group before any trace events
-// for that category group is reported. For example, to have a category group
-// always show up in the "record categories" list for manually selecting
-// settings in about://tracing.
-#define TRACE_EVENT_WARMUP_CATEGORY(category_group) \
-  INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO(category_group)
-
-// Macro to efficiently determine, through polling, if a new trace has begun.
-#define TRACE_EVENT_IS_NEW_TRACE(ret)                                      \
-  do {                                                                     \
-    static int INTERNAL_TRACE_EVENT_UID(lastRecordingNumber) = 0;          \
-    int num_traces_recorded = TRACE_EVENT_API_GET_NUM_TRACES_RECORDED();   \
-    if (num_traces_recorded != -1 &&                                       \
-        num_traces_recorded !=                                             \
-            INTERNAL_TRACE_EVENT_UID(lastRecordingNumber)) {               \
-      INTERNAL_TRACE_EVENT_UID(lastRecordingNumber) = num_traces_recorded; \
-      *ret = true;                                                         \
-    } else {                                                               \
-      *ret = false;                                                        \
-    }                                                                      \
-  } while (0)
-
-// Macro for getting the real base::TimeTicks::Now() which can be overridden in
-// headless when VirtualTime is enabled.
-#define TRACE_TIME_TICKS_NOW() INTERNAL_TRACE_TIME_TICKS_NOW()
-
-// Macro for getting the real base::Time::Now() which can be overridden in
-// headless when VirtualTime is enabled.
-#define TRACE_TIME_NOW() INTERNAL_TRACE_TIME_NOW()
-
-// Notes regarding the following definitions:
-// New values can be added and propagated to third party libraries, but existing
-// definitions must never be changed, because third party libraries may use old
-// definitions.
-
-// Phase indicates the nature of an event entry. E.g. part of a begin/end pair.
-#define TRACE_EVENT_PHASE_BEGIN ('B')
-#define TRACE_EVENT_PHASE_END ('E')
-#define TRACE_EVENT_PHASE_COMPLETE ('X')
-#define TRACE_EVENT_PHASE_INSTANT ('I')
-#define TRACE_EVENT_PHASE_ASYNC_BEGIN ('S')
-#define TRACE_EVENT_PHASE_ASYNC_STEP_INTO ('T')
-#define TRACE_EVENT_PHASE_ASYNC_STEP_PAST ('p')
-#define TRACE_EVENT_PHASE_ASYNC_END ('F')
-#define TRACE_EVENT_PHASE_NESTABLE_ASYNC_BEGIN ('b')
-#define TRACE_EVENT_PHASE_NESTABLE_ASYNC_END ('e')
-#define TRACE_EVENT_PHASE_NESTABLE_ASYNC_INSTANT ('n')
-#define TRACE_EVENT_PHASE_FLOW_BEGIN ('s')
-#define TRACE_EVENT_PHASE_FLOW_STEP ('t')
-#define TRACE_EVENT_PHASE_FLOW_END ('f')
-#define TRACE_EVENT_PHASE_METADATA ('M')
-#define TRACE_EVENT_PHASE_COUNTER ('C')
-#define TRACE_EVENT_PHASE_SAMPLE ('P')
-#define TRACE_EVENT_PHASE_CREATE_OBJECT ('N')
-#define TRACE_EVENT_PHASE_SNAPSHOT_OBJECT ('O')
-#define TRACE_EVENT_PHASE_DELETE_OBJECT ('D')
-#define TRACE_EVENT_PHASE_MEMORY_DUMP ('v')
-#define TRACE_EVENT_PHASE_MARK ('R')
-#define TRACE_EVENT_PHASE_CLOCK_SYNC ('c')
-#define TRACE_EVENT_PHASE_ENTER_CONTEXT ('(')
-#define TRACE_EVENT_PHASE_LEAVE_CONTEXT (')')
-#define TRACE_EVENT_PHASE_LINK_IDS ('=')
-
-// Flags for changing the behavior of TRACE_EVENT_API_ADD_TRACE_EVENT.
-#define TRACE_EVENT_FLAG_NONE (static_cast<unsigned int>(0))
-#define TRACE_EVENT_FLAG_COPY (static_cast<unsigned int>(1 << 0))
-#define TRACE_EVENT_FLAG_HAS_ID (static_cast<unsigned int>(1 << 1))
-// TODO(crbug.com/639003): Free this bit after ID mangling is deprecated.
-#define TRACE_EVENT_FLAG_MANGLE_ID (static_cast<unsigned int>(1 << 2))
-#define TRACE_EVENT_FLAG_SCOPE_OFFSET (static_cast<unsigned int>(1 << 3))
-#define TRACE_EVENT_FLAG_SCOPE_EXTRA (static_cast<unsigned int>(1 << 4))
-#define TRACE_EVENT_FLAG_EXPLICIT_TIMESTAMP (static_cast<unsigned int>(1 << 5))
-#define TRACE_EVENT_FLAG_ASYNC_TTS (static_cast<unsigned int>(1 << 6))
-#define TRACE_EVENT_FLAG_BIND_TO_ENCLOSING (static_cast<unsigned int>(1 << 7))
-#define TRACE_EVENT_FLAG_FLOW_IN (static_cast<unsigned int>(1 << 8))
-#define TRACE_EVENT_FLAG_FLOW_OUT (static_cast<unsigned int>(1 << 9))
-#define TRACE_EVENT_FLAG_HAS_CONTEXT_ID (static_cast<unsigned int>(1 << 10))
-#define TRACE_EVENT_FLAG_HAS_PROCESS_ID (static_cast<unsigned int>(1 << 11))
-#define TRACE_EVENT_FLAG_HAS_LOCAL_ID (static_cast<unsigned int>(1 << 12))
-#define TRACE_EVENT_FLAG_HAS_GLOBAL_ID (static_cast<unsigned int>(1 << 13))
-
-#define TRACE_EVENT_FLAG_SCOPE_MASK                          \
-  (static_cast<unsigned int>(TRACE_EVENT_FLAG_SCOPE_OFFSET | \
-                             TRACE_EVENT_FLAG_SCOPE_EXTRA))
-
-// Type values for identifying types in the TraceValue union.
-#define TRACE_VALUE_TYPE_BOOL (static_cast<unsigned char>(1))
-#define TRACE_VALUE_TYPE_UINT (static_cast<unsigned char>(2))
-#define TRACE_VALUE_TYPE_INT (static_cast<unsigned char>(3))
-#define TRACE_VALUE_TYPE_DOUBLE (static_cast<unsigned char>(4))
-#define TRACE_VALUE_TYPE_POINTER (static_cast<unsigned char>(5))
-#define TRACE_VALUE_TYPE_STRING (static_cast<unsigned char>(6))
-#define TRACE_VALUE_TYPE_COPY_STRING (static_cast<unsigned char>(7))
-#define TRACE_VALUE_TYPE_CONVERTABLE (static_cast<unsigned char>(8))
-
-// Enum reflecting the scope of an INSTANT event. Must fit within
-// TRACE_EVENT_FLAG_SCOPE_MASK.
-#define TRACE_EVENT_SCOPE_GLOBAL (static_cast<unsigned char>(0 << 3))
-#define TRACE_EVENT_SCOPE_PROCESS (static_cast<unsigned char>(1 << 3))
-#define TRACE_EVENT_SCOPE_THREAD (static_cast<unsigned char>(2 << 3))
-
-#define TRACE_EVENT_SCOPE_NAME_GLOBAL ('g')
-#define TRACE_EVENT_SCOPE_NAME_PROCESS ('p')
-#define TRACE_EVENT_SCOPE_NAME_THREAD ('t')
-
-#endif  // BASE_TRACE_EVENT_COMMON_TRACE_EVENT_COMMON_H_
diff --git a/base/trace_event/etw_manifest/chrome_events_win.man b/base/trace_event/etw_manifest/chrome_events_win.man
deleted file mode 100644
index 10a8ddf..0000000
--- a/base/trace_event/etw_manifest/chrome_events_win.man
+++ /dev/null
@@ -1,84 +0,0 @@
-﻿<?xml version='1.0' encoding='utf-8' standalone='yes'?>
-<instrumentationManifest
-    xmlns="http://schemas.microsoft.com/win/2004/08/events"
-    xmlns:win="http://manifests.microsoft.com/win/2004/08/windows/events"
-    xmlns:xs="http://www.w3.org/2001/XMLSchema"
-    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-    xsi:schemaLocation="http://schemas.microsoft.com/win/2004/08/events eventman.xsd"
-    >
-  <instrumentation>
-    <events>
-      <provider
-          guid="{D2D578D9-2936-45B6-A09f-30E32715F42D}"
-          messageFileName="chrome.dll"
-          name="Chrome"
-          resourceFileName="chrome.dll"
-          symbol="CHROME"
-          >
-        <channels>
-          <importChannel
-              chid="SYSTEM"
-              name="System"
-              />
-        </channels>
-        <templates>
-          <template tid="tid_chrome_event">
-            <data
-                inType="win:AnsiString"
-                name="Name"
-                />
-            <data
-                inType="win:AnsiString"
-                name="Phase"
-                />
-            <data
-                inType="win:AnsiString"
-                name="Arg Name 1"
-                />
-            <data
-                inType="win:AnsiString"
-                name="Arg Value 1"
-                />
-            <data
-                inType="win:AnsiString"
-                name="Arg Name 2"
-                />
-            <data
-                inType="win:AnsiString"
-                name="Arg Value 2"
-                />
-            <data
-                inType="win:AnsiString"
-                name="Arg Name 3"
-                />
-            <data
-                inType="win:AnsiString"
-                name="Arg Value 3"
-                />
-          </template>
-        </templates>
-        <events>
-          <event
-              channel="SYSTEM"
-              level="win:Informational"
-              message="$(string.ChromeEvent.EventMessage)"
-              opcode="win:Info"
-              symbol="ChromeEvent"
-              template="tid_chrome_event"
-              value="1"
-              />
-        </events>
-      </provider>
-    </events>
-  </instrumentation>
-  <localization xmlns="http://schemas.microsoft.com/win/2004/08/events">
-    <resources culture="en-US">
-      <stringTable>
-        <string
-            id="ChromeEvent.EventMessage"
-            value="Chrome Event: %1 (%2)"
-            />
-      </stringTable>
-    </resources>
-  </localization>
-</instrumentationManifest>
diff --git a/base/trace_event/event_name_filter.cc b/base/trace_event/event_name_filter.cc
deleted file mode 100644
index 7bf932e..0000000
--- a/base/trace_event/event_name_filter.cc
+++ /dev/null
@@ -1,26 +0,0 @@
-// Copyright 2016 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/trace_event/event_name_filter.h"
-
-#include "base/trace_event/trace_event_impl.h"
-
-namespace base {
-namespace trace_event {
-
-// static
-const char EventNameFilter::kName[] = "event_whitelist_predicate";
-
-EventNameFilter::EventNameFilter(
-    std::unique_ptr<EventNamesWhitelist> event_names_whitelist)
-    : event_names_whitelist_(std::move(event_names_whitelist)) {}
-
-EventNameFilter::~EventNameFilter() = default;
-
-bool EventNameFilter::FilterTraceEvent(const TraceEvent& trace_event) const {
-  return event_names_whitelist_->count(trace_event.name()) != 0;
-}
-
-}  // namespace trace_event
-}  // namespace base
diff --git a/base/trace_event/event_name_filter.h b/base/trace_event/event_name_filter.h
deleted file mode 100644
index 19333b3..0000000
--- a/base/trace_event/event_name_filter.h
+++ /dev/null
@@ -1,46 +0,0 @@
-// Copyright 2016 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_TRACE_EVENT_EVENT_NAME_FILTER_H_
-#define BASE_TRACE_EVENT_EVENT_NAME_FILTER_H_
-
-#include <memory>
-#include <string>
-#include <unordered_set>
-
-#include "base/base_export.h"
-#include "base/macros.h"
-#include "base/trace_event/trace_event_filter.h"
-
-namespace base {
-namespace trace_event {
-
-class TraceEvent;
-
-// Filters trace events by checking the full name against a whitelist.
-// The current implementation is quite simple and dumb and just uses a
-// hashtable which requires char* to std::string conversion. It could be smarter
-// and use a bloom filter trie. However, today this is used too rarely to
-// justify that cost.
-class BASE_EXPORT EventNameFilter : public TraceEventFilter {
- public:
-  using EventNamesWhitelist = std::unordered_set<std::string>;
-  static const char kName[];
-
-  EventNameFilter(std::unique_ptr<EventNamesWhitelist>);
-  ~EventNameFilter() override;
-
-  // TraceEventFilter implementation.
-  bool FilterTraceEvent(const TraceEvent&) const override;
-
- private:
-  std::unique_ptr<const EventNamesWhitelist> event_names_whitelist_;
-
-  DISALLOW_COPY_AND_ASSIGN(EventNameFilter);
-};
-
-}  // namespace trace_event
-}  // namespace base
-
-#endif  // BASE_TRACE_EVENT_EVENT_NAME_FILTER_H_
diff --git a/base/trace_event/heap_profiler.h b/base/trace_event/heap_profiler.h
deleted file mode 100644
index c8deaf6..0000000
--- a/base/trace_event/heap_profiler.h
+++ /dev/null
@@ -1,119 +0,0 @@
-// Copyright 2016 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_TRACE_EVENT_HEAP_PROFILER_H
-#define BASE_TRACE_EVENT_HEAP_PROFILER_H
-
-#include "base/compiler_specific.h"
-#include "base/trace_event/heap_profiler_allocation_context_tracker.h"
-
-// This header file defines the set of macros that are used to track memory
-// usage in the heap profiler. This is in addition to the macros defined in
-// trace_event.h and are specific to heap profiler. This file also defines
-// implementation details of these macros.
-
-// Implementation detail: heap profiler macros create temporary variables to
-// keep instrumentation overhead low. These macros give each temporary variable
-// a unique name based on the line number to prevent name collisions.
-#define INTERNAL_HEAP_PROFILER_UID3(a, b) heap_profiler_unique_##a##b
-#define INTERNAL_HEAP_PROFILER_UID2(a, b) INTERNAL_HEAP_PROFILER_UID3(a, b)
-#define INTERNAL_HEAP_PROFILER_UID(name_prefix) \
-  INTERNAL_HEAP_PROFILER_UID2(name_prefix, __LINE__)
-
-// Scoped tracker for task execution context in the heap profiler.
-#define TRACE_HEAP_PROFILER_API_SCOPED_TASK_EXECUTION \
-  trace_event_internal::HeapProfilerScopedTaskExecutionTracker
-
-// Scoped tracker that tracks the given program counter as a native stack frame
-// in the heap profiler.
-#define TRACE_HEAP_PROFILER_API_SCOPED_WITH_PROGRAM_COUNTER \
-  trace_event_internal::HeapProfilerScopedStackFrame
-
-// A scoped ignore event used to tell heap profiler to ignore all the
-// allocations in the scope. It is useful to exclude allocations made for
-// tracing from the heap profiler dumps.
-#define HEAP_PROFILER_SCOPED_IGNORE                                          \
-  trace_event_internal::HeapProfilerScopedIgnore INTERNAL_HEAP_PROFILER_UID( \
-      scoped_ignore)
-
-namespace trace_event_internal {
-
-// HeapProfilerScopedTaskExecutionTracker records the current task's context in
-// the heap profiler.
-class HeapProfilerScopedTaskExecutionTracker {
- public:
-  inline explicit HeapProfilerScopedTaskExecutionTracker(
-      const char* task_context)
-      : context_(task_context) {
-    using base::trace_event::AllocationContextTracker;
-    if (UNLIKELY(AllocationContextTracker::capture_mode() !=
-                 AllocationContextTracker::CaptureMode::DISABLED)) {
-      AllocationContextTracker::GetInstanceForCurrentThread()
-          ->PushCurrentTaskContext(context_);
-    }
-  }
-
-  inline ~HeapProfilerScopedTaskExecutionTracker() {
-    using base::trace_event::AllocationContextTracker;
-    if (UNLIKELY(AllocationContextTracker::capture_mode() !=
-                 AllocationContextTracker::CaptureMode::DISABLED)) {
-      AllocationContextTracker::GetInstanceForCurrentThread()
-          ->PopCurrentTaskContext(context_);
-    }
-  }
-
- private:
-  const char* context_;
-};
-
-class HeapProfilerScopedStackFrame {
- public:
-  inline explicit HeapProfilerScopedStackFrame(const void* program_counter)
-      : program_counter_(program_counter) {
-    using base::trace_event::AllocationContextTracker;
-    if (UNLIKELY(AllocationContextTracker::capture_mode() ==
-                 AllocationContextTracker::CaptureMode::MIXED_STACK)) {
-      AllocationContextTracker::GetInstanceForCurrentThread()
-          ->PushNativeStackFrame(program_counter_);
-    }
-  }
-
-  inline ~HeapProfilerScopedStackFrame() {
-    using base::trace_event::AllocationContextTracker;
-    if (UNLIKELY(AllocationContextTracker::capture_mode() ==
-                 AllocationContextTracker::CaptureMode::MIXED_STACK)) {
-      AllocationContextTracker::GetInstanceForCurrentThread()
-          ->PopNativeStackFrame(program_counter_);
-    }
-  }
-
- private:
-  const void* const program_counter_;
-};
-
-class BASE_EXPORT HeapProfilerScopedIgnore {
- public:
-  inline HeapProfilerScopedIgnore() {
-    using base::trace_event::AllocationContextTracker;
-    if (UNLIKELY(
-            AllocationContextTracker::capture_mode() !=
-            AllocationContextTracker::CaptureMode::DISABLED)) {
-      AllocationContextTracker::GetInstanceForCurrentThread()
-          ->begin_ignore_scope();
-    }
-  }
-  inline ~HeapProfilerScopedIgnore() {
-    using base::trace_event::AllocationContextTracker;
-    if (UNLIKELY(
-            AllocationContextTracker::capture_mode() !=
-            AllocationContextTracker::CaptureMode::DISABLED)) {
-      AllocationContextTracker::GetInstanceForCurrentThread()
-          ->end_ignore_scope();
-    }
-  }
-};
-
-}  // namespace trace_event_internal
-
-#endif  // BASE_TRACE_EVENT_HEAP_PROFILER_H
diff --git a/base/trace_event/heap_profiler_allocation_context.cc b/base/trace_event/heap_profiler_allocation_context.cc
deleted file mode 100644
index bdc3c58..0000000
--- a/base/trace_event/heap_profiler_allocation_context.cc
+++ /dev/null
@@ -1,88 +0,0 @@
-// Copyright 2015 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/trace_event/heap_profiler_allocation_context.h"
-
-#include <cstring>
-
-#include "base/hash.h"
-#include "base/macros.h"
-
-namespace base {
-namespace trace_event {
-
-bool operator < (const StackFrame& lhs, const StackFrame& rhs) {
-  return lhs.value < rhs.value;
-}
-
-bool operator == (const StackFrame& lhs, const StackFrame& rhs) {
-  return lhs.value == rhs.value;
-}
-
-bool operator != (const StackFrame& lhs, const StackFrame& rhs) {
-  return !(lhs.value == rhs.value);
-}
-
-Backtrace::Backtrace() = default;
-
-bool operator==(const Backtrace& lhs, const Backtrace& rhs) {
-  if (lhs.frame_count != rhs.frame_count) return false;
-  return std::equal(lhs.frames, lhs.frames + lhs.frame_count, rhs.frames);
-}
-
-bool operator!=(const Backtrace& lhs, const Backtrace& rhs) {
-  return !(lhs == rhs);
-}
-
-AllocationContext::AllocationContext(): type_name(nullptr) {}
-
-AllocationContext::AllocationContext(const Backtrace& backtrace,
-                                     const char* type_name)
-  : backtrace(backtrace), type_name(type_name) {}
-
-bool operator==(const AllocationContext& lhs, const AllocationContext& rhs) {
-  return (lhs.backtrace == rhs.backtrace) && (lhs.type_name == rhs.type_name);
-}
-
-bool operator!=(const AllocationContext& lhs, const AllocationContext& rhs) {
-  return !(lhs == rhs);
-}
-
-}  // namespace trace_event
-}  // namespace base
-
-namespace std {
-
-using base::trace_event::AllocationContext;
-using base::trace_event::Backtrace;
-using base::trace_event::StackFrame;
-
-size_t hash<StackFrame>::operator()(const StackFrame& frame) const {
-  return hash<const void*>()(frame.value);
-}
-
-size_t hash<Backtrace>::operator()(const Backtrace& backtrace) const {
-  const void* values[Backtrace::kMaxFrameCount];
-  for (size_t i = 0; i != backtrace.frame_count; ++i) {
-    values[i] = backtrace.frames[i].value;
-  }
-  return base::PersistentHash(values, backtrace.frame_count * sizeof(*values));
-}
-
-size_t hash<AllocationContext>::operator()(const AllocationContext& ctx) const {
-  size_t backtrace_hash = hash<Backtrace>()(ctx.backtrace);
-
-  // Multiplicative hash from [Knuth 1998]. Works best if |size_t| is 32 bits,
-  // because the magic number is a prime very close to 2^32 / golden ratio, but
-  // will still redistribute keys bijectively on 64-bit architectures because
-  // the magic number is coprime to 2^64.
-  size_t type_hash = reinterpret_cast<size_t>(ctx.type_name) * 2654435761;
-
-  // Multiply one side to break the commutativity of +. Multiplication with a
-  // number coprime to |numeric_limits<size_t>::max() + 1| is bijective so
-  // randomness is preserved.
-  return (backtrace_hash * 3) + type_hash;
-}
-
-}  // namespace std
diff --git a/base/trace_event/heap_profiler_allocation_context.h b/base/trace_event/heap_profiler_allocation_context.h
deleted file mode 100644
index c35663f..0000000
--- a/base/trace_event/heap_profiler_allocation_context.h
+++ /dev/null
@@ -1,132 +0,0 @@
-// Copyright 2015 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_TRACE_EVENT_HEAP_PROFILER_ALLOCATION_CONTEXT_H_
-#define BASE_TRACE_EVENT_HEAP_PROFILER_ALLOCATION_CONTEXT_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-#include <functional>
-
-#include "base/base_export.h"
-
-namespace base {
-namespace trace_event {
-
-// When heap profiling is enabled, tracing keeps track of the allocation
-// context for each allocation intercepted. It is generated by the
-// |AllocationContextTracker| which keeps stacks of context in TLS.
-// The tracker is initialized lazily.
-
-// The backtrace in the allocation context is a snapshot of the stack. For now,
-// this is the pseudo stack where frames are created by trace event macros. In
-// the future, we might add the option to use the native call stack. In that
-// case, |Backtrace| and |AllocationContextTracker::GetContextSnapshot| might
-// have different implementations that can be selected by a compile time flag.
-
-// The number of stack frames stored in the backtrace is a trade off between
-// memory used for tracing and accuracy. Measurements done on a prototype
-// revealed that:
-//
-// - In 60 percent of the cases, pseudo stack depth <= 7.
-// - In 87 percent of the cases, pseudo stack depth <= 9.
-// - In 95 percent of the cases, pseudo stack depth <= 11.
-//
-// See the design doc (https://goo.gl/4s7v7b) for more details.
-
-// Represents (pseudo) stack frame. Used in Backtrace class below.
-//
-// Conceptually stack frame is identified by its value, and type is used
-// mostly to properly format the value. Value is expected to be a valid
-// pointer from process' address space.
-struct BASE_EXPORT StackFrame {
-  enum class Type {
-    TRACE_EVENT_NAME,   // const char* string
-    THREAD_NAME,        // const char* thread name
-    PROGRAM_COUNTER,    // as returned by stack tracing (e.g. by StackTrace)
-  };
-
-  static StackFrame FromTraceEventName(const char* name) {
-    return {Type::TRACE_EVENT_NAME, name};
-  }
-  static StackFrame FromThreadName(const char* name) {
-    return {Type::THREAD_NAME, name};
-  }
-  static StackFrame FromProgramCounter(const void* pc) {
-    return {Type::PROGRAM_COUNTER, pc};
-  }
-
-  Type type;
-  const void* value;
-};
-
-bool BASE_EXPORT operator < (const StackFrame& lhs, const StackFrame& rhs);
-bool BASE_EXPORT operator == (const StackFrame& lhs, const StackFrame& rhs);
-bool BASE_EXPORT operator != (const StackFrame& lhs, const StackFrame& rhs);
-
-struct BASE_EXPORT Backtrace {
-  Backtrace();
-
-  // If the stack is higher than what can be stored here, the top frames
-  // (the ones further from main()) are stored. Depth of 12 is enough for most
-  // pseudo traces (see above), but not for native traces, where we need more.
-  enum { kMaxFrameCount = 48 };
-  StackFrame frames[kMaxFrameCount];
-  size_t frame_count = 0;
-};
-
-bool BASE_EXPORT operator==(const Backtrace& lhs, const Backtrace& rhs);
-bool BASE_EXPORT operator!=(const Backtrace& lhs, const Backtrace& rhs);
-
-// The |AllocationContext| is context metadata that is kept for every allocation
-// when heap profiling is enabled. To simplify memory management for book-
-// keeping, this struct has a fixed size.
-struct BASE_EXPORT AllocationContext {
-  AllocationContext();
-  AllocationContext(const Backtrace& backtrace, const char* type_name);
-
-  Backtrace backtrace;
-
-  // Type name of the type stored in the allocated memory. A null pointer
-  // indicates "unknown type". Grouping is done by comparing pointers, not by
-  // deep string comparison. In a component build, where a type name can have a
-  // string literal in several dynamic libraries, this may distort grouping.
-  const char* type_name;
-};
-
-bool BASE_EXPORT operator==(const AllocationContext& lhs,
-                            const AllocationContext& rhs);
-bool BASE_EXPORT operator!=(const AllocationContext& lhs,
-                            const AllocationContext& rhs);
-
-// Struct to store the size and count of the allocations.
-struct AllocationMetrics {
-  size_t size;
-  size_t count;
-};
-
-}  // namespace trace_event
-}  // namespace base
-
-namespace std {
-
-template <>
-struct BASE_EXPORT hash<base::trace_event::StackFrame> {
-  size_t operator()(const base::trace_event::StackFrame& frame) const;
-};
-
-template <>
-struct BASE_EXPORT hash<base::trace_event::Backtrace> {
-  size_t operator()(const base::trace_event::Backtrace& backtrace) const;
-};
-
-template <>
-struct BASE_EXPORT hash<base::trace_event::AllocationContext> {
-  size_t operator()(const base::trace_event::AllocationContext& context) const;
-};
-
-}  // namespace std
-
-#endif  // BASE_TRACE_EVENT_HEAP_PROFILER_ALLOCATION_CONTEXT_H_
diff --git a/base/trace_event/heap_profiler_allocation_context_tracker.cc b/base/trace_event/heap_profiler_allocation_context_tracker.cc
deleted file mode 100644
index 526eac8..0000000
--- a/base/trace_event/heap_profiler_allocation_context_tracker.cc
+++ /dev/null
@@ -1,253 +0,0 @@
-// Copyright 2015 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/trace_event/heap_profiler_allocation_context_tracker.h"
-
-#include <algorithm>
-#include <iterator>
-
-#include "base/atomicops.h"
-#include "base/debug/leak_annotations.h"
-#include "base/debug/stack_trace.h"
-#include "base/no_destructor.h"
-#include "base/threading/platform_thread.h"
-#include "base/threading/thread_local_storage.h"
-#include "base/trace_event/heap_profiler_allocation_context.h"
-#include "build_config.h"
-
-#if defined(OS_LINUX) || defined(OS_ANDROID)
-#include <sys/prctl.h>
-#endif
-
-namespace base {
-namespace trace_event {
-
-subtle::Atomic32 AllocationContextTracker::capture_mode_ =
-    static_cast<int32_t>(AllocationContextTracker::CaptureMode::DISABLED);
-
-namespace {
-
-const size_t kMaxStackDepth = 128u;
-const size_t kMaxTaskDepth = 16u;
-AllocationContextTracker* const kInitializingSentinel =
-    reinterpret_cast<AllocationContextTracker*>(-1);
-
-// This function is added to the TLS slot to clean up the instance when the
-// thread exits.
-void DestructAllocationContextTracker(void* alloc_ctx_tracker) {
-  delete static_cast<AllocationContextTracker*>(alloc_ctx_tracker);
-}
-
-ThreadLocalStorage::Slot& AllocationContextTrackerTLS() {
-  static NoDestructor<ThreadLocalStorage::Slot> tls_alloc_ctx_tracker(
-      &DestructAllocationContextTracker);
-  return *tls_alloc_ctx_tracker;
-}
-
-// Cannot call ThreadIdNameManager::GetName because it holds a lock and causes
-// deadlock when lock is already held by ThreadIdNameManager before the current
-// allocation. Gets the thread name from kernel if available or returns a string
-// with id. This function intentionally leaks the allocated strings since they
-// are used to tag allocations even after the thread dies.
-const char* GetAndLeakThreadName() {
-  char name[16];
-#if defined(OS_LINUX) || defined(OS_ANDROID)
-  // If the thread name is not set, try to get it from prctl. Thread name might
-  // not be set in cases where the thread started before heap profiling was
-  // enabled.
-  int err = prctl(PR_GET_NAME, name);
-  if (!err) {
-    return strdup(name);
-  }
-#endif  // defined(OS_LINUX) || defined(OS_ANDROID)
-
-  // Use tid if we don't have a thread name.
-  snprintf(name, sizeof(name), "%lu",
-           static_cast<unsigned long>(PlatformThread::CurrentId()));
-  return strdup(name);
-}
-
-}  // namespace
-
-// static
-AllocationContextTracker*
-AllocationContextTracker::GetInstanceForCurrentThread() {
-  AllocationContextTracker* tracker = static_cast<AllocationContextTracker*>(
-      AllocationContextTrackerTLS().Get());
-  if (tracker == kInitializingSentinel)
-    return nullptr;  // Re-entrancy case.
-
-  if (!tracker) {
-    AllocationContextTrackerTLS().Set(kInitializingSentinel);
-    tracker = new AllocationContextTracker();
-    AllocationContextTrackerTLS().Set(tracker);
-  }
-
-  return tracker;
-}
-
-AllocationContextTracker::AllocationContextTracker()
-    : thread_name_(nullptr), ignore_scope_depth_(0) {
-  tracked_stack_.reserve(kMaxStackDepth);
-  task_contexts_.reserve(kMaxTaskDepth);
-}
-AllocationContextTracker::~AllocationContextTracker() = default;
-
-// static
-void AllocationContextTracker::SetCurrentThreadName(const char* name) {
-  if (name && capture_mode() != CaptureMode::DISABLED) {
-    GetInstanceForCurrentThread()->thread_name_ = name;
-  }
-}
-
-// static
-void AllocationContextTracker::SetCaptureMode(CaptureMode mode) {
-  // Release ordering ensures that when a thread observes |capture_mode_| to
-  // be true through an acquire load, the TLS slot has been initialized.
-  subtle::Release_Store(&capture_mode_, static_cast<int32_t>(mode));
-}
-
-void AllocationContextTracker::PushPseudoStackFrame(
-    AllocationContextTracker::PseudoStackFrame stack_frame) {
-  // Impose a limit on the height to verify that every push is popped, because
-  // in practice the pseudo stack never grows higher than ~20 frames.
-  if (tracked_stack_.size() < kMaxStackDepth) {
-    tracked_stack_.push_back(
-        StackFrame::FromTraceEventName(stack_frame.trace_event_name));
-  } else {
-    NOTREACHED();
-  }
-}
-
-void AllocationContextTracker::PopPseudoStackFrame(
-    AllocationContextTracker::PseudoStackFrame stack_frame) {
-  // Guard for stack underflow. If tracing was started with a TRACE_EVENT in
-  // scope, the frame was never pushed, so it is possible that pop is called
-  // on an empty stack.
-  if (tracked_stack_.empty())
-    return;
-
-  tracked_stack_.pop_back();
-}
-
-void AllocationContextTracker::PushNativeStackFrame(const void* pc) {
-  if (tracked_stack_.size() < kMaxStackDepth)
-    tracked_stack_.push_back(StackFrame::FromProgramCounter(pc));
-  else
-    NOTREACHED();
-}
-
-void AllocationContextTracker::PopNativeStackFrame(const void* pc) {
-  if (tracked_stack_.empty())
-    return;
-
-  DCHECK_EQ(pc, tracked_stack_.back().value);
-  tracked_stack_.pop_back();
-}
-
-void AllocationContextTracker::PushCurrentTaskContext(const char* context) {
-  DCHECK(context);
-  if (task_contexts_.size() < kMaxTaskDepth)
-    task_contexts_.push_back(context);
-  else
-    NOTREACHED();
-}
-
-void AllocationContextTracker::PopCurrentTaskContext(const char* context) {
-  // Guard for stack underflow. If tracing was started with a TRACE_EVENT in
-  // scope, the context was never pushed, so it is possible that pop is called
-  // on an empty stack.
-  if (task_contexts_.empty())
-    return;
-
-  DCHECK_EQ(context, task_contexts_.back())
-      << "Encountered an unmatched context end";
-  task_contexts_.pop_back();
-}
-
-bool AllocationContextTracker::GetContextSnapshot(AllocationContext* ctx) {
-  if (ignore_scope_depth_)
-    return false;
-
-  CaptureMode mode = static_cast<CaptureMode>(
-      subtle::NoBarrier_Load(&capture_mode_));
-
-  auto* backtrace = std::begin(ctx->backtrace.frames);
-  auto* backtrace_end = std::end(ctx->backtrace.frames);
-
-  if (!thread_name_) {
-    // Ignore the string allocation made by GetAndLeakThreadName to avoid
-    // reentrancy.
-    ignore_scope_depth_++;
-    thread_name_ = GetAndLeakThreadName();
-    ANNOTATE_LEAKING_OBJECT_PTR(thread_name_);
-    DCHECK(thread_name_);
-    ignore_scope_depth_--;
-  }
-
-  // Add the thread name as the first entry in pseudo stack.
-  if (thread_name_) {
-    *backtrace++ = StackFrame::FromThreadName(thread_name_);
-  }
-
-  switch (mode) {
-    case CaptureMode::DISABLED:
-      {
-        break;
-      }
-    case CaptureMode::PSEUDO_STACK:
-    case CaptureMode::MIXED_STACK:
-      {
-        for (const StackFrame& stack_frame : tracked_stack_) {
-          if (backtrace == backtrace_end)
-            break;
-          *backtrace++ = stack_frame;
-        }
-        break;
-      }
-    case CaptureMode::NATIVE_STACK:
-      {
-// Backtrace contract requires us to return bottom frames, i.e.
-// from main() and up. Stack unwinding produces top frames, i.e.
-// from this point and up until main(). We intentionally request
-// kMaxFrameCount + 1 frames, so that we know if there are more frames
-// than our backtrace capacity.
-#if !defined(OS_NACL)  // We don't build base/debug/stack_trace.cc for NaCl.
-        // Fall-back to capturing the stack with base::debug::StackTrace,
-        // which is likely slower, but more reliable.
-        base::debug::StackTrace stack_trace(Backtrace::kMaxFrameCount + 1);
-        size_t frame_count = 0u;
-        const void* const* frames = stack_trace.Addresses(&frame_count);
-
-        // If there are too many frames, keep the ones furthest from main().
-        size_t backtrace_capacity = backtrace_end - backtrace;
-        int32_t starting_frame_index = frame_count;
-        if (frame_count > backtrace_capacity) {
-          starting_frame_index = backtrace_capacity - 1;
-          *backtrace++ = StackFrame::FromTraceEventName("<truncated>");
-        }
-        for (int32_t i = starting_frame_index - 1; i >= 0; --i) {
-          const void* frame = frames[i];
-          *backtrace++ = StackFrame::FromProgramCounter(frame);
-        }
-#endif  // !defined(OS_NACL)
-        break;
-      }
-  }
-
-  ctx->backtrace.frame_count = backtrace - std::begin(ctx->backtrace.frames);
-
-  // TODO(ssid): Fix crbug.com/594803 to add file name as 3rd dimension
-  // (component name) in the heap profiler and not piggy back on the type name.
-  if (!task_contexts_.empty()) {
-    ctx->type_name = task_contexts_.back();
-  } else {
-    ctx->type_name = nullptr;
-  }
-
-  return true;
-}
-
-}  // namespace trace_event
-}  // namespace base
diff --git a/base/trace_event/heap_profiler_allocation_context_tracker.h b/base/trace_event/heap_profiler_allocation_context_tracker.h
deleted file mode 100644
index da03b7f..0000000
--- a/base/trace_event/heap_profiler_allocation_context_tracker.h
+++ /dev/null
@@ -1,140 +0,0 @@
-// Copyright 2015 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_TRACE_EVENT_HEAP_PROFILER_ALLOCATION_CONTEXT_TRACKER_H_
-#define BASE_TRACE_EVENT_HEAP_PROFILER_ALLOCATION_CONTEXT_TRACKER_H_
-
-#include <vector>
-
-#include "base/atomicops.h"
-#include "base/base_export.h"
-#include "base/macros.h"
-#include "base/trace_event/heap_profiler_allocation_context.h"
-
-namespace base {
-namespace trace_event {
-
-// AllocationContextTracker is a thread-local object. Its main purpose is to
-// keep track of a pseudo stack of trace events. Chrome has been instrumented
-// with lots of `TRACE_EVENT` macros. These trace events push their name to a
-// thread-local stack when they go into scope, and pop when they go out of
-// scope, if all of the following conditions have been met:
-//
-//  * A trace is being recorded.
-//  * The category of the event is enabled in the trace config.
-//  * Heap profiling is enabled (with the `--enable-heap-profiling` flag).
-//
-// This means that allocations that occur before tracing is started will not
-// have backtrace information in their context.
-//
-// AllocationContextTracker also keeps track of some thread state not related to
-// trace events. See |AllocationContext|.
-//
-// A thread-local instance of the context tracker is initialized lazily when it
-// is first accessed. This might be because a trace event pushed or popped, or
-// because `GetContextSnapshot()` was called when an allocation occurred
-class BASE_EXPORT AllocationContextTracker {
- public:
-  enum class CaptureMode : int32_t {
-    DISABLED,      // Don't capture anything
-    PSEUDO_STACK,  // Backtrace has trace events
-    MIXED_STACK,   // Backtrace has trace events + from
-                   // HeapProfilerScopedStackFrame
-    NATIVE_STACK,  // Backtrace has full native backtraces from stack unwinding
-  };
-
-  // Stack frame constructed from trace events in codebase.
-  struct BASE_EXPORT PseudoStackFrame {
-    const char* trace_event_category;
-    const char* trace_event_name;
-
-    bool operator==(const PseudoStackFrame& other) const {
-      return trace_event_category == other.trace_event_category &&
-             trace_event_name == other.trace_event_name;
-    }
-  };
-
-  // Globally sets capturing mode.
-  // TODO(primiano): How to guard against *_STACK -> DISABLED -> *_STACK?
-  static void SetCaptureMode(CaptureMode mode);
-
-  // Returns global capturing mode.
-  inline static CaptureMode capture_mode() {
-    // A little lag after heap profiling is enabled or disabled is fine, it is
-    // more important that the check is as cheap as possible when capturing is
-    // not enabled, so do not issue a memory barrier in the fast path.
-    if (subtle::NoBarrier_Load(&capture_mode_) ==
-            static_cast<int32_t>(CaptureMode::DISABLED))
-      return CaptureMode::DISABLED;
-
-    // In the slow path, an acquire load is required to pair with the release
-    // store in |SetCaptureMode|. This is to ensure that the TLS slot for
-    // the thread-local allocation context tracker has been initialized if
-    // |capture_mode| returns something other than DISABLED.
-    return static_cast<CaptureMode>(subtle::Acquire_Load(&capture_mode_));
-  }
-
-  // Returns the thread-local instance, creating one if necessary. Returns
-  // always a valid instance, unless it is called re-entrantly, in which case
-  // returns nullptr in the nested calls.
-  static AllocationContextTracker* GetInstanceForCurrentThread();
-
-  // Set the thread name in the AllocationContextTracker of the current thread
-  // if capture is enabled.
-  static void SetCurrentThreadName(const char* name);
-
-  // Starts and ends a new ignore scope between which the allocations are
-  // ignored by the heap profiler. GetContextSnapshot() returns false when
-  // allocations are ignored.
-  void begin_ignore_scope() { ignore_scope_depth_++; }
-  void end_ignore_scope() {
-    if (ignore_scope_depth_)
-      ignore_scope_depth_--;
-  }
-
-  // Pushes and pops a frame onto the thread-local pseudo stack.
-  // TODO(ssid): Change PseudoStackFrame to const char*. Only event name is
-  // used.
-  void PushPseudoStackFrame(PseudoStackFrame stack_frame);
-  void PopPseudoStackFrame(PseudoStackFrame stack_frame);
-
-  // Pushes and pops a native stack frame onto thread local tracked stack.
-  void PushNativeStackFrame(const void* pc);
-  void PopNativeStackFrame(const void* pc);
-
-  // Push and pop current task's context. A stack is used to support nested
-  // tasks and the top of the stack will be used in allocation context.
-  void PushCurrentTaskContext(const char* context);
-  void PopCurrentTaskContext(const char* context);
-
-  // Fills a snapshot of the current thread-local context. Doesn't fill and
-  // returns false if allocations are being ignored.
-  bool GetContextSnapshot(AllocationContext* snapshot);
-
-  ~AllocationContextTracker();
-
- private:
-  AllocationContextTracker();
-
-  static subtle::Atomic32 capture_mode_;
-
-  // The pseudo stack where frames are |TRACE_EVENT| names or inserted PCs.
-  std::vector<StackFrame> tracked_stack_;
-
-  // The thread name is used as the first entry in the pseudo stack.
-  const char* thread_name_;
-
-  // Stack of tasks' contexts. Context serves as a different dimension than
-  // pseudo stack to cluster allocations.
-  std::vector<const char*> task_contexts_;
-
-  uint32_t ignore_scope_depth_;
-
-  DISALLOW_COPY_AND_ASSIGN(AllocationContextTracker);
-};
-
-}  // namespace trace_event
-}  // namespace base
-
-#endif  // BASE_TRACE_EVENT_HEAP_PROFILER_ALLOCATION_CONTEXT_TRACKER_H_
diff --git a/base/trace_event/heap_profiler_event_filter.cc b/base/trace_event/heap_profiler_event_filter.cc
deleted file mode 100644
index 937072c..0000000
--- a/base/trace_event/heap_profiler_event_filter.cc
+++ /dev/null
@@ -1,70 +0,0 @@
-// Copyright 2016 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/trace_event/heap_profiler_event_filter.h"
-
-#include "base/trace_event/category_registry.h"
-#include "base/trace_event/heap_profiler_allocation_context_tracker.h"
-#include "base/trace_event/trace_category.h"
-#include "base/trace_event/trace_event.h"
-#include "base/trace_event/trace_event_impl.h"
-
-namespace base {
-namespace trace_event {
-
-namespace {
-
-inline bool IsPseudoStackEnabled() {
-  // Only PSEUDO_STACK and MIXED_STACK modes require trace events.
-  return AllocationContextTracker::capture_mode() ==
-             AllocationContextTracker::CaptureMode::PSEUDO_STACK ||
-         AllocationContextTracker::capture_mode() ==
-             AllocationContextTracker::CaptureMode::MIXED_STACK;
-}
-
-inline AllocationContextTracker* GetThreadLocalTracker() {
-  return AllocationContextTracker::GetInstanceForCurrentThread();
-}
-
-}  // namespace
-
-// static
-const char HeapProfilerEventFilter::kName[] = "heap_profiler_predicate";
-
-HeapProfilerEventFilter::HeapProfilerEventFilter() = default;
-HeapProfilerEventFilter::~HeapProfilerEventFilter() = default;
-
-bool HeapProfilerEventFilter::FilterTraceEvent(
-    const TraceEvent& trace_event) const {
-  if (!IsPseudoStackEnabled())
-    return true;
-
-  // TODO(primiano): Add support for events with copied name crbug.com/581079.
-  if (trace_event.flags() & TRACE_EVENT_FLAG_COPY)
-    return true;
-
-  const auto* category = CategoryRegistry::GetCategoryByStatePtr(
-      trace_event.category_group_enabled());
-  AllocationContextTracker::PseudoStackFrame frame = {category->name(),
-                                                      trace_event.name()};
-  if (trace_event.phase() == TRACE_EVENT_PHASE_BEGIN ||
-      trace_event.phase() == TRACE_EVENT_PHASE_COMPLETE) {
-    GetThreadLocalTracker()->PushPseudoStackFrame(frame);
-  } else if (trace_event.phase() == TRACE_EVENT_PHASE_END) {
-    // The pop for |TRACE_EVENT_PHASE_COMPLETE| events is in |EndEvent|.
-    GetThreadLocalTracker()->PopPseudoStackFrame(frame);
-  }
-  // Do not filter-out any events and always return true. TraceLog adds the
-  // event only if it is enabled for recording.
-  return true;
-}
-
-void HeapProfilerEventFilter::EndEvent(const char* category_name,
-                                       const char* event_name) const {
-  if (IsPseudoStackEnabled())
-    GetThreadLocalTracker()->PopPseudoStackFrame({category_name, event_name});
-}
-
-}  // namespace trace_event
-}  // namespace base
diff --git a/base/trace_event/heap_profiler_event_filter.h b/base/trace_event/heap_profiler_event_filter.h
deleted file mode 100644
index 47368a1..0000000
--- a/base/trace_event/heap_profiler_event_filter.h
+++ /dev/null
@@ -1,40 +0,0 @@
-// Copyright 2016 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_TRACE_EVENT_HEAP_PROFILER_EVENT_FILTER_H_
-#define BASE_TRACE_EVENT_HEAP_PROFILER_EVENT_FILTER_H_
-
-#include "base/base_export.h"
-#include "base/macros.h"
-#include "base/trace_event/trace_event_filter.h"
-
-namespace base {
-namespace trace_event {
-
-class TraceEvent;
-
-// This filter unconditionally accepts all events and pushes/pops them from the
-// thread-local AllocationContextTracker instance as they are seen.
-// This is used to cheaply construct the heap profiler pseudo stack without
-// having to actually record all events.
-class BASE_EXPORT HeapProfilerEventFilter : public TraceEventFilter {
- public:
-  static const char kName[];
-
-  HeapProfilerEventFilter();
-  ~HeapProfilerEventFilter() override;
-
-  // TraceEventFilter implementation.
-  bool FilterTraceEvent(const TraceEvent& trace_event) const override;
-  void EndEvent(const char* category_name,
-                const char* event_name) const override;
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(HeapProfilerEventFilter);
-};
-
-}  // namespace trace_event
-}  // namespace base
-
-#endif  // BASE_TRACE_EVENT_HEAP_PROFILER_EVENT_FILTER_H_
diff --git a/base/trace_event/heap_profiler_heap_dump_writer.cc b/base/trace_event/heap_profiler_heap_dump_writer.cc
deleted file mode 100644
index 71c3d97..0000000
--- a/base/trace_event/heap_profiler_heap_dump_writer.cc
+++ /dev/null
@@ -1,323 +0,0 @@
-// Copyright 2015 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/trace_event/heap_profiler_heap_dump_writer.h"
-
-#include <stdint.h>
-
-#include <algorithm>
-#include <iterator>
-#include <tuple>
-#include <utility>
-#include <vector>
-
-#include "base/format_macros.h"
-#include "base/logging.h"
-#include "base/macros.h"
-#include "base/strings/stringprintf.h"
-#include "base/trace_event/heap_profiler_serialization_state.h"
-#include "base/trace_event/heap_profiler_stack_frame_deduplicator.h"
-#include "base/trace_event/heap_profiler_type_name_deduplicator.h"
-#include "base/trace_event/trace_config.h"
-#include "base/trace_event/trace_event.h"
-#include "base/trace_event/trace_event_argument.h"
-#include "base/trace_event/trace_log.h"
-
-// Most of what the |HeapDumpWriter| does is aggregating detailed information
-// about the heap and deciding what to dump. The Input to this process is a list
-// of |AllocationContext|s and size pairs.
-//
-// The pairs are grouped into |Bucket|s. A bucket is a group of (context, size)
-// pairs where the properties of the contexts share a prefix. (Type name is
-// considered a list of length one here.) First all pairs are put into one
-// bucket that represents the entire heap. Then this bucket is recursively
-// broken down into smaller buckets. Each bucket keeps track of whether further
-// breakdown is possible.
-
-namespace base {
-namespace trace_event {
-namespace internal {
-namespace {
-
-// Denotes a property of |AllocationContext| to break down by.
-enum class BreakDownMode { kByBacktrace, kByTypeName };
-
-// A group of bytes for which the context shares a prefix.
-struct Bucket {
-  Bucket()
-      : size(0),
-        count(0),
-        backtrace_cursor(0),
-        is_broken_down_by_type_name(false) {}
-
-  std::vector<std::pair<const AllocationContext*, AllocationMetrics>>
-      metrics_by_context;
-
-  // The sum of the sizes of |metrics_by_context|.
-  size_t size;
-
-  // The sum of number of allocations of |metrics_by_context|.
-  size_t count;
-
-  // The index of the stack frame that has not yet been broken down by. For all
-  // elements in this bucket, the stack frames 0 up to (but not including) the
-  // cursor, must be equal.
-  size_t backtrace_cursor;
-
-  // When true, the type name for all elements in this bucket must be equal.
-  bool is_broken_down_by_type_name;
-};
-
-// Comparison operator to order buckets by their size.
-bool operator<(const Bucket& lhs, const Bucket& rhs) {
-  return lhs.size < rhs.size;
-}
-
-// Groups the allocations in the bucket by |break_by|. The buckets in the
-// returned list will have |backtrace_cursor| advanced or
-// |is_broken_down_by_type_name| set depending on the property to group by.
-std::vector<Bucket> GetSubbuckets(const Bucket& bucket,
-                                  BreakDownMode break_by) {
-  std::unordered_map<const void*, Bucket> breakdown;
-
-  if (break_by == BreakDownMode::kByBacktrace) {
-    for (const auto& context_and_metrics : bucket.metrics_by_context) {
-      const Backtrace& backtrace = context_and_metrics.first->backtrace;
-      const StackFrame* begin = std::begin(backtrace.frames);
-      const StackFrame* end = begin + backtrace.frame_count;
-      const StackFrame* cursor = begin + bucket.backtrace_cursor;
-
-      DCHECK_LE(cursor, end);
-
-      if (cursor != end) {
-        Bucket& subbucket = breakdown[cursor->value];
-        subbucket.size += context_and_metrics.second.size;
-        subbucket.count += context_and_metrics.second.count;
-        subbucket.metrics_by_context.push_back(context_and_metrics);
-        subbucket.backtrace_cursor = bucket.backtrace_cursor + 1;
-        subbucket.is_broken_down_by_type_name =
-            bucket.is_broken_down_by_type_name;
-        DCHECK_GT(subbucket.size, 0u);
-        DCHECK_GT(subbucket.count, 0u);
-      }
-    }
-  } else if (break_by == BreakDownMode::kByTypeName) {
-    if (!bucket.is_broken_down_by_type_name) {
-      for (const auto& context_and_metrics : bucket.metrics_by_context) {
-        const AllocationContext* context = context_and_metrics.first;
-        Bucket& subbucket = breakdown[context->type_name];
-        subbucket.size += context_and_metrics.second.size;
-        subbucket.count += context_and_metrics.second.count;
-        subbucket.metrics_by_context.push_back(context_and_metrics);
-        subbucket.backtrace_cursor = bucket.backtrace_cursor;
-        subbucket.is_broken_down_by_type_name = true;
-        DCHECK_GT(subbucket.size, 0u);
-        DCHECK_GT(subbucket.count, 0u);
-      }
-    }
-  }
-
-  std::vector<Bucket> buckets;
-  buckets.reserve(breakdown.size());
-  for (auto key_bucket : breakdown)
-    buckets.push_back(key_bucket.second);
-
-  return buckets;
-}
-
-// Breaks down the bucket by |break_by|. Returns only buckets that contribute
-// more than |min_size_bytes| to the total size. The long tail is omitted.
-std::vector<Bucket> BreakDownBy(const Bucket& bucket,
-                                BreakDownMode break_by,
-                                size_t min_size_bytes) {
-  std::vector<Bucket> buckets = GetSubbuckets(bucket, break_by);
-
-  // Ensure that |buckets| is a max-heap (the data structure, not memory heap),
-  // so its front contains the largest bucket. Buckets should be iterated
-  // ordered by size, but sorting the vector is overkill because the long tail
-  // of small buckets will be discarded. By using a max-heap, the optimal case
-  // where all but the first bucket are discarded is O(n). The worst case where
-  // no bucket is discarded is doing a heap sort, which is O(n log n).
-  std::make_heap(buckets.begin(), buckets.end());
-
-  // Keep including buckets until adding one would increase the number of
-  // bytes accounted for by |min_size_bytes|. The large buckets end up in
-  // [it, end()), [begin(), it) is the part that contains the max-heap
-  // of small buckets.
-  std::vector<Bucket>::iterator it;
-  for (it = buckets.end(); it != buckets.begin(); --it) {
-    if (buckets.front().size < min_size_bytes)
-      break;
-
-    // Put the largest bucket in [begin, it) at |it - 1| and max-heapify
-    // [begin, it - 1). This puts the next largest bucket at |buckets.front()|.
-    std::pop_heap(buckets.begin(), it);
-  }
-
-  // At this point, |buckets| looks like this (numbers are bucket sizes):
-  //
-  // <-- max-heap of small buckets --->
-  //                                  <-- large buckets by ascending size -->
-  // [ 19 | 11 | 13 | 7 | 2 | 5 | ... | 83 | 89 | 97 ]
-  //   ^                                ^              ^
-  //   |                                |              |
-  //   begin()                          it             end()
-
-  // Discard the long tail of buckets that contribute less than a percent.
-  buckets.erase(buckets.begin(), it);
-
-  return buckets;
-}
-
-}  // namespace
-
-bool operator<(Entry lhs, Entry rhs) {
-  // There is no need to compare |size|. If the backtrace and type name are
-  // equal then the sizes must be equal as well.
-  return std::tie(lhs.stack_frame_id, lhs.type_id) <
-         std::tie(rhs.stack_frame_id, rhs.type_id);
-}
-
-HeapDumpWriter::HeapDumpWriter(StackFrameDeduplicator* stack_frame_deduplicator,
-                               TypeNameDeduplicator* type_name_deduplicator,
-                               uint32_t breakdown_threshold_bytes)
-    : stack_frame_deduplicator_(stack_frame_deduplicator),
-      type_name_deduplicator_(type_name_deduplicator),
-      breakdown_threshold_bytes_(breakdown_threshold_bytes) {}
-
-HeapDumpWriter::~HeapDumpWriter() = default;
-
-bool HeapDumpWriter::AddEntryForBucket(const Bucket& bucket) {
-  // The contexts in the bucket are all different, but the [begin, cursor) range
-  // is equal for all contexts in the bucket, and the type names are the same if
-  // |is_broken_down_by_type_name| is set.
-  DCHECK(!bucket.metrics_by_context.empty());
-
-  const AllocationContext* context = bucket.metrics_by_context.front().first;
-
-  const StackFrame* backtrace_begin = std::begin(context->backtrace.frames);
-  const StackFrame* backtrace_end = backtrace_begin + bucket.backtrace_cursor;
-  DCHECK_LE(bucket.backtrace_cursor, arraysize(context->backtrace.frames));
-
-  Entry entry;
-  entry.stack_frame_id =
-      stack_frame_deduplicator_->Insert(backtrace_begin, backtrace_end);
-
-  // Deduplicate the type name, or use ID -1 if type name is not set.
-  entry.type_id = bucket.is_broken_down_by_type_name
-                      ? type_name_deduplicator_->Insert(context->type_name)
-                      : -1;
-
-  entry.size = bucket.size;
-  entry.count = bucket.count;
-
-  auto position_and_inserted = entries_.insert(entry);
-  return position_and_inserted.second;
-}
-
-void HeapDumpWriter::BreakDown(const Bucket& bucket) {
-  auto by_backtrace = BreakDownBy(bucket, BreakDownMode::kByBacktrace,
-                                  breakdown_threshold_bytes_);
-  auto by_type_name = BreakDownBy(bucket, BreakDownMode::kByTypeName,
-                                  breakdown_threshold_bytes_);
-
-  // Insert entries for the buckets. If a bucket was not present before, it has
-  // not been broken down before, so recursively continue breaking down in that
-  // case. There might be multiple routes to the same entry (first break down
-  // by type name, then by backtrace, or first by backtrace and then by type),
-  // so a set is used to avoid dumping and breaking down entries more than once.
-
-  for (const Bucket& subbucket : by_backtrace)
-    if (AddEntryForBucket(subbucket))
-      BreakDown(subbucket);
-
-  for (const Bucket& subbucket : by_type_name)
-    if (AddEntryForBucket(subbucket))
-      BreakDown(subbucket);
-}
-
-const std::set<Entry>& HeapDumpWriter::Summarize(
-    const std::unordered_map<AllocationContext, AllocationMetrics>&
-        metrics_by_context) {
-  // Start with one bucket that represents the entire heap. Iterate by
-  // reference, because the allocation contexts are going to point to allocation
-  // contexts stored in |metrics_by_context|.
-  Bucket root_bucket;
-  for (const auto& context_and_metrics : metrics_by_context) {
-    DCHECK_GT(context_and_metrics.second.size, 0u);
-    DCHECK_GT(context_and_metrics.second.count, 0u);
-    const AllocationContext* context = &context_and_metrics.first;
-    root_bucket.metrics_by_context.push_back(
-        std::make_pair(context, context_and_metrics.second));
-    root_bucket.size += context_and_metrics.second.size;
-    root_bucket.count += context_and_metrics.second.count;
-  }
-
-  AddEntryForBucket(root_bucket);
-
-  // Recursively break down the heap and fill |entries_| with entries to dump.
-  BreakDown(root_bucket);
-
-  return entries_;
-}
-
-std::unique_ptr<TracedValue> Serialize(const std::set<Entry>& entries) {
-  std::string buffer;
-  std::unique_ptr<TracedValue> traced_value(new TracedValue);
-
-  traced_value->BeginArray("entries");
-
-  for (const Entry& entry : entries) {
-    traced_value->BeginDictionary();
-
-    // Format size as hexadecimal string into |buffer|.
-    SStringPrintf(&buffer, "%" PRIx64, static_cast<uint64_t>(entry.size));
-    traced_value->SetString("size", buffer);
-
-    SStringPrintf(&buffer, "%" PRIx64, static_cast<uint64_t>(entry.count));
-    traced_value->SetString("count", buffer);
-
-    if (entry.stack_frame_id == -1) {
-      // An empty backtrace (which will have ID -1) is represented by the empty
-      // string, because there is no leaf frame to reference in |stackFrames|.
-      traced_value->SetString("bt", "");
-    } else {
-      // Format index of the leaf frame as a string, because |stackFrames| is a
-      // dictionary, not an array.
-      SStringPrintf(&buffer, "%i", entry.stack_frame_id);
-      traced_value->SetString("bt", buffer);
-    }
-
-    // Type ID -1 (cumulative size for all types) is represented by the absence
-    // of the "type" key in the dictionary.
-    if (entry.type_id != -1) {
-      // Format the type ID as a string.
-      SStringPrintf(&buffer, "%i", entry.type_id);
-      traced_value->SetString("type", buffer);
-    }
-
-    traced_value->EndDictionary();
-  }
-
-  traced_value->EndArray();  // "entries"
-  return traced_value;
-}
-
-}  // namespace internal
-
-std::unique_ptr<TracedValue> ExportHeapDump(
-    const std::unordered_map<AllocationContext, AllocationMetrics>&
-        metrics_by_context,
-    const HeapProfilerSerializationState& heap_profiler_serialization_state) {
-  TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("memory-infra"), "ExportHeapDump");
-  internal::HeapDumpWriter writer(
-      heap_profiler_serialization_state.stack_frame_deduplicator(),
-      heap_profiler_serialization_state.type_name_deduplicator(),
-      heap_profiler_serialization_state
-          .heap_profiler_breakdown_threshold_bytes());
-  return Serialize(writer.Summarize(metrics_by_context));
-}
-
-}  // namespace trace_event
-}  // namespace base
diff --git a/base/trace_event/heap_profiler_heap_dump_writer.h b/base/trace_event/heap_profiler_heap_dump_writer.h
deleted file mode 100644
index 3366c28..0000000
--- a/base/trace_event/heap_profiler_heap_dump_writer.h
+++ /dev/null
@@ -1,115 +0,0 @@
-// Copyright 2015 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_TRACE_EVENT_HEAP_PROFILER_HEAP_DUMP_WRITER_H_
-#define BASE_TRACE_EVENT_HEAP_PROFILER_HEAP_DUMP_WRITER_H_
-
-#include <stddef.h>
-
-#include <memory>
-#include <set>
-#include <unordered_map>
-
-#include "base/base_export.h"
-#include "base/macros.h"
-#include "base/trace_event/heap_profiler_allocation_context.h"
-
-namespace base {
-namespace trace_event {
-
-class HeapProfilerSerializationState;
-class StackFrameDeduplicator;
-class TracedValue;
-class TypeNameDeduplicator;
-
-// Aggregates |metrics_by_context|, recursively breaks down the heap, and
-// returns a traced value with an "entries" array that can be dumped in the
-// trace log, following the format described in https://goo.gl/KY7zVE. The
-// number of entries is kept reasonable because long tails are not included.
-BASE_EXPORT std::unique_ptr<TracedValue> ExportHeapDump(
-    const std::unordered_map<AllocationContext, AllocationMetrics>&
-        metrics_by_context,
-    const HeapProfilerSerializationState& heap_profiler_serialization_state);
-
-namespace internal {
-
-namespace {
-struct Bucket;
-}
-
-// An entry in the "entries" array as described in https://goo.gl/KY7zVE.
-struct BASE_EXPORT Entry {
-  size_t size;
-  size_t count;
-
-  // References a backtrace in the stack frame deduplicator. -1 means empty
-  // backtrace (the root of the tree).
-  int stack_frame_id;
-
-  // References a type name in the type name deduplicator. -1 indicates that
-  // the size is the cumulative size for all types (the root of the tree).
-  int type_id;
-};
-
-// Comparison operator to enable putting |Entry| in a |std::set|.
-BASE_EXPORT bool operator<(Entry lhs, Entry rhs);
-
-// Serializes entries to an "entries" array in a traced value.
-BASE_EXPORT std::unique_ptr<TracedValue> Serialize(const std::set<Entry>& dump);
-
-// Helper class to dump a snapshot of an |AllocationRegister| or other heap
-// bookkeeping structure into a |TracedValue|. This class is intended to be
-// used as a one-shot local instance on the stack.
-class BASE_EXPORT HeapDumpWriter {
- public:
-  // The |stack_frame_deduplicator| and |type_name_deduplicator| are not owned.
-  // The heap dump writer assumes exclusive access to them during the lifetime
-  // of the dump writer. The heap dumps are broken down for allocations bigger
-  // than |breakdown_threshold_bytes|.
-  HeapDumpWriter(StackFrameDeduplicator* stack_frame_deduplicator,
-                 TypeNameDeduplicator* type_name_deduplicator,
-                 uint32_t breakdown_threshold_bytes);
-
-  ~HeapDumpWriter();
-
-  // Aggregates allocations to compute the total size of the heap, then breaks
-  // down the heap recursively. This produces the values that should be dumped
-  // in the "entries" array. The number of entries is kept reasonable because
-  // long tails are not included. Use |Serialize| to convert to a traced value.
-  const std::set<Entry>& Summarize(
-      const std::unordered_map<AllocationContext, AllocationMetrics>&
-          metrics_by_context);
-
- private:
-  // Inserts an |Entry| for |Bucket| into |entries_|. Returns false if the
-  // entry was present before, true if it was not.
-  bool AddEntryForBucket(const Bucket& bucket);
-
-  // Recursively breaks down a bucket into smaller buckets and adds entries for
-  // the buckets worth dumping to |entries_|.
-  void BreakDown(const Bucket& bucket);
-
-  // The collection of entries that is filled by |Summarize|.
-  std::set<Entry> entries_;
-
-  // Helper for generating the |stackFrames| dictionary. Not owned, must outlive
-  // this heap dump writer instance.
-  StackFrameDeduplicator* const stack_frame_deduplicator_;
-
-  // Helper for converting type names to IDs. Not owned, must outlive this heap
-  // dump writer instance.
-  TypeNameDeduplicator* const type_name_deduplicator_;
-
-  // Minimum size of an allocation for which an allocation bucket will be
-  // broken down with children.
-  uint32_t breakdown_threshold_bytes_;
-
-  DISALLOW_COPY_AND_ASSIGN(HeapDumpWriter);
-};
-
-}  // namespace internal
-}  // namespace trace_event
-}  // namespace base
-
-#endif  // BASE_TRACE_EVENT_HEAP_PROFILER_HEAP_DUMP_WRITER_H_
diff --git a/base/trace_event/heap_profiler_serialization_state.cc b/base/trace_event/heap_profiler_serialization_state.cc
deleted file mode 100644
index b1866e7..0000000
--- a/base/trace_event/heap_profiler_serialization_state.cc
+++ /dev/null
@@ -1,27 +0,0 @@
-// Copyright 2015 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/trace_event/heap_profiler_serialization_state.h"
-
-namespace base {
-namespace trace_event {
-
-HeapProfilerSerializationState::HeapProfilerSerializationState()
-    : heap_profiler_breakdown_threshold_bytes_(0) {}
-HeapProfilerSerializationState::~HeapProfilerSerializationState() = default;
-
-void HeapProfilerSerializationState::SetStackFrameDeduplicator(
-    std::unique_ptr<StackFrameDeduplicator> stack_frame_deduplicator) {
-  DCHECK(!stack_frame_deduplicator_);
-  stack_frame_deduplicator_ = std::move(stack_frame_deduplicator);
-}
-
-void HeapProfilerSerializationState::SetTypeNameDeduplicator(
-    std::unique_ptr<TypeNameDeduplicator> type_name_deduplicator) {
-  DCHECK(!type_name_deduplicator_);
-  type_name_deduplicator_ = std::move(type_name_deduplicator);
-}
-
-}  // namespace trace_event
-}  // namespace base
diff --git a/base/trace_event/heap_profiler_serialization_state.h b/base/trace_event/heap_profiler_serialization_state.h
deleted file mode 100644
index 53c5687..0000000
--- a/base/trace_event/heap_profiler_serialization_state.h
+++ /dev/null
@@ -1,80 +0,0 @@
-// Copyright 2015 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_TRACE_EVENT_HEAP_PROFILER_SERIALIZATION_STATE_H_
-#define BASE_TRACE_EVENT_HEAP_PROFILER_SERIALIZATION_STATE_H_
-
-#include <memory>
-#include <set>
-
-#include "base/base_export.h"
-#include "base/trace_event/heap_profiler_stack_frame_deduplicator.h"
-#include "base/trace_event/heap_profiler_type_name_deduplicator.h"
-#include "base/trace_event/memory_dump_request_args.h"
-
-namespace base {
-namespace trace_event {
-
-// Container for state variables that should be shared across all the memory
-// dumps in a tracing session.
-class BASE_EXPORT HeapProfilerSerializationState
-    : public RefCountedThreadSafe<HeapProfilerSerializationState> {
- public:
-  HeapProfilerSerializationState();
-
-  // Returns the stack frame deduplicator that should be used by memory dump
-  // providers when doing a heap dump.
-  StackFrameDeduplicator* stack_frame_deduplicator() const {
-    return stack_frame_deduplicator_.get();
-  }
-
-  void SetStackFrameDeduplicator(
-      std::unique_ptr<StackFrameDeduplicator> stack_frame_deduplicator);
-
-  // Returns the type name deduplicator that should be used by memory dump
-  // providers when doing a heap dump.
-  TypeNameDeduplicator* type_name_deduplicator() const {
-    return type_name_deduplicator_.get();
-  }
-
-  void SetTypeNameDeduplicator(
-      std::unique_ptr<TypeNameDeduplicator> type_name_deduplicator);
-
-  void SetAllowedDumpModes(
-      std::set<MemoryDumpLevelOfDetail> allowed_dump_modes);
-
-  bool IsDumpModeAllowed(MemoryDumpLevelOfDetail dump_mode) const;
-
-  void set_heap_profiler_breakdown_threshold_bytes(uint32_t value) {
-    heap_profiler_breakdown_threshold_bytes_ = value;
-  }
-
-  uint32_t heap_profiler_breakdown_threshold_bytes() const {
-    return heap_profiler_breakdown_threshold_bytes_;
-  }
-
-  bool is_initialized() const {
-    return stack_frame_deduplicator_ && type_name_deduplicator_ &&
-           heap_profiler_breakdown_threshold_bytes_;
-  }
-
- private:
-  friend class RefCountedThreadSafe<HeapProfilerSerializationState>;
-  ~HeapProfilerSerializationState();
-
-  // Deduplicates backtraces in heap dumps so they can be written once when the
-  // trace is finalized.
-  std::unique_ptr<StackFrameDeduplicator> stack_frame_deduplicator_;
-
-  // Deduplicates type names in heap dumps so they can be written once when the
-  // trace is finalized.
-  std::unique_ptr<TypeNameDeduplicator> type_name_deduplicator_;
-
-  uint32_t heap_profiler_breakdown_threshold_bytes_;
-};
-
-}  // namespace trace_event
-}  // namespace base
-
-#endif  // BASE_TRACE_EVENT_HEAP_PROFILER_SERIALIZATION_STATE_H
diff --git a/base/trace_event/heap_profiler_stack_frame_deduplicator.cc b/base/trace_event/heap_profiler_stack_frame_deduplicator.cc
deleted file mode 100644
index c05cd0a..0000000
--- a/base/trace_event/heap_profiler_stack_frame_deduplicator.cc
+++ /dev/null
@@ -1,195 +0,0 @@
-// Copyright 2015 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/trace_event/heap_profiler_stack_frame_deduplicator.h"
-
-#include <inttypes.h>
-#include <stddef.h>
-
-#include <algorithm>
-#include <string>
-#include <utility>
-
-#include "base/hash.h"
-#include "base/strings/stringprintf.h"
-#include "base/trace_event/memory_usage_estimator.h"
-#include "base/trace_event/trace_event.h"
-#include "base/trace_event/trace_event_argument.h"
-#include "base/trace_event/trace_event_memory_overhead.h"
-
-namespace base {
-namespace trace_event {
-
-namespace {
-
-// Dumb hash function that nevertheless works surprisingly well and
-// produces ~0 collisions on real backtraces.
-size_t HashBacktrace(const StackFrame* begin, const StackFrame* end) {
-  size_t hash = 0;
-  for (; begin != end; begin++) {
-    hash += reinterpret_cast<uintptr_t>(begin->value);
-  }
-  return hash;
-}
-
-}  // namespace
-
-StackFrameDeduplicator::FrameNode::FrameNode(StackFrame frame,
-                                             int parent_frame_index)
-    : frame(frame), parent_frame_index(parent_frame_index) {}
-StackFrameDeduplicator::FrameNode::FrameNode(const FrameNode& other) = default;
-StackFrameDeduplicator::FrameNode::~FrameNode() = default;
-
-size_t StackFrameDeduplicator::FrameNode::EstimateMemoryUsage() const {
-  return base::trace_event::EstimateMemoryUsage(children);
-}
-
-StackFrameDeduplicator::StackFrameDeduplicator() = default;
-StackFrameDeduplicator::~StackFrameDeduplicator() = default;
-
-bool StackFrameDeduplicator::Match(int frame_index,
-                                   const StackFrame* begin_frame,
-                                   const StackFrame* end_frame) const {
-  // |frame_index| identifies the bottom frame, i.e. we need to walk
-  // backtrace backwards.
-  const StackFrame* current_frame = end_frame - 1;
-  for (; current_frame >= begin_frame; --current_frame) {
-    const FrameNode& node = frames_[frame_index];
-    if (node.frame != *current_frame) {
-      break;
-    }
-
-    frame_index = node.parent_frame_index;
-    if (frame_index == FrameNode::kInvalidFrameIndex) {
-      if (current_frame == begin_frame) {
-        // We're at the top node and we matched all backtrace frames,
-        // i.e. we successfully matched the backtrace.
-        return true;
-      }
-      break;
-    }
-  }
-
-  return false;
-}
-
-int StackFrameDeduplicator::Insert(const StackFrame* begin_frame,
-                                   const StackFrame* end_frame) {
-  if (begin_frame == end_frame) {
-    return FrameNode::kInvalidFrameIndex;
-  }
-
-  size_t backtrace_hash = HashBacktrace(begin_frame, end_frame);
-
-  // Check if we know about this backtrace.
-  auto backtrace_it = backtrace_lookup_table_.find(backtrace_hash);
-  if (backtrace_it != backtrace_lookup_table_.end()) {
-    int backtrace_index = backtrace_it->second;
-    if (Match(backtrace_index, begin_frame, end_frame)) {
-      return backtrace_index;
-    }
-  }
-
-  int frame_index = FrameNode::kInvalidFrameIndex;
-  base::flat_map<StackFrame, int>* nodes = &roots_;
-
-  // Loop through the frames, early out when a frame is null.
-  for (const StackFrame* it = begin_frame; it != end_frame; it++) {
-    StackFrame frame = *it;
-
-    auto node = nodes->find(frame);
-    if (node == nodes->end()) {
-      // There is no tree node for this frame yet, create it. The parent node
-      // is the node associated with the previous frame.
-      FrameNode frame_node(frame, frame_index);
-
-      // The new frame node will be appended, so its index is the current size
-      // of the vector.
-      frame_index = static_cast<int>(frames_.size());
-
-      // Add the node to the trie so it will be found next time.
-      nodes->insert(std::make_pair(frame, frame_index));
-
-      // Append the node after modifying |nodes|, because the |frames_| vector
-      // might need to resize, and this invalidates the |nodes| pointer.
-      frames_.push_back(frame_node);
-    } else {
-      // A tree node for this frame exists. Look for the next one.
-      frame_index = node->second;
-    }
-
-    nodes = &frames_[frame_index].children;
-  }
-
-  // Remember the backtrace.
-  backtrace_lookup_table_[backtrace_hash] = frame_index;
-
-  return frame_index;
-}
-
-void StackFrameDeduplicator::AppendAsTraceFormat(std::string* out) const {
-  TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("memory-infra"),
-               "StackFrameDeduplicator::AppendAsTraceFormat");
-  out->append("{");  // Begin the |stackFrames| dictionary.
-
-  int i = 0;
-  auto frame_node = begin();
-  auto it_end = end();
-  std::string stringify_buffer;
-
-  while (frame_node != it_end) {
-    // The |stackFrames| format is a dictionary, not an array, so the
-    // keys are stringified indices. Write the index manually, then use
-    // |TracedValue| to format the object. This is to avoid building the
-    // entire dictionary as a |TracedValue| in memory.
-    SStringPrintf(&stringify_buffer, "\"%d\":", i);
-    out->append(stringify_buffer);
-
-    std::unique_ptr<TracedValue> frame_node_value(new TracedValue);
-    const StackFrame& frame = frame_node->frame;
-    switch (frame.type) {
-      case StackFrame::Type::TRACE_EVENT_NAME:
-        frame_node_value->SetString("name",
-                                    static_cast<const char*>(frame.value));
-        break;
-      case StackFrame::Type::THREAD_NAME:
-        SStringPrintf(&stringify_buffer,
-                      "[Thread: %s]",
-                      static_cast<const char*>(frame.value));
-        frame_node_value->SetString("name", stringify_buffer);
-        break;
-      case StackFrame::Type::PROGRAM_COUNTER:
-        SStringPrintf(&stringify_buffer,
-                      "pc:%" PRIxPTR,
-                      reinterpret_cast<uintptr_t>(frame.value));
-        frame_node_value->SetString("name", stringify_buffer);
-        break;
-    }
-    if (frame_node->parent_frame_index != FrameNode::kInvalidFrameIndex) {
-      SStringPrintf(&stringify_buffer, "%d", frame_node->parent_frame_index);
-      frame_node_value->SetString("parent", stringify_buffer);
-    }
-    frame_node_value->AppendAsTraceFormat(out);
-
-    i++;
-    frame_node++;
-
-    if (frame_node != it_end)
-      out->append(",");
-  }
-
-  out->append("}");  // End the |stackFrames| dictionary.
-}
-
-void StackFrameDeduplicator::EstimateTraceMemoryOverhead(
-    TraceEventMemoryOverhead* overhead) {
-  size_t memory_usage = EstimateMemoryUsage(frames_) +
-                        EstimateMemoryUsage(roots_) +
-                        EstimateMemoryUsage(backtrace_lookup_table_);
-  overhead->Add(TraceEventMemoryOverhead::kHeapProfilerStackFrameDeduplicator,
-                sizeof(StackFrameDeduplicator) + memory_usage);
-}
-
-}  // namespace trace_event
-}  // namespace base
diff --git a/base/trace_event/heap_profiler_stack_frame_deduplicator.h b/base/trace_event/heap_profiler_stack_frame_deduplicator.h
deleted file mode 100644
index ac8d895..0000000
--- a/base/trace_event/heap_profiler_stack_frame_deduplicator.h
+++ /dev/null
@@ -1,94 +0,0 @@
-// Copyright 2015 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_TRACE_EVENT_HEAP_PROFILER_STACK_FRAME_DEDUPLICATOR_H_
-#define BASE_TRACE_EVENT_HEAP_PROFILER_STACK_FRAME_DEDUPLICATOR_H_
-
-#include <string>
-#include <unordered_map>
-
-#include "base/base_export.h"
-#include "base/containers/circular_deque.h"
-#include "base/containers/flat_map.h"
-#include "base/macros.h"
-#include "base/trace_event/heap_profiler_allocation_context.h"
-#include "base/trace_event/trace_event_impl.h"
-
-namespace base {
-namespace trace_event {
-
-class TraceEventMemoryOverhead;
-
-// A data structure that allows grouping a set of backtraces in a space-
-// efficient manner by creating a call tree and writing it as a set of (node,
-// parent) pairs. The tree nodes reference both parent and children. The parent
-// is referenced by index into |frames_|. The children are referenced via a map
-// of |StackFrame|s to index into |frames_|. So there is a trie for bottum-up
-// lookup of a backtrace for deduplication, and a tree for compact storage in
-// the trace log.
-class BASE_EXPORT StackFrameDeduplicator : public ConvertableToTraceFormat {
- public:
-  // A node in the call tree.
-  struct FrameNode {
-    FrameNode(StackFrame frame, int parent_frame_index);
-    FrameNode(const FrameNode& other);
-    ~FrameNode();
-
-    size_t EstimateMemoryUsage() const;
-
-    StackFrame frame;
-
-    // The index of the parent stack frame in |frames_|, or kInvalidFrameIndex
-    // if there is no parent frame (when it is at the bottom of the call stack).
-    int parent_frame_index;
-    constexpr static int kInvalidFrameIndex = -1;
-
-    // Indices into |frames_| of frames called from the current frame.
-    base::flat_map<StackFrame, int> children;
-  };
-
-  using ConstIterator = base::circular_deque<FrameNode>::const_iterator;
-
-  StackFrameDeduplicator();
-  ~StackFrameDeduplicator() override;
-
-  // Inserts a backtrace where |beginFrame| is a pointer to the bottom frame
-  // (e.g. main) and |endFrame| is a pointer past the top frame (most recently
-  // called function), and returns the index of its leaf node in |frames_|.
-  // Returns -1 if the backtrace is empty.
-  int Insert(const StackFrame* beginFrame, const StackFrame* endFrame);
-
-  // Iterators over the frame nodes in the call tree.
-  ConstIterator begin() const { return frames_.begin(); }
-  ConstIterator end() const { return frames_.end(); }
-
-  // Writes the |stackFrames| dictionary as defined in https://goo.gl/GerkV8 to
-  // the trace log.
-  void AppendAsTraceFormat(std::string* out) const override;
-
-  // Estimates memory overhead including |sizeof(StackFrameDeduplicator)|.
-  void EstimateTraceMemoryOverhead(TraceEventMemoryOverhead* overhead) override;
-
- private:
-  // Checks that existing backtrace identified by |frame_index| equals
-  // to the one identified by |begin_frame|, |end_frame|.
-  bool Match(int frame_index,
-             const StackFrame* begin_frame,
-             const StackFrame* end_frame) const;
-
-  base::flat_map<StackFrame, int> roots_;
-  base::circular_deque<FrameNode> frames_;
-
-  // {backtrace_hash -> frame_index} map for finding backtraces that are
-  // already added. Backtraces themselves are not stored in the map, instead
-  // Match() is used on the found frame_index to detect collisions.
-  std::unordered_map<size_t, int> backtrace_lookup_table_;
-
-  DISALLOW_COPY_AND_ASSIGN(StackFrameDeduplicator);
-};
-
-}  // namespace trace_event
-}  // namespace base
-
-#endif  // BASE_TRACE_EVENT_HEAP_PROFILER_STACK_FRAME_DEDUPLICATOR_H_
diff --git a/base/trace_event/heap_profiler_type_name_deduplicator.cc b/base/trace_event/heap_profiler_type_name_deduplicator.cc
deleted file mode 100644
index 360f239..0000000
--- a/base/trace_event/heap_profiler_type_name_deduplicator.cc
+++ /dev/null
@@ -1,82 +0,0 @@
-// Copyright 2015 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/trace_event/heap_profiler_type_name_deduplicator.h"
-
-#include <stddef.h>
-#include <stdlib.h>
-#include <string>
-#include <utility>
-
-#include "base/json/string_escape.h"
-#include "base/strings/string_split.h"
-#include "base/strings/stringprintf.h"
-#include "base/trace_event/memory_usage_estimator.h"
-#include "base/trace_event/trace_event.h"
-#include "base/trace_event/trace_event_memory_overhead.h"
-
-namespace base {
-namespace trace_event {
-
-TypeNameDeduplicator::TypeNameDeduplicator() {
-  // A null pointer has type ID 0 ("unknown type");
-  type_ids_.insert(std::make_pair(nullptr, 0));
-}
-
-TypeNameDeduplicator::~TypeNameDeduplicator() = default;
-
-int TypeNameDeduplicator::Insert(const char* type_name) {
-  auto result = type_ids_.insert(std::make_pair(type_name, 0));
-  auto& elem = result.first;
-  bool did_not_exist_before = result.second;
-
-  if (did_not_exist_before) {
-    // The type IDs are assigned sequentially and they are zero-based, so
-    // |size() - 1| is the ID of the new element.
-    elem->second = static_cast<int>(type_ids_.size() - 1);
-  }
-
-  return elem->second;
-}
-
-void TypeNameDeduplicator::AppendAsTraceFormat(std::string* out) const {
-  TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("memory-infra"),
-               "TypeNameDeduplicator::AppendAsTraceFormat");
-  out->append("{");  // Begin the type names dictionary.
-
-  auto it = type_ids_.begin();
-  std::string buffer;
-
-  // Write the first entry manually; the null pointer must not be dereferenced.
-  // (The first entry is the null pointer because a |std::map| is ordered.)
-  it++;
-  out->append("\"0\":\"[unknown]\"");
-
-  for (; it != type_ids_.end(); it++) {
-    // Type IDs in the trace are strings, write them as stringified keys of
-    // a dictionary.
-    SStringPrintf(&buffer, ",\"%d\":", it->second);
-
-    // TODO(ssid): crbug.com/594803 the type name is misused for file name in
-    // some cases.
-    StringPiece type_info = it->first;
-
-    // |EscapeJSONString| appends, it does not overwrite |buffer|.
-    bool put_in_quotes = true;
-    EscapeJSONString(type_info, put_in_quotes, &buffer);
-    out->append(buffer);
-  }
-
-  out->append("}");  // End the type names dictionary.
-}
-
-void TypeNameDeduplicator::EstimateTraceMemoryOverhead(
-    TraceEventMemoryOverhead* overhead) {
-  size_t memory_usage = EstimateMemoryUsage(type_ids_);
-  overhead->Add(TraceEventMemoryOverhead::kHeapProfilerTypeNameDeduplicator,
-                sizeof(TypeNameDeduplicator) + memory_usage);
-}
-
-}  // namespace trace_event
-}  // namespace base
diff --git a/base/trace_event/heap_profiler_type_name_deduplicator.h b/base/trace_event/heap_profiler_type_name_deduplicator.h
deleted file mode 100644
index 2d26c73..0000000
--- a/base/trace_event/heap_profiler_type_name_deduplicator.h
+++ /dev/null
@@ -1,45 +0,0 @@
-// Copyright 2015 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_TRACE_EVENT_HEAP_PROFILER_TYPE_NAME_DEDUPLICATOR_H_
-#define BASE_TRACE_EVENT_HEAP_PROFILER_TYPE_NAME_DEDUPLICATOR_H_
-
-#include <map>
-#include <string>
-
-#include "base/base_export.h"
-#include "base/macros.h"
-#include "base/trace_event/trace_event_impl.h"
-
-namespace base {
-namespace trace_event {
-
-class TraceEventMemoryOverhead;
-
-// Data structure that assigns a unique numeric ID to |const char*|s.
-class BASE_EXPORT TypeNameDeduplicator : public ConvertableToTraceFormat {
- public:
-  TypeNameDeduplicator();
-  ~TypeNameDeduplicator() override;
-
-  // Inserts a type name and returns its ID.
-  int Insert(const char* type_name);
-
-  // Writes the type ID -> type name mapping to the trace log.
-  void AppendAsTraceFormat(std::string* out) const override;
-
-  // Estimates memory overhead including |sizeof(TypeNameDeduplicator)|.
-  void EstimateTraceMemoryOverhead(TraceEventMemoryOverhead* overhead) override;
-
- private:
-  // Map from type name to type ID.
-  std::map<const char*, int> type_ids_;
-
-  DISALLOW_COPY_AND_ASSIGN(TypeNameDeduplicator);
-};
-
-}  // namespace trace_event
-}  // namespace base
-
-#endif  // BASE_TRACE_EVENT_HEAP_PROFILER_TYPE_NAME_DEDUPLICATOR_H_
diff --git a/base/trace_event/java_heap_dump_provider_android.cc b/base/trace_event/java_heap_dump_provider_android.cc
deleted file mode 100644
index 684f730..0000000
--- a/base/trace_event/java_heap_dump_provider_android.cc
+++ /dev/null
@@ -1,47 +0,0 @@
-// Copyright 2015 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/trace_event/java_heap_dump_provider_android.h"
-
-#include "base/android/java_runtime.h"
-#include "base/trace_event/process_memory_dump.h"
-
-namespace base {
-namespace trace_event {
-
-// static
-JavaHeapDumpProvider* JavaHeapDumpProvider::GetInstance() {
-  return Singleton<JavaHeapDumpProvider,
-                   LeakySingletonTraits<JavaHeapDumpProvider>>::get();
-}
-
-JavaHeapDumpProvider::JavaHeapDumpProvider() {
-}
-
-JavaHeapDumpProvider::~JavaHeapDumpProvider() {
-}
-
-// Called at trace dump point time. Creates a snapshot with the memory counters
-// for the current process.
-bool JavaHeapDumpProvider::OnMemoryDump(const MemoryDumpArgs& args,
-                                        ProcessMemoryDump* pmd) {
-  // These numbers come from java.lang.Runtime stats.
-  long total_heap_size = 0;
-  long free_heap_size = 0;
-  android::JavaRuntime::GetMemoryUsage(&total_heap_size, &free_heap_size);
-
-  MemoryAllocatorDump* outer_dump = pmd->CreateAllocatorDump("java_heap");
-  outer_dump->AddScalar(MemoryAllocatorDump::kNameSize,
-                        MemoryAllocatorDump::kUnitsBytes, total_heap_size);
-
-  MemoryAllocatorDump* inner_dump =
-      pmd->CreateAllocatorDump("java_heap/allocated_objects");
-  inner_dump->AddScalar(MemoryAllocatorDump::kNameSize,
-                        MemoryAllocatorDump::kUnitsBytes,
-                        total_heap_size - free_heap_size);
-  return true;
-}
-
-}  // namespace trace_event
-}  // namespace base
diff --git a/base/trace_event/java_heap_dump_provider_android.h b/base/trace_event/java_heap_dump_provider_android.h
deleted file mode 100644
index b9f2333..0000000
--- a/base/trace_event/java_heap_dump_provider_android.h
+++ /dev/null
@@ -1,36 +0,0 @@
-// Copyright 2015 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_TRACE_EVENT_JAVA_HEAP_DUMP_PROVIDER_ANDROID_H_
-#define BASE_TRACE_EVENT_JAVA_HEAP_DUMP_PROVIDER_ANDROID_H_
-
-#include "base/macros.h"
-#include "base/memory/singleton.h"
-#include "base/trace_event/memory_dump_provider.h"
-
-namespace base {
-namespace trace_event {
-
-// Dump provider which collects process-wide memory stats.
-class BASE_EXPORT JavaHeapDumpProvider : public MemoryDumpProvider {
- public:
-  static JavaHeapDumpProvider* GetInstance();
-
-  // MemoryDumpProvider implementation.
-  bool OnMemoryDump(const MemoryDumpArgs& args,
-                    ProcessMemoryDump* pmd) override;
-
- private:
-  friend struct DefaultSingletonTraits<JavaHeapDumpProvider>;
-
-  JavaHeapDumpProvider();
-  ~JavaHeapDumpProvider() override;
-
-  DISALLOW_COPY_AND_ASSIGN(JavaHeapDumpProvider);
-};
-
-}  // namespace trace_event
-}  // namespace base
-
-#endif  // BASE_TRACE_EVENT_JAVA_HEAP_DUMP_PROVIDER_ANDROID_H_
diff --git a/base/trace_event/malloc_dump_provider.cc b/base/trace_event/malloc_dump_provider.cc
deleted file mode 100644
index 04a4dd5..0000000
--- a/base/trace_event/malloc_dump_provider.cc
+++ /dev/null
@@ -1,188 +0,0 @@
-// Copyright 2015 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/trace_event/malloc_dump_provider.h"
-
-#include <stddef.h>
-
-#include <unordered_map>
-
-#include "base/allocator/allocator_extension.h"
-#include "base/debug/profiler.h"
-#include "base/trace_event/process_memory_dump.h"
-#include "base/trace_event/trace_event_argument.h"
-#include "build_config.h"
-
-#if defined(OS_MACOSX)
-#include <malloc/malloc.h>
-#else
-#include <malloc.h>
-#endif
-#if defined(OS_WIN)
-#include <windows.h>
-#endif
-
-namespace base {
-namespace trace_event {
-
-namespace {
-#if defined(OS_WIN)
-// A structure containing some information about a given heap.
-struct WinHeapInfo {
-  size_t committed_size;
-  size_t uncommitted_size;
-  size_t allocated_size;
-  size_t block_count;
-};
-
-// NOTE: crbug.com/665516
-// Unfortunately, there is no safe way to collect information from secondary
-// heaps due to limitations and racy nature of this piece of WinAPI.
-void WinHeapMemoryDumpImpl(WinHeapInfo* crt_heap_info) {
-  // Iterate through whichever heap our CRT is using.
-  HANDLE crt_heap = reinterpret_cast<HANDLE>(_get_heap_handle());
-  ::HeapLock(crt_heap);
-  PROCESS_HEAP_ENTRY heap_entry;
-  heap_entry.lpData = nullptr;
-  // Walk over all the entries in the main heap.
-  while (::HeapWalk(crt_heap, &heap_entry) != FALSE) {
-    if ((heap_entry.wFlags & PROCESS_HEAP_ENTRY_BUSY) != 0) {
-      crt_heap_info->allocated_size += heap_entry.cbData;
-      crt_heap_info->block_count++;
-    } else if ((heap_entry.wFlags & PROCESS_HEAP_REGION) != 0) {
-      crt_heap_info->committed_size += heap_entry.Region.dwCommittedSize;
-      crt_heap_info->uncommitted_size += heap_entry.Region.dwUnCommittedSize;
-    }
-  }
-  CHECK(::HeapUnlock(crt_heap) == TRUE);
-}
-#endif  // defined(OS_WIN)
-}  // namespace
-
-// static
-const char MallocDumpProvider::kAllocatedObjects[] = "malloc/allocated_objects";
-
-// static
-MallocDumpProvider* MallocDumpProvider::GetInstance() {
-  return Singleton<MallocDumpProvider,
-                   LeakySingletonTraits<MallocDumpProvider>>::get();
-}
-
-MallocDumpProvider::MallocDumpProvider() = default;
-MallocDumpProvider::~MallocDumpProvider() = default;
-
-// Called at trace dump point time. Creates a snapshot the memory counters for
-// the current process.
-bool MallocDumpProvider::OnMemoryDump(const MemoryDumpArgs& args,
-                                      ProcessMemoryDump* pmd) {
-  {
-    base::AutoLock auto_lock(emit_metrics_on_memory_dump_lock_);
-    if (!emit_metrics_on_memory_dump_)
-      return true;
-  }
-
-  size_t total_virtual_size = 0;
-  size_t resident_size = 0;
-  size_t allocated_objects_size = 0;
-  size_t allocated_objects_count = 0;
-#if defined(USE_TCMALLOC)
-  bool res =
-      allocator::GetNumericProperty("generic.heap_size", &total_virtual_size);
-  DCHECK(res);
-  res = allocator::GetNumericProperty("generic.total_physical_bytes",
-                                      &resident_size);
-  DCHECK(res);
-  res = allocator::GetNumericProperty("generic.current_allocated_bytes",
-                                      &allocated_objects_size);
-  DCHECK(res);
-#elif defined(OS_MACOSX) || defined(OS_IOS)
-  malloc_statistics_t stats = {0};
-  malloc_zone_statistics(nullptr, &stats);
-  total_virtual_size = stats.size_allocated;
-  allocated_objects_size = stats.size_in_use;
-
-  // Resident size is approximated pretty well by stats.max_size_in_use.
-  // However, on macOS, freed blocks are both resident and reusable, which is
-  // semantically equivalent to deallocated. The implementation of libmalloc
-  // will also only hold a fixed number of freed regions before actually
-  // starting to deallocate them, so stats.max_size_in_use is also not
-  // representative of the peak size. As a result, stats.max_size_in_use is
-  // typically somewhere between actually resident [non-reusable] pages, and
-  // peak size. This is not very useful, so we just use stats.size_in_use for
-  // resident_size, even though it's an underestimate and fails to account for
-  // fragmentation. See
-  // https://bugs.chromium.org/p/chromium/issues/detail?id=695263#c1.
-  resident_size = stats.size_in_use;
-#elif defined(OS_WIN)
-  // This is too expensive on Windows, crbug.com/780735.
-  if (args.level_of_detail == MemoryDumpLevelOfDetail::DETAILED) {
-    WinHeapInfo main_heap_info = {};
-    WinHeapMemoryDumpImpl(&main_heap_info);
-    total_virtual_size =
-        main_heap_info.committed_size + main_heap_info.uncommitted_size;
-    // Resident size is approximated with committed heap size. Note that it is
-    // possible to do this with better accuracy on windows by intersecting the
-    // working set with the virtual memory ranges occuipied by the heap. It's
-    // not clear that this is worth it, as it's fairly expensive to do.
-    resident_size = main_heap_info.committed_size;
-    allocated_objects_size = main_heap_info.allocated_size;
-    allocated_objects_count = main_heap_info.block_count;
-  }
-#elif defined(OS_FUCHSIA)
-// TODO(fuchsia): Port, see https://crbug.com/706592.
-#else
-  struct mallinfo info = mallinfo();
-  DCHECK_GE(info.arena + info.hblkhd, info.uordblks);
-
-  // In case of Android's jemalloc |arena| is 0 and the outer pages size is
-  // reported by |hblkhd|. In case of dlmalloc the total is given by
-  // |arena| + |hblkhd|. For more details see link: http://goo.gl/fMR8lF.
-  total_virtual_size = info.arena + info.hblkhd;
-  resident_size = info.uordblks;
-
-  // Total allocated space is given by |uordblks|.
-  allocated_objects_size = info.uordblks;
-#endif
-
-  MemoryAllocatorDump* outer_dump = pmd->CreateAllocatorDump("malloc");
-  outer_dump->AddScalar("virtual_size", MemoryAllocatorDump::kUnitsBytes,
-                        total_virtual_size);
-  outer_dump->AddScalar(MemoryAllocatorDump::kNameSize,
-                        MemoryAllocatorDump::kUnitsBytes, resident_size);
-
-  MemoryAllocatorDump* inner_dump = pmd->CreateAllocatorDump(kAllocatedObjects);
-  inner_dump->AddScalar(MemoryAllocatorDump::kNameSize,
-                        MemoryAllocatorDump::kUnitsBytes,
-                        allocated_objects_size);
-  if (allocated_objects_count != 0) {
-    inner_dump->AddScalar(MemoryAllocatorDump::kNameObjectCount,
-                          MemoryAllocatorDump::kUnitsObjects,
-                          allocated_objects_count);
-  }
-
-  if (resident_size > allocated_objects_size) {
-    // Explicitly specify why is extra memory resident. In tcmalloc it accounts
-    // for free lists and caches. In mac and ios it accounts for the
-    // fragmentation and metadata.
-    MemoryAllocatorDump* other_dump =
-        pmd->CreateAllocatorDump("malloc/metadata_fragmentation_caches");
-    other_dump->AddScalar(MemoryAllocatorDump::kNameSize,
-                          MemoryAllocatorDump::kUnitsBytes,
-                          resident_size - allocated_objects_size);
-  }
-  return true;
-}
-
-void MallocDumpProvider::EnableMetrics() {
-  base::AutoLock auto_lock(emit_metrics_on_memory_dump_lock_);
-  emit_metrics_on_memory_dump_ = true;
-}
-
-void MallocDumpProvider::DisableMetrics() {
-  base::AutoLock auto_lock(emit_metrics_on_memory_dump_lock_);
-  emit_metrics_on_memory_dump_ = false;
-}
-
-}  // namespace trace_event
-}  // namespace base
diff --git a/base/trace_event/malloc_dump_provider.h b/base/trace_event/malloc_dump_provider.h
deleted file mode 100644
index 726c382..0000000
--- a/base/trace_event/malloc_dump_provider.h
+++ /dev/null
@@ -1,56 +0,0 @@
-// Copyright 2015 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_TRACE_EVENT_MALLOC_DUMP_PROVIDER_H_
-#define BASE_TRACE_EVENT_MALLOC_DUMP_PROVIDER_H_
-
-#include "base/macros.h"
-#include "base/memory/singleton.h"
-#include "base/synchronization/lock.h"
-#include "base/trace_event/memory_dump_provider.h"
-#include "build_config.h"
-
-#if defined(OS_LINUX) || defined(OS_ANDROID) || defined(OS_WIN) || \
-    (defined(OS_MACOSX) && !defined(OS_IOS))
-#define MALLOC_MEMORY_TRACING_SUPPORTED
-#endif
-
-namespace base {
-namespace trace_event {
-
-// Dump provider which collects process-wide memory stats.
-class BASE_EXPORT MallocDumpProvider : public MemoryDumpProvider {
- public:
-  // Name of the allocated_objects dump. Use this to declare suballocator dumps
-  // from other dump providers.
-  static const char kAllocatedObjects[];
-
-  static MallocDumpProvider* GetInstance();
-
-  // MemoryDumpProvider implementation.
-  bool OnMemoryDump(const MemoryDumpArgs& args,
-                    ProcessMemoryDump* pmd) override;
-
-  // Used by out-of-process heap-profiling. When malloc is profiled by an
-  // external process, that process will be responsible for emitting metrics on
-  // behalf of this one. Thus, MallocDumpProvider should not do anything.
-  void EnableMetrics();
-  void DisableMetrics();
-
- private:
-  friend struct DefaultSingletonTraits<MallocDumpProvider>;
-
-  MallocDumpProvider();
-  ~MallocDumpProvider() override;
-
-  bool emit_metrics_on_memory_dump_ = true;
-  base::Lock emit_metrics_on_memory_dump_lock_;
-
-  DISALLOW_COPY_AND_ASSIGN(MallocDumpProvider);
-};
-
-}  // namespace trace_event
-}  // namespace base
-
-#endif  // BASE_TRACE_EVENT_MALLOC_DUMP_PROVIDER_H_
diff --git a/base/trace_event/memory_allocator_dump.cc b/base/trace_event/memory_allocator_dump.cc
deleted file mode 100644
index 5260a73..0000000
--- a/base/trace_event/memory_allocator_dump.cc
+++ /dev/null
@@ -1,148 +0,0 @@
-// Copyright 2015 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/trace_event/memory_allocator_dump.h"
-
-#include <string.h>
-
-#include "base/format_macros.h"
-#include "base/memory/ptr_util.h"
-#include "base/strings/stringprintf.h"
-#include "base/trace_event/memory_dump_manager.h"
-#include "base/trace_event/memory_dump_provider.h"
-#include "base/trace_event/process_memory_dump.h"
-#include "base/trace_event/trace_event_argument.h"
-#include "base/values.h"
-
-namespace base {
-namespace trace_event {
-
-const char MemoryAllocatorDump::kNameSize[] = "size";
-const char MemoryAllocatorDump::kNameObjectCount[] = "object_count";
-const char MemoryAllocatorDump::kTypeScalar[] = "scalar";
-const char MemoryAllocatorDump::kTypeString[] = "string";
-const char MemoryAllocatorDump::kUnitsBytes[] = "bytes";
-const char MemoryAllocatorDump::kUnitsObjects[] = "objects";
-
-MemoryAllocatorDump::MemoryAllocatorDump(
-    const std::string& absolute_name,
-    MemoryDumpLevelOfDetail level_of_detail,
-    const MemoryAllocatorDumpGuid& guid)
-    : absolute_name_(absolute_name),
-      guid_(guid),
-      level_of_detail_(level_of_detail),
-      flags_(Flags::DEFAULT) {
-  // The |absolute_name| cannot be empty.
-  DCHECK(!absolute_name.empty());
-
-  // The |absolute_name| can contain slash separator, but not leading or
-  // trailing ones.
-  DCHECK(absolute_name[0] != '/' && *absolute_name.rbegin() != '/');
-}
-
-MemoryAllocatorDump::~MemoryAllocatorDump() = default;
-
-void MemoryAllocatorDump::AddScalar(const char* name,
-                                    const char* units,
-                                    uint64_t value) {
-  entries_.emplace_back(name, units, value);
-}
-
-void MemoryAllocatorDump::AddString(const char* name,
-                                    const char* units,
-                                    const std::string& value) {
-  // String attributes are disabled in background mode.
-  if (level_of_detail_ == MemoryDumpLevelOfDetail::BACKGROUND) {
-    NOTREACHED();
-    return;
-  }
-  entries_.emplace_back(name, units, value);
-}
-
-void MemoryAllocatorDump::AsValueInto(TracedValue* value) const {
-  std::string string_conversion_buffer;
-  value->BeginDictionaryWithCopiedName(absolute_name_);
-  value->SetString("guid", guid_.ToString());
-  value->BeginDictionary("attrs");
-
-  for (const Entry& entry : entries_) {
-    value->BeginDictionaryWithCopiedName(entry.name);
-    switch (entry.entry_type) {
-      case Entry::kUint64:
-        SStringPrintf(&string_conversion_buffer, "%" PRIx64,
-                      entry.value_uint64);
-        value->SetString("type", kTypeScalar);
-        value->SetString("units", entry.units);
-        value->SetString("value", string_conversion_buffer);
-        break;
-      case Entry::kString:
-        value->SetString("type", kTypeString);
-        value->SetString("units", entry.units);
-        value->SetString("value", entry.value_string);
-        break;
-    }
-    value->EndDictionary();
-  }
-  value->EndDictionary();  // "attrs": { ... }
-  if (flags_)
-    value->SetInteger("flags", flags_);
-  value->EndDictionary();  // "allocator_name/heap_subheap": { ... }
-}
-
-uint64_t MemoryAllocatorDump::GetSizeInternal() const {
-  if (cached_size_.has_value())
-    return *cached_size_;
-  for (const auto& entry : entries_) {
-    if (entry.entry_type == Entry::kUint64 && entry.units == kUnitsBytes &&
-        strcmp(entry.name.c_str(), kNameSize) == 0) {
-      cached_size_ = entry.value_uint64;
-      return entry.value_uint64;
-    }
-  }
-  return 0;
-};
-
-MemoryAllocatorDump::Entry::Entry() : entry_type(kString), value_uint64() {}
-MemoryAllocatorDump::Entry::Entry(MemoryAllocatorDump::Entry&&) noexcept =
-    default;
-MemoryAllocatorDump::Entry& MemoryAllocatorDump::Entry::operator=(
-    MemoryAllocatorDump::Entry&&) = default;
-MemoryAllocatorDump::Entry::Entry(std::string name,
-                                  std::string units,
-                                  uint64_t value)
-    : name(name), units(units), entry_type(kUint64), value_uint64(value) {}
-MemoryAllocatorDump::Entry::Entry(std::string name,
-                                  std::string units,
-                                  std::string value)
-    : name(name), units(units), entry_type(kString), value_string(value) {}
-
-bool MemoryAllocatorDump::Entry::operator==(const Entry& rhs) const {
-  if (!(name == rhs.name && units == rhs.units && entry_type == rhs.entry_type))
-    return false;
-  switch (entry_type) {
-    case EntryType::kUint64:
-      return value_uint64 == rhs.value_uint64;
-    case EntryType::kString:
-      return value_string == rhs.value_string;
-  }
-  NOTREACHED();
-  return false;
-}
-
-void PrintTo(const MemoryAllocatorDump::Entry& entry, std::ostream* out) {
-  switch (entry.entry_type) {
-    case MemoryAllocatorDump::Entry::EntryType::kUint64:
-      *out << "<Entry(\"" << entry.name << "\", \"" << entry.units << "\", "
-           << entry.value_uint64 << ")>";
-      return;
-    case MemoryAllocatorDump::Entry::EntryType::kString:
-      *out << "<Entry(\"" << entry.name << "\", \"" << entry.units << "\", \""
-           << entry.value_string << "\")>";
-      return;
-  }
-  NOTREACHED();
-}
-
-}  // namespace trace_event
-}  // namespace base
diff --git a/base/trace_event/memory_allocator_dump.h b/base/trace_event/memory_allocator_dump.h
deleted file mode 100644
index de38afd..0000000
--- a/base/trace_event/memory_allocator_dump.h
+++ /dev/null
@@ -1,153 +0,0 @@
-// Copyright 2015 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_TRACE_EVENT_MEMORY_ALLOCATOR_DUMP_H_
-#define BASE_TRACE_EVENT_MEMORY_ALLOCATOR_DUMP_H_
-
-#include <stdint.h>
-
-#include <memory>
-#include <ostream>
-#include <string>
-
-#include "base/base_export.h"
-#include "base/gtest_prod_util.h"
-#include "base/logging.h"
-#include "base/macros.h"
-#include "base/optional.h"
-#include "base/trace_event/memory_allocator_dump_guid.h"
-#include "base/trace_event/memory_dump_request_args.h"
-#include "base/trace_event/trace_event_argument.h"
-#include "base/unguessable_token.h"
-#include "base/values.h"
-
-namespace base {
-namespace trace_event {
-
-class ProcessMemoryDump;
-class TracedValue;
-
-// Data model for user-land memory allocator dumps.
-class BASE_EXPORT MemoryAllocatorDump {
- public:
-  enum Flags {
-    DEFAULT = 0,
-
-    // A dump marked weak will be discarded by TraceViewer.
-    WEAK = 1 << 0,
-  };
-
-  // In the TraceViewer UI table each MemoryAllocatorDump becomes
-  // a row and each Entry generates a column (if it doesn't already
-  // exist).
-  struct BASE_EXPORT Entry {
-    enum EntryType {
-      kUint64,
-      kString,
-    };
-
-    // By design name, units and value_string are  always coming from
-    // indefinitely lived const char* strings, the only reason we copy
-    // them into a std::string is to handle Mojo (de)serialization.
-    // TODO(hjd): Investigate optimization (e.g. using StringPiece).
-    Entry();  // Only for deserialization.
-    Entry(std::string name, std::string units, uint64_t value);
-    Entry(std::string name, std::string units, std::string value);
-    Entry(Entry&& other) noexcept;
-    Entry& operator=(Entry&& other);
-    bool operator==(const Entry& rhs) const;
-
-    std::string name;
-    std::string units;
-
-    EntryType entry_type;
-
-    uint64_t value_uint64;
-    std::string value_string;
-
-    DISALLOW_COPY_AND_ASSIGN(Entry);
-  };
-
-  MemoryAllocatorDump(const std::string& absolute_name,
-                      MemoryDumpLevelOfDetail,
-                      const MemoryAllocatorDumpGuid&);
-  ~MemoryAllocatorDump();
-
-  // Standard attribute |name|s for the AddScalar and AddString() methods.
-  static const char kNameSize[];          // To represent allocated space.
-  static const char kNameObjectCount[];   // To represent number of objects.
-
-  // Standard attribute |unit|s for the AddScalar and AddString() methods.
-  static const char kUnitsBytes[];    // Unit name to represent bytes.
-  static const char kUnitsObjects[];  // Unit name to represent #objects.
-
-  // Constants used only internally and by tests.
-  static const char kTypeScalar[];  // Type name for scalar attributes.
-  static const char kTypeString[];  // Type name for string attributes.
-
-  // Setters for scalar attributes. Some examples:
-  // - "size" column (all dumps are expected to have at least this one):
-  //     AddScalar(kNameSize, kUnitsBytes, 1234);
-  // - Some extra-column reporting internal details of the subsystem:
-  //    AddScalar("number_of_freelist_entries", kUnitsObjects, 42)
-  // - Other informational column:
-  //    AddString("kitten", "name", "shadow");
-  void AddScalar(const char* name, const char* units, uint64_t value);
-  void AddString(const char* name, const char* units, const std::string& value);
-
-  // Absolute name, unique within the scope of an entire ProcessMemoryDump.
-  const std::string& absolute_name() const { return absolute_name_; }
-
-  // Called at trace generation time to populate the TracedValue.
-  void AsValueInto(TracedValue* value) const;
-
-  // Get the size for this dump.
-  // The size is the value set with AddScalar(kNameSize, kUnitsBytes, size);
-  // TODO(hjd): this should return an Optional<uint64_t>.
-  uint64_t GetSizeInternal() const;
-
-  MemoryDumpLevelOfDetail level_of_detail() const { return level_of_detail_; }
-
-  // Use enum Flags to set values.
-  void set_flags(int flags) { flags_ |= flags; }
-  void clear_flags(int flags) { flags_ &= ~flags; }
-  int flags() const { return flags_; }
-
-  // |guid| is an optional global dump identifier, unique across all processes
-  // within the scope of a global dump. It is only required when using the
-  // graph APIs (see TODO_method_name) to express retention / suballocation or
-  // cross process sharing. See crbug.com/492102 for design docs.
-  // Subsequent MemoryAllocatorDump(s) with the same |absolute_name| are
-  // expected to have the same guid.
-  const MemoryAllocatorDumpGuid& guid() const { return guid_; }
-
-  const std::vector<Entry>& entries() const { return entries_; }
-
-  // Only for mojo serialization, which can mutate the collection.
-  std::vector<Entry>* mutable_entries_for_serialization() const {
-    cached_size_.reset();  // The caller can mutate the collection.
-
-    // Mojo takes a const input argument even for move-only types that can be
-    // mutate while serializing (like this one). Hence the const_cast.
-    return const_cast<std::vector<Entry>*>(&entries_);
-  }
-
- private:
-  const std::string absolute_name_;
-  MemoryAllocatorDumpGuid guid_;
-  MemoryDumpLevelOfDetail level_of_detail_;
-  int flags_;  // See enum Flags.
-  mutable Optional<uint64_t> cached_size_;  // Lazy, for GetSizeInternal().
-  std::vector<Entry> entries_;
-
-  DISALLOW_COPY_AND_ASSIGN(MemoryAllocatorDump);
-};
-
-// This is required by gtest to print a readable output on test failures.
-void BASE_EXPORT PrintTo(const MemoryAllocatorDump::Entry&, std::ostream*);
-
-}  // namespace trace_event
-}  // namespace base
-
-#endif  // BASE_TRACE_EVENT_MEMORY_ALLOCATOR_DUMP_H_
diff --git a/base/trace_event/memory_allocator_dump_guid.cc b/base/trace_event/memory_allocator_dump_guid.cc
deleted file mode 100644
index 08ac677..0000000
--- a/base/trace_event/memory_allocator_dump_guid.cc
+++ /dev/null
@@ -1,40 +0,0 @@
-// Copyright 2015 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/trace_event/memory_allocator_dump_guid.h"
-
-#include "base/format_macros.h"
-#include "base/sha1.h"
-#include "base/strings/stringprintf.h"
-
-namespace base {
-namespace trace_event {
-
-namespace {
-
-uint64_t HashString(const std::string& str) {
-  uint64_t hash[(kSHA1Length + sizeof(uint64_t) - 1) / sizeof(uint64_t)] = {0};
-  SHA1HashBytes(reinterpret_cast<const unsigned char*>(str.data()), str.size(),
-                reinterpret_cast<unsigned char*>(hash));
-  return hash[0];
-}
-
-}  // namespace
-
-MemoryAllocatorDumpGuid::MemoryAllocatorDumpGuid(uint64_t guid) : guid_(guid) {}
-
-MemoryAllocatorDumpGuid::MemoryAllocatorDumpGuid()
-    : MemoryAllocatorDumpGuid(0u) {
-}
-
-MemoryAllocatorDumpGuid::MemoryAllocatorDumpGuid(const std::string& guid_str)
-    : MemoryAllocatorDumpGuid(HashString(guid_str)) {
-}
-
-std::string MemoryAllocatorDumpGuid::ToString() const {
-  return StringPrintf("%" PRIx64, guid_);
-}
-
-}  // namespace trace_event
-}  // namespace base
diff --git a/base/trace_event/memory_allocator_dump_guid.h b/base/trace_event/memory_allocator_dump_guid.h
deleted file mode 100644
index 2a420a2..0000000
--- a/base/trace_event/memory_allocator_dump_guid.h
+++ /dev/null
@@ -1,55 +0,0 @@
-// Copyright 2015 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_TRACE_EVENT_MEMORY_ALLOCATOR_DUMP_GUID_H_
-#define BASE_TRACE_EVENT_MEMORY_ALLOCATOR_DUMP_GUID_H_
-
-#include <stdint.h>
-
-#include <string>
-
-#include "base/base_export.h"
-
-namespace base {
-namespace trace_event {
-
-class BASE_EXPORT MemoryAllocatorDumpGuid {
- public:
-  MemoryAllocatorDumpGuid();
-  explicit MemoryAllocatorDumpGuid(uint64_t guid);
-
-  // Utility ctor to hash a GUID if the caller prefers a string. The caller
-  // still has to ensure that |guid_str| is unique, per snapshot, within the
-  // global scope of all the traced processes.
-  explicit MemoryAllocatorDumpGuid(const std::string& guid_str);
-
-  uint64_t ToUint64() const { return guid_; }
-
-  // Returns a (hex-encoded) string representation of the guid.
-  std::string ToString() const;
-
-  bool empty() const { return guid_ == 0u; }
-
-  bool operator==(const MemoryAllocatorDumpGuid& other) const {
-    return guid_ == other.guid_;
-  }
-
-  bool operator!=(const MemoryAllocatorDumpGuid& other) const {
-    return !(*this == other);
-  }
-
-  bool operator<(const MemoryAllocatorDumpGuid& other) const {
-    return guid_ < other.guid_;
-  }
-
- private:
-  uint64_t guid_;
-
-  // Deliberately copy-able.
-};
-
-}  // namespace trace_event
-}  // namespace base
-
-#endif  // BASE_TRACE_EVENT_MEMORY_ALLOCATOR_DUMP_GUID_H_
diff --git a/base/trace_event/memory_dump_manager.cc b/base/trace_event/memory_dump_manager.cc
deleted file mode 100644
index 60ba1bb..0000000
--- a/base/trace_event/memory_dump_manager.cc
+++ /dev/null
@@ -1,762 +0,0 @@
-// Copyright 2015 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/trace_event/memory_dump_manager.h"
-
-#include <inttypes.h>
-#include <stdio.h>
-
-#include <algorithm>
-#include <memory>
-#include <utility>
-
-#include "base/base_switches.h"
-#include "base/command_line.h"
-#include "base/debug/alias.h"
-#include "base/debug/stack_trace.h"
-#include "base/debug/thread_heap_usage_tracker.h"
-#include "base/memory/ptr_util.h"
-#include "base/sequenced_task_runner.h"
-#include "base/strings/string_util.h"
-#include "base/third_party/dynamic_annotations/dynamic_annotations.h"
-#include "base/threading/thread.h"
-#include "base/threading/thread_task_runner_handle.h"
-#include "base/trace_event/heap_profiler.h"
-#include "base/trace_event/heap_profiler_allocation_context_tracker.h"
-#include "base/trace_event/heap_profiler_event_filter.h"
-#include "base/trace_event/heap_profiler_serialization_state.h"
-#include "base/trace_event/heap_profiler_stack_frame_deduplicator.h"
-#include "base/trace_event/heap_profiler_type_name_deduplicator.h"
-#include "base/trace_event/malloc_dump_provider.h"
-#include "base/trace_event/memory_dump_provider.h"
-#include "base/trace_event/memory_dump_scheduler.h"
-#include "base/trace_event/memory_infra_background_whitelist.h"
-#include "base/trace_event/memory_peak_detector.h"
-#include "base/trace_event/process_memory_dump.h"
-#include "base/trace_event/trace_event.h"
-#include "base/trace_event/trace_event_argument.h"
-#include "build_config.h"
-
-#if defined(OS_ANDROID)
-#include "base/trace_event/java_heap_dump_provider_android.h"
-
-#endif  // defined(OS_ANDROID)
-
-namespace base {
-namespace trace_event {
-
-namespace {
-
-const char* const kTraceEventArgNames[] = {"dumps"};
-const unsigned char kTraceEventArgTypes[] = {TRACE_VALUE_TYPE_CONVERTABLE};
-
-MemoryDumpManager* g_memory_dump_manager_for_testing = nullptr;
-
-// Temporary (until peak detector and scheduler are moved outside of here)
-// trampoline function to match the |request_dump_function| passed to Initialize
-// to the callback expected by MemoryPeakDetector and MemoryDumpScheduler.
-// TODO(primiano): remove this.
-void DoGlobalDumpWithoutCallback(
-    MemoryDumpManager::RequestGlobalDumpFunction global_dump_fn,
-    MemoryDumpType dump_type,
-    MemoryDumpLevelOfDetail level_of_detail) {
-  global_dump_fn.Run(dump_type, level_of_detail);
-}
-
-// Proxy class which wraps a ConvertableToTraceFormat owned by the
-// |heap_profiler_serialization_state| into a proxy object that can be added to
-// the trace event log. This is to solve the problem that the
-// HeapProfilerSerializationState is refcounted but the tracing subsystem wants
-// a std::unique_ptr<ConvertableToTraceFormat>.
-template <typename T>
-struct SessionStateConvertableProxy : public ConvertableToTraceFormat {
-  using GetterFunctPtr = T* (HeapProfilerSerializationState::*)() const;
-
-  SessionStateConvertableProxy(scoped_refptr<HeapProfilerSerializationState>
-                                   heap_profiler_serialization_state,
-                               GetterFunctPtr getter_function)
-      : heap_profiler_serialization_state(heap_profiler_serialization_state),
-        getter_function(getter_function) {}
-
-  void AppendAsTraceFormat(std::string* out) const override {
-    return (heap_profiler_serialization_state.get()->*getter_function)()
-        ->AppendAsTraceFormat(out);
-  }
-
-  void EstimateTraceMemoryOverhead(
-      TraceEventMemoryOverhead* overhead) override {
-    return (heap_profiler_serialization_state.get()->*getter_function)()
-        ->EstimateTraceMemoryOverhead(overhead);
-  }
-
-  scoped_refptr<HeapProfilerSerializationState>
-      heap_profiler_serialization_state;
-  GetterFunctPtr const getter_function;
-};
-
-void NotifyHeapProfilingEnabledOnMDPThread(
-    scoped_refptr<MemoryDumpProviderInfo> mdpinfo,
-    bool profiling_enabled) {
-  mdpinfo->dump_provider->OnHeapProfilingEnabled(profiling_enabled);
-}
-
-inline bool ShouldEnableMDPAllocatorHooks(HeapProfilingMode mode) {
-  return (mode == kHeapProfilingModePseudo) ||
-         (mode == kHeapProfilingModeNative) ||
-         (mode == kHeapProfilingModeBackground);
-}
-
-}  // namespace
-
-// static
-const char* const MemoryDumpManager::kTraceCategory =
-    TRACE_DISABLED_BY_DEFAULT("memory-infra");
-
-// static
-const int MemoryDumpManager::kMaxConsecutiveFailuresCount = 3;
-
-// static
-const uint64_t MemoryDumpManager::kInvalidTracingProcessId = 0;
-
-// static
-const char* const MemoryDumpManager::kSystemAllocatorPoolName =
-#if defined(MALLOC_MEMORY_TRACING_SUPPORTED)
-    MallocDumpProvider::kAllocatedObjects;
-#else
-    nullptr;
-#endif
-
-// static
-MemoryDumpManager* MemoryDumpManager::GetInstance() {
-  if (g_memory_dump_manager_for_testing)
-    return g_memory_dump_manager_for_testing;
-
-  return Singleton<MemoryDumpManager,
-                   LeakySingletonTraits<MemoryDumpManager>>::get();
-}
-
-// static
-std::unique_ptr<MemoryDumpManager>
-MemoryDumpManager::CreateInstanceForTesting() {
-  DCHECK(!g_memory_dump_manager_for_testing);
-  std::unique_ptr<MemoryDumpManager> instance(new MemoryDumpManager());
-  g_memory_dump_manager_for_testing = instance.get();
-  return instance;
-}
-
-MemoryDumpManager::MemoryDumpManager()
-    : is_coordinator_(false),
-      tracing_process_id_(kInvalidTracingProcessId),
-      dumper_registrations_ignored_for_testing_(false),
-      heap_profiling_mode_(kHeapProfilingModeDisabled) {}
-
-MemoryDumpManager::~MemoryDumpManager() {
-  Thread* dump_thread = nullptr;
-  {
-    AutoLock lock(lock_);
-    if (dump_thread_) {
-      dump_thread = dump_thread_.get();
-    }
-  }
-  if (dump_thread) {
-    dump_thread->Stop();
-  }
-  AutoLock lock(lock_);
-  dump_thread_.reset();
-  g_memory_dump_manager_for_testing = nullptr;
-}
-
-bool MemoryDumpManager::EnableHeapProfiling(HeapProfilingMode profiling_mode) {
-  AutoLock lock(lock_);
-  heap_profiling_mode_ = kHeapProfilingModeInvalid;
-  return false;
-}
-
-HeapProfilingMode MemoryDumpManager::GetHeapProfilingMode() {
-  AutoLock lock(lock_);
-  return heap_profiling_mode_;
-}
-
-void MemoryDumpManager::Initialize(
-    RequestGlobalDumpFunction request_dump_function,
-    bool is_coordinator) {
-  {
-    AutoLock lock(lock_);
-    DCHECK(!request_dump_function.is_null());
-    DCHECK(!can_request_global_dumps());
-    request_dump_function_ = request_dump_function;
-    is_coordinator_ = is_coordinator;
-  }
-
-// Enable the core dump providers.
-#if defined(MALLOC_MEMORY_TRACING_SUPPORTED)
-  base::trace_event::MemoryDumpProvider::Options options;
-  options.supports_heap_profiling = true;
-  RegisterDumpProvider(MallocDumpProvider::GetInstance(), "Malloc", nullptr,
-                       options);
-#endif
-
-#if defined(OS_ANDROID)
-  RegisterDumpProvider(JavaHeapDumpProvider::GetInstance(), "JavaHeap",
-                       nullptr);
-#endif
-
-  TRACE_EVENT_WARMUP_CATEGORY(kTraceCategory);
-}
-
-void MemoryDumpManager::RegisterDumpProvider(
-    MemoryDumpProvider* mdp,
-    const char* name,
-    scoped_refptr<SingleThreadTaskRunner> task_runner,
-    MemoryDumpProvider::Options options) {
-  options.dumps_on_single_thread_task_runner = true;
-  RegisterDumpProviderInternal(mdp, name, std::move(task_runner), options);
-}
-
-void MemoryDumpManager::RegisterDumpProvider(
-    MemoryDumpProvider* mdp,
-    const char* name,
-    scoped_refptr<SingleThreadTaskRunner> task_runner) {
-  // Set |dumps_on_single_thread_task_runner| to true because all providers
-  // without task runner are run on dump thread.
-  MemoryDumpProvider::Options options;
-  options.dumps_on_single_thread_task_runner = true;
-  RegisterDumpProviderInternal(mdp, name, std::move(task_runner), options);
-}
-
-void MemoryDumpManager::RegisterDumpProviderWithSequencedTaskRunner(
-    MemoryDumpProvider* mdp,
-    const char* name,
-    scoped_refptr<SequencedTaskRunner> task_runner,
-    MemoryDumpProvider::Options options) {
-  DCHECK(task_runner);
-  options.dumps_on_single_thread_task_runner = false;
-  RegisterDumpProviderInternal(mdp, name, std::move(task_runner), options);
-}
-
-void MemoryDumpManager::RegisterDumpProviderInternal(
-    MemoryDumpProvider* mdp,
-    const char* name,
-    scoped_refptr<SequencedTaskRunner> task_runner,
-    const MemoryDumpProvider::Options& options) {
-  if (dumper_registrations_ignored_for_testing_)
-    return;
-
-  // Only a handful of MDPs are required to compute the memory metrics. These
-  // have small enough performance overhead that it is resonable to run them
-  // in the background while the user is doing other things. Those MDPs are
-  // 'whitelisted for background mode'.
-  bool whitelisted_for_background_mode = IsMemoryDumpProviderWhitelisted(name);
-
-  scoped_refptr<MemoryDumpProviderInfo> mdpinfo =
-      new MemoryDumpProviderInfo(mdp, name, std::move(task_runner), options,
-                                 whitelisted_for_background_mode);
-
-  if (options.is_fast_polling_supported) {
-    DCHECK(!mdpinfo->task_runner) << "MemoryDumpProviders capable of fast "
-                                     "polling must NOT be thread bound.";
-  }
-
-  {
-    AutoLock lock(lock_);
-    bool already_registered = !dump_providers_.insert(mdpinfo).second;
-    // This actually happens in some tests which don't have a clean tear-down
-    // path for RenderThreadImpl::Init().
-    if (already_registered)
-      return;
-
-    if (options.is_fast_polling_supported)
-      MemoryPeakDetector::GetInstance()->NotifyMemoryDumpProvidersChanged();
-
-    if (ShouldEnableMDPAllocatorHooks(heap_profiling_mode_))
-      NotifyHeapProfilingEnabledLocked(mdpinfo, true);
-  }
-}
-
-void MemoryDumpManager::UnregisterDumpProvider(MemoryDumpProvider* mdp) {
-  UnregisterDumpProviderInternal(mdp, false /* delete_async */);
-}
-
-void MemoryDumpManager::UnregisterAndDeleteDumpProviderSoon(
-    std::unique_ptr<MemoryDumpProvider> mdp) {
-  UnregisterDumpProviderInternal(mdp.release(), true /* delete_async */);
-}
-
-void MemoryDumpManager::UnregisterDumpProviderInternal(
-    MemoryDumpProvider* mdp,
-    bool take_mdp_ownership_and_delete_async) {
-  std::unique_ptr<MemoryDumpProvider> owned_mdp;
-  if (take_mdp_ownership_and_delete_async)
-    owned_mdp.reset(mdp);
-
-  AutoLock lock(lock_);
-
-  auto mdp_iter = dump_providers_.begin();
-  for (; mdp_iter != dump_providers_.end(); ++mdp_iter) {
-    if ((*mdp_iter)->dump_provider == mdp)
-      break;
-  }
-
-  if (mdp_iter == dump_providers_.end())
-    return;  // Not registered / already unregistered.
-
-  if (take_mdp_ownership_and_delete_async) {
-    // The MDP will be deleted whenever the MDPInfo struct will, that is either:
-    // - At the end of this function, if no dump is in progress.
-    // - In ContinueAsyncProcessDump() when MDPInfo is removed from
-    //   |pending_dump_providers|.
-    // - When the provider is removed from other clients (MemoryPeakDetector).
-    DCHECK(!(*mdp_iter)->owned_dump_provider);
-    (*mdp_iter)->owned_dump_provider = std::move(owned_mdp);
-  } else {
-    // If you hit this DCHECK, your dump provider has a bug.
-    // Unregistration of a MemoryDumpProvider is safe only if:
-    // - The MDP has specified a sequenced task runner affinity AND the
-    //   unregistration happens on the same task runner. So that the MDP cannot
-    //   unregister and be in the middle of a OnMemoryDump() at the same time.
-    // - The MDP has NOT specified a task runner affinity and its ownership is
-    //   transferred via UnregisterAndDeleteDumpProviderSoon().
-    // In all the other cases, it is not possible to guarantee that the
-    // unregistration will not race with OnMemoryDump() calls.
-    DCHECK((*mdp_iter)->task_runner &&
-           (*mdp_iter)->task_runner->RunsTasksInCurrentSequence())
-        << "MemoryDumpProvider \"" << (*mdp_iter)->name << "\" attempted to "
-        << "unregister itself in a racy way. Please file a crbug.";
-  }
-
-  if ((*mdp_iter)->options.is_fast_polling_supported) {
-    DCHECK(take_mdp_ownership_and_delete_async);
-    MemoryPeakDetector::GetInstance()->NotifyMemoryDumpProvidersChanged();
-  }
-
-  // The MDPInfo instance can still be referenced by the
-  // |ProcessMemoryDumpAsyncState.pending_dump_providers|. For this reason
-  // the MDPInfo is flagged as disabled. It will cause InvokeOnMemoryDump()
-  // to just skip it, without actually invoking the |mdp|, which might be
-  // destroyed by the caller soon after this method returns.
-  (*mdp_iter)->disabled = true;
-  dump_providers_.erase(mdp_iter);
-}
-
-void MemoryDumpManager::GetDumpProvidersForPolling(
-    std::vector<scoped_refptr<MemoryDumpProviderInfo>>* providers) {
-  DCHECK(providers->empty());
-  AutoLock lock(lock_);
-  for (const scoped_refptr<MemoryDumpProviderInfo>& mdp : dump_providers_) {
-    if (mdp->options.is_fast_polling_supported)
-      providers->push_back(mdp);
-  }
-}
-
-bool MemoryDumpManager::IsDumpProviderRegisteredForTesting(
-    MemoryDumpProvider* provider) {
-  AutoLock lock(lock_);
-
-  for (const auto& info : dump_providers_) {
-    if (info->dump_provider == provider)
-      return true;
-  }
-  return false;
-}
-
-scoped_refptr<base::SequencedTaskRunner>
-MemoryDumpManager::GetOrCreateBgTaskRunnerLocked() {
-  lock_.AssertAcquired();
-
-  if (dump_thread_)
-    return dump_thread_->task_runner();
-
-  dump_thread_ = std::make_unique<Thread>("MemoryInfra");
-  bool started = dump_thread_->Start();
-  CHECK(started);
-
-  return dump_thread_->task_runner();
-}
-
-void MemoryDumpManager::CreateProcessDump(
-    const MemoryDumpRequestArgs& args,
-    const ProcessMemoryDumpCallback& callback) {
-  char guid_str[20];
-  sprintf(guid_str, "0x%" PRIx64, args.dump_guid);
-  TRACE_EVENT_NESTABLE_ASYNC_BEGIN1(kTraceCategory, "ProcessMemoryDump",
-                                    TRACE_ID_LOCAL(args.dump_guid), "dump_guid",
-                                    TRACE_STR_COPY(guid_str));
-
-  // If argument filter is enabled then only background mode dumps should be
-  // allowed. In case the trace config passed for background tracing session
-  // missed the allowed modes argument, it crashes here instead of creating
-  // unexpected dumps.
-  if (TraceLog::GetInstance()
-          ->GetCurrentTraceConfig()
-          .IsArgumentFilterEnabled()) {
-    CHECK_EQ(MemoryDumpLevelOfDetail::BACKGROUND, args.level_of_detail);
-  }
-
-  std::unique_ptr<ProcessMemoryDumpAsyncState> pmd_async_state;
-  {
-    AutoLock lock(lock_);
-
-    // MDM could have been disabled by this point destroying
-    // |heap_profiler_serialization_state|. If heap profiling is enabled we
-    // require session state so if heap profiling is on and session state is
-    // absent we fail the dump immediately. If heap profiler is enabled during
-    // the dump, then the dump succeeds since the dump was requested before, and
-    // the future process dumps will contain heap dumps.
-    if (args.dump_type != MemoryDumpType::SUMMARY_ONLY &&
-        ShouldEnableMDPAllocatorHooks(heap_profiling_mode_) &&
-        !heap_profiler_serialization_state_) {
-      callback.Run(false /* success */, args.dump_guid, nullptr);
-      return;
-    }
-
-    pmd_async_state.reset(new ProcessMemoryDumpAsyncState(
-        args, dump_providers_, heap_profiler_serialization_state_, callback,
-        GetOrCreateBgTaskRunnerLocked()));
-
-    // If enabled, holds back the peak detector resetting its estimation window.
-    MemoryPeakDetector::GetInstance()->Throttle();
-  }
-
-  // Start the process dump. This involves task runner hops as specified by the
-  // MemoryDumpProvider(s) in RegisterDumpProvider()).
-  ContinueAsyncProcessDump(pmd_async_state.release());
-}
-
-// Invokes OnMemoryDump() on all MDPs that are next in the pending list and run
-// on the current sequenced task runner. If the next MDP does not run in current
-// sequenced task runner, then switches to that task runner and continues. All
-// OnMemoryDump() invocations are linearized. |lock_| is used in these functions
-// purely to ensure consistency w.r.t. (un)registrations of |dump_providers_|.
-void MemoryDumpManager::ContinueAsyncProcessDump(
-    ProcessMemoryDumpAsyncState* owned_pmd_async_state) {
-  HEAP_PROFILER_SCOPED_IGNORE;
-  // Initalizes the ThreadLocalEventBuffer to guarantee that the TRACE_EVENTs
-  // in the PostTask below don't end up registering their own dump providers
-  // (for discounting trace memory overhead) while holding the |lock_|.
-  TraceLog::GetInstance()->InitializeThreadLocalEventBufferIfSupported();
-
-  // In theory |owned_pmd_async_state| should be a unique_ptr. The only reason
-  // why it isn't is because of the corner case logic of |did_post_task|
-  // above, which needs to take back the ownership of the |pmd_async_state| when
-  // the PostTask() fails.
-  // Unfortunately, PostTask() destroys the unique_ptr arguments upon failure
-  // to prevent accidental leaks. Using a unique_ptr would prevent us to to
-  // skip the hop and move on. Hence the manual naked -> unique ptr juggling.
-  auto pmd_async_state = WrapUnique(owned_pmd_async_state);
-  owned_pmd_async_state = nullptr;
-
-  while (!pmd_async_state->pending_dump_providers.empty()) {
-    // Read MemoryDumpProviderInfo thread safety considerations in
-    // memory_dump_manager.h when accessing |mdpinfo| fields.
-    MemoryDumpProviderInfo* mdpinfo =
-        pmd_async_state->pending_dump_providers.back().get();
-
-    // If we are in background mode, we should invoke only the whitelisted
-    // providers. Ignore other providers and continue.
-    if (pmd_async_state->req_args.level_of_detail ==
-            MemoryDumpLevelOfDetail::BACKGROUND &&
-        !mdpinfo->whitelisted_for_background_mode) {
-      pmd_async_state->pending_dump_providers.pop_back();
-      continue;
-    }
-
-    // If the dump provider did not specify a task runner affinity, dump on
-    // |dump_thread_|.
-    scoped_refptr<SequencedTaskRunner> task_runner = mdpinfo->task_runner;
-    if (!task_runner) {
-      DCHECK(mdpinfo->options.dumps_on_single_thread_task_runner);
-      task_runner = pmd_async_state->dump_thread_task_runner;
-      DCHECK(task_runner);
-    }
-
-    // If |RunsTasksInCurrentSequence()| is true then no PostTask is
-    // required since we are on the right SequencedTaskRunner.
-    if (task_runner->RunsTasksInCurrentSequence()) {
-      InvokeOnMemoryDump(mdpinfo, pmd_async_state->process_memory_dump.get());
-      pmd_async_state->pending_dump_providers.pop_back();
-      continue;
-    }
-
-    bool did_post_task = task_runner->PostTask(
-        FROM_HERE,
-        BindOnce(&MemoryDumpManager::ContinueAsyncProcessDump, Unretained(this),
-                 Unretained(pmd_async_state.get())));
-
-    if (did_post_task) {
-      // Ownership is tranferred to the posted task.
-      ignore_result(pmd_async_state.release());
-      return;
-    }
-
-    // PostTask usually fails only if the process or thread is shut down. So,
-    // the dump provider is disabled here. But, don't disable unbound dump
-    // providers, since the |dump_thread_| is controlled by MDM.
-    if (mdpinfo->task_runner) {
-      // A locked access is required to R/W |disabled| (for the
-      // UnregisterAndDeleteDumpProviderSoon() case).
-      AutoLock lock(lock_);
-      mdpinfo->disabled = true;
-    }
-
-    // PostTask failed. Ignore the dump provider and continue.
-    pmd_async_state->pending_dump_providers.pop_back();
-  }
-
-  FinishAsyncProcessDump(std::move(pmd_async_state));
-}
-
-// This function is called on the right task runner for current MDP. It is
-// either the task runner specified by MDP or |dump_thread_task_runner| if the
-// MDP did not specify task runner. Invokes the dump provider's OnMemoryDump()
-// (unless disabled).
-void MemoryDumpManager::InvokeOnMemoryDump(MemoryDumpProviderInfo* mdpinfo,
-                                           ProcessMemoryDump* pmd) {
-  HEAP_PROFILER_SCOPED_IGNORE;
-  DCHECK(!mdpinfo->task_runner ||
-         mdpinfo->task_runner->RunsTasksInCurrentSequence());
-
-  TRACE_EVENT1(kTraceCategory, "MemoryDumpManager::InvokeOnMemoryDump",
-               "dump_provider.name", mdpinfo->name);
-
-  // Do not add any other TRACE_EVENT macro (or function that might have them)
-  // below this point. Under some rare circunstances, they can re-initialize
-  // and invalide the current ThreadLocalEventBuffer MDP, making the
-  // |should_dump| check below susceptible to TOCTTOU bugs
-  // (https://crbug.com/763365).
-
-  bool is_thread_bound;
-  {
-    // A locked access is required to R/W |disabled| (for the
-    // UnregisterAndDeleteDumpProviderSoon() case).
-    AutoLock lock(lock_);
-
-    // Unregister the dump provider if it failed too many times consecutively.
-    if (!mdpinfo->disabled &&
-        mdpinfo->consecutive_failures >= kMaxConsecutiveFailuresCount) {
-      mdpinfo->disabled = true;
-      DLOG(ERROR) << "Disabling MemoryDumpProvider \"" << mdpinfo->name
-                  << "\". Dump failed multiple times consecutively.";
-    }
-    if (mdpinfo->disabled)
-      return;
-
-    is_thread_bound = mdpinfo->task_runner != nullptr;
-  }  // AutoLock lock(lock_);
-
-  // Invoke the dump provider.
-
-  // A stack allocated string with dump provider name is useful to debug
-  // crashes while invoking dump after a |dump_provider| is not unregistered
-  // in safe way.
-  char provider_name_for_debugging[16];
-  strncpy(provider_name_for_debugging, mdpinfo->name,
-          sizeof(provider_name_for_debugging) - 1);
-  provider_name_for_debugging[sizeof(provider_name_for_debugging) - 1] = '\0';
-  base::debug::Alias(provider_name_for_debugging);
-
-  ANNOTATE_BENIGN_RACE(&mdpinfo->disabled, "best-effort race detection");
-  CHECK(!is_thread_bound ||
-        !*(static_cast<volatile bool*>(&mdpinfo->disabled)));
-  bool dump_successful =
-      mdpinfo->dump_provider->OnMemoryDump(pmd->dump_args(), pmd);
-  mdpinfo->consecutive_failures =
-      dump_successful ? 0 : mdpinfo->consecutive_failures + 1;
-}
-
-void MemoryDumpManager::FinishAsyncProcessDump(
-    std::unique_ptr<ProcessMemoryDumpAsyncState> pmd_async_state) {
-  HEAP_PROFILER_SCOPED_IGNORE;
-  DCHECK(pmd_async_state->pending_dump_providers.empty());
-  const uint64_t dump_guid = pmd_async_state->req_args.dump_guid;
-  if (!pmd_async_state->callback_task_runner->BelongsToCurrentThread()) {
-    scoped_refptr<SingleThreadTaskRunner> callback_task_runner =
-        pmd_async_state->callback_task_runner;
-    callback_task_runner->PostTask(
-        FROM_HERE, BindOnce(&MemoryDumpManager::FinishAsyncProcessDump,
-                            Unretained(this), std::move(pmd_async_state)));
-    return;
-  }
-
-  TRACE_EVENT0(kTraceCategory, "MemoryDumpManager::FinishAsyncProcessDump");
-
-  // In the general case (allocators and edges) the serialization into the trace
-  // buffer is handled by the memory-infra service (see tracing_observer.cc).
-  // This special case below deals only with serialization of the heap profiler
-  // and is temporary given the upcoming work on the out-of-process heap
-  // profiler.
-  const auto& args = pmd_async_state->req_args;
-  if (!pmd_async_state->process_memory_dump->heap_dumps().empty()) {
-    std::unique_ptr<TracedValue> traced_value = std::make_unique<TracedValue>();
-    pmd_async_state->process_memory_dump->SerializeHeapProfilerDumpsInto(
-        traced_value.get());
-
-    traced_value->SetString("level_of_detail",
-                            base::trace_event::MemoryDumpLevelOfDetailToString(
-                                args.level_of_detail));
-    std::unique_ptr<base::trace_event::ConvertableToTraceFormat> event_value(
-        std::move(traced_value));
-    TRACE_EVENT_API_ADD_TRACE_EVENT_WITH_PROCESS_ID(
-        TRACE_EVENT_PHASE_MEMORY_DUMP,
-        base::trace_event::TraceLog::GetCategoryGroupEnabled(
-            base::trace_event::MemoryDumpManager::kTraceCategory),
-        base::trace_event::MemoryDumpTypeToString(args.dump_type),
-        trace_event_internal::kGlobalScope, args.dump_guid,
-        base::kNullProcessId, 1 /* num_args */, kTraceEventArgNames,
-        kTraceEventArgTypes, nullptr /* arg_values */, &event_value,
-        TRACE_EVENT_FLAG_HAS_ID);
-  }
-
-  if (!pmd_async_state->callback.is_null()) {
-    pmd_async_state->callback.Run(
-        true /* success */, dump_guid,
-        std::move(pmd_async_state->process_memory_dump));
-    pmd_async_state->callback.Reset();
-  }
-
-  TRACE_EVENT_NESTABLE_ASYNC_END0(kTraceCategory, "ProcessMemoryDump",
-                                  TRACE_ID_LOCAL(dump_guid));
-}
-
-void MemoryDumpManager::SetupForTracing(
-    const TraceConfig::MemoryDumpConfig& memory_dump_config) {
-  AutoLock lock(lock_);
-  heap_profiler_serialization_state_ = new HeapProfilerSerializationState();
-  heap_profiler_serialization_state_
-      ->set_heap_profiler_breakdown_threshold_bytes(
-          memory_dump_config.heap_profiler_options.breakdown_threshold_bytes);
-  InitializeHeapProfilerStateIfNeededLocked();
-
-  // At this point we must have the ability to request global dumps.
-  DCHECK(can_request_global_dumps());
-
-  MemoryDumpScheduler::Config periodic_config;
-  bool peak_detector_configured = false;
-  for (const auto& trigger : memory_dump_config.triggers) {
-    if (trigger.trigger_type == MemoryDumpType::PERIODIC_INTERVAL) {
-      if (periodic_config.triggers.empty()) {
-        periodic_config.callback =
-            BindRepeating(&DoGlobalDumpWithoutCallback, request_dump_function_,
-                          MemoryDumpType::PERIODIC_INTERVAL);
-      }
-      periodic_config.triggers.push_back(
-          {trigger.level_of_detail, trigger.min_time_between_dumps_ms});
-    } else if (trigger.trigger_type == MemoryDumpType::PEAK_MEMORY_USAGE) {
-      // At most one peak trigger is allowed.
-      CHECK(!peak_detector_configured);
-      peak_detector_configured = true;
-      MemoryPeakDetector::GetInstance()->Setup(
-          BindRepeating(&MemoryDumpManager::GetDumpProvidersForPolling,
-                        Unretained(this)),
-          GetOrCreateBgTaskRunnerLocked(),
-          BindRepeating(&DoGlobalDumpWithoutCallback, request_dump_function_,
-                        MemoryDumpType::PEAK_MEMORY_USAGE,
-                        trigger.level_of_detail));
-
-      MemoryPeakDetector::Config peak_config;
-      peak_config.polling_interval_ms = 10;
-      peak_config.min_time_between_peaks_ms = trigger.min_time_between_dumps_ms;
-      peak_config.enable_verbose_poll_tracing =
-          trigger.level_of_detail == MemoryDumpLevelOfDetail::DETAILED;
-      MemoryPeakDetector::GetInstance()->Start(peak_config);
-
-      // When peak detection is enabled, trigger a dump straight away as it
-      // gives a good reference point for analyzing the trace.
-      if (is_coordinator_) {
-        GetOrCreateBgTaskRunnerLocked()->PostTask(
-            FROM_HERE,
-            BindOnce(&DoGlobalDumpWithoutCallback, request_dump_function_,
-                     MemoryDumpType::PEAK_MEMORY_USAGE,
-                     trigger.level_of_detail));
-      }
-    }
-  }
-
-  // Only coordinator process triggers periodic memory dumps.
-  if (is_coordinator_ && !periodic_config.triggers.empty()) {
-    MemoryDumpScheduler::GetInstance()->Start(periodic_config,
-                                              GetOrCreateBgTaskRunnerLocked());
-  }
-}
-
-void MemoryDumpManager::TeardownForTracing() {
-  // There might be a memory dump in progress while this happens. Therefore,
-  // ensure that the MDM state which depends on the tracing enabled / disabled
-  // state is always accessed by the dumping methods holding the |lock_|.
-  AutoLock lock(lock_);
-
-  MemoryDumpScheduler::GetInstance()->Stop();
-  MemoryPeakDetector::GetInstance()->TearDown();
-  heap_profiler_serialization_state_ = nullptr;
-}
-
-void MemoryDumpManager::InitializeHeapProfilerStateIfNeededLocked() {
-  lock_.AssertAcquired();
-  if (!ShouldEnableMDPAllocatorHooks(heap_profiling_mode_) ||
-      !heap_profiler_serialization_state_ ||
-      heap_profiler_serialization_state_->is_initialized()) {
-    return;
-  }
-  // If heap profiling is enabled, the stack frame deduplicator and type name
-  // deduplicator will be in use. Add a metadata events to write the frames
-  // and type IDs.
-  heap_profiler_serialization_state_->SetStackFrameDeduplicator(
-      WrapUnique(new StackFrameDeduplicator));
-  heap_profiler_serialization_state_->SetTypeNameDeduplicator(
-      WrapUnique(new TypeNameDeduplicator));
-
-  TRACE_EVENT_API_ADD_METADATA_EVENT(
-      TraceLog::GetCategoryGroupEnabled("__metadata"), "stackFrames",
-      "stackFrames",
-      std::make_unique<SessionStateConvertableProxy<StackFrameDeduplicator>>(
-          heap_profiler_serialization_state_,
-          &HeapProfilerSerializationState::stack_frame_deduplicator));
-
-  TRACE_EVENT_API_ADD_METADATA_EVENT(
-      TraceLog::GetCategoryGroupEnabled("__metadata"), "typeNames", "typeNames",
-      std::make_unique<SessionStateConvertableProxy<TypeNameDeduplicator>>(
-          heap_profiler_serialization_state_,
-          &HeapProfilerSerializationState::type_name_deduplicator));
-}
-
-void MemoryDumpManager::NotifyHeapProfilingEnabledLocked(
-    scoped_refptr<MemoryDumpProviderInfo> mdpinfo,
-    bool enabled) {
-  lock_.AssertAcquired();
-  if (!mdpinfo->options.supports_heap_profiling)
-    return;
-
-  const auto& task_runner = mdpinfo->task_runner
-                                ? mdpinfo->task_runner
-                                : GetOrCreateBgTaskRunnerLocked();
-  // TODO(ssid): Post tasks only for MDPs that support heap profiling.
-  task_runner->PostTask(
-      FROM_HERE,
-      BindOnce(&NotifyHeapProfilingEnabledOnMDPThread, mdpinfo, enabled));
-}
-
-MemoryDumpManager::ProcessMemoryDumpAsyncState::ProcessMemoryDumpAsyncState(
-    MemoryDumpRequestArgs req_args,
-    const MemoryDumpProviderInfo::OrderedSet& dump_providers,
-    scoped_refptr<HeapProfilerSerializationState>
-        heap_profiler_serialization_state_in,
-    ProcessMemoryDumpCallback callback,
-    scoped_refptr<SequencedTaskRunner> dump_thread_task_runner)
-    : req_args(req_args),
-      heap_profiler_serialization_state(
-          std::move(heap_profiler_serialization_state_in)),
-      callback(callback),
-      callback_task_runner(ThreadTaskRunnerHandle::Get()),
-      dump_thread_task_runner(std::move(dump_thread_task_runner)) {
-  pending_dump_providers.reserve(dump_providers.size());
-  pending_dump_providers.assign(dump_providers.rbegin(), dump_providers.rend());
-  MemoryDumpArgs args = {req_args.level_of_detail, req_args.dump_guid};
-  process_memory_dump = std::make_unique<ProcessMemoryDump>(
-      heap_profiler_serialization_state, args);
-}
-
-MemoryDumpManager::ProcessMemoryDumpAsyncState::~ProcessMemoryDumpAsyncState() =
-    default;
-
-}  // namespace trace_event
-}  // namespace base
diff --git a/base/trace_event/memory_dump_manager.h b/base/trace_event/memory_dump_manager.h
deleted file mode 100644
index 072a7d6..0000000
--- a/base/trace_event/memory_dump_manager.h
+++ /dev/null
@@ -1,320 +0,0 @@
-// Copyright 2015 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_TRACE_EVENT_MEMORY_DUMP_MANAGER_H_
-#define BASE_TRACE_EVENT_MEMORY_DUMP_MANAGER_H_
-
-#include <stdint.h>
-
-#include <map>
-#include <memory>
-#include <unordered_set>
-#include <vector>
-
-#include "base/atomicops.h"
-#include "base/containers/hash_tables.h"
-#include "base/macros.h"
-#include "base/memory/ref_counted.h"
-#include "base/memory/singleton.h"
-#include "base/synchronization/lock.h"
-#include "base/trace_event/memory_allocator_dump.h"
-#include "base/trace_event/memory_dump_provider_info.h"
-#include "base/trace_event/memory_dump_request_args.h"
-#include "base/trace_event/process_memory_dump.h"
-#include "base/trace_event/trace_event.h"
-
-namespace base {
-
-class SequencedTaskRunner;
-class SingleThreadTaskRunner;
-class Thread;
-
-namespace trace_event {
-
-class MemoryDumpProvider;
-class HeapProfilerSerializationState;
-
-enum HeapProfilingMode {
-  kHeapProfilingModeDisabled,
-  kHeapProfilingModeTaskProfiler,  // Per task counters for allocs and frees.
-  kHeapProfilingModeBackground,    // Pseudo stacks without default filtering.
-  kHeapProfilingModePseudo,  // Pseudo stacks with default filtering categories.
-  kHeapProfilingModeNative,  // Native stacks
-  kHeapProfilingModeInvalid  // Disabled permanently or unsupported.
-};
-
-// This is the interface exposed to the rest of the codebase to deal with
-// memory tracing. The main entry point for clients is represented by
-// RequestDumpPoint(). The extension by Un(RegisterDumpProvider).
-class BASE_EXPORT MemoryDumpManager {
- public:
-  using RequestGlobalDumpFunction =
-      RepeatingCallback<void(MemoryDumpType, MemoryDumpLevelOfDetail)>;
-
-  static const char* const kTraceCategory;
-
-  // This value is returned as the tracing id of the child processes by
-  // GetTracingProcessId() when tracing is not enabled.
-  static const uint64_t kInvalidTracingProcessId;
-
-  static MemoryDumpManager* GetInstance();
-  static std::unique_ptr<MemoryDumpManager> CreateInstanceForTesting();
-
-  // Invoked once per process to listen to trace begin / end events.
-  // Initialization can happen after (Un)RegisterMemoryDumpProvider() calls
-  // and the MemoryDumpManager guarantees to support this.
-  // On the other side, the MemoryDumpManager will not be fully operational
-  // (any CreateProcessDump() will return a failure) until initialized.
-  // Arguments:
-  //  is_coordinator: True when current process coordinates the periodic dump
-  //      triggering.
-  //  request_dump_function: Function to invoke a global dump. Global dump
-  //      involves embedder-specific behaviors like multiprocess handshaking.
-  //      TODO(primiano): this is only required to trigger global dumps from
-  //      the scheduler and the peak detector. Should be removed once they are
-  //      both moved out of base.
-  void Initialize(RequestGlobalDumpFunction request_dump_function,
-                  bool is_coordinator);
-
-  // (Un)Registers a MemoryDumpProvider instance.
-  // Args:
-  //  - mdp: the MemoryDumpProvider instance to be registered. MemoryDumpManager
-  //      does NOT take memory ownership of |mdp|, which is expected to either
-  //      be a singleton or unregister itself.
-  //  - name: a friendly name (duplicates allowed). Used for debugging and
-  //      run-time profiling of memory-infra internals. Must be a long-lived
-  //      C string.
-  //  - task_runner: either a SingleThreadTaskRunner or SequencedTaskRunner. All
-  //      the calls to |mdp| will be run on the given |task_runner|. If passed
-  //      null |mdp| should be able to handle calls on arbitrary threads.
-  //  - options: extra optional arguments. See memory_dump_provider.h.
-  void RegisterDumpProvider(MemoryDumpProvider* mdp,
-                            const char* name,
-                            scoped_refptr<SingleThreadTaskRunner> task_runner);
-  void RegisterDumpProvider(MemoryDumpProvider* mdp,
-                            const char* name,
-                            scoped_refptr<SingleThreadTaskRunner> task_runner,
-                            MemoryDumpProvider::Options options);
-  void RegisterDumpProviderWithSequencedTaskRunner(
-      MemoryDumpProvider* mdp,
-      const char* name,
-      scoped_refptr<SequencedTaskRunner> task_runner,
-      MemoryDumpProvider::Options options);
-  void UnregisterDumpProvider(MemoryDumpProvider* mdp);
-
-  // Unregisters an unbound dump provider and takes care about its deletion
-  // asynchronously. Can be used only for for dump providers with no
-  // task-runner affinity.
-  // This method takes ownership of the dump provider and guarantees that:
-  //  - The |mdp| will be deleted at some point in the near future.
-  //  - Its deletion will not happen concurrently with the OnMemoryDump() call.
-  // Note that OnMemoryDump() and PollFastMemoryTotal() calls can still happen
-  // after this method returns.
-  void UnregisterAndDeleteDumpProviderSoon(
-      std::unique_ptr<MemoryDumpProvider> mdp);
-
-  // Prepare MemoryDumpManager for CreateProcessDump() calls for tracing-related
-  // modes (i.e. |level_of_detail| != SUMMARY_ONLY).
-  // Also initializes the peak detector, scheduler and heap profiler with the
-  // given config.
-  void SetupForTracing(const TraceConfig::MemoryDumpConfig&);
-
-  // Tear-down tracing related state.
-  // Non-tracing modes (e.g. SUMMARY_ONLY) will continue to work.
-  void TeardownForTracing();
-
-  // Creates a memory dump for the current process and appends it to the trace.
-  // |callback| will be invoked asynchronously upon completion on the same
-  // thread on which CreateProcessDump() was called. This method should only be
-  // used by the memory-infra service while creating a global memory dump.
-  void CreateProcessDump(const MemoryDumpRequestArgs& args,
-                         const ProcessMemoryDumpCallback& callback);
-
-  // Enable heap profiling with specified |profiling_mode|.
-  // Use kHeapProfilingModeDisabled to disable, but it can't be re-enabled then.
-  // Returns true if mode has been *changed* to the desired |profiling_mode|.
-  bool EnableHeapProfiling(HeapProfilingMode profiling_mode);
-  HeapProfilingMode GetHeapProfilingMode();
-
-  // Lets tests see if a dump provider is registered.
-  bool IsDumpProviderRegisteredForTesting(MemoryDumpProvider*);
-
-  const scoped_refptr<HeapProfilerSerializationState>&
-  heap_profiler_serialization_state_for_testing() const {
-    return heap_profiler_serialization_state_;
-  }
-
-  // Returns a unique id for identifying the processes. The id can be
-  // retrieved by child processes only when tracing is enabled. This is
-  // intended to express cross-process sharing of memory dumps on the
-  // child-process side, without having to know its own child process id.
-  uint64_t GetTracingProcessId() const { return tracing_process_id_; }
-  void set_tracing_process_id(uint64_t tracing_process_id) {
-    tracing_process_id_ = tracing_process_id;
-  }
-
-  // Returns the name for a the allocated_objects dump. Use this to declare
-  // suballocator dumps from other dump providers.
-  // It will return nullptr if there is no dump provider for the system
-  // allocator registered (which is currently the case for Mac OS).
-  const char* system_allocator_pool_name() const {
-    return kSystemAllocatorPoolName;
-  };
-
-  // When set to true, calling |RegisterMemoryDumpProvider| is a no-op.
-  void set_dumper_registrations_ignored_for_testing(bool ignored) {
-    dumper_registrations_ignored_for_testing_ = ignored;
-  }
-
- private:
-  friend std::default_delete<MemoryDumpManager>;  // For the testing instance.
-  friend struct DefaultSingletonTraits<MemoryDumpManager>;
-  friend class MemoryDumpManagerTest;
-  FRIEND_TEST_ALL_PREFIXES(MemoryDumpManagerTest,
-                           NoStackOverflowWithTooManyMDPs);
-
-  // Holds the state of a process memory dump that needs to be carried over
-  // across task runners in order to fulfill an asynchronous CreateProcessDump()
-  // request. At any time exactly one task runner owns a
-  // ProcessMemoryDumpAsyncState.
-  struct ProcessMemoryDumpAsyncState {
-    ProcessMemoryDumpAsyncState(
-        MemoryDumpRequestArgs req_args,
-        const MemoryDumpProviderInfo::OrderedSet& dump_providers,
-        scoped_refptr<HeapProfilerSerializationState>
-            heap_profiler_serialization_state,
-        ProcessMemoryDumpCallback callback,
-        scoped_refptr<SequencedTaskRunner> dump_thread_task_runner);
-    ~ProcessMemoryDumpAsyncState();
-
-    // A ProcessMemoryDump to collect data from MemoryDumpProviders.
-    std::unique_ptr<ProcessMemoryDump> process_memory_dump;
-
-    // The arguments passed to the initial CreateProcessDump() request.
-    const MemoryDumpRequestArgs req_args;
-
-    // An ordered sequence of dump providers that have to be invoked to complete
-    // the dump. This is a copy of |dump_providers_| at the beginning of a dump
-    // and becomes empty at the end, when all dump providers have been invoked.
-    std::vector<scoped_refptr<MemoryDumpProviderInfo>> pending_dump_providers;
-
-    // The HeapProfilerSerializationState object, which is shared by all
-    // the ProcessMemoryDump and MemoryAllocatorDump instances through all the
-    // tracing session lifetime.
-    scoped_refptr<HeapProfilerSerializationState>
-        heap_profiler_serialization_state;
-
-    // Callback passed to the initial call to CreateProcessDump().
-    ProcessMemoryDumpCallback callback;
-
-    // The thread on which FinishAsyncProcessDump() (and hence |callback|)
-    // should be invoked. This is the thread on which the initial
-    // CreateProcessDump() request was called.
-    const scoped_refptr<SingleThreadTaskRunner> callback_task_runner;
-
-    // The thread on which unbound dump providers should be invoked.
-    // This is essentially |dump_thread_|.task_runner() but needs to be kept
-    // as a separate variable as it needs to be accessed by arbitrary dumpers'
-    // threads outside of the lock_ to avoid races when disabling tracing.
-    // It is immutable for all the duration of a tracing session.
-    const scoped_refptr<SequencedTaskRunner> dump_thread_task_runner;
-
-   private:
-    DISALLOW_COPY_AND_ASSIGN(ProcessMemoryDumpAsyncState);
-  };
-
-  static const int kMaxConsecutiveFailuresCount;
-  static const char* const kSystemAllocatorPoolName;
-
-  MemoryDumpManager();
-  virtual ~MemoryDumpManager();
-
-  static void SetInstanceForTesting(MemoryDumpManager* instance);
-
-  // Lazily initializes dump_thread_ and returns its TaskRunner.
-  scoped_refptr<base::SequencedTaskRunner> GetOrCreateBgTaskRunnerLocked();
-
-  // Calls InvokeOnMemoryDump() for the each MDP that belongs to the current
-  // task runner and switches to the task runner of the next MDP. Handles
-  // failures in MDP and thread hops, and always calls FinishAsyncProcessDump()
-  // at the end.
-  void ContinueAsyncProcessDump(
-      ProcessMemoryDumpAsyncState* owned_pmd_async_state);
-
-  // Invokes OnMemoryDump() of the given MDP. Should be called on the MDP task
-  // runner.
-  void InvokeOnMemoryDump(MemoryDumpProviderInfo* mdpinfo,
-                          ProcessMemoryDump* pmd);
-
-  void FinishAsyncProcessDump(
-      std::unique_ptr<ProcessMemoryDumpAsyncState> pmd_async_state);
-
-  // Helper for RegierDumpProvider* functions.
-  void RegisterDumpProviderInternal(
-      MemoryDumpProvider* mdp,
-      const char* name,
-      scoped_refptr<SequencedTaskRunner> task_runner,
-      const MemoryDumpProvider::Options& options);
-
-  // Helper for the public UnregisterDumpProvider* functions.
-  void UnregisterDumpProviderInternal(MemoryDumpProvider* mdp,
-                                      bool take_mdp_ownership_and_delete_async);
-
-  // Fills the passed vector with the subset of dump providers which were
-  // registered with is_fast_polling_supported == true.
-  void GetDumpProvidersForPolling(
-      std::vector<scoped_refptr<MemoryDumpProviderInfo>>*);
-
-  // Initialize |heap_profiler_serialization_state_| when tracing and heap
-  // profiler are enabled.
-  void InitializeHeapProfilerStateIfNeededLocked();
-
-  // Sends OnHeapProfilingEnabled() notifcation to mdp ensuring OnMemoryDump()
-  // is not called at the same time.
-  void NotifyHeapProfilingEnabledLocked(
-      scoped_refptr<MemoryDumpProviderInfo> mdpinfo,
-      bool enabled);
-
-  bool can_request_global_dumps() const {
-    return !request_dump_function_.is_null();
-  }
-
-  // An ordered set of registered MemoryDumpProviderInfo(s), sorted by task
-  // runner affinity (MDPs belonging to the same task runners are adjacent).
-  MemoryDumpProviderInfo::OrderedSet dump_providers_;
-
-  // Shared among all the PMDs to keep state scoped to the tracing session.
-  scoped_refptr<HeapProfilerSerializationState>
-      heap_profiler_serialization_state_;
-
-  // Function provided by the embedder to handle global dump requests.
-  RequestGlobalDumpFunction request_dump_function_;
-
-  // True when current process coordinates the periodic dump triggering.
-  bool is_coordinator_;
-
-  // Protects from concurrent accesses to the local state, eg: to guard against
-  // disabling logging while dumping on another thread.
-  Lock lock_;
-
-  // Thread used for MemoryDumpProviders which don't specify a task runner
-  // affinity.
-  std::unique_ptr<Thread> dump_thread_;
-
-  // The unique id of the child process. This is created only for tracing and is
-  // expected to be valid only when tracing is enabled.
-  uint64_t tracing_process_id_;
-
-  // When true, calling |RegisterMemoryDumpProvider| is a no-op.
-  bool dumper_registrations_ignored_for_testing_;
-
-  HeapProfilingMode heap_profiling_mode_;
-
-  DISALLOW_COPY_AND_ASSIGN(MemoryDumpManager);
-};
-
-}  // namespace trace_event
-}  // namespace base
-
-#endif  // BASE_TRACE_EVENT_MEMORY_DUMP_MANAGER_H_
diff --git a/base/trace_event/memory_dump_manager_test_utils.h b/base/trace_event/memory_dump_manager_test_utils.h
deleted file mode 100644
index 413017f..0000000
--- a/base/trace_event/memory_dump_manager_test_utils.h
+++ /dev/null
@@ -1,38 +0,0 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_TRACE_EVENT_MEMORY_DUMP_MANAGER_TEST_UTILS_H_
-#define BASE_TRACE_EVENT_MEMORY_DUMP_MANAGER_TEST_UTILS_H_
-
-#include "base/bind.h"
-#include "base/trace_event/memory_dump_manager.h"
-#include "base/trace_event/memory_dump_request_args.h"
-
-namespace base {
-namespace trace_event {
-
-void RequestGlobalDumpForInProcessTesting(
-    base::trace_event::MemoryDumpType dump_type,
-    base::trace_event::MemoryDumpLevelOfDetail level_of_detail) {
-  MemoryDumpRequestArgs local_args = {0 /* dump_guid */, dump_type,
-                                      level_of_detail};
-  MemoryDumpManager::GetInstance()->CreateProcessDump(
-      local_args, ProcessMemoryDumpCallback());
-};
-
-// Short circuits the RequestGlobalDumpFunction() to CreateProcessDump(),
-// effectively allowing to use both in unittests with the same behavior.
-// Unittests are in-process only and don't require all the multi-process
-// dump handshaking (which would require bits outside of base).
-void InitializeMemoryDumpManagerForInProcessTesting(bool is_coordinator) {
-  MemoryDumpManager* instance = MemoryDumpManager::GetInstance();
-  instance->set_dumper_registrations_ignored_for_testing(true);
-  instance->Initialize(BindRepeating(&RequestGlobalDumpForInProcessTesting),
-                       is_coordinator);
-}
-
-}  // namespace trace_event
-}  // namespace base
-
-#endif  // BASE_TRACE_EVENT_MEMORY_DUMP_MANAGER_TEST_UTILS_H_
diff --git a/base/trace_event/memory_dump_provider.h b/base/trace_event/memory_dump_provider.h
deleted file mode 100644
index b458bfb..0000000
--- a/base/trace_event/memory_dump_provider.h
+++ /dev/null
@@ -1,81 +0,0 @@
-// Copyright 2015 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_TRACE_EVENT_MEMORY_DUMP_PROVIDER_H_
-#define BASE_TRACE_EVENT_MEMORY_DUMP_PROVIDER_H_
-
-#include "base/base_export.h"
-#include "base/macros.h"
-#include "base/process/process_handle.h"
-#include "base/trace_event/memory_dump_request_args.h"
-
-namespace base {
-namespace trace_event {
-
-class ProcessMemoryDump;
-
-// The contract interface that memory dump providers must implement.
-class BASE_EXPORT MemoryDumpProvider {
- public:
-  // Optional arguments for MemoryDumpManager::RegisterDumpProvider().
-  struct Options {
-    Options()
-        : dumps_on_single_thread_task_runner(false),
-          is_fast_polling_supported(false),
-          supports_heap_profiling(false) {}
-
-    // |dumps_on_single_thread_task_runner| is true if the dump provider runs on
-    // a SingleThreadTaskRunner, which is usually the case. It is faster to run
-    // all providers that run on the same thread together without thread hops.
-    bool dumps_on_single_thread_task_runner;
-
-    // Set to true if the dump provider implementation supports high frequency
-    // polling. Only providers running without task runner affinity are
-    // supported.
-    bool is_fast_polling_supported;
-
-    // Set to true when the dump provider supports heap profiling. MDM sends
-    // OnHeapProfiling() notifications only if this is set to true.
-    bool supports_heap_profiling;
-  };
-
-  virtual ~MemoryDumpProvider() = default;
-
-  // Called by the MemoryDumpManager when generating memory dumps.
-  // The |args| specify if the embedder should generate light/heavy dumps on
-  // dump requests. The embedder should return true if the |pmd| was
-  // successfully populated, false if something went wrong and the dump should
-  // be considered invalid.
-  // (Note, the MemoryDumpManager has a fail-safe logic which will disable the
-  // MemoryDumpProvider for the entire trace session if it fails consistently).
-  virtual bool OnMemoryDump(const MemoryDumpArgs& args,
-                            ProcessMemoryDump* pmd) = 0;
-
-  // Called by the MemoryDumpManager when an allocator should start or stop
-  // collecting extensive allocation data, if supported. Called only when
-  // |supports_heap_profiling| is set to true.
-  virtual void OnHeapProfilingEnabled(bool enabled) {}
-
-  // Quickly record the total memory usage in |memory_total|. This method will
-  // be called only when the dump provider registration has
-  // |is_fast_polling_supported| set to true. This method is used for polling at
-  // high frequency for detecting peaks. See comment on
-  // |is_fast_polling_supported| option if you need to override this method.
-  virtual void PollFastMemoryTotal(uint64_t* memory_total) {}
-
-  // Indicates that fast memory polling is not going to be used in the near
-  // future and the MDP can tear down any resource kept around for fast memory
-  // polling.
-  virtual void SuspendFastMemoryPolling() {}
-
- protected:
-  MemoryDumpProvider() = default;
-
-  DISALLOW_COPY_AND_ASSIGN(MemoryDumpProvider);
-};
-
-}  // namespace trace_event
-}  // namespace base
-
-#endif  // BASE_TRACE_EVENT_MEMORY_DUMP_PROVIDER_H_
diff --git a/base/trace_event/memory_dump_provider_info.cc b/base/trace_event/memory_dump_provider_info.cc
deleted file mode 100644
index 3220476..0000000
--- a/base/trace_event/memory_dump_provider_info.cc
+++ /dev/null
@@ -1,43 +0,0 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/trace_event/memory_dump_provider_info.h"
-
-#include <tuple>
-
-#include "base/sequenced_task_runner.h"
-
-namespace base {
-namespace trace_event {
-
-MemoryDumpProviderInfo::MemoryDumpProviderInfo(
-    MemoryDumpProvider* dump_provider,
-    const char* name,
-    scoped_refptr<SequencedTaskRunner> task_runner,
-    const MemoryDumpProvider::Options& options,
-    bool whitelisted_for_background_mode)
-    : dump_provider(dump_provider),
-      options(options),
-      name(name),
-      task_runner(std::move(task_runner)),
-      whitelisted_for_background_mode(whitelisted_for_background_mode),
-      consecutive_failures(0),
-      disabled(false) {}
-
-MemoryDumpProviderInfo::~MemoryDumpProviderInfo() = default;
-
-bool MemoryDumpProviderInfo::Comparator::operator()(
-    const scoped_refptr<MemoryDumpProviderInfo>& a,
-    const scoped_refptr<MemoryDumpProviderInfo>& b) const {
-  if (!a || !b)
-    return a.get() < b.get();
-  // Ensure that unbound providers (task_runner == nullptr) always run last.
-  // Rationale: some unbound dump providers are known to be slow, keep them last
-  // to avoid skewing timings of the other dump providers.
-  return std::tie(a->task_runner, a->dump_provider) >
-         std::tie(b->task_runner, b->dump_provider);
-}
-
-}  // namespace trace_event
-}  // namespace base
diff --git a/base/trace_event/memory_dump_provider_info.h b/base/trace_event/memory_dump_provider_info.h
deleted file mode 100644
index f0ea1e6..0000000
--- a/base/trace_event/memory_dump_provider_info.h
+++ /dev/null
@@ -1,108 +0,0 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_TRACE_EVENT_MEMORY_DUMP_PROVIDER_INFO_H_
-#define BASE_TRACE_EVENT_MEMORY_DUMP_PROVIDER_INFO_H_
-
-#include <memory>
-#include <set>
-
-#include "base/base_export.h"
-#include "base/memory/ref_counted.h"
-#include "base/trace_event/memory_dump_provider.h"
-
-namespace base {
-
-class SequencedTaskRunner;
-
-namespace trace_event {
-
-// Wraps a MemoryDumpProvider (MDP), which is registered via
-// MemoryDumpManager(MDM)::RegisterDumpProvider(), holding the extra information
-// required to deal with it (which task runner it should be invoked onto,
-// whether it has been disabled, etc.)
-// More importantly, having a refptr to this object guarantees that a MDP that
-// is not thread-bound (hence which can only be unregistered via
-// MDM::UnregisterAndDeleteDumpProviderSoon()) will stay alive as long as the
-// refptr is held.
-//
-// Lifetime:
-// At any time, there is at most one instance of this class for each instance
-// of a given MemoryDumpProvider, but there might be several scoped_refptr
-// holding onto each of this. Specifically:
-// - In nominal conditions, there is a refptr for each registered MDP in the
-//   MDM's |dump_providers_| list.
-// - In most cases, the only refptr (in the |dump_providers_| list) is destroyed
-//   by MDM::UnregisterDumpProvider().
-// - However, when MDM starts a dump, the list of refptrs is copied into the
-//   ProcessMemoryDumpAsyncState. That list is pruned as MDP(s) are invoked.
-// - If UnregisterDumpProvider() is called on a non-thread-bound MDP while a
-//   dump is in progress, the extar extra of the handle is destroyed in
-//   MDM::SetupNextMemoryDump() or MDM::InvokeOnMemoryDump(), when the copy
-//   inside ProcessMemoryDumpAsyncState is erase()-d.
-// - The PeakDetector can keep extra refptrs when enabled.
-struct BASE_EXPORT MemoryDumpProviderInfo
-    : public RefCountedThreadSafe<MemoryDumpProviderInfo> {
- public:
-  // Define a total order based on the |task_runner| affinity, so that MDPs
-  // belonging to the same SequencedTaskRunner are adjacent in the set.
-  struct Comparator {
-    bool operator()(const scoped_refptr<MemoryDumpProviderInfo>& a,
-                    const scoped_refptr<MemoryDumpProviderInfo>& b) const;
-  };
-  using OrderedSet =
-      std::set<scoped_refptr<MemoryDumpProviderInfo>, Comparator>;
-
-  MemoryDumpProviderInfo(MemoryDumpProvider* dump_provider,
-                         const char* name,
-                         scoped_refptr<SequencedTaskRunner> task_runner,
-                         const MemoryDumpProvider::Options& options,
-                         bool whitelisted_for_background_mode);
-
-  // It is safe to access the const fields below from any thread as they are
-  // never mutated.
-
-  MemoryDumpProvider* const dump_provider;
-
-  // The |options| arg passed to MDM::RegisterDumpProvider().
-  const MemoryDumpProvider::Options options;
-
-  // Human readable name, not unique (distinct MDP instances might have the same
-  // name). Used for debugging, testing and whitelisting for BACKGROUND mode.
-  const char* const name;
-
-  // The task runner on which the MDP::OnMemoryDump call should be posted onto.
-  // Can be nullptr, in which case the MDP will be invoked on a background
-  // thread handled by MDM.
-  const scoped_refptr<SequencedTaskRunner> task_runner;
-
-  // True if the dump provider is whitelisted for background mode.
-  const bool whitelisted_for_background_mode;
-
-  // These fields below, instead, are not thread safe and can be mutated only:
-  // - On the |task_runner|, when not null (i.e. for thread-bound MDPS).
-  // - By the MDM's background thread (or in any other way that guarantees
-  //   sequencing) for non-thread-bound MDPs.
-
-  // Used to transfer ownership for UnregisterAndDeleteDumpProviderSoon().
-  // nullptr in all other cases.
-  std::unique_ptr<MemoryDumpProvider> owned_dump_provider;
-
-  // For fail-safe logic (auto-disable failing MDPs).
-  int consecutive_failures;
-
-  // Flagged either by the auto-disable logic or during unregistration.
-  bool disabled;
-
- private:
-  friend class base::RefCountedThreadSafe<MemoryDumpProviderInfo>;
-  ~MemoryDumpProviderInfo();
-
-  DISALLOW_COPY_AND_ASSIGN(MemoryDumpProviderInfo);
-};
-
-}  // namespace trace_event
-}  // namespace base
-
-#endif  // BASE_TRACE_EVENT_MEMORY_DUMP_PROVIDER_INFO_H_
diff --git a/base/trace_event/memory_dump_request_args.cc b/base/trace_event/memory_dump_request_args.cc
deleted file mode 100644
index 3cb9cab..0000000
--- a/base/trace_event/memory_dump_request_args.cc
+++ /dev/null
@@ -1,68 +0,0 @@
-// Copyright 2015 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/trace_event/memory_dump_request_args.h"
-
-#include "base/logging.h"
-
-namespace base {
-namespace trace_event {
-
-// static
-const char* MemoryDumpTypeToString(const MemoryDumpType& dump_type) {
-  switch (dump_type) {
-    case MemoryDumpType::PERIODIC_INTERVAL:
-      return "periodic_interval";
-    case MemoryDumpType::EXPLICITLY_TRIGGERED:
-      return "explicitly_triggered";
-    case MemoryDumpType::PEAK_MEMORY_USAGE:
-      return "peak_memory_usage";
-    case MemoryDumpType::SUMMARY_ONLY:
-      return "summary_only";
-  }
-  NOTREACHED();
-  return "unknown";
-}
-
-MemoryDumpType StringToMemoryDumpType(const std::string& str) {
-  if (str == "periodic_interval")
-    return MemoryDumpType::PERIODIC_INTERVAL;
-  if (str == "explicitly_triggered")
-    return MemoryDumpType::EXPLICITLY_TRIGGERED;
-  if (str == "peak_memory_usage")
-    return MemoryDumpType::PEAK_MEMORY_USAGE;
-  if (str == "summary_only")
-    return MemoryDumpType::SUMMARY_ONLY;
-  NOTREACHED();
-  return MemoryDumpType::LAST;
-}
-
-const char* MemoryDumpLevelOfDetailToString(
-    const MemoryDumpLevelOfDetail& level_of_detail) {
-  switch (level_of_detail) {
-    case MemoryDumpLevelOfDetail::BACKGROUND:
-      return "background";
-    case MemoryDumpLevelOfDetail::LIGHT:
-      return "light";
-    case MemoryDumpLevelOfDetail::DETAILED:
-      return "detailed";
-  }
-  NOTREACHED();
-  return "unknown";
-}
-
-MemoryDumpLevelOfDetail StringToMemoryDumpLevelOfDetail(
-    const std::string& str) {
-  if (str == "background")
-    return MemoryDumpLevelOfDetail::BACKGROUND;
-  if (str == "light")
-    return MemoryDumpLevelOfDetail::LIGHT;
-  if (str == "detailed")
-    return MemoryDumpLevelOfDetail::DETAILED;
-  NOTREACHED();
-  return MemoryDumpLevelOfDetail::LAST;
-}
-
-}  // namespace trace_event
-}  // namespace base
diff --git a/base/trace_event/memory_dump_request_args.h b/base/trace_event/memory_dump_request_args.h
deleted file mode 100644
index 41bc99b..0000000
--- a/base/trace_event/memory_dump_request_args.h
+++ /dev/null
@@ -1,102 +0,0 @@
-// Copyright 2015 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_TRACE_EVENT_MEMORY_DUMP_REQUEST_ARGS_H_
-#define BASE_TRACE_EVENT_MEMORY_DUMP_REQUEST_ARGS_H_
-
-// This file defines the types and structs used to issue memory dump requests.
-// These are also used in the IPCs for coordinating inter-process memory dumps.
-
-#include <stdint.h>
-#include <map>
-#include <memory>
-#include <string>
-
-#include "base/base_export.h"
-#include "base/callback.h"
-#include "base/optional.h"
-#include "base/process/process_handle.h"
-
-namespace base {
-namespace trace_event {
-
-class ProcessMemoryDump;
-
-// Captures the reason why a memory dump is being requested. This is to allow
-// selective enabling of dumps, filtering and post-processing. Keep this
-// consistent with memory_instrumentation.mojo and
-// memory_instrumentation_struct_traits.{h,cc}
-enum class MemoryDumpType {
-  PERIODIC_INTERVAL,     // Dumping memory at periodic intervals.
-  EXPLICITLY_TRIGGERED,  // Non maskable dump request.
-  PEAK_MEMORY_USAGE,     // Dumping memory at detected peak total memory usage.
-  SUMMARY_ONLY,          // Calculate just the summary & don't add to the trace.
-  LAST = SUMMARY_ONLY
-};
-
-// Tells the MemoryDumpProvider(s) how much detailed their dumps should be.
-// Keep this consistent with memory_instrumentation.mojo and
-// memory_instrumentation_struct_traits.{h,cc}
-enum class MemoryDumpLevelOfDetail : uint32_t {
-  FIRST,
-
-  // For background tracing mode. The dump time is quick, and typically just the
-  // totals are expected. Suballocations need not be specified. Dump name must
-  // contain only pre-defined strings and string arguments cannot be added.
-  BACKGROUND = FIRST,
-
-  // For the levels below, MemoryDumpProvider instances must guarantee that the
-  // total size reported in the root node is consistent. Only the granularity of
-  // the child MemoryAllocatorDump(s) differs with the levels.
-
-  // Few entries, typically a fixed number, per dump.
-  LIGHT,
-
-  // Unrestricted amount of entries per dump.
-  DETAILED,
-
-  LAST = DETAILED
-};
-
-// Keep this consistent with memory_instrumentation.mojo and
-// memory_instrumentation_struct_traits.{h,cc}
-struct BASE_EXPORT MemoryDumpRequestArgs {
-  // Globally unique identifier. In multi-process dumps, all processes issue a
-  // local dump with the same guid. This allows the trace importers to
-  // reconstruct the global dump.
-  uint64_t dump_guid;
-
-  MemoryDumpType dump_type;
-  MemoryDumpLevelOfDetail level_of_detail;
-};
-
-// Args for ProcessMemoryDump and passed to OnMemoryDump calls for memory dump
-// providers. Dump providers are expected to read the args for creating dumps.
-struct MemoryDumpArgs {
-  // Specifies how detailed the dumps should be.
-  MemoryDumpLevelOfDetail level_of_detail;
-
-  // Globally unique identifier. In multi-process dumps, all processes issue a
-  // local dump with the same guid. This allows the trace importers to
-  // reconstruct the global dump.
-  uint64_t dump_guid;
-};
-
-using ProcessMemoryDumpCallback = Callback<
-    void(bool success, uint64_t dump_guid, std::unique_ptr<ProcessMemoryDump>)>;
-
-BASE_EXPORT const char* MemoryDumpTypeToString(const MemoryDumpType& dump_type);
-
-BASE_EXPORT MemoryDumpType StringToMemoryDumpType(const std::string& str);
-
-BASE_EXPORT const char* MemoryDumpLevelOfDetailToString(
-    const MemoryDumpLevelOfDetail& level_of_detail);
-
-BASE_EXPORT MemoryDumpLevelOfDetail
-StringToMemoryDumpLevelOfDetail(const std::string& str);
-
-}  // namespace trace_event
-}  // namespace base
-
-#endif  // BASE_TRACE_EVENT_MEMORY_DUMP_REQUEST_ARGS_H_
diff --git a/base/trace_event/memory_dump_scheduler.cc b/base/trace_event/memory_dump_scheduler.cc
deleted file mode 100644
index 8b03f5c..0000000
--- a/base/trace_event/memory_dump_scheduler.cc
+++ /dev/null
@@ -1,118 +0,0 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/trace_event/memory_dump_scheduler.h"
-
-#include <algorithm>
-#include <limits>
-
-#include "base/bind.h"
-#include "base/logging.h"
-#include "base/threading/sequenced_task_runner_handle.h"
-
-namespace base {
-namespace trace_event {
-
-// static
-MemoryDumpScheduler* MemoryDumpScheduler::GetInstance() {
-  static MemoryDumpScheduler* instance = new MemoryDumpScheduler();
-  return instance;
-}
-
-MemoryDumpScheduler::MemoryDumpScheduler() : period_ms_(0), generation_(0) {}
-MemoryDumpScheduler::~MemoryDumpScheduler() {
-  // Hit only in tests. Check that tests don't leave without stopping.
-  DCHECK(!is_enabled_for_testing());
-}
-
-void MemoryDumpScheduler::Start(
-    MemoryDumpScheduler::Config config,
-    scoped_refptr<SequencedTaskRunner> task_runner) {
-  DCHECK(!task_runner_);
-  task_runner_ = task_runner;
-  task_runner->PostTask(FROM_HERE, BindOnce(&MemoryDumpScheduler::StartInternal,
-                                            Unretained(this), config));
-}
-
-void MemoryDumpScheduler::Stop() {
-  if (!task_runner_)
-    return;
-  task_runner_->PostTask(FROM_HERE, BindOnce(&MemoryDumpScheduler::StopInternal,
-                                             Unretained(this)));
-  task_runner_ = nullptr;
-}
-
-void MemoryDumpScheduler::StartInternal(MemoryDumpScheduler::Config config) {
-  uint32_t light_dump_period_ms = 0;
-  uint32_t heavy_dump_period_ms = 0;
-  uint32_t min_period_ms = std::numeric_limits<uint32_t>::max();
-  for (const Config::Trigger& trigger : config.triggers) {
-    DCHECK_GT(trigger.period_ms, 0u);
-    switch (trigger.level_of_detail) {
-      case MemoryDumpLevelOfDetail::BACKGROUND:
-        break;
-      case MemoryDumpLevelOfDetail::LIGHT:
-        DCHECK_EQ(0u, light_dump_period_ms);
-        light_dump_period_ms = trigger.period_ms;
-        break;
-      case MemoryDumpLevelOfDetail::DETAILED:
-        DCHECK_EQ(0u, heavy_dump_period_ms);
-        heavy_dump_period_ms = trigger.period_ms;
-        break;
-    }
-    min_period_ms = std::min(min_period_ms, trigger.period_ms);
-  }
-
-  DCHECK_EQ(0u, light_dump_period_ms % min_period_ms);
-  DCHECK_EQ(0u, heavy_dump_period_ms % min_period_ms);
-  DCHECK(!config.callback.is_null());
-  callback_ = config.callback;
-  period_ms_ = min_period_ms;
-  tick_count_ = 0;
-  light_dump_rate_ = light_dump_period_ms / min_period_ms;
-  heavy_dump_rate_ = heavy_dump_period_ms / min_period_ms;
-
-  // Trigger the first dump after 200ms.
-  // TODO(lalitm): this is a tempoarary hack to delay the first scheduled dump
-  // so that the child processes get tracing enabled notification via IPC.
-  // See crbug.com/770151.
-  SequencedTaskRunnerHandle::Get()->PostDelayedTask(
-      FROM_HERE,
-      BindOnce(&MemoryDumpScheduler::Tick, Unretained(this), ++generation_),
-      TimeDelta::FromMilliseconds(200));
-}
-
-void MemoryDumpScheduler::StopInternal() {
-  period_ms_ = 0;
-  generation_++;
-  callback_.Reset();
-}
-
-void MemoryDumpScheduler::Tick(uint32_t expected_generation) {
-  if (period_ms_ == 0 || generation_ != expected_generation)
-    return;
-
-  MemoryDumpLevelOfDetail level_of_detail = MemoryDumpLevelOfDetail::BACKGROUND;
-  if (light_dump_rate_ > 0 && tick_count_ % light_dump_rate_ == 0)
-    level_of_detail = MemoryDumpLevelOfDetail::LIGHT;
-  if (heavy_dump_rate_ > 0 && tick_count_ % heavy_dump_rate_ == 0)
-    level_of_detail = MemoryDumpLevelOfDetail::DETAILED;
-  tick_count_++;
-
-  callback_.Run(level_of_detail);
-
-  SequencedTaskRunnerHandle::Get()->PostDelayedTask(
-      FROM_HERE,
-      BindOnce(&MemoryDumpScheduler::Tick, Unretained(this),
-               expected_generation),
-      TimeDelta::FromMilliseconds(period_ms_));
-}
-
-MemoryDumpScheduler::Config::Config() = default;
-MemoryDumpScheduler::Config::~Config() = default;
-MemoryDumpScheduler::Config::Config(const MemoryDumpScheduler::Config&) =
-    default;
-
-}  // namespace trace_event
-}  // namespace base
diff --git a/base/trace_event/memory_dump_scheduler.h b/base/trace_event/memory_dump_scheduler.h
deleted file mode 100644
index 21334f0..0000000
--- a/base/trace_event/memory_dump_scheduler.h
+++ /dev/null
@@ -1,76 +0,0 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_TRACE_EVENT_MEMORY_DUMP_SCHEDULER_H
-#define BASE_TRACE_EVENT_MEMORY_DUMP_SCHEDULER_H
-
-#include <stdint.h>
-
-#include <vector>
-
-#include "base/base_export.h"
-#include "base/callback.h"
-#include "base/memory/ref_counted.h"
-#include "base/trace_event/memory_dump_request_args.h"
-
-namespace base {
-class SequencedTaskRunner;
-
-namespace trace_event {
-
-// Schedules global dump requests based on the triggers added. The methods of
-// this class are NOT thread safe and the client has to take care of invoking
-// all the methods of the class safely.
-class BASE_EXPORT MemoryDumpScheduler {
- public:
-  using PeriodicCallback = RepeatingCallback<void(MemoryDumpLevelOfDetail)>;
-
-  // Passed to Start().
-  struct BASE_EXPORT Config {
-    struct Trigger {
-      MemoryDumpLevelOfDetail level_of_detail;
-      uint32_t period_ms;
-    };
-
-    Config();
-    Config(const Config&);
-    ~Config();
-
-    std::vector<Trigger> triggers;
-    PeriodicCallback callback;
-  };
-
-  static MemoryDumpScheduler* GetInstance();
-
-  void Start(Config, scoped_refptr<SequencedTaskRunner> task_runner);
-  void Stop();
-  bool is_enabled_for_testing() const { return bool(task_runner_); }
-
- private:
-  friend class MemoryDumpSchedulerTest;
-  MemoryDumpScheduler();
-  ~MemoryDumpScheduler();
-
-  void StartInternal(Config);
-  void StopInternal();
-  void Tick(uint32_t expected_generation);
-
-  // Accessed only by the public methods (never from the task runner itself).
-  scoped_refptr<SequencedTaskRunner> task_runner_;
-
-  // These fields instead are only accessed from within the task runner.
-  uint32_t period_ms_;   // 0 == disabled.
-  uint32_t generation_;  // Used to invalidate outstanding tasks after Stop().
-  uint32_t tick_count_;
-  uint32_t light_dump_rate_;
-  uint32_t heavy_dump_rate_;
-  PeriodicCallback callback_;
-
-  DISALLOW_COPY_AND_ASSIGN(MemoryDumpScheduler);
-};
-
-}  // namespace trace_event
-}  // namespace base
-
-#endif  // BASE_TRACE_EVENT_MEMORY_DUMP_SCHEDULER_H
diff --git a/base/trace_event/memory_infra_background_whitelist.cc b/base/trace_event/memory_infra_background_whitelist.cc
deleted file mode 100644
index 0e69c7c..0000000
--- a/base/trace_event/memory_infra_background_whitelist.cc
+++ /dev/null
@@ -1,386 +0,0 @@
-// Copyright 2016 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/trace_event/memory_infra_background_whitelist.h"
-
-#include <ctype.h>
-#include <string.h>
-
-#include <string>
-
-#include "base/strings/string_util.h"
-
-namespace base {
-namespace trace_event {
-namespace {
-
-// The names of dump providers whitelisted for background tracing. Dump
-// providers can be added here only if the background mode dump has very
-// little processor and memory overhead.
-// TODO(ssid): Some dump providers do not create ownership edges on background
-// dump. So, the effective size will not be correct.
-const char* const kDumpProviderWhitelist[] = {
-    "android::ResourceManagerImpl",
-    "AutocompleteController",
-    "BlinkGC",
-    "BlinkObjectCounters",
-    "BlobStorageContext",
-    "ClientDiscardableSharedMemoryManager",
-    "DOMStorage",
-    "DownloadService",
-    "DiscardableSharedMemoryManager",
-    "gpu::BufferManager",
-    "gpu::RenderbufferManager",
-    "gpu::TextureManager",
-    "FontCaches",
-    "HistoryReport",
-    "IPCChannel",
-    "IndexedDBBackingStore",
-    "InMemoryURLIndex",
-    "JavaHeap",
-    "LevelDB",
-    "LeveldbValueStore",
-    "LocalStorage",
-    "Malloc",
-    "MemoryCache",
-    "MojoHandleTable",
-    "MojoLevelDB",
-    "MojoMessages",
-    "PartitionAlloc",
-    "ProcessMemoryMetrics",
-    "RenderProcessHost",
-    "SharedMemoryTracker",
-    "Skia",
-    "Sql",
-    "URLRequestContext",
-    "V8Isolate",
-    "SyncDirectory",
-    "TabRestoreServiceHelper",
-    nullptr  // End of list marker.
-};
-
-// A list of string names that are allowed for the memory allocator dumps in
-// background mode.
-const char* const kAllocatorDumpNameWhitelist[] = {
-    "blink_gc",
-    "blink_gc/allocated_objects",
-    "blink_objects/AudioHandler",
-    "blink_objects/Document",
-    "blink_objects/Frame",
-    "blink_objects/JSEventListener",
-    "blink_objects/LayoutObject",
-    "blink_objects/MediaKeySession",
-    "blink_objects/MediaKeys",
-    "blink_objects/Node",
-    "blink_objects/Resource",
-    "blink_objects/RTCPeerConnection",
-    "blink_objects/ScriptPromise",
-    "blink_objects/PausableObject",
-    "blink_objects/V8PerContextData",
-    "blink_objects/WorkerGlobalScope",
-    "blink_objects/UACSSResource",
-    "blink_objects/ResourceFetcher",
-    "components/download/controller_0x?",
-    "discardable",
-    "discardable/child_0x?",
-    "extensions/value_store/Extensions.Database.Open.Settings/0x?",
-    "extensions/value_store/Extensions.Database.Open.Rules/0x?",
-    "extensions/value_store/Extensions.Database.Open.State/0x?",
-    "extensions/value_store/Extensions.Database.Open/0x?",
-    "extensions/value_store/Extensions.Database.Restore/0x?",
-    "extensions/value_store/Extensions.Database.Value.Restore/0x?",
-    "font_caches/font_platform_data_cache",
-    "font_caches/shape_caches",
-    "gpu/gl/buffers/share_group_0x?",
-    "gpu/gl/renderbuffers/share_group_0x?",
-    "gpu/gl/textures/share_group_0x?",
-    "history/delta_file_service/leveldb_0x?",
-    "history/usage_reports_buffer/leveldb_0x?",
-    "java_heap",
-    "java_heap/allocated_objects",
-    "leveldatabase",
-    "leveldatabase/block_cache/browser",
-    "leveldatabase/block_cache/in_memory",
-    "leveldatabase/block_cache/unified",
-    "leveldatabase/block_cache/web",
-    "leveldatabase/db_0x?",
-    "leveldatabase/db_0x?/block_cache",
-    "leveldatabase/memenv_0x?",
-    "malloc",
-    "malloc/allocated_objects",
-    "malloc/metadata_fragmentation_caches",
-    "mojo",
-    "mojo/data_pipe_consumer",
-    "mojo/data_pipe_producer",
-    "mojo/messages",
-    "mojo/message_pipe",
-    "mojo/platform_handle",
-    "mojo/queued_ipc_channel_message/0x?",
-    "mojo/render_process_host/0x?",
-    "mojo/shared_buffer",
-    "mojo/unknown",
-    "mojo/watcher",
-    "net/http_network_session_0x?",
-    "net/http_network_session_0x?/quic_stream_factory",
-    "net/http_network_session_0x?/socket_pool",
-    "net/http_network_session_0x?/spdy_session_pool",
-    "net/http_network_session_0x?/stream_factory",
-    "net/ssl_session_cache",
-    "net/url_request_context",
-    "net/url_request_context/app_request",
-    "net/url_request_context/app_request/0x?",
-    "net/url_request_context/app_request/0x?/cookie_monster",
-    "net/url_request_context/app_request/0x?/cookie_monster/cookies",
-    "net/url_request_context/app_request/0x?/cookie_monster/"
-    "tasks_pending_global",
-    "net/url_request_context/app_request/0x?/cookie_monster/"
-    "tasks_pending_for_key",
-    "net/url_request_context/app_request/0x?/http_cache",
-    "net/url_request_context/app_request/0x?/http_cache/memory_backend",
-    "net/url_request_context/app_request/0x?/http_cache/simple_backend",
-    "net/url_request_context/app_request/0x?/http_network_session",
-    "net/url_request_context/extensions",
-    "net/url_request_context/extensions/0x?",
-    "net/url_request_context/extensions/0x?/cookie_monster",
-    "net/url_request_context/extensions/0x?/cookie_monster/cookies",
-    "net/url_request_context/extensions/0x?/cookie_monster/"
-    "tasks_pending_global",
-    "net/url_request_context/extensions/0x?/cookie_monster/"
-    "tasks_pending_for_key",
-    "net/url_request_context/extensions/0x?/http_cache",
-    "net/url_request_context/extensions/0x?/http_cache/memory_backend",
-    "net/url_request_context/extensions/0x?/http_cache/simple_backend",
-    "net/url_request_context/extensions/0x?/http_network_session",
-    "net/url_request_context/isolated_media",
-    "net/url_request_context/isolated_media/0x?",
-    "net/url_request_context/isolated_media/0x?/cookie_monster",
-    "net/url_request_context/isolated_media/0x?/cookie_monster/cookies",
-    "net/url_request_context/isolated_media/0x?/cookie_monster/"
-    "tasks_pending_global",
-    "net/url_request_context/isolated_media/0x?/cookie_monster/"
-    "tasks_pending_for_key",
-    "net/url_request_context/isolated_media/0x?/http_cache",
-    "net/url_request_context/isolated_media/0x?/http_cache/memory_backend",
-    "net/url_request_context/isolated_media/0x?/http_cache/simple_backend",
-    "net/url_request_context/isolated_media/0x?/http_network_session",
-    "net/url_request_context/main",
-    "net/url_request_context/main/0x?",
-    "net/url_request_context/main/0x?/cookie_monster",
-    "net/url_request_context/main/0x?/cookie_monster/cookies",
-    "net/url_request_context/main/0x?/cookie_monster/tasks_pending_global",
-    "net/url_request_context/main/0x?/cookie_monster/tasks_pending_for_key",
-    "net/url_request_context/main/0x?/http_cache",
-    "net/url_request_context/main/0x?/http_cache/memory_backend",
-    "net/url_request_context/main/0x?/http_cache/simple_backend",
-    "net/url_request_context/main/0x?/http_network_session",
-    "net/url_request_context/main_media",
-    "net/url_request_context/main_media/0x?",
-    "net/url_request_context/main_media/0x?/cookie_monster",
-    "net/url_request_context/main_media/0x?/cookie_monster/cookies",
-    "net/url_request_context/main_media/0x?/cookie_monster/"
-    "tasks_pending_global",
-    "net/url_request_context/main_media/0x?/cookie_monster/"
-    "tasks_pending_for_key",
-    "net/url_request_context/main_media/0x?/http_cache",
-    "net/url_request_context/main_media/0x?/http_cache/memory_backend",
-    "net/url_request_context/main_media/0x?/http_cache/simple_backend",
-    "net/url_request_context/main_media/0x?/http_network_session",
-    "net/url_request_context/proxy",
-    "net/url_request_context/proxy/0x?",
-    "net/url_request_context/proxy/0x?/cookie_monster",
-    "net/url_request_context/proxy/0x?/cookie_monster/cookies",
-    "net/url_request_context/proxy/0x?/cookie_monster/tasks_pending_global",
-    "net/url_request_context/proxy/0x?/cookie_monster/tasks_pending_for_key",
-    "net/url_request_context/proxy/0x?/http_cache",
-    "net/url_request_context/proxy/0x?/http_cache/memory_backend",
-    "net/url_request_context/proxy/0x?/http_cache/simple_backend",
-    "net/url_request_context/proxy/0x?/http_network_session",
-    "net/url_request_context/safe_browsing",
-    "net/url_request_context/safe_browsing/0x?",
-    "net/url_request_context/safe_browsing/0x?/cookie_monster",
-    "net/url_request_context/safe_browsing/0x?/cookie_monster/cookies",
-    "net/url_request_context/safe_browsing/0x?/cookie_monster/"
-    "tasks_pending_global",
-    "net/url_request_context/safe_browsing/0x?/cookie_monster/"
-    "tasks_pending_for_key",
-    "net/url_request_context/safe_browsing/0x?/http_cache",
-    "net/url_request_context/safe_browsing/0x?/http_cache/memory_backend",
-    "net/url_request_context/safe_browsing/0x?/http_cache/simple_backend",
-    "net/url_request_context/safe_browsing/0x?/http_network_session",
-    "net/url_request_context/system",
-    "net/url_request_context/system/0x?",
-    "net/url_request_context/system/0x?/cookie_monster",
-    "net/url_request_context/system/0x?/cookie_monster/cookies",
-    "net/url_request_context/system/0x?/cookie_monster/tasks_pending_global",
-    "net/url_request_context/system/0x?/cookie_monster/tasks_pending_for_key",
-    "net/url_request_context/system/0x?/http_cache",
-    "net/url_request_context/system/0x?/http_cache/memory_backend",
-    "net/url_request_context/system/0x?/http_cache/simple_backend",
-    "net/url_request_context/system/0x?/http_network_session",
-    "net/url_request_context/unknown",
-    "net/url_request_context/unknown/0x?",
-    "net/url_request_context/unknown/0x?/cookie_monster",
-    "net/url_request_context/unknown/0x?/cookie_monster/cookies",
-    "net/url_request_context/unknown/0x?/cookie_monster/tasks_pending_global",
-    "net/url_request_context/unknown/0x?/cookie_monster/tasks_pending_for_key",
-    "net/url_request_context/unknown/0x?/http_cache",
-    "net/url_request_context/unknown/0x?/http_cache/memory_backend",
-    "net/url_request_context/unknown/0x?/http_cache/simple_backend",
-    "net/url_request_context/unknown/0x?/http_network_session",
-    "omnibox/autocomplete_controller/0x?",
-    "omnibox/in_memory_url_index/0x?",
-    "web_cache/Image_resources",
-    "web_cache/CSS stylesheet_resources",
-    "web_cache/Script_resources",
-    "web_cache/XSL stylesheet_resources",
-    "web_cache/Font_resources",
-    "web_cache/Other_resources",
-    "partition_alloc/allocated_objects",
-    "partition_alloc/partitions",
-    "partition_alloc/partitions/array_buffer",
-    "partition_alloc/partitions/buffer",
-    "partition_alloc/partitions/fast_malloc",
-    "partition_alloc/partitions/layout",
-    "skia/sk_glyph_cache",
-    "skia/sk_resource_cache",
-    "sqlite",
-    "ui/resource_manager_0x?/default_resource/0x?",
-    "ui/resource_manager_0x?/tinted_resource",
-    "v8/isolate_0x?/contexts/detached_context",
-    "v8/isolate_0x?/contexts/native_context",
-    "v8/isolate_0x?/heap_spaces",
-    "v8/isolate_0x?/heap_spaces/code_space",
-    "v8/isolate_0x?/heap_spaces/large_object_space",
-    "v8/isolate_0x?/heap_spaces/map_space",
-    "v8/isolate_0x?/heap_spaces/new_space",
-    "v8/isolate_0x?/heap_spaces/old_space",
-    "v8/isolate_0x?/heap_spaces/read_only_space",
-    "v8/isolate_0x?/malloc",
-    "v8/isolate_0x?/zapped_for_debug",
-    "site_storage/blob_storage/0x?",
-    "site_storage/index_db/db_0x?",
-    "site_storage/index_db/memenv_0x?",
-    "site_storage/localstorage/0x?/cache_size",
-    "site_storage/localstorage/0x?/leveldb",
-    "site_storage/session_storage/0x?",
-    "site_storage/session_storage/0x?/cache_size",
-    "sync/0x?/kernel",
-    "sync/0x?/store",
-    "sync/0x?/model_type/APP",
-    "sync/0x?/model_type/APP_LIST",
-    "sync/0x?/model_type/APP_NOTIFICATION",
-    "sync/0x?/model_type/APP_SETTING",
-    "sync/0x?/model_type/ARC_PACKAGE",
-    "sync/0x?/model_type/ARTICLE",
-    "sync/0x?/model_type/AUTOFILL",
-    "sync/0x?/model_type/AUTOFILL_PROFILE",
-    "sync/0x?/model_type/AUTOFILL_WALLET",
-    "sync/0x?/model_type/BOOKMARK",
-    "sync/0x?/model_type/DEVICE_INFO",
-    "sync/0x?/model_type/DICTIONARY",
-    "sync/0x?/model_type/EXPERIMENTS",
-    "sync/0x?/model_type/EXTENSION",
-    "sync/0x?/model_type/EXTENSION_SETTING",
-    "sync/0x?/model_type/FAVICON_IMAGE",
-    "sync/0x?/model_type/FAVICON_TRACKING",
-    "sync/0x?/model_type/HISTORY_DELETE_DIRECTIVE",
-    "sync/0x?/model_type/MANAGED_USER",
-    "sync/0x?/model_type/MANAGED_USER_SETTING",
-    "sync/0x?/model_type/MANAGED_USER_SHARED_SETTING",
-    "sync/0x?/model_type/MANAGED_USER_WHITELIST",
-    "sync/0x?/model_type/NIGORI",
-    "sync/0x?/model_type/PASSWORD",
-    "sync/0x?/model_type/PREFERENCE",
-    "sync/0x?/model_type/PRINTER",
-    "sync/0x?/model_type/PRIORITY_PREFERENCE",
-    "sync/0x?/model_type/READING_LIST",
-    "sync/0x?/model_type/SEARCH_ENGINE",
-    "sync/0x?/model_type/SESSION",
-    "sync/0x?/model_type/SYNCED_NOTIFICATION",
-    "sync/0x?/model_type/SYNCED_NOTIFICATION_APP_INFO",
-    "sync/0x?/model_type/THEME",
-    "sync/0x?/model_type/TYPED_URL",
-    "sync/0x?/model_type/USER_EVENT",
-    "sync/0x?/model_type/WALLET_METADATA",
-    "sync/0x?/model_type/WIFI_CREDENTIAL",
-    "tab_restore/service_helper_0x?/entries",
-    "tab_restore/service_helper_0x?/entries/tab_0x?",
-    "tab_restore/service_helper_0x?/entries/window_0x?",
-    "tracing/heap_profiler_blink_gc/AllocationRegister",
-    "tracing/heap_profiler_malloc/AllocationRegister",
-    "tracing/heap_profiler_partition_alloc/AllocationRegister",
-    nullptr  // End of list marker.
-};
-
-const char* const* g_dump_provider_whitelist = kDumpProviderWhitelist;
-const char* const* g_allocator_dump_name_whitelist =
-    kAllocatorDumpNameWhitelist;
-
-bool IsMemoryDumpProviderInList(const char* mdp_name, const char* const* list) {
-  for (size_t i = 0; list[i] != nullptr; ++i) {
-    if (strcmp(mdp_name, list[i]) == 0)
-      return true;
-  }
-  return false;
-}
-
-}  // namespace
-
-bool IsMemoryDumpProviderWhitelisted(const char* mdp_name) {
-  return IsMemoryDumpProviderInList(mdp_name, g_dump_provider_whitelist);
-}
-
-bool IsMemoryAllocatorDumpNameWhitelisted(const std::string& name) {
-  // Global dumps are explicitly whitelisted for background use.
-  if (base::StartsWith(name, "global/", CompareCase::SENSITIVE)) {
-    for (size_t i = strlen("global/"); i < name.size(); i++)
-      if (!base::IsHexDigit(name[i]))
-        return false;
-    return true;
-  }
-
-  if (base::StartsWith(name, "shared_memory/", CompareCase::SENSITIVE)) {
-    for (size_t i = strlen("shared_memory/"); i < name.size(); i++)
-      if (!base::IsHexDigit(name[i]))
-        return false;
-    return true;
-  }
-
-  // Remove special characters, numbers (including hexadecimal which are marked
-  // by '0x') from the given string.
-  const size_t length = name.size();
-  std::string stripped_str;
-  stripped_str.reserve(length);
-  bool parsing_hex = false;
-  for (size_t i = 0; i < length; ++i) {
-    if (parsing_hex && isxdigit(name[i]))
-      continue;
-    parsing_hex = false;
-    if (i + 1 < length && name[i] == '0' && name[i + 1] == 'x') {
-      parsing_hex = true;
-      stripped_str.append("0x?");
-      ++i;
-    } else {
-      stripped_str.push_back(name[i]);
-    }
-  }
-
-  for (size_t i = 0; g_allocator_dump_name_whitelist[i] != nullptr; ++i) {
-    if (stripped_str == g_allocator_dump_name_whitelist[i]) {
-      return true;
-    }
-  }
-  return false;
-}
-
-void SetDumpProviderWhitelistForTesting(const char* const* list) {
-  g_dump_provider_whitelist = list;
-}
-
-void SetAllocatorDumpNameWhitelistForTesting(const char* const* list) {
-  g_allocator_dump_name_whitelist = list;
-}
-
-}  // namespace trace_event
-}  // namespace base
diff --git a/base/trace_event/memory_infra_background_whitelist.h b/base/trace_event/memory_infra_background_whitelist.h
deleted file mode 100644
index b8d704a..0000000
--- a/base/trace_event/memory_infra_background_whitelist.h
+++ /dev/null
@@ -1,33 +0,0 @@
-// Copyright 2016 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_TRACE_EVENT_MEMORY_INFRA_BACKGROUND_WHITELIST_H_
-#define BASE_TRACE_EVENT_MEMORY_INFRA_BACKGROUND_WHITELIST_H_
-
-// This file contains the whitelists for background mode to limit the tracing
-// overhead and remove sensitive information from traces.
-
-#include <string>
-
-#include "base/base_export.h"
-
-namespace base {
-namespace trace_event {
-
-// Checks if the given |mdp_name| is in the whitelist.
-bool BASE_EXPORT IsMemoryDumpProviderWhitelisted(const char* mdp_name);
-
-// Checks if the given |name| matches any of the whitelisted patterns.
-bool BASE_EXPORT IsMemoryAllocatorDumpNameWhitelisted(const std::string& name);
-
-// The whitelist is replaced with the given list for tests. The last element of
-// the list must be nullptr.
-void BASE_EXPORT SetDumpProviderWhitelistForTesting(const char* const* list);
-void BASE_EXPORT
-SetAllocatorDumpNameWhitelistForTesting(const char* const* list);
-
-}  // namespace trace_event
-}  // namespace base
-
-#endif  // BASE_TRACE_EVENT_MEMORY_INFRA_BACKGROUND_WHITELIST_H_
diff --git a/base/trace_event/memory_peak_detector.cc b/base/trace_event/memory_peak_detector.cc
deleted file mode 100644
index 5f2ea91..0000000
--- a/base/trace_event/memory_peak_detector.cc
+++ /dev/null
@@ -1,288 +0,0 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/trace_event/memory_peak_detector.h"
-
-#include <algorithm>
-
-#include "base/bind.h"
-#include "base/logging.h"
-#include "base/sys_info.h"
-#include "base/threading/sequenced_task_runner_handle.h"
-#include "base/time/time.h"
-#include "base/trace_event/memory_dump_manager.h"
-#include "base/trace_event/memory_dump_provider_info.h"
-#include "base/trace_event/trace_event.h"
-#include "build_config.h"
-
-namespace base {
-namespace trace_event {
-
-// static
-MemoryPeakDetector* MemoryPeakDetector::GetInstance() {
-  static MemoryPeakDetector* instance = new MemoryPeakDetector();
-  return instance;
-}
-
-MemoryPeakDetector::MemoryPeakDetector()
-    : generation_(0),
-      state_(NOT_INITIALIZED),
-      poll_tasks_count_for_testing_(0) {}
-
-MemoryPeakDetector::~MemoryPeakDetector() {
-  // This is hit only in tests, in which case the test is expected to TearDown()
-  // cleanly and not leave the peak detector running.
-  DCHECK_EQ(NOT_INITIALIZED, state_);
-}
-
-void MemoryPeakDetector::Setup(
-    const GetDumpProvidersFunction& get_dump_providers_function,
-    const scoped_refptr<SequencedTaskRunner>& task_runner,
-    const OnPeakDetectedCallback& on_peak_detected_callback) {
-  DCHECK(!get_dump_providers_function.is_null());
-  DCHECK(task_runner);
-  DCHECK(!on_peak_detected_callback.is_null());
-  DCHECK(state_ == NOT_INITIALIZED || state_ == DISABLED);
-  DCHECK(dump_providers_.empty());
-  get_dump_providers_function_ = get_dump_providers_function;
-  task_runner_ = task_runner;
-  on_peak_detected_callback_ = on_peak_detected_callback;
-  state_ = DISABLED;
-  config_ = {};
-  ResetPollHistory();
-
-  static_threshold_bytes_ = 0;
-#if !defined(OS_NACL)
-  // Set threshold to 1% of total system memory.
-  static_threshold_bytes_ =
-      static_cast<uint64_t>(SysInfo::AmountOfPhysicalMemory()) / 100;
-#endif
-  // Fallback, mostly for test environments where AmountOfPhysicalMemory() is
-  // broken.
-  static_threshold_bytes_ =
-      std::max(static_threshold_bytes_, static_cast<uint64_t>(5 * 1024 * 1024));
-}
-
-void MemoryPeakDetector::TearDown() {
-  if (task_runner_) {
-    task_runner_->PostTask(
-        FROM_HERE,
-        BindOnce(&MemoryPeakDetector::TearDownInternal, Unretained(this)));
-  }
-  task_runner_ = nullptr;
-}
-
-void MemoryPeakDetector::Start(MemoryPeakDetector::Config config) {
-  if (!config.polling_interval_ms) {
-    NOTREACHED();
-    return;
-  }
-  task_runner_->PostTask(FROM_HERE, BindOnce(&MemoryPeakDetector::StartInternal,
-                                             Unretained(this), config));
-}
-
-void MemoryPeakDetector::Stop() {
-  task_runner_->PostTask(
-      FROM_HERE, BindOnce(&MemoryPeakDetector::StopInternal, Unretained(this)));
-}
-
-void MemoryPeakDetector::Throttle() {
-  if (!task_runner_)
-    return;  // Can be called before Setup().
-  task_runner_->PostTask(
-      FROM_HERE, BindOnce(&MemoryPeakDetector::ResetPollHistory,
-                          Unretained(this), true /* keep_last_sample */));
-}
-
-void MemoryPeakDetector::NotifyMemoryDumpProvidersChanged() {
-  if (!task_runner_)
-    return;  // Can be called before Setup().
-  task_runner_->PostTask(
-      FROM_HERE,
-      BindOnce(&MemoryPeakDetector::ReloadDumpProvidersAndStartPollingIfNeeded,
-               Unretained(this)));
-}
-
-void MemoryPeakDetector::StartInternal(MemoryPeakDetector::Config config) {
-  DCHECK_EQ(DISABLED, state_);
-  state_ = ENABLED;
-  config_ = config;
-  ResetPollHistory();
-
-  // If there are any dump providers available,
-  // NotifyMemoryDumpProvidersChanged will fetch them and start the polling.
-  // Otherwise this will remain in the ENABLED state and the actual polling
-  // will start on the next call to
-  // ReloadDumpProvidersAndStartPollingIfNeeded().
-  // Depending on the sandbox model, it is possible that no polling-capable
-  // dump providers will be ever available.
-  ReloadDumpProvidersAndStartPollingIfNeeded();
-}
-
-void MemoryPeakDetector::StopInternal() {
-  DCHECK_NE(NOT_INITIALIZED, state_);
-  state_ = DISABLED;
-  ++generation_;
-  for (const scoped_refptr<MemoryDumpProviderInfo>& mdp_info : dump_providers_)
-    mdp_info->dump_provider->SuspendFastMemoryPolling();
-  dump_providers_.clear();
-}
-
-void MemoryPeakDetector::TearDownInternal() {
-  StopInternal();
-  get_dump_providers_function_.Reset();
-  on_peak_detected_callback_.Reset();
-  state_ = NOT_INITIALIZED;
-}
-
-void MemoryPeakDetector::ReloadDumpProvidersAndStartPollingIfNeeded() {
-  if (state_ == DISABLED || state_ == NOT_INITIALIZED)
-    return;  // Start() will re-fetch the MDP list later.
-
-  DCHECK((state_ == RUNNING && !dump_providers_.empty()) ||
-         (state_ == ENABLED && dump_providers_.empty()));
-
-  dump_providers_.clear();
-
-  // This is really MemoryDumpManager::GetDumpProvidersForPolling, % testing.
-  get_dump_providers_function_.Run(&dump_providers_);
-
-  if (state_ == ENABLED && !dump_providers_.empty()) {
-    // It's now time to start polling for realz.
-    state_ = RUNNING;
-    task_runner_->PostTask(
-        FROM_HERE, BindOnce(&MemoryPeakDetector::PollMemoryAndDetectPeak,
-                            Unretained(this), ++generation_));
-  } else if (state_ == RUNNING && dump_providers_.empty()) {
-    // Will cause the next PollMemoryAndDetectPeak() task to early return.
-    state_ = ENABLED;
-    ++generation_;
-  }
-}
-
-void MemoryPeakDetector::PollMemoryAndDetectPeak(uint32_t expected_generation) {
-  if (state_ != RUNNING || generation_ != expected_generation)
-    return;
-
-  // We should never end up in a situation where state_ == RUNNING but all dump
-  // providers are gone.
-  DCHECK(!dump_providers_.empty());
-
-  poll_tasks_count_for_testing_++;
-  uint64_t polled_mem_bytes = 0;
-  for (const scoped_refptr<MemoryDumpProviderInfo>& mdp_info :
-       dump_providers_) {
-    DCHECK(mdp_info->options.is_fast_polling_supported);
-    uint64_t value = 0;
-    mdp_info->dump_provider->PollFastMemoryTotal(&value);
-    polled_mem_bytes += value;
-  }
-  if (config_.enable_verbose_poll_tracing) {
-    TRACE_COUNTER1(MemoryDumpManager::kTraceCategory, "PolledMemoryMB",
-                   polled_mem_bytes / 1024 / 1024);
-  }
-
-  // Peak detection logic. Design doc: https://goo.gl/0kOU4A .
-  bool is_peak = false;
-  if (skip_polls_ > 0) {
-    skip_polls_--;
-  } else if (last_dump_memory_total_ == 0) {
-    last_dump_memory_total_ = polled_mem_bytes;
-  } else if (polled_mem_bytes > 0) {
-    int64_t diff_from_last_dump = polled_mem_bytes - last_dump_memory_total_;
-
-    DCHECK_GT(static_threshold_bytes_, 0u);
-    is_peak =
-        diff_from_last_dump > static_cast<int64_t>(static_threshold_bytes_);
-
-    if (!is_peak)
-      is_peak = DetectPeakUsingSlidingWindowStddev(polled_mem_bytes);
-  }
-
-  DCHECK_GT(config_.polling_interval_ms, 0u);
-  SequencedTaskRunnerHandle::Get()->PostDelayedTask(
-      FROM_HERE,
-      BindOnce(&MemoryPeakDetector::PollMemoryAndDetectPeak, Unretained(this),
-               expected_generation),
-      TimeDelta::FromMilliseconds(config_.polling_interval_ms));
-
-  if (!is_peak)
-    return;
-  TRACE_EVENT_INSTANT1(MemoryDumpManager::kTraceCategory,
-                       "Peak memory detected", TRACE_EVENT_SCOPE_PROCESS,
-                       "PolledMemoryMB", polled_mem_bytes / 1024 / 1024);
-  ResetPollHistory(true /* keep_last_sample */);
-  last_dump_memory_total_ = polled_mem_bytes;
-  on_peak_detected_callback_.Run();
-}
-
-bool MemoryPeakDetector::DetectPeakUsingSlidingWindowStddev(
-    uint64_t polled_mem_bytes) {
-  DCHECK(polled_mem_bytes);
-  samples_bytes_[samples_index_] = polled_mem_bytes;
-  samples_index_ = (samples_index_ + 1) % kSlidingWindowNumSamples;
-  float mean = 0;
-  for (uint32_t i = 0; i < kSlidingWindowNumSamples; ++i) {
-    if (samples_bytes_[i] == 0)
-      return false;  // Not enough samples to detect peaks.
-    mean += samples_bytes_[i];
-  }
-  mean /= kSlidingWindowNumSamples;
-  float variance = 0;
-  for (uint32_t i = 0; i < kSlidingWindowNumSamples; ++i) {
-    const float deviation = samples_bytes_[i] - mean;
-    variance += deviation * deviation;
-  }
-  variance /= kSlidingWindowNumSamples;
-
-  // If stddev is less than 0.2% then we consider that the process is inactive.
-  if (variance < (mean / 500) * (mean / 500))
-    return false;
-
-  // (mean + 3.69 * stddev) corresponds to a value that is higher than current
-  // sample with 99.99% probability.
-  const float cur_sample_deviation = polled_mem_bytes - mean;
-  return cur_sample_deviation * cur_sample_deviation > (3.69 * 3.69 * variance);
-}
-
-void MemoryPeakDetector::ResetPollHistory(bool keep_last_sample) {
-  // TODO(primiano,ssid): this logic should probably be revisited. In the case
-  // of Android, the browser process sees the total of all processes memory in
-  // the same peak detector instance. Perhaps the best thing to do here is to
-  // keep the window of samples around and just bump the skip_polls_.
-  last_dump_memory_total_ = 0;
-  if (keep_last_sample) {
-    const uint32_t prev_index =
-        samples_index_ > 0 ? samples_index_ - 1 : kSlidingWindowNumSamples - 1;
-    last_dump_memory_total_ = samples_bytes_[prev_index];
-  }
-  memset(samples_bytes_, 0, sizeof(samples_bytes_));
-  samples_index_ = 0;
-  skip_polls_ = 0;
-  if (config_.polling_interval_ms > 0) {
-    skip_polls_ =
-        (config_.min_time_between_peaks_ms + config_.polling_interval_ms - 1) /
-        config_.polling_interval_ms;
-  }
-}
-
-void MemoryPeakDetector::SetStaticThresholdForTesting(
-    uint64_t static_threshold_bytes) {
-  DCHECK_EQ(DISABLED, state_);
-  static_threshold_bytes_ = static_threshold_bytes;
-}
-
-MemoryPeakDetector::MemoryPeakDetector::Config::Config()
-    : Config(0, 0, false) {}
-
-MemoryPeakDetector::MemoryPeakDetector::Config::Config(
-    uint32_t polling_interval_ms,
-    uint32_t min_time_between_peaks_ms,
-    bool enable_verbose_poll_tracing)
-    : polling_interval_ms(polling_interval_ms),
-      min_time_between_peaks_ms(min_time_between_peaks_ms),
-      enable_verbose_poll_tracing(enable_verbose_poll_tracing) {}
-
-}  // namespace trace_event
-}  // namespace base
diff --git a/base/trace_event/memory_peak_detector.h b/base/trace_event/memory_peak_detector.h
deleted file mode 100644
index bbe205b..0000000
--- a/base/trace_event/memory_peak_detector.h
+++ /dev/null
@@ -1,184 +0,0 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_TRACE_EVENT_MEMORY_PEAK_DETECTOR_H_
-#define BASE_TRACE_EVENT_MEMORY_PEAK_DETECTOR_H_
-
-#include <stdint.h>
-
-#include <memory>
-#include <vector>
-
-#include "base/base_export.h"
-#include "base/callback.h"
-#include "base/macros.h"
-#include "base/memory/ref_counted.h"
-
-namespace base {
-
-class SequencedTaskRunner;
-
-namespace trace_event {
-
-struct MemoryDumpProviderInfo;
-
-// Detects temporally local memory peaks. Peak detection is based on
-// continuously querying memory usage using MemoryDumpprovider(s) that support
-// fast polling (e.g., ProcessMetricsDumpProvider which under the hoods reads
-// /proc/PID/statm on Linux) and using a combination of:
-// - An static threshold (currently 1% of total system memory).
-// - Sliding window stddev analysis.
-// Design doc: https://goo.gl/0kOU4A .
-// This class is NOT thread-safe, the caller has to ensure linearization of
-// the calls to the public methods. In any case, the public methods do NOT have
-// to be called from the |task_runner| on which the polling tasks run.
-class BASE_EXPORT MemoryPeakDetector {
- public:
-  using OnPeakDetectedCallback = RepeatingClosure;
-  using DumpProvidersList = std::vector<scoped_refptr<MemoryDumpProviderInfo>>;
-  using GetDumpProvidersFunction = RepeatingCallback<void(DumpProvidersList*)>;
-
-  enum State {
-    NOT_INITIALIZED = 0,  // Before Setup()
-    DISABLED,             // Before Start() or after Stop().
-    ENABLED,              // After Start() but no dump_providers_ are available.
-    RUNNING  // After Start(). The PollMemoryAndDetectPeak() task is scheduled.
-  };
-
-  // Peak detector configuration, passed to Start().
-  struct BASE_EXPORT Config {
-    Config();
-    Config(uint32_t polling_interval_ms,
-           uint32_t min_time_between_peaks_ms,
-           bool enable_verbose_poll_tracing);
-
-    // The rate at which memory will be polled. Polls will happen on the task
-    // runner passed to Setup().
-    uint32_t polling_interval_ms;
-
-    // Two consecutive peak detection callbacks will happen at least
-    // |min_time_between_peaks_ms| apart from each other.
-    uint32_t min_time_between_peaks_ms;
-
-    // When enabled causes a TRACE_COUNTER event to be injected in the trace
-    // for each poll (if tracing is enabled).
-    bool enable_verbose_poll_tracing;
-  };
-
-  static MemoryPeakDetector* GetInstance();
-
-  // Configures the peak detector, binding the polling tasks on the given
-  // thread. Setup() can be called several times, provided that: (1) Stop()
-  // is called; (2a) the previous task_runner is flushed or (2b) the task_runner
-  // remains the same.
-  // GetDumpProvidersFunction: is the function that will be invoked to get
-  //   an updated list of polling-capable dump providers. This is really just
-  //   MemoryDumpManager::GetDumpProvidersForPolling, but this extra level of
-  //   indirection allows easier testing.
-  // SequencedTaskRunner: the task runner where PollMemoryAndDetectPeak() will
-  //  be periodically called.
-  // OnPeakDetectedCallback: a callback that will be invoked on the
-  //   given task runner when a memory peak is detected.
-  void Setup(const GetDumpProvidersFunction&,
-             const scoped_refptr<SequencedTaskRunner>&,
-             const OnPeakDetectedCallback&);
-
-  // Releases the |task_runner_| and the bound callbacks.
-  void TearDown();
-
-  // This posts a task onto the passed task runner which refreshes the list of
-  // dump providers via the GetDumpProvidersFunction. If at least one dump
-  // provider is available, this starts immediately polling on the task runner.
-  // If not, the detector remains in the ENABLED state and will start polling
-  // automatically (i.e. without requiring another call to Start()) on the
-  // next call to NotifyMemoryDumpProvidersChanged().
-  void Start(Config);
-
-  // Stops the polling on the task runner (if was active at all). This doesn't
-  // wait for the task runner to drain pending tasks, so it is possible that
-  // a polling will happen concurrently (or in the immediate future) with the
-  // Stop() call. It is responsibility of the caller to drain or synchronize
-  // with the task runner.
-  void Stop();
-
-  // If Start()-ed, prevents that a peak callback is triggered before the next
-  // |min_time_between_peaks_ms|. No-op if the peak detector is not enabled.
-  void Throttle();
-
-  // Used by MemoryDumpManager to notify that the list of polling-capable dump
-  // providers has changed. The peak detector will reload the list on the next
-  // polling task. This function can be called before Setup(), in which
-  // case will be just a no-op.
-  void NotifyMemoryDumpProvidersChanged();
-
-  void SetStaticThresholdForTesting(uint64_t static_threshold_bytes);
-
- private:
-  friend class MemoryPeakDetectorTest;
-
-  static constexpr uint32_t kSlidingWindowNumSamples = 50;
-
-  MemoryPeakDetector();
-  ~MemoryPeakDetector();
-
-  // All these methods are always called on the |task_runner_|.
-  void StartInternal(Config);
-  void StopInternal();
-  void TearDownInternal();
-  void ReloadDumpProvidersAndStartPollingIfNeeded();
-  void PollMemoryAndDetectPeak(uint32_t expected_generation);
-  bool DetectPeakUsingSlidingWindowStddev(uint64_t last_sample_bytes);
-  void ResetPollHistory(bool keep_last_sample = false);
-
-  // It is safe to call these testing methods only on the |task_runner_|.
-  State state_for_testing() const { return state_; }
-  uint32_t poll_tasks_count_for_testing() const {
-    return poll_tasks_count_for_testing_;
-  }
-
-  // The task runner where all the internal calls are posted onto. This field
-  // must be NOT be accessed by the tasks posted on the |task_runner_| because
-  // there might still be outstanding tasks on the |task_runner_| while this
-  // refptr is reset. This can only be safely accessed by the public methods
-  // above, which the client of this class is supposed to call sequentially.
-  scoped_refptr<SequencedTaskRunner> task_runner_;
-
-  // After the Setup() call, the fields below, must be accessed only from
-  // the |task_runner_|.
-
-  // Bound function to get an updated list of polling-capable dump providers.
-  GetDumpProvidersFunction get_dump_providers_function_;
-
-  // The callback to invoke when peaks are detected.
-  OnPeakDetectedCallback on_peak_detected_callback_;
-
-  // List of polling-aware dump providers to invoke upon each poll.
-  DumpProvidersList dump_providers_;
-
-  // The generation is incremented every time the |state_| is changed and causes
-  // PollMemoryAndDetectPeak() to early out if the posted task doesn't match the
-  // most recent |generation_|. This allows to drop on the floor outstanding
-  // PostDelayedTask that refer to an old sequence that was later Stop()-ed or
-  // disabled because of NotifyMemoryDumpProvidersChanged().
-  uint32_t generation_;
-
-  State state_;
-
-  // Config passed to Start(), only valid when |state_| = {ENABLED, RUNNING}.
-  Config config_;
-
-  uint64_t static_threshold_bytes_;
-  uint32_t skip_polls_;
-  uint64_t last_dump_memory_total_;
-  uint64_t samples_bytes_[kSlidingWindowNumSamples];
-  uint32_t samples_index_;
-  uint32_t poll_tasks_count_for_testing_;
-
-  DISALLOW_COPY_AND_ASSIGN(MemoryPeakDetector);
-};
-
-}  // namespace trace_event
-}  // namespace base
-
-#endif  // BASE_TRACE_EVENT_MEMORY_PEAK_DETECTOR_H_
diff --git a/base/trace_event/memory_usage_estimator.cc b/base/trace_event/memory_usage_estimator.cc
deleted file mode 100644
index c769d5b..0000000
--- a/base/trace_event/memory_usage_estimator.cc
+++ /dev/null
@@ -1,14 +0,0 @@
-// Copyright 2016 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/trace_event/memory_usage_estimator.h"
-
-namespace base {
-namespace trace_event {
-
-template size_t EstimateMemoryUsage(const std::string&);
-template size_t EstimateMemoryUsage(const string16&);
-
-}  // namespace trace_event
-}  // namespace base
diff --git a/base/trace_event/memory_usage_estimator.h b/base/trace_event/memory_usage_estimator.h
deleted file mode 100644
index 214c64a..0000000
--- a/base/trace_event/memory_usage_estimator.h
+++ /dev/null
@@ -1,654 +0,0 @@
-// Copyright 2016 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_TRACE_EVENT_MEMORY_USAGE_ESTIMATOR_H_
-#define BASE_TRACE_EVENT_MEMORY_USAGE_ESTIMATOR_H_
-
-#include <stdint.h>
-
-#include <array>
-#include <deque>
-#include <list>
-#include <map>
-#include <memory>
-#include <queue>
-#include <set>
-#include <stack>
-#include <string>
-#include <type_traits>
-#include <unordered_map>
-#include <unordered_set>
-#include <vector>
-
-#include "base/base_export.h"
-#include "base/containers/circular_deque.h"
-#include "base/containers/flat_map.h"
-#include "base/containers/flat_set.h"
-#include "base/containers/linked_list.h"
-#include "base/containers/mru_cache.h"
-#include "base/containers/queue.h"
-#include "base/stl_util.h"
-#include "base/strings/string16.h"
-#include "base/template_util.h"
-
-// Composable memory usage estimators.
-//
-// This file defines set of EstimateMemoryUsage(object) functions that return
-// approximate memory usage of their argument.
-//
-// The ultimate goal is to make memory usage estimation for a class simply a
-// matter of aggregating EstimateMemoryUsage() results over all fields.
-//
-// That is achieved via composability: if EstimateMemoryUsage() is defined
-// for T then EstimateMemoryUsage() is also defined for any combination of
-// containers holding T (e.g. std::map<int, std::vector<T>>).
-//
-// There are two ways of defining EstimateMemoryUsage() for a type:
-//
-// 1. As a global function 'size_t EstimateMemoryUsage(T)' in
-//    in base::trace_event namespace.
-//
-// 2. As 'size_t T::EstimateMemoryUsage() const' method. In this case
-//    EstimateMemoryUsage(T) function in base::trace_event namespace is
-//    provided automatically.
-//
-// Here is an example implementation:
-//
-// size_t foo::bar::MyClass::EstimateMemoryUsage() const {
-//   return base::trace_event::EstimateMemoryUsage(name_) +
-//          base::trace_event::EstimateMemoryUsage(id_) +
-//          base::trace_event::EstimateMemoryUsage(items_);
-// }
-//
-// The approach is simple: first call EstimateMemoryUsage() on all members,
-// then recursively fix compilation errors that are caused by types not
-// implementing EstimateMemoryUsage().
-
-namespace base {
-namespace trace_event {
-
-// Declarations
-
-// If T declares 'EstimateMemoryUsage() const' member function, then
-// global function EstimateMemoryUsage(T) is available, and just calls
-// the member function.
-template <class T>
-auto EstimateMemoryUsage(const T& object)
-    -> decltype(object.EstimateMemoryUsage());
-
-// String
-
-template <class C, class T, class A>
-size_t EstimateMemoryUsage(const std::basic_string<C, T, A>& string);
-
-// Arrays
-
-template <class T, size_t N>
-size_t EstimateMemoryUsage(const std::array<T, N>& array);
-
-template <class T, size_t N>
-size_t EstimateMemoryUsage(T (&array)[N]);
-
-template <class T>
-size_t EstimateMemoryUsage(const T* array, size_t array_length);
-
-// std::unique_ptr
-
-template <class T, class D>
-size_t EstimateMemoryUsage(const std::unique_ptr<T, D>& ptr);
-
-template <class T, class D>
-size_t EstimateMemoryUsage(const std::unique_ptr<T[], D>& array,
-                           size_t array_length);
-
-// std::shared_ptr
-
-template <class T>
-size_t EstimateMemoryUsage(const std::shared_ptr<T>& ptr);
-
-// Containers
-
-template <class F, class S>
-size_t EstimateMemoryUsage(const std::pair<F, S>& pair);
-
-template <class T, class A>
-size_t EstimateMemoryUsage(const std::vector<T, A>& vector);
-
-template <class T, class A>
-size_t EstimateMemoryUsage(const std::list<T, A>& list);
-
-template <class T>
-size_t EstimateMemoryUsage(const base::LinkedList<T>& list);
-
-template <class T, class C, class A>
-size_t EstimateMemoryUsage(const std::set<T, C, A>& set);
-
-template <class T, class C, class A>
-size_t EstimateMemoryUsage(const std::multiset<T, C, A>& set);
-
-template <class K, class V, class C, class A>
-size_t EstimateMemoryUsage(const std::map<K, V, C, A>& map);
-
-template <class K, class V, class C, class A>
-size_t EstimateMemoryUsage(const std::multimap<K, V, C, A>& map);
-
-template <class T, class H, class KE, class A>
-size_t EstimateMemoryUsage(const std::unordered_set<T, H, KE, A>& set);
-
-template <class T, class H, class KE, class A>
-size_t EstimateMemoryUsage(const std::unordered_multiset<T, H, KE, A>& set);
-
-template <class K, class V, class H, class KE, class A>
-size_t EstimateMemoryUsage(const std::unordered_map<K, V, H, KE, A>& map);
-
-template <class K, class V, class H, class KE, class A>
-size_t EstimateMemoryUsage(const std::unordered_multimap<K, V, H, KE, A>& map);
-
-template <class T, class A>
-size_t EstimateMemoryUsage(const std::deque<T, A>& deque);
-
-template <class T, class C>
-size_t EstimateMemoryUsage(const std::queue<T, C>& queue);
-
-template <class T, class C>
-size_t EstimateMemoryUsage(const std::priority_queue<T, C>& queue);
-
-template <class T, class C>
-size_t EstimateMemoryUsage(const std::stack<T, C>& stack);
-
-template <class T>
-size_t EstimateMemoryUsage(const base::circular_deque<T>& deque);
-
-template <class T, class C>
-size_t EstimateMemoryUsage(const base::flat_set<T, C>& set);
-
-template <class K, class V, class C>
-size_t EstimateMemoryUsage(const base::flat_map<K, V, C>& map);
-
-template <class Key,
-          class Payload,
-          class HashOrComp,
-          template <typename, typename, typename> class Map>
-size_t EstimateMemoryUsage(const MRUCacheBase<Key, Payload, HashOrComp, Map>&);
-
-// TODO(dskiba):
-//   std::forward_list
-
-// Definitions
-
-namespace internal {
-
-// HasEMU<T>::value is true iff EstimateMemoryUsage(T) is available.
-// (This is the default version, which is false.)
-template <class T, class X = void>
-struct HasEMU : std::false_type {};
-
-// This HasEMU specialization is only picked up if there exists function
-// EstimateMemoryUsage(const T&) that returns size_t. Simpler ways to
-// achieve this don't work on MSVC.
-template <class T>
-struct HasEMU<
-    T,
-    typename std::enable_if<std::is_same<
-        size_t,
-        decltype(EstimateMemoryUsage(std::declval<const T&>()))>::value>::type>
-    : std::true_type {};
-
-// EMUCaller<T> does three things:
-// 1. Defines Call() method that calls EstimateMemoryUsage(T) if it's
-//    available.
-// 2. If EstimateMemoryUsage(T) is not available, but T has trivial dtor
-//    (i.e. it's POD, integer, pointer, enum, etc.) then it defines Call()
-//    method that returns 0. This is useful for containers, which allocate
-//    memory regardless of T (also for cases like std::map<int, MyClass>).
-// 3. Finally, if EstimateMemoryUsage(T) is not available, then it triggers
-//    a static_assert with a helpful message. That cuts numbers of errors
-//    considerably - if you just call EstimateMemoryUsage(T) but it's not
-//    available for T, then compiler will helpfully list *all* possible
-//    variants of it, with an explanation for each.
-template <class T, class X = void>
-struct EMUCaller {
-  // std::is_same<> below makes static_assert depend on T, in order to
-  // prevent it from asserting regardless instantiation.
-  static_assert(std::is_same<T, std::false_type>::value,
-                "Neither global function 'size_t EstimateMemoryUsage(T)' "
-                "nor member function 'size_t T::EstimateMemoryUsage() const' "
-                "is defined for the type.");
-
-  static size_t Call(const T&) { return 0; }
-};
-
-template <class T>
-struct EMUCaller<T, typename std::enable_if<HasEMU<T>::value>::type> {
-  static size_t Call(const T& value) { return EstimateMemoryUsage(value); }
-};
-
-template <template <class...> class Container, class I, class = void>
-struct IsComplexIteratorForContainer : std::false_type {};
-
-template <template <class...> class Container, class I>
-struct IsComplexIteratorForContainer<
-    Container,
-    I,
-    std::enable_if_t<!std::is_pointer<I>::value &&
-                     base::internal::is_iterator<I>::value>> {
-  using value_type = typename std::iterator_traits<I>::value_type;
-  using container_type = Container<value_type>;
-
-  // We use enum instead of static constexpr bool, beause we don't have inline
-  // variables until c++17.
-  //
-  // The downside is - value is not of type bool.
-  enum : bool {
-    value =
-        std::is_same<typename container_type::iterator, I>::value ||
-        std::is_same<typename container_type::const_iterator, I>::value ||
-        std::is_same<typename container_type::reverse_iterator, I>::value ||
-        std::is_same<typename container_type::const_reverse_iterator, I>::value,
-  };
-};
-
-template <class I, template <class...> class... Containers>
-constexpr bool OneOfContainersComplexIterators() {
-  // We are forced to create a temporary variable to workaround a compilation
-  // error in msvs.
-  const bool all_tests[] = {
-      IsComplexIteratorForContainer<Containers, I>::value...};
-  for (bool test : all_tests)
-    if (test)
-      return true;
-  return false;
-}
-
-// std::array has an extra required template argument. We curry it.
-template <class T>
-using array_test_helper = std::array<T, 1>;
-
-template <class I>
-constexpr bool IsStandardContainerComplexIterator() {
-  // TODO(dyaroshev): deal with maps iterators if there is a need.
-  // It requires to parse pairs into keys and values.
-  // TODO(dyaroshev): deal with unordered containers: they do not have reverse
-  // iterators.
-  return OneOfContainersComplexIterators<
-      I, array_test_helper, std::vector, std::deque,
-      /*std::forward_list,*/ std::list, std::set, std::multiset>();
-}
-
-// Work around MSVS bug. For some reason constexpr function doesn't work.
-// However variable template does.
-template <typename T>
-constexpr bool IsKnownNonAllocatingType_v =
-    std::is_trivially_destructible<T>::value ||
-    IsStandardContainerComplexIterator<T>();
-
-template <class T>
-struct EMUCaller<
-    T,
-    std::enable_if_t<!HasEMU<T>::value && IsKnownNonAllocatingType_v<T>>> {
-  static size_t Call(const T& value) { return 0; }
-};
-
-}  // namespace internal
-
-// Proxy that deducts T and calls EMUCaller<T>.
-// To be used by EstimateMemoryUsage() implementations for containers.
-template <class T>
-size_t EstimateItemMemoryUsage(const T& value) {
-  return internal::EMUCaller<T>::Call(value);
-}
-
-template <class I>
-size_t EstimateIterableMemoryUsage(const I& iterable) {
-  size_t memory_usage = 0;
-  for (const auto& item : iterable) {
-    memory_usage += EstimateItemMemoryUsage(item);
-  }
-  return memory_usage;
-}
-
-// Global EstimateMemoryUsage(T) that just calls T::EstimateMemoryUsage().
-template <class T>
-auto EstimateMemoryUsage(const T& object)
-    -> decltype(object.EstimateMemoryUsage()) {
-  static_assert(
-      std::is_same<decltype(object.EstimateMemoryUsage()), size_t>::value,
-      "'T::EstimateMemoryUsage() const' must return size_t.");
-  return object.EstimateMemoryUsage();
-}
-
-// String
-
-template <class C, class T, class A>
-size_t EstimateMemoryUsage(const std::basic_string<C, T, A>& string) {
-  using string_type = std::basic_string<C, T, A>;
-  using value_type = typename string_type::value_type;
-  // C++11 doesn't leave much room for implementors - std::string can
-  // use short string optimization, but that's about it. We detect SSO
-  // by checking that c_str() points inside |string|.
-  const uint8_t* cstr = reinterpret_cast<const uint8_t*>(string.c_str());
-  const uint8_t* inline_cstr = reinterpret_cast<const uint8_t*>(&string);
-  if (cstr >= inline_cstr && cstr < inline_cstr + sizeof(string)) {
-    // SSO string
-    return 0;
-  }
-  return (string.capacity() + 1) * sizeof(value_type);
-}
-
-// Use explicit instantiations from the .cc file (reduces bloat).
-extern template BASE_EXPORT size_t EstimateMemoryUsage(const std::string&);
-extern template BASE_EXPORT size_t EstimateMemoryUsage(const string16&);
-
-// Arrays
-
-template <class T, size_t N>
-size_t EstimateMemoryUsage(const std::array<T, N>& array) {
-  return EstimateIterableMemoryUsage(array);
-}
-
-template <class T, size_t N>
-size_t EstimateMemoryUsage(T (&array)[N]) {
-  return EstimateIterableMemoryUsage(array);
-}
-
-template <class T>
-size_t EstimateMemoryUsage(const T* array, size_t array_length) {
-  size_t memory_usage = sizeof(T) * array_length;
-  for (size_t i = 0; i != array_length; ++i) {
-    memory_usage += EstimateItemMemoryUsage(array[i]);
-  }
-  return memory_usage;
-}
-
-// std::unique_ptr
-
-template <class T, class D>
-size_t EstimateMemoryUsage(const std::unique_ptr<T, D>& ptr) {
-  return ptr ? (sizeof(T) + EstimateItemMemoryUsage(*ptr)) : 0;
-}
-
-template <class T, class D>
-size_t EstimateMemoryUsage(const std::unique_ptr<T[], D>& array,
-                           size_t array_length) {
-  return EstimateMemoryUsage(array.get(), array_length);
-}
-
-// std::shared_ptr
-
-template <class T>
-size_t EstimateMemoryUsage(const std::shared_ptr<T>& ptr) {
-  auto use_count = ptr.use_count();
-  if (use_count == 0) {
-    return 0;
-  }
-  // Model shared_ptr after libc++,
-  // see __shared_ptr_pointer from include/memory
-  struct SharedPointer {
-    void* vtbl;
-    long shared_owners;
-    long shared_weak_owners;
-    T* value;
-  };
-  // If object of size S shared N > S times we prefer to (potentially)
-  // overestimate than to return 0.
-  return sizeof(SharedPointer) +
-         (EstimateItemMemoryUsage(*ptr) + (use_count - 1)) / use_count;
-}
-
-// std::pair
-
-template <class F, class S>
-size_t EstimateMemoryUsage(const std::pair<F, S>& pair) {
-  return EstimateItemMemoryUsage(pair.first) +
-         EstimateItemMemoryUsage(pair.second);
-}
-
-// std::vector
-
-template <class T, class A>
-size_t EstimateMemoryUsage(const std::vector<T, A>& vector) {
-  return sizeof(T) * vector.capacity() + EstimateIterableMemoryUsage(vector);
-}
-
-// std::list
-
-template <class T, class A>
-size_t EstimateMemoryUsage(const std::list<T, A>& list) {
-  using value_type = typename std::list<T, A>::value_type;
-  struct Node {
-    Node* prev;
-    Node* next;
-    value_type value;
-  };
-  return sizeof(Node) * list.size() +
-         EstimateIterableMemoryUsage(list);
-}
-
-template <class T>
-size_t EstimateMemoryUsage(const base::LinkedList<T>& list) {
-  size_t memory_usage = 0u;
-  for (base::LinkNode<T>* node = list.head(); node != list.end();
-       node = node->next()) {
-    // Since we increment by calling node = node->next() we know that node
-    // isn't nullptr.
-    memory_usage += EstimateMemoryUsage(*node->value()) + sizeof(T);
-  }
-  return memory_usage;
-}
-
-// Tree containers
-
-template <class V>
-size_t EstimateTreeMemoryUsage(size_t size) {
-  // Tree containers are modeled after libc++
-  // (__tree_node from include/__tree)
-  struct Node {
-    Node* left;
-    Node* right;
-    Node* parent;
-    bool is_black;
-    V value;
-  };
-  return sizeof(Node) * size;
-}
-
-template <class T, class C, class A>
-size_t EstimateMemoryUsage(const std::set<T, C, A>& set) {
-  using value_type = typename std::set<T, C, A>::value_type;
-  return EstimateTreeMemoryUsage<value_type>(set.size()) +
-         EstimateIterableMemoryUsage(set);
-}
-
-template <class T, class C, class A>
-size_t EstimateMemoryUsage(const std::multiset<T, C, A>& set) {
-  using value_type = typename std::multiset<T, C, A>::value_type;
-  return EstimateTreeMemoryUsage<value_type>(set.size()) +
-         EstimateIterableMemoryUsage(set);
-}
-
-template <class K, class V, class C, class A>
-size_t EstimateMemoryUsage(const std::map<K, V, C, A>& map) {
-  using value_type = typename std::map<K, V, C, A>::value_type;
-  return EstimateTreeMemoryUsage<value_type>(map.size()) +
-         EstimateIterableMemoryUsage(map);
-}
-
-template <class K, class V, class C, class A>
-size_t EstimateMemoryUsage(const std::multimap<K, V, C, A>& map) {
-  using value_type = typename std::multimap<K, V, C, A>::value_type;
-  return EstimateTreeMemoryUsage<value_type>(map.size()) +
-         EstimateIterableMemoryUsage(map);
-}
-
-// HashMap containers
-
-namespace internal {
-
-// While hashtable containers model doesn't depend on STL implementation, one
-// detail still crept in: bucket_count. It's used in size estimation, but its
-// value after inserting N items is not predictable.
-// This function is specialized by unittests to return constant value, thus
-// excluding bucket_count from testing.
-template <class V>
-size_t HashMapBucketCountForTesting(size_t bucket_count) {
-  return bucket_count;
-}
-
-template <class MruCacheType>
-size_t DoEstimateMemoryUsageForMruCache(const MruCacheType& mru_cache) {
-  return EstimateMemoryUsage(mru_cache.ordering_) +
-         EstimateMemoryUsage(mru_cache.index_);
-}
-
-}  // namespace internal
-
-template <class V>
-size_t EstimateHashMapMemoryUsage(size_t bucket_count, size_t size) {
-  // Hashtable containers are modeled after libc++
-  // (__hash_node from include/__hash_table)
-  struct Node {
-    void* next;
-    size_t hash;
-    V value;
-  };
-  using Bucket = void*;
-  bucket_count = internal::HashMapBucketCountForTesting<V>(bucket_count);
-  return sizeof(Bucket) * bucket_count + sizeof(Node) * size;
-}
-
-template <class K, class H, class KE, class A>
-size_t EstimateMemoryUsage(const std::unordered_set<K, H, KE, A>& set) {
-  using value_type = typename std::unordered_set<K, H, KE, A>::value_type;
-  return EstimateHashMapMemoryUsage<value_type>(set.bucket_count(),
-                                                set.size()) +
-         EstimateIterableMemoryUsage(set);
-}
-
-template <class K, class H, class KE, class A>
-size_t EstimateMemoryUsage(const std::unordered_multiset<K, H, KE, A>& set) {
-  using value_type = typename std::unordered_multiset<K, H, KE, A>::value_type;
-  return EstimateHashMapMemoryUsage<value_type>(set.bucket_count(),
-                                                set.size()) +
-         EstimateIterableMemoryUsage(set);
-}
-
-template <class K, class V, class H, class KE, class A>
-size_t EstimateMemoryUsage(const std::unordered_map<K, V, H, KE, A>& map) {
-  using value_type = typename std::unordered_map<K, V, H, KE, A>::value_type;
-  return EstimateHashMapMemoryUsage<value_type>(map.bucket_count(),
-                                                map.size()) +
-         EstimateIterableMemoryUsage(map);
-}
-
-template <class K, class V, class H, class KE, class A>
-size_t EstimateMemoryUsage(const std::unordered_multimap<K, V, H, KE, A>& map) {
-  using value_type =
-      typename std::unordered_multimap<K, V, H, KE, A>::value_type;
-  return EstimateHashMapMemoryUsage<value_type>(map.bucket_count(),
-                                                map.size()) +
-         EstimateIterableMemoryUsage(map);
-}
-
-// std::deque
-
-template <class T, class A>
-size_t EstimateMemoryUsage(const std::deque<T, A>& deque) {
-// Since std::deque implementations are wildly different
-// (see crbug.com/674287), we can't have one "good enough"
-// way to estimate.
-
-// kBlockSize      - minimum size of a block, in bytes
-// kMinBlockLength - number of elements in a block
-//                   if sizeof(T) > kBlockSize
-#if defined(_LIBCPP_VERSION)
-  size_t kBlockSize = 4096;
-  size_t kMinBlockLength = 16;
-#elif defined(__GLIBCXX__)
-  size_t kBlockSize = 512;
-  size_t kMinBlockLength = 1;
-#elif defined(_MSC_VER)
-  size_t kBlockSize = 16;
-  size_t kMinBlockLength = 1;
-#else
-  size_t kBlockSize = 0;
-  size_t kMinBlockLength = 1;
-#endif
-
-  size_t block_length =
-      (sizeof(T) > kBlockSize) ? kMinBlockLength : kBlockSize / sizeof(T);
-
-  size_t blocks = (deque.size() + block_length - 1) / block_length;
-
-#if defined(__GLIBCXX__)
-  // libstdc++: deque always has at least one block
-  if (!blocks)
-    blocks = 1;
-#endif
-
-#if defined(_LIBCPP_VERSION)
-  // libc++: deque keeps at most two blocks when it shrinks,
-  // so even if the size is zero, deque might be holding up
-  // to 4096 * 2 bytes. One way to know whether deque has
-  // ever allocated (and hence has 1 or 2 blocks) is to check
-  // iterator's pointer. Non-zero value means that deque has
-  // at least one block.
-  if (!blocks && deque.begin().operator->())
-    blocks = 1;
-#endif
-
-  return (blocks * block_length * sizeof(T)) +
-         EstimateIterableMemoryUsage(deque);
-}
-
-// Container adapters
-
-template <class T, class C>
-size_t EstimateMemoryUsage(const std::queue<T, C>& queue) {
-  return EstimateMemoryUsage(GetUnderlyingContainer(queue));
-}
-
-template <class T, class C>
-size_t EstimateMemoryUsage(const std::priority_queue<T, C>& queue) {
-  return EstimateMemoryUsage(GetUnderlyingContainer(queue));
-}
-
-template <class T, class C>
-size_t EstimateMemoryUsage(const std::stack<T, C>& stack) {
-  return EstimateMemoryUsage(GetUnderlyingContainer(stack));
-}
-
-// base::circular_deque
-
-template <class T>
-size_t EstimateMemoryUsage(const base::circular_deque<T>& deque) {
-  return sizeof(T) * deque.capacity() + EstimateIterableMemoryUsage(deque);
-}
-
-// Flat containers
-
-template <class T, class C>
-size_t EstimateMemoryUsage(const base::flat_set<T, C>& set) {
-  using value_type = typename base::flat_set<T, C>::value_type;
-  return sizeof(value_type) * set.capacity() + EstimateIterableMemoryUsage(set);
-}
-
-template <class K, class V, class C>
-size_t EstimateMemoryUsage(const base::flat_map<K, V, C>& map) {
-  using value_type = typename base::flat_map<K, V, C>::value_type;
-  return sizeof(value_type) * map.capacity() + EstimateIterableMemoryUsage(map);
-}
-
-template <class Key,
-          class Payload,
-          class HashOrComp,
-          template <typename, typename, typename> class Map>
-size_t EstimateMemoryUsage(
-    const MRUCacheBase<Key, Payload, HashOrComp, Map>& mru_cache) {
-  return internal::DoEstimateMemoryUsageForMruCache(mru_cache);
-}
-
-}  // namespace trace_event
-}  // namespace base
-
-#endif  // BASE_TRACE_EVENT_MEMORY_USAGE_ESTIMATOR_H_
diff --git a/base/trace_event/process_memory_dump.cc b/base/trace_event/process_memory_dump.cc
deleted file mode 100644
index d565b47..0000000
--- a/base/trace_event/process_memory_dump.cc
+++ /dev/null
@@ -1,545 +0,0 @@
-// Copyright 2015 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/trace_event/process_memory_dump.h"
-
-#include <errno.h>
-
-#include <vector>
-
-#include "base/memory/ptr_util.h"
-#include "base/memory/shared_memory_tracker.h"
-#include "base/process/process_metrics.h"
-#include "base/strings/stringprintf.h"
-#include "base/trace_event/heap_profiler_heap_dump_writer.h"
-#include "base/trace_event/heap_profiler_serialization_state.h"
-#include "base/trace_event/memory_infra_background_whitelist.h"
-#include "base/trace_event/trace_event_argument.h"
-#include "base/unguessable_token.h"
-#include "build_config.h"
-
-#if defined(OS_IOS)
-#include <mach/vm_page_size.h>
-#endif
-
-#if defined(OS_POSIX) || defined(OS_FUCHSIA)
-#include <sys/mman.h>
-#endif
-
-#if defined(OS_WIN)
-#include <windows.h>  // Must be in front of other Windows header files
-
-#include <Psapi.h>
-#endif
-
-namespace base {
-namespace trace_event {
-
-namespace {
-
-const char kEdgeTypeOwnership[] = "ownership";
-
-std::string GetSharedGlobalAllocatorDumpName(
-    const MemoryAllocatorDumpGuid& guid) {
-  return "global/" + guid.ToString();
-}
-
-#if defined(COUNT_RESIDENT_BYTES_SUPPORTED)
-size_t GetSystemPageCount(size_t mapped_size, size_t page_size) {
-  return (mapped_size + page_size - 1) / page_size;
-}
-#endif
-
-UnguessableToken GetTokenForCurrentProcess() {
-  static UnguessableToken instance = UnguessableToken::Create();
-  return instance;
-}
-
-}  // namespace
-
-// static
-bool ProcessMemoryDump::is_black_hole_non_fatal_for_testing_ = false;
-
-#if defined(COUNT_RESIDENT_BYTES_SUPPORTED)
-// static
-size_t ProcessMemoryDump::GetSystemPageSize() {
-#if defined(OS_IOS)
-  // On iOS, getpagesize() returns the user page sizes, but for allocating
-  // arrays for mincore(), kernel page sizes is needed. Use vm_kernel_page_size
-  // as recommended by Apple, https://forums.developer.apple.com/thread/47532/.
-  // Refer to http://crbug.com/542671 and Apple rdar://23651782
-  return vm_kernel_page_size;
-#else
-  return base::GetPageSize();
-#endif  // defined(OS_IOS)
-}
-
-// static
-size_t ProcessMemoryDump::CountResidentBytes(void* start_address,
-                                             size_t mapped_size) {
-  const size_t page_size = GetSystemPageSize();
-  const uintptr_t start_pointer = reinterpret_cast<uintptr_t>(start_address);
-  DCHECK_EQ(0u, start_pointer % page_size);
-
-  size_t offset = 0;
-  size_t total_resident_pages = 0;
-  bool failure = false;
-
-  // An array as large as number of pages in memory segment needs to be passed
-  // to the query function. To avoid allocating a large array, the given block
-  // of memory is split into chunks of size |kMaxChunkSize|.
-  const size_t kMaxChunkSize = 8 * 1024 * 1024;
-  size_t max_vec_size =
-      GetSystemPageCount(std::min(mapped_size, kMaxChunkSize), page_size);
-#if defined(OS_WIN)
-  std::unique_ptr<PSAPI_WORKING_SET_EX_INFORMATION[]> vec(
-      new PSAPI_WORKING_SET_EX_INFORMATION[max_vec_size]);
-#elif defined(OS_MACOSX)
-  std::unique_ptr<char[]> vec(new char[max_vec_size]);
-#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
-  std::unique_ptr<unsigned char[]> vec(new unsigned char[max_vec_size]);
-#endif
-
-  while (offset < mapped_size) {
-    uintptr_t chunk_start = (start_pointer + offset);
-    const size_t chunk_size = std::min(mapped_size - offset, kMaxChunkSize);
-    const size_t page_count = GetSystemPageCount(chunk_size, page_size);
-    size_t resident_page_count = 0;
-#if defined(OS_WIN)
-    for (size_t i = 0; i < page_count; i++) {
-      vec[i].VirtualAddress =
-          reinterpret_cast<void*>(chunk_start + i * page_size);
-    }
-    DWORD vec_size = static_cast<DWORD>(
-        page_count * sizeof(PSAPI_WORKING_SET_EX_INFORMATION));
-    failure = !QueryWorkingSetEx(GetCurrentProcess(), vec.get(), vec_size);
-
-    for (size_t i = 0; i < page_count; i++)
-      resident_page_count += vec[i].VirtualAttributes.Valid;
-#elif defined(OS_FUCHSIA)
-    // TODO(fuchsia): Port, see https://crbug.com/706592.
-    ALLOW_UNUSED_LOCAL(chunk_start);
-    ALLOW_UNUSED_LOCAL(page_count);
-#elif defined(OS_MACOSX)
-    // mincore in MAC does not fail with EAGAIN.
-    failure =
-        !!mincore(reinterpret_cast<void*>(chunk_start), chunk_size, vec.get());
-    for (size_t i = 0; i < page_count; i++)
-      resident_page_count += vec[i] & MINCORE_INCORE ? 1 : 0;
-#elif defined(OS_POSIX)
-    int error_counter = 0;
-    int result = 0;
-    // HANDLE_EINTR tries for 100 times. So following the same pattern.
-    do {
-      result =
-#if defined(OS_AIX)
-          mincore(reinterpret_cast<char*>(chunk_start), chunk_size,
-                  reinterpret_cast<char*>(vec.get()));
-#else
-          mincore(reinterpret_cast<void*>(chunk_start), chunk_size, vec.get());
-#endif
-    } while (result == -1 && errno == EAGAIN && error_counter++ < 100);
-    failure = !!result;
-
-    for (size_t i = 0; i < page_count; i++)
-      resident_page_count += vec[i] & 1;
-#endif
-
-    if (failure)
-      break;
-
-    total_resident_pages += resident_page_count * page_size;
-    offset += kMaxChunkSize;
-  }
-
-  DCHECK(!failure);
-  if (failure) {
-    total_resident_pages = 0;
-    LOG(ERROR) << "CountResidentBytes failed. The resident size is invalid";
-  }
-  return total_resident_pages;
-}
-
-// static
-base::Optional<size_t> ProcessMemoryDump::CountResidentBytesInSharedMemory(
-    void* start_address,
-    size_t mapped_size) {
-#if defined(OS_MACOSX) && !defined(OS_IOS)
-  // On macOS, use mach_vm_region instead of mincore for performance
-  // (crbug.com/742042).
-  mach_vm_size_t dummy_size = 0;
-  mach_vm_address_t address =
-      reinterpret_cast<mach_vm_address_t>(start_address);
-  vm_region_top_info_data_t info;
-  MachVMRegionResult result =
-      GetTopInfo(mach_task_self(), &dummy_size, &address, &info);
-  if (result == MachVMRegionResult::Error) {
-    LOG(ERROR) << "CountResidentBytesInSharedMemory failed. The resident size "
-                  "is invalid";
-    return base::Optional<size_t>();
-  }
-
-  size_t resident_pages =
-      info.private_pages_resident + info.shared_pages_resident;
-
-  // On macOS, measurements for private memory footprint overcount by
-  // faulted pages in anonymous shared memory. To discount for this, we touch
-  // all the resident pages in anonymous shared memory here, thus making them
-  // faulted as well. This relies on two assumptions:
-  //
-  // 1) Consumers use shared memory from front to back. Thus, if there are
-  // (N) resident pages, those pages represent the first N * PAGE_SIZE bytes in
-  // the shared memory region.
-  //
-  // 2) This logic is run shortly before the logic that calculates
-  // phys_footprint, thus ensuring that the discrepancy between faulted and
-  // resident pages is minimal.
-  //
-  // The performance penalty is expected to be small.
-  //
-  // * Most of the time, we expect the pages to already be resident and faulted,
-  // thus incurring a cache penalty read hit [since we read from each resident
-  // page].
-  //
-  // * Rarely, we expect the pages to be resident but not faulted, resulting in
-  // soft faults + cache penalty.
-  //
-  // * If assumption (1) is invalid, this will potentially fault some
-  // previously non-resident pages, thus increasing memory usage, without fixing
-  // the accounting.
-  //
-  // Sanity check in case the mapped size is less than the total size of the
-  // region.
-  size_t pages_to_fault =
-      std::min(resident_pages, (mapped_size + PAGE_SIZE - 1) / PAGE_SIZE);
-
-  volatile char* base_address = static_cast<char*>(start_address);
-  for (size_t i = 0; i < pages_to_fault; ++i) {
-    // Reading from a volatile is a visible side-effect for the purposes of
-    // optimization. This guarantees that the optimizer will not kill this line.
-    base_address[i * PAGE_SIZE];
-  }
-
-  return resident_pages * PAGE_SIZE;
-#else
-  return CountResidentBytes(start_address, mapped_size);
-#endif  // defined(OS_MACOSX) && !defined(OS_IOS)
-}
-
-#endif  // defined(COUNT_RESIDENT_BYTES_SUPPORTED)
-
-ProcessMemoryDump::ProcessMemoryDump(
-    scoped_refptr<HeapProfilerSerializationState>
-        heap_profiler_serialization_state,
-    const MemoryDumpArgs& dump_args)
-    : process_token_(GetTokenForCurrentProcess()),
-      heap_profiler_serialization_state_(
-          std::move(heap_profiler_serialization_state)),
-      dump_args_(dump_args) {}
-
-ProcessMemoryDump::~ProcessMemoryDump() = default;
-ProcessMemoryDump::ProcessMemoryDump(ProcessMemoryDump&& other) = default;
-ProcessMemoryDump& ProcessMemoryDump::operator=(ProcessMemoryDump&& other) =
-    default;
-
-MemoryAllocatorDump* ProcessMemoryDump::CreateAllocatorDump(
-    const std::string& absolute_name) {
-  return AddAllocatorDumpInternal(std::make_unique<MemoryAllocatorDump>(
-      absolute_name, dump_args_.level_of_detail, GetDumpId(absolute_name)));
-}
-
-MemoryAllocatorDump* ProcessMemoryDump::CreateAllocatorDump(
-    const std::string& absolute_name,
-    const MemoryAllocatorDumpGuid& guid) {
-  return AddAllocatorDumpInternal(std::make_unique<MemoryAllocatorDump>(
-      absolute_name, dump_args_.level_of_detail, guid));
-}
-
-MemoryAllocatorDump* ProcessMemoryDump::AddAllocatorDumpInternal(
-    std::unique_ptr<MemoryAllocatorDump> mad) {
-  // In background mode return the black hole dump, if invalid dump name is
-  // given.
-  if (dump_args_.level_of_detail == MemoryDumpLevelOfDetail::BACKGROUND &&
-      !IsMemoryAllocatorDumpNameWhitelisted(mad->absolute_name())) {
-    return GetBlackHoleMad();
-  }
-
-  auto insertion_result = allocator_dumps_.insert(
-      std::make_pair(mad->absolute_name(), std::move(mad)));
-  MemoryAllocatorDump* inserted_mad = insertion_result.first->second.get();
-  DCHECK(insertion_result.second) << "Duplicate name: "
-                                  << inserted_mad->absolute_name();
-  return inserted_mad;
-}
-
-MemoryAllocatorDump* ProcessMemoryDump::GetAllocatorDump(
-    const std::string& absolute_name) const {
-  auto it = allocator_dumps_.find(absolute_name);
-  if (it != allocator_dumps_.end())
-    return it->second.get();
-  if (black_hole_mad_)
-    return black_hole_mad_.get();
-  return nullptr;
-}
-
-MemoryAllocatorDump* ProcessMemoryDump::GetOrCreateAllocatorDump(
-    const std::string& absolute_name) {
-  MemoryAllocatorDump* mad = GetAllocatorDump(absolute_name);
-  return mad ? mad : CreateAllocatorDump(absolute_name);
-}
-
-MemoryAllocatorDump* ProcessMemoryDump::CreateSharedGlobalAllocatorDump(
-    const MemoryAllocatorDumpGuid& guid) {
-  // A shared allocator dump can be shared within a process and the guid could
-  // have been created already.
-  MemoryAllocatorDump* mad = GetSharedGlobalAllocatorDump(guid);
-  if (mad && mad != black_hole_mad_.get()) {
-    // The weak flag is cleared because this method should create a non-weak
-    // dump.
-    mad->clear_flags(MemoryAllocatorDump::Flags::WEAK);
-    return mad;
-  }
-  return CreateAllocatorDump(GetSharedGlobalAllocatorDumpName(guid), guid);
-}
-
-MemoryAllocatorDump* ProcessMemoryDump::CreateWeakSharedGlobalAllocatorDump(
-    const MemoryAllocatorDumpGuid& guid) {
-  MemoryAllocatorDump* mad = GetSharedGlobalAllocatorDump(guid);
-  if (mad && mad != black_hole_mad_.get())
-    return mad;
-  mad = CreateAllocatorDump(GetSharedGlobalAllocatorDumpName(guid), guid);
-  mad->set_flags(MemoryAllocatorDump::Flags::WEAK);
-  return mad;
-}
-
-MemoryAllocatorDump* ProcessMemoryDump::GetSharedGlobalAllocatorDump(
-    const MemoryAllocatorDumpGuid& guid) const {
-  return GetAllocatorDump(GetSharedGlobalAllocatorDumpName(guid));
-}
-
-void ProcessMemoryDump::DumpHeapUsage(
-    const std::unordered_map<base::trace_event::AllocationContext,
-                             base::trace_event::AllocationMetrics>&
-        metrics_by_context,
-    base::trace_event::TraceEventMemoryOverhead& overhead,
-    const char* allocator_name) {
-  // The heap profiler serialization state can be null here if heap profiler was
-  // enabled when a process dump is in progress.
-  if (heap_profiler_serialization_state() && !metrics_by_context.empty()) {
-    DCHECK_EQ(0ul, heap_dumps_.count(allocator_name));
-    std::unique_ptr<TracedValue> heap_dump = ExportHeapDump(
-        metrics_by_context, *heap_profiler_serialization_state());
-    heap_dumps_[allocator_name] = std::move(heap_dump);
-  }
-
-  std::string base_name = base::StringPrintf("tracing/heap_profiler_%s",
-                                             allocator_name);
-  overhead.DumpInto(base_name.c_str(), this);
-}
-
-void ProcessMemoryDump::SetAllocatorDumpsForSerialization(
-    std::vector<std::unique_ptr<MemoryAllocatorDump>> dumps) {
-  DCHECK(allocator_dumps_.empty());
-  for (std::unique_ptr<MemoryAllocatorDump>& dump : dumps)
-    AddAllocatorDumpInternal(std::move(dump));
-}
-
-std::vector<ProcessMemoryDump::MemoryAllocatorDumpEdge>
-ProcessMemoryDump::GetAllEdgesForSerialization() const {
-  std::vector<MemoryAllocatorDumpEdge> edges;
-  edges.reserve(allocator_dumps_edges_.size());
-  for (const auto& it : allocator_dumps_edges_)
-    edges.push_back(it.second);
-  return edges;
-}
-
-void ProcessMemoryDump::SetAllEdgesForSerialization(
-    const std::vector<ProcessMemoryDump::MemoryAllocatorDumpEdge>& edges) {
-  DCHECK(allocator_dumps_edges_.empty());
-  for (const MemoryAllocatorDumpEdge& edge : edges) {
-    auto it_and_inserted = allocator_dumps_edges_.emplace(edge.source, edge);
-    DCHECK(it_and_inserted.second);
-  }
-}
-
-void ProcessMemoryDump::Clear() {
-  allocator_dumps_.clear();
-  allocator_dumps_edges_.clear();
-  heap_dumps_.clear();
-}
-
-void ProcessMemoryDump::TakeAllDumpsFrom(ProcessMemoryDump* other) {
-  // Moves the ownership of all MemoryAllocatorDump(s) contained in |other|
-  // into this ProcessMemoryDump, checking for duplicates.
-  for (auto& it : other->allocator_dumps_)
-    AddAllocatorDumpInternal(std::move(it.second));
-  other->allocator_dumps_.clear();
-
-  // Move all the edges.
-  allocator_dumps_edges_.insert(other->allocator_dumps_edges_.begin(),
-                                other->allocator_dumps_edges_.end());
-  other->allocator_dumps_edges_.clear();
-
-  for (auto& it : other->heap_dumps_) {
-    DCHECK_EQ(0ul, heap_dumps_.count(it.first));
-    heap_dumps_.insert(std::make_pair(it.first, std::move(it.second)));
-  }
-  other->heap_dumps_.clear();
-}
-
-void ProcessMemoryDump::SerializeAllocatorDumpsInto(TracedValue* value) const {
-  if (allocator_dumps_.size() > 0) {
-    value->BeginDictionary("allocators");
-    for (const auto& allocator_dump_it : allocator_dumps_)
-      allocator_dump_it.second->AsValueInto(value);
-    value->EndDictionary();
-  }
-
-  value->BeginArray("allocators_graph");
-  for (const auto& it : allocator_dumps_edges_) {
-    const MemoryAllocatorDumpEdge& edge = it.second;
-    value->BeginDictionary();
-    value->SetString("source", edge.source.ToString());
-    value->SetString("target", edge.target.ToString());
-    value->SetInteger("importance", edge.importance);
-    value->SetString("type", kEdgeTypeOwnership);
-    value->EndDictionary();
-  }
-  value->EndArray();
-}
-
-void ProcessMemoryDump::SerializeHeapProfilerDumpsInto(
-    TracedValue* value) const {
-  if (heap_dumps_.size() == 0)
-    return;
-  value->BeginDictionary("heaps");
-  for (const auto& name_and_dump : heap_dumps_)
-    value->SetValueWithCopiedName(name_and_dump.first, *name_and_dump.second);
-  value->EndDictionary();  // "heaps"
-}
-
-void ProcessMemoryDump::AddOwnershipEdge(const MemoryAllocatorDumpGuid& source,
-                                         const MemoryAllocatorDumpGuid& target,
-                                         int importance) {
-  // This will either override an existing edge or create a new one.
-  auto it = allocator_dumps_edges_.find(source);
-  int max_importance = importance;
-  if (it != allocator_dumps_edges_.end()) {
-    DCHECK_EQ(target.ToUint64(), it->second.target.ToUint64());
-    max_importance = std::max(importance, it->second.importance);
-  }
-  allocator_dumps_edges_[source] = {source, target, max_importance,
-                                    false /* overridable */};
-}
-
-void ProcessMemoryDump::AddOwnershipEdge(
-    const MemoryAllocatorDumpGuid& source,
-    const MemoryAllocatorDumpGuid& target) {
-  AddOwnershipEdge(source, target, 0 /* importance */);
-}
-
-void ProcessMemoryDump::AddOverridableOwnershipEdge(
-    const MemoryAllocatorDumpGuid& source,
-    const MemoryAllocatorDumpGuid& target,
-    int importance) {
-  if (allocator_dumps_edges_.count(source) == 0) {
-    allocator_dumps_edges_[source] = {source, target, importance,
-                                      true /* overridable */};
-  } else {
-    // An edge between the source and target already exits. So, do nothing here
-    // since the new overridable edge is implicitly overridden by a strong edge
-    // which was created earlier.
-    DCHECK(!allocator_dumps_edges_[source].overridable);
-  }
-}
-
-void ProcessMemoryDump::CreateSharedMemoryOwnershipEdge(
-    const MemoryAllocatorDumpGuid& client_local_dump_guid,
-    const UnguessableToken& shared_memory_guid,
-    int importance) {
-  CreateSharedMemoryOwnershipEdgeInternal(client_local_dump_guid,
-                                          shared_memory_guid, importance,
-                                          false /*is_weak*/);
-}
-
-void ProcessMemoryDump::CreateWeakSharedMemoryOwnershipEdge(
-    const MemoryAllocatorDumpGuid& client_local_dump_guid,
-    const UnguessableToken& shared_memory_guid,
-    int importance) {
-  CreateSharedMemoryOwnershipEdgeInternal(
-      client_local_dump_guid, shared_memory_guid, importance, true /*is_weak*/);
-}
-
-void ProcessMemoryDump::CreateSharedMemoryOwnershipEdgeInternal(
-    const MemoryAllocatorDumpGuid& client_local_dump_guid,
-    const UnguessableToken& shared_memory_guid,
-    int importance,
-    bool is_weak) {
-  DCHECK(!shared_memory_guid.is_empty());
-  // New model where the global dumps created by SharedMemoryTracker are used
-  // for the clients.
-
-  // The guid of the local dump created by SharedMemoryTracker for the memory
-  // segment.
-  auto local_shm_guid =
-      GetDumpId(SharedMemoryTracker::GetDumpNameForTracing(shared_memory_guid));
-
-  // The dump guid of the global dump created by the tracker for the memory
-  // segment.
-  auto global_shm_guid =
-      SharedMemoryTracker::GetGlobalDumpIdForTracing(shared_memory_guid);
-
-  // Create an edge between local dump of the client and the local dump of the
-  // SharedMemoryTracker. Do not need to create the dumps here since the tracker
-  // would create them. The importance is also required here for the case of
-  // single process mode.
-  AddOwnershipEdge(client_local_dump_guid, local_shm_guid, importance);
-
-  // TODO(ssid): Handle the case of weak dumps here. This needs a new function
-  // GetOrCreaetGlobalDump() in PMD since we need to change the behavior of the
-  // created global dump.
-  // Create an edge that overrides the edge created by SharedMemoryTracker.
-  AddOwnershipEdge(local_shm_guid, global_shm_guid, importance);
-}
-
-void ProcessMemoryDump::AddSuballocation(const MemoryAllocatorDumpGuid& source,
-                                         const std::string& target_node_name) {
-  // Do not create new dumps for suballocations in background mode.
-  if (dump_args_.level_of_detail == MemoryDumpLevelOfDetail::BACKGROUND)
-    return;
-
-  std::string child_mad_name = target_node_name + "/__" + source.ToString();
-  MemoryAllocatorDump* target_child_mad = CreateAllocatorDump(child_mad_name);
-  AddOwnershipEdge(source, target_child_mad->guid());
-}
-
-MemoryAllocatorDump* ProcessMemoryDump::GetBlackHoleMad() {
-  DCHECK(is_black_hole_non_fatal_for_testing_);
-  if (!black_hole_mad_) {
-    std::string name = "discarded";
-    black_hole_mad_.reset(new MemoryAllocatorDump(
-        name, dump_args_.level_of_detail, GetDumpId(name)));
-  }
-  return black_hole_mad_.get();
-}
-
-MemoryAllocatorDumpGuid ProcessMemoryDump::GetDumpId(
-    const std::string& absolute_name) {
-  return MemoryAllocatorDumpGuid(StringPrintf(
-      "%s:%s", process_token().ToString().c_str(), absolute_name.c_str()));
-}
-
-bool ProcessMemoryDump::MemoryAllocatorDumpEdge::operator==(
-    const MemoryAllocatorDumpEdge& other) const {
-  return source == other.source && target == other.target &&
-         importance == other.importance && overridable == other.overridable;
-}
-
-bool ProcessMemoryDump::MemoryAllocatorDumpEdge::operator!=(
-    const MemoryAllocatorDumpEdge& other) const {
-  return !(*this == other);
-}
-
-}  // namespace trace_event
-}  // namespace base
diff --git a/base/trace_event/process_memory_dump.h b/base/trace_event/process_memory_dump.h
deleted file mode 100644
index b2ce66f..0000000
--- a/base/trace_event/process_memory_dump.h
+++ /dev/null
@@ -1,304 +0,0 @@
-// Copyright 2015 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_TRACE_EVENT_PROCESS_MEMORY_DUMP_H_
-#define BASE_TRACE_EVENT_PROCESS_MEMORY_DUMP_H_
-
-#include <stddef.h>
-
-#include <map>
-#include <unordered_map>
-#include <vector>
-
-#include "base/base_export.h"
-#include "base/macros.h"
-#include "base/memory/ref_counted.h"
-#include "base/trace_event/heap_profiler_serialization_state.h"
-#include "base/trace_event/memory_allocator_dump.h"
-#include "base/trace_event/memory_allocator_dump_guid.h"
-#include "base/trace_event/memory_dump_request_args.h"
-#include "build_config.h"
-
-// Define COUNT_RESIDENT_BYTES_SUPPORTED if platform supports counting of the
-// resident memory.
-#if !defined(OS_NACL)
-#define COUNT_RESIDENT_BYTES_SUPPORTED
-#endif
-
-namespace base {
-
-class SharedMemory;
-class UnguessableToken;
-
-namespace trace_event {
-
-class HeapProfilerSerializationState;
-class TracedValue;
-
-// ProcessMemoryDump is as a strongly typed container which holds the dumps
-// produced by the MemoryDumpProvider(s) for a specific process.
-class BASE_EXPORT ProcessMemoryDump {
- public:
-  struct BASE_EXPORT MemoryAllocatorDumpEdge {
-    bool operator==(const MemoryAllocatorDumpEdge&) const;
-    bool operator!=(const MemoryAllocatorDumpEdge&) const;
-
-    MemoryAllocatorDumpGuid source;
-    MemoryAllocatorDumpGuid target;
-    int importance = 0;
-    bool overridable = false;
-  };
-
-  // Maps allocator dumps absolute names (allocator_name/heap/subheap) to
-  // MemoryAllocatorDump instances.
-  using AllocatorDumpsMap =
-      std::map<std::string, std::unique_ptr<MemoryAllocatorDump>>;
-
-  using HeapDumpsMap = std::map<std::string, std::unique_ptr<TracedValue>>;
-
-  // Stores allocator dump edges indexed by source allocator dump GUID.
-  using AllocatorDumpEdgesMap =
-      std::map<MemoryAllocatorDumpGuid, MemoryAllocatorDumpEdge>;
-
-#if defined(COUNT_RESIDENT_BYTES_SUPPORTED)
-  // Returns the number of bytes in a kernel memory page. Some platforms may
-  // have a different value for kernel page sizes from user page sizes. It is
-  // important to use kernel memory page sizes for resident bytes calculation.
-  // In most cases, the two are the same.
-  static size_t GetSystemPageSize();
-
-  // Returns the total bytes resident for a virtual address range, with given
-  // |start_address| and |mapped_size|. |mapped_size| is specified in bytes. The
-  // value returned is valid only if the given range is currently mmapped by the
-  // process. The |start_address| must be page-aligned.
-  static size_t CountResidentBytes(void* start_address, size_t mapped_size);
-
-  // The same as above, but the given mapped range should belong to the
-  // shared_memory's mapped region.
-  static base::Optional<size_t> CountResidentBytesInSharedMemory(
-      void* start_address,
-      size_t mapped_size);
-#endif
-
-  ProcessMemoryDump(scoped_refptr<HeapProfilerSerializationState>
-                        heap_profiler_serialization_state,
-                    const MemoryDumpArgs& dump_args);
-  ProcessMemoryDump(ProcessMemoryDump&&);
-  ~ProcessMemoryDump();
-
-  ProcessMemoryDump& operator=(ProcessMemoryDump&&);
-
-  // Creates a new MemoryAllocatorDump with the given name and returns the
-  // empty object back to the caller.
-  // Arguments:
-  //   absolute_name: a name that uniquely identifies allocator dumps produced
-  //       by this provider. It is possible to specify nesting by using a
-  //       path-like string (e.g., v8/isolate1/heap1, v8/isolate1/heap2).
-  //       Leading or trailing slashes are not allowed.
-  //   guid: an optional identifier, unique among all processes within the
-  //       scope of a global dump. This is only relevant when using
-  //       AddOwnershipEdge() to express memory sharing. If omitted,
-  //       it will be automatically generated.
-  // ProcessMemoryDump handles the memory ownership of its MemoryAllocatorDumps.
-  MemoryAllocatorDump* CreateAllocatorDump(const std::string& absolute_name);
-  MemoryAllocatorDump* CreateAllocatorDump(const std::string& absolute_name,
-                                           const MemoryAllocatorDumpGuid& guid);
-
-  // Looks up a MemoryAllocatorDump given its allocator and heap names, or
-  // nullptr if not found.
-  MemoryAllocatorDump* GetAllocatorDump(const std::string& absolute_name) const;
-
-  // Do NOT use this method. All dump providers should use
-  // CreateAllocatorDump(). Tries to create a new MemoryAllocatorDump only if it
-  // doesn't already exist. Creating multiple dumps with same name using
-  // GetOrCreateAllocatorDump() would override the existing scalars in MAD and
-  // cause misreporting. This method is used only in rare cases multiple
-  // components create allocator dumps with same name and only one of them adds
-  // size.
-  MemoryAllocatorDump* GetOrCreateAllocatorDump(
-      const std::string& absolute_name);
-
-  // Creates a shared MemoryAllocatorDump, to express cross-process sharing.
-  // Shared allocator dumps are allowed to have duplicate guids within the
-  // global scope, in order to reference the same dump from multiple processes.
-  // See the design doc goo.gl/keU6Bf for reference usage patterns.
-  MemoryAllocatorDump* CreateSharedGlobalAllocatorDump(
-      const MemoryAllocatorDumpGuid& guid);
-
-  // Creates a shared MemoryAllocatorDump as CreateSharedGlobalAllocatorDump,
-  // but with a WEAK flag. A weak dump will be discarded unless a non-weak dump
-  // is created using CreateSharedGlobalAllocatorDump by at least one process.
-  // The WEAK flag does not apply if a non-weak dump with the same GUID already
-  // exists or is created later. All owners and children of the discarded dump
-  // will also be discarded transitively.
-  MemoryAllocatorDump* CreateWeakSharedGlobalAllocatorDump(
-      const MemoryAllocatorDumpGuid& guid);
-
-  // Looks up a shared MemoryAllocatorDump given its guid.
-  MemoryAllocatorDump* GetSharedGlobalAllocatorDump(
-      const MemoryAllocatorDumpGuid& guid) const;
-
-  // Returns the map of the MemoryAllocatorDumps added to this dump.
-  const AllocatorDumpsMap& allocator_dumps() const { return allocator_dumps_; }
-
-  AllocatorDumpsMap* mutable_allocator_dumps_for_serialization() const {
-    // Mojo takes a const input argument even for move-only types that can be
-    // mutate while serializing (like this one). Hence the const_cast.
-    return const_cast<AllocatorDumpsMap*>(&allocator_dumps_);
-  }
-  void SetAllocatorDumpsForSerialization(
-      std::vector<std::unique_ptr<MemoryAllocatorDump>>);
-
-  // Only for mojo serialization.
-  std::vector<MemoryAllocatorDumpEdge> GetAllEdgesForSerialization() const;
-  void SetAllEdgesForSerialization(const std::vector<MemoryAllocatorDumpEdge>&);
-
-  // Dumps heap usage with |allocator_name|.
-  void DumpHeapUsage(
-      const std::unordered_map<base::trace_event::AllocationContext,
-                               base::trace_event::AllocationMetrics>&
-          metrics_by_context,
-      base::trace_event::TraceEventMemoryOverhead& overhead,
-      const char* allocator_name);
-
-  // Adds an ownership relationship between two MemoryAllocatorDump(s) with the
-  // semantics: |source| owns |target|, and has the effect of attributing
-  // the memory usage of |target| to |source|. |importance| is optional and
-  // relevant only for the cases of co-ownership, where it acts as a z-index:
-  // the owner with the highest importance will be attributed |target|'s memory.
-  // If an edge is present, its importance will not be updated unless
-  // |importance| is larger.
-  void AddOwnershipEdge(const MemoryAllocatorDumpGuid& source,
-                        const MemoryAllocatorDumpGuid& target,
-                        int importance);
-  void AddOwnershipEdge(const MemoryAllocatorDumpGuid& source,
-                        const MemoryAllocatorDumpGuid& target);
-
-  // Adds edges that can be overriden by a later or earlier call to
-  // AddOwnershipEdge() with the same source and target with a different
-  // |importance| value.
-  void AddOverridableOwnershipEdge(const MemoryAllocatorDumpGuid& source,
-                                   const MemoryAllocatorDumpGuid& target,
-                                   int importance);
-
-  // Creates ownership edges for memory backed by base::SharedMemory. Handles
-  // the case of cross process sharing and importnace of ownership for the case
-  // with and without the base::SharedMemory dump provider. The new version
-  // should just use global dumps created by SharedMemoryTracker and this
-  // function handles the transition until we get SharedMemory IDs through mojo
-  // channel crbug.com/713763. The weak version creates a weak global dump.
-  // |client_local_dump_guid| The guid of the local dump created by the client
-  // of base::SharedMemory.
-  // |shared_memory_guid| The ID of the base::SharedMemory that is assigned
-  // globally, used to create global dump edges in the new model.
-  // |importance| Importance of the global dump edges to say if the current
-  // process owns the memory segment.
-  void CreateSharedMemoryOwnershipEdge(
-      const MemoryAllocatorDumpGuid& client_local_dump_guid,
-      const UnguessableToken& shared_memory_guid,
-      int importance);
-  void CreateWeakSharedMemoryOwnershipEdge(
-      const MemoryAllocatorDumpGuid& client_local_dump_guid,
-      const UnguessableToken& shared_memory_guid,
-      int importance);
-
-  const AllocatorDumpEdgesMap& allocator_dumps_edges() const {
-    return allocator_dumps_edges_;
-  }
-
-  // Utility method to add a suballocation relationship with the following
-  // semantics: |source| is suballocated from |target_node_name|.
-  // This creates a child node of |target_node_name| and adds an ownership edge
-  // between |source| and the new child node. As a result, the UI will not
-  // account the memory of |source| in the target node.
-  void AddSuballocation(const MemoryAllocatorDumpGuid& source,
-                        const std::string& target_node_name);
-
-  const scoped_refptr<HeapProfilerSerializationState>&
-  heap_profiler_serialization_state() const {
-    return heap_profiler_serialization_state_;
-  }
-
-  // Removes all the MemoryAllocatorDump(s) contained in this instance. This
-  // ProcessMemoryDump can be safely reused as if it was new once this returns.
-  void Clear();
-
-  // Merges all MemoryAllocatorDump(s) contained in |other| inside this
-  // ProcessMemoryDump, transferring their ownership to this instance.
-  // |other| will be an empty ProcessMemoryDump after this method returns.
-  // This is to allow dump providers to pre-populate ProcessMemoryDump instances
-  // and later move their contents into the ProcessMemoryDump passed as argument
-  // of the MemoryDumpProvider::OnMemoryDump(ProcessMemoryDump*) callback.
-  void TakeAllDumpsFrom(ProcessMemoryDump* other);
-
-  // Populate the traced value with information about the memory allocator
-  // dumps.
-  void SerializeAllocatorDumpsInto(TracedValue* value) const;
-
-  // Populate the traced value with information about the heap profiler.
-  void SerializeHeapProfilerDumpsInto(TracedValue* value) const;
-
-  const HeapDumpsMap& heap_dumps() const { return heap_dumps_; }
-
-  const MemoryDumpArgs& dump_args() const { return dump_args_; }
-
- private:
-  FRIEND_TEST_ALL_PREFIXES(ProcessMemoryDumpTest, BackgroundModeTest);
-  FRIEND_TEST_ALL_PREFIXES(ProcessMemoryDumpTest, SharedMemoryOwnershipTest);
-  FRIEND_TEST_ALL_PREFIXES(ProcessMemoryDumpTest, GuidsTest);
-
-  MemoryAllocatorDump* AddAllocatorDumpInternal(
-      std::unique_ptr<MemoryAllocatorDump> mad);
-
-  // A per-process token, valid throughout all the lifetime of the current
-  // process, used to disambiguate dumps with the same name generated in
-  // different processes.
-  const UnguessableToken& process_token() const { return process_token_; }
-  void set_process_token_for_testing(UnguessableToken token) {
-    process_token_ = token;
-  };
-
-  // Returns the Guid of the dump for the given |absolute_name| for
-  // for the given process' token. |process_token| is used to disambiguate GUIDs
-  // derived from the same name under different processes.
-  MemoryAllocatorDumpGuid GetDumpId(const std::string& absolute_name);
-
-  void CreateSharedMemoryOwnershipEdgeInternal(
-      const MemoryAllocatorDumpGuid& client_local_dump_guid,
-      const UnguessableToken& shared_memory_guid,
-      int importance,
-      bool is_weak);
-
-  MemoryAllocatorDump* GetBlackHoleMad();
-
-  UnguessableToken process_token_;
-  AllocatorDumpsMap allocator_dumps_;
-  HeapDumpsMap heap_dumps_;
-
-  // State shared among all PMDs instances created in a given trace session.
-  scoped_refptr<HeapProfilerSerializationState>
-      heap_profiler_serialization_state_;
-
-  // Keeps track of relationships between MemoryAllocatorDump(s).
-  AllocatorDumpEdgesMap allocator_dumps_edges_;
-
-  // Level of detail of the current dump.
-  MemoryDumpArgs dump_args_;
-
-  // This allocator dump is returned when an invalid dump is created in
-  // background mode. The attributes of the dump are ignored and not added to
-  // the trace.
-  std::unique_ptr<MemoryAllocatorDump> black_hole_mad_;
-
-  // When set to true, the DCHECK(s) for invalid dump creations on the
-  // background mode are disabled for testing.
-  static bool is_black_hole_non_fatal_for_testing_;
-
-  DISALLOW_COPY_AND_ASSIGN(ProcessMemoryDump);
-};
-
-}  // namespace trace_event
-}  // namespace base
-
-#endif  // BASE_TRACE_EVENT_PROCESS_MEMORY_DUMP_H_
diff --git a/base/trace_event/trace_buffer.cc b/base/trace_event/trace_buffer.cc
deleted file mode 100644
index 8de470f..0000000
--- a/base/trace_event/trace_buffer.cc
+++ /dev/null
@@ -1,347 +0,0 @@
-// Copyright 2015 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/trace_event/trace_buffer.h"
-
-#include <memory>
-#include <utility>
-#include <vector>
-
-#include "base/macros.h"
-#include "base/trace_event/heap_profiler.h"
-#include "base/trace_event/trace_event_impl.h"
-
-namespace base {
-namespace trace_event {
-
-namespace {
-
-class TraceBufferRingBuffer : public TraceBuffer {
- public:
-  TraceBufferRingBuffer(size_t max_chunks)
-      : max_chunks_(max_chunks),
-        recyclable_chunks_queue_(new size_t[queue_capacity()]),
-        queue_head_(0),
-        queue_tail_(max_chunks),
-        current_iteration_index_(0),
-        current_chunk_seq_(1) {
-    chunks_.reserve(max_chunks);
-    for (size_t i = 0; i < max_chunks; ++i)
-      recyclable_chunks_queue_[i] = i;
-  }
-
-  std::unique_ptr<TraceBufferChunk> GetChunk(size_t* index) override {
-    HEAP_PROFILER_SCOPED_IGNORE;
-
-    // Because the number of threads is much less than the number of chunks,
-    // the queue should never be empty.
-    DCHECK(!QueueIsEmpty());
-
-    *index = recyclable_chunks_queue_[queue_head_];
-    queue_head_ = NextQueueIndex(queue_head_);
-    current_iteration_index_ = queue_head_;
-
-    if (*index >= chunks_.size())
-      chunks_.resize(*index + 1);
-
-    TraceBufferChunk* chunk = chunks_[*index].release();
-    chunks_[*index] = nullptr;  // Put nullptr in the slot of a in-flight chunk.
-    if (chunk)
-      chunk->Reset(current_chunk_seq_++);
-    else
-      chunk = new TraceBufferChunk(current_chunk_seq_++);
-
-    return std::unique_ptr<TraceBufferChunk>(chunk);
-  }
-
-  void ReturnChunk(size_t index,
-                   std::unique_ptr<TraceBufferChunk> chunk) override {
-    // When this method is called, the queue should not be full because it
-    // can contain all chunks including the one to be returned.
-    DCHECK(!QueueIsFull());
-    DCHECK(chunk);
-    DCHECK_LT(index, chunks_.size());
-    DCHECK(!chunks_[index]);
-    chunks_[index] = std::move(chunk);
-    recyclable_chunks_queue_[queue_tail_] = index;
-    queue_tail_ = NextQueueIndex(queue_tail_);
-  }
-
-  bool IsFull() const override { return false; }
-
-  size_t Size() const override {
-    // This is approximate because not all of the chunks are full.
-    return chunks_.size() * TraceBufferChunk::kTraceBufferChunkSize;
-  }
-
-  size_t Capacity() const override {
-    return max_chunks_ * TraceBufferChunk::kTraceBufferChunkSize;
-  }
-
-  TraceEvent* GetEventByHandle(TraceEventHandle handle) override {
-    if (handle.chunk_index >= chunks_.size())
-      return nullptr;
-    TraceBufferChunk* chunk = chunks_[handle.chunk_index].get();
-    if (!chunk || chunk->seq() != handle.chunk_seq)
-      return nullptr;
-    return chunk->GetEventAt(handle.event_index);
-  }
-
-  const TraceBufferChunk* NextChunk() override {
-    if (chunks_.empty())
-      return nullptr;
-
-    while (current_iteration_index_ != queue_tail_) {
-      size_t chunk_index = recyclable_chunks_queue_[current_iteration_index_];
-      current_iteration_index_ = NextQueueIndex(current_iteration_index_);
-      if (chunk_index >= chunks_.size())  // Skip uninitialized chunks.
-        continue;
-      DCHECK(chunks_[chunk_index]);
-      return chunks_[chunk_index].get();
-    }
-    return nullptr;
-  }
-
-  void EstimateTraceMemoryOverhead(
-      TraceEventMemoryOverhead* overhead) override {
-    overhead->Add(TraceEventMemoryOverhead::kTraceBuffer, sizeof(*this));
-    for (size_t queue_index = queue_head_; queue_index != queue_tail_;
-         queue_index = NextQueueIndex(queue_index)) {
-      size_t chunk_index = recyclable_chunks_queue_[queue_index];
-      if (chunk_index >= chunks_.size())  // Skip uninitialized chunks.
-        continue;
-      chunks_[chunk_index]->EstimateTraceMemoryOverhead(overhead);
-    }
-  }
-
- private:
-  bool QueueIsEmpty() const { return queue_head_ == queue_tail_; }
-
-  size_t QueueSize() const {
-    return queue_tail_ > queue_head_
-               ? queue_tail_ - queue_head_
-               : queue_tail_ + queue_capacity() - queue_head_;
-  }
-
-  bool QueueIsFull() const { return QueueSize() == queue_capacity() - 1; }
-
-  size_t queue_capacity() const {
-    // One extra space to help distinguish full state and empty state.
-    return max_chunks_ + 1;
-  }
-
-  size_t NextQueueIndex(size_t index) const {
-    index++;
-    if (index >= queue_capacity())
-      index = 0;
-    return index;
-  }
-
-  size_t max_chunks_;
-  std::vector<std::unique_ptr<TraceBufferChunk>> chunks_;
-
-  std::unique_ptr<size_t[]> recyclable_chunks_queue_;
-  size_t queue_head_;
-  size_t queue_tail_;
-
-  size_t current_iteration_index_;
-  uint32_t current_chunk_seq_;
-
-  DISALLOW_COPY_AND_ASSIGN(TraceBufferRingBuffer);
-};
-
-class TraceBufferVector : public TraceBuffer {
- public:
-  TraceBufferVector(size_t max_chunks)
-      : in_flight_chunk_count_(0),
-        current_iteration_index_(0),
-        max_chunks_(max_chunks) {
-    chunks_.reserve(max_chunks_);
-  }
-
-  std::unique_ptr<TraceBufferChunk> GetChunk(size_t* index) override {
-    HEAP_PROFILER_SCOPED_IGNORE;
-
-    // This function may be called when adding normal events or indirectly from
-    // AddMetadataEventsWhileLocked(). We can not DECHECK(!IsFull()) because we
-    // have to add the metadata events and flush thread-local buffers even if
-    // the buffer is full.
-    *index = chunks_.size();
-    // Put nullptr in the slot of a in-flight chunk.
-    chunks_.push_back(nullptr);
-    ++in_flight_chunk_count_;
-    // + 1 because zero chunk_seq is not allowed.
-    return std::unique_ptr<TraceBufferChunk>(
-        new TraceBufferChunk(static_cast<uint32_t>(*index) + 1));
-  }
-
-  void ReturnChunk(size_t index,
-                   std::unique_ptr<TraceBufferChunk> chunk) override {
-    DCHECK_GT(in_flight_chunk_count_, 0u);
-    DCHECK_LT(index, chunks_.size());
-    DCHECK(!chunks_[index]);
-    --in_flight_chunk_count_;
-    chunks_[index] = std::move(chunk);
-  }
-
-  bool IsFull() const override { return chunks_.size() >= max_chunks_; }
-
-  size_t Size() const override {
-    // This is approximate because not all of the chunks are full.
-    return chunks_.size() * TraceBufferChunk::kTraceBufferChunkSize;
-  }
-
-  size_t Capacity() const override {
-    return max_chunks_ * TraceBufferChunk::kTraceBufferChunkSize;
-  }
-
-  TraceEvent* GetEventByHandle(TraceEventHandle handle) override {
-    if (handle.chunk_index >= chunks_.size())
-      return nullptr;
-    TraceBufferChunk* chunk = chunks_[handle.chunk_index].get();
-    if (!chunk || chunk->seq() != handle.chunk_seq)
-      return nullptr;
-    return chunk->GetEventAt(handle.event_index);
-  }
-
-  const TraceBufferChunk* NextChunk() override {
-    while (current_iteration_index_ < chunks_.size()) {
-      // Skip in-flight chunks.
-      const TraceBufferChunk* chunk = chunks_[current_iteration_index_++].get();
-      if (chunk)
-        return chunk;
-    }
-    return nullptr;
-  }
-
-  void EstimateTraceMemoryOverhead(
-      TraceEventMemoryOverhead* overhead) override {
-    const size_t chunks_ptr_vector_allocated_size =
-        sizeof(*this) + max_chunks_ * sizeof(decltype(chunks_)::value_type);
-    const size_t chunks_ptr_vector_resident_size =
-        sizeof(*this) + chunks_.size() * sizeof(decltype(chunks_)::value_type);
-    overhead->Add(TraceEventMemoryOverhead::kTraceBuffer,
-                  chunks_ptr_vector_allocated_size,
-                  chunks_ptr_vector_resident_size);
-    for (size_t i = 0; i < chunks_.size(); ++i) {
-      TraceBufferChunk* chunk = chunks_[i].get();
-      // Skip the in-flight (nullptr) chunks. They will be accounted by the
-      // per-thread-local dumpers, see ThreadLocalEventBuffer::OnMemoryDump.
-      if (chunk)
-        chunk->EstimateTraceMemoryOverhead(overhead);
-    }
-  }
-
- private:
-  size_t in_flight_chunk_count_;
-  size_t current_iteration_index_;
-  size_t max_chunks_;
-  std::vector<std::unique_ptr<TraceBufferChunk>> chunks_;
-
-  DISALLOW_COPY_AND_ASSIGN(TraceBufferVector);
-};
-
-}  // namespace
-
-TraceBufferChunk::TraceBufferChunk(uint32_t seq) : next_free_(0), seq_(seq) {}
-
-TraceBufferChunk::~TraceBufferChunk() = default;
-
-void TraceBufferChunk::Reset(uint32_t new_seq) {
-  for (size_t i = 0; i < next_free_; ++i)
-    chunk_[i].Reset();
-  next_free_ = 0;
-  seq_ = new_seq;
-  cached_overhead_estimate_.reset();
-}
-
-TraceEvent* TraceBufferChunk::AddTraceEvent(size_t* event_index) {
-  DCHECK(!IsFull());
-  *event_index = next_free_++;
-  return &chunk_[*event_index];
-}
-
-void TraceBufferChunk::EstimateTraceMemoryOverhead(
-    TraceEventMemoryOverhead* overhead) {
-  if (!cached_overhead_estimate_) {
-    cached_overhead_estimate_.reset(new TraceEventMemoryOverhead);
-
-    // When estimating the size of TraceBufferChunk, exclude the array of trace
-    // events, as they are computed individually below.
-    cached_overhead_estimate_->Add(TraceEventMemoryOverhead::kTraceBufferChunk,
-                                   sizeof(*this) - sizeof(chunk_));
-  }
-
-  const size_t num_cached_estimated_events =
-      cached_overhead_estimate_->GetCount(
-          TraceEventMemoryOverhead::kTraceEvent);
-  DCHECK_LE(num_cached_estimated_events, size());
-
-  if (IsFull() && num_cached_estimated_events == size()) {
-    overhead->Update(*cached_overhead_estimate_);
-    return;
-  }
-
-  for (size_t i = num_cached_estimated_events; i < size(); ++i)
-    chunk_[i].EstimateTraceMemoryOverhead(cached_overhead_estimate_.get());
-
-  if (IsFull()) {
-    cached_overhead_estimate_->AddSelf();
-  } else {
-    // The unused TraceEvents in |chunks_| are not cached. They will keep
-    // changing as new TraceEvents are added to this chunk, so they are
-    // computed on the fly.
-    const size_t num_unused_trace_events = capacity() - size();
-    overhead->Add(TraceEventMemoryOverhead::kUnusedTraceEvent,
-                  num_unused_trace_events * sizeof(TraceEvent));
-  }
-
-  overhead->Update(*cached_overhead_estimate_);
-}
-
-TraceResultBuffer::OutputCallback
-TraceResultBuffer::SimpleOutput::GetCallback() {
-  return Bind(&SimpleOutput::Append, Unretained(this));
-}
-
-void TraceResultBuffer::SimpleOutput::Append(
-    const std::string& json_trace_output) {
-  json_output += json_trace_output;
-}
-
-TraceResultBuffer::TraceResultBuffer() : append_comma_(false) {}
-
-TraceResultBuffer::~TraceResultBuffer() = default;
-
-void TraceResultBuffer::SetOutputCallback(
-    const OutputCallback& json_chunk_callback) {
-  output_callback_ = json_chunk_callback;
-}
-
-void TraceResultBuffer::Start() {
-  append_comma_ = false;
-  output_callback_.Run("[");
-}
-
-void TraceResultBuffer::AddFragment(const std::string& trace_fragment) {
-  if (append_comma_)
-    output_callback_.Run(",");
-  append_comma_ = true;
-  output_callback_.Run(trace_fragment);
-}
-
-void TraceResultBuffer::Finish() {
-  output_callback_.Run("]");
-}
-
-TraceBuffer* TraceBuffer::CreateTraceBufferRingBuffer(size_t max_chunks) {
-  return new TraceBufferRingBuffer(max_chunks);
-}
-
-TraceBuffer* TraceBuffer::CreateTraceBufferVectorOfSize(size_t max_chunks) {
-  return new TraceBufferVector(max_chunks);
-}
-
-}  // namespace trace_event
-}  // namespace base
diff --git a/base/trace_event/trace_buffer.h b/base/trace_event/trace_buffer.h
deleted file mode 100644
index 3d6465f..0000000
--- a/base/trace_event/trace_buffer.h
+++ /dev/null
@@ -1,130 +0,0 @@
-// Copyright 2015 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_TRACE_EVENT_TRACE_BUFFER_H_
-#define BASE_TRACE_EVENT_TRACE_BUFFER_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-#include "base/base_export.h"
-#include "base/trace_event/trace_event.h"
-#include "base/trace_event/trace_event_impl.h"
-
-namespace base {
-
-namespace trace_event {
-
-// TraceBufferChunk is the basic unit of TraceBuffer.
-class BASE_EXPORT TraceBufferChunk {
- public:
-  explicit TraceBufferChunk(uint32_t seq);
-  ~TraceBufferChunk();
-
-  void Reset(uint32_t new_seq);
-  TraceEvent* AddTraceEvent(size_t* event_index);
-  bool IsFull() const { return next_free_ == kTraceBufferChunkSize; }
-
-  uint32_t seq() const { return seq_; }
-  size_t capacity() const { return kTraceBufferChunkSize; }
-  size_t size() const { return next_free_; }
-
-  TraceEvent* GetEventAt(size_t index) {
-    DCHECK(index < size());
-    return &chunk_[index];
-  }
-  const TraceEvent* GetEventAt(size_t index) const {
-    DCHECK(index < size());
-    return &chunk_[index];
-  }
-
-  void EstimateTraceMemoryOverhead(TraceEventMemoryOverhead* overhead);
-
-  // These values must be kept consistent with the numbers of bits of
-  // chunk_index and event_index fields in TraceEventHandle
-  // (in trace_event_impl.h).
-  static const size_t kMaxChunkIndex = (1u << 26) - 1;
-  static const size_t kTraceBufferChunkSize = 64;
-
- private:
-  size_t next_free_;
-  std::unique_ptr<TraceEventMemoryOverhead> cached_overhead_estimate_;
-  TraceEvent chunk_[kTraceBufferChunkSize];
-  uint32_t seq_;
-};
-
-// TraceBuffer holds the events as they are collected.
-class BASE_EXPORT TraceBuffer {
- public:
-  virtual ~TraceBuffer() = default;
-
-  virtual std::unique_ptr<TraceBufferChunk> GetChunk(size_t* index) = 0;
-  virtual void ReturnChunk(size_t index,
-                           std::unique_ptr<TraceBufferChunk> chunk) = 0;
-
-  virtual bool IsFull() const = 0;
-  virtual size_t Size() const = 0;
-  virtual size_t Capacity() const = 0;
-  virtual TraceEvent* GetEventByHandle(TraceEventHandle handle) = 0;
-
-  // For iteration. Each TraceBuffer can only be iterated once.
-  virtual const TraceBufferChunk* NextChunk() = 0;
-
-
-  // Computes an estimate of the size of the buffer, including all the retained
-  // objects.
-  virtual void EstimateTraceMemoryOverhead(
-      TraceEventMemoryOverhead* overhead) = 0;
-
-  static TraceBuffer* CreateTraceBufferRingBuffer(size_t max_chunks);
-  static TraceBuffer* CreateTraceBufferVectorOfSize(size_t max_chunks);
-};
-
-// TraceResultBuffer collects and converts trace fragments returned by TraceLog
-// to JSON output.
-class BASE_EXPORT TraceResultBuffer {
- public:
-  typedef base::Callback<void(const std::string&)> OutputCallback;
-
-  // If you don't need to stream JSON chunks out efficiently, and just want to
-  // get a complete JSON string after calling Finish, use this struct to collect
-  // JSON trace output.
-  struct BASE_EXPORT SimpleOutput {
-    OutputCallback GetCallback();
-    void Append(const std::string& json_string);
-
-    // Do what you want with the json_output_ string after calling
-    // TraceResultBuffer::Finish.
-    std::string json_output;
-  };
-
-  TraceResultBuffer();
-  ~TraceResultBuffer();
-
-  // Set callback. The callback will be called during Start with the initial
-  // JSON output and during AddFragment and Finish with following JSON output
-  // chunks. The callback target must live past the last calls to
-  // TraceResultBuffer::Start/AddFragment/Finish.
-  void SetOutputCallback(const OutputCallback& json_chunk_callback);
-
-  // Start JSON output. This resets all internal state, so you can reuse
-  // the TraceResultBuffer by calling Start.
-  void Start();
-
-  // Call AddFragment 0 or more times to add trace fragments from TraceLog.
-  void AddFragment(const std::string& trace_fragment);
-
-  // When all fragments have been added, call Finish to complete the JSON
-  // formatted output.
-  void Finish();
-
- private:
-  OutputCallback output_callback_;
-  bool append_comma_;
-};
-
-}  // namespace trace_event
-}  // namespace base
-
-#endif  // BASE_TRACE_EVENT_TRACE_BUFFER_H_
diff --git a/base/trace_event/trace_category.h b/base/trace_event/trace_category.h
deleted file mode 100644
index 792bc5e..0000000
--- a/base/trace_event/trace_category.h
+++ /dev/null
@@ -1,109 +0,0 @@
-// Copyright 2016 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_TRACE_EVENT_TRACE_CATEGORY_H_
-#define BASE_TRACE_EVENT_TRACE_CATEGORY_H_
-
-#include <stdint.h>
-
-namespace base {
-namespace trace_event {
-
-// Captures the state of an invidivual trace category. Nothing except tracing
-// internals (e.g., TraceLog) is supposed to have non-const Category pointers.
-struct TraceCategory {
-  // The TRACE_EVENT macros should only use this value as a bool.
-  // These enum values are effectively a public API and third_party projects
-  // depend on their value. Hence, never remove or recycle existing bits, unless
-  // you are sure that all the third-party projects that depend on this have
-  // been updated.
-  enum StateFlags : uint8_t {
-    ENABLED_FOR_RECORDING = 1 << 0,
-
-    // Not used anymore.
-    DEPRECATED_ENABLED_FOR_MONITORING = 1 << 1,
-    DEPRECATED_ENABLED_FOR_EVENT_CALLBACK = 1 << 2,
-
-    ENABLED_FOR_ETW_EXPORT = 1 << 3,
-    ENABLED_FOR_FILTERING = 1 << 4
-  };
-
-  static const TraceCategory* FromStatePtr(const uint8_t* state_ptr) {
-    static_assert(
-        offsetof(TraceCategory, state_) == 0,
-        "|state_| must be the first field of the TraceCategory class.");
-    return reinterpret_cast<const TraceCategory*>(state_ptr);
-  }
-
-  bool is_valid() const { return name_ != nullptr; }
-  void set_name(const char* name) { name_ = name; }
-  const char* name() const {
-    DCHECK(is_valid());
-    return name_;
-  }
-
-  // TODO(primiano): This is an intermediate solution to deal with the fact that
-  // today TRACE_EVENT* macros cache the state ptr. They should just cache the
-  // full TraceCategory ptr, which is immutable, and use these helper function
-  // here. This will get rid of the need of this awkward ptr getter completely.
-  const uint8_t* state_ptr() const {
-    return const_cast<const uint8_t*>(&state_);
-  }
-
-  uint8_t state() const {
-    return *const_cast<volatile const uint8_t*>(&state_);
-  }
-
-  bool is_enabled() const { return state() != 0; }
-
-  void set_state(uint8_t state) {
-    *const_cast<volatile uint8_t*>(&state_) = state;
-  }
-
-  void clear_state_flag(StateFlags flag) { set_state(state() & (~flag)); }
-  void set_state_flag(StateFlags flag) { set_state(state() | flag); }
-
-  uint32_t enabled_filters() const {
-    return *const_cast<volatile const uint32_t*>(&enabled_filters_);
-  }
-
-  bool is_filter_enabled(size_t index) const {
-    DCHECK(index < sizeof(enabled_filters_) * 8);
-    return (enabled_filters() & (1 << index)) != 0;
-  }
-
-  void set_enabled_filters(uint32_t enabled_filters) {
-    *const_cast<volatile uint32_t*>(&enabled_filters_) = enabled_filters;
-  }
-
-  void reset_for_testing() {
-    set_state(0);
-    set_enabled_filters(0);
-  }
-
-  // These fields should not be accessed directly, not even by tracing code.
-  // The only reason why these are not private is because it makes it impossible
-  // to have a global array of TraceCategory in category_registry.cc without
-  // creating initializers. See discussion on goo.gl/qhZN94 and
-  // crbug.com/{660967,660828}.
-
-  // The enabled state. TRACE_EVENT* macros will capture events if any of the
-  // flags here are set. Since TRACE_EVENTx macros are used in a lot of
-  // fast-paths, accesses to this field are non-barriered and racy by design.
-  // This field is mutated when starting/stopping tracing and we don't care
-  // about missing some events.
-  uint8_t state_;
-
-  // When ENABLED_FOR_FILTERING is set, this contains a bitmap to the
-  // corresponding filter (see event_filters.h).
-  uint32_t enabled_filters_;
-
-  // TraceCategory group names are long lived static strings.
-  const char* name_;
-};
-
-}  // namespace trace_event
-}  // namespace base
-
-#endif  // BASE_TRACE_EVENT_TRACE_CATEGORY_H_
diff --git a/base/trace_event/trace_config.cc b/base/trace_event/trace_config.cc
deleted file mode 100644
index 624a29c..0000000
--- a/base/trace_event/trace_config.cc
+++ /dev/null
@@ -1,557 +0,0 @@
-// Copyright (c) 2015 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/trace_event/trace_config.h"
-
-#include <stddef.h>
-
-#include <utility>
-
-#include "base/json/json_reader.h"
-#include "base/json/json_writer.h"
-#include "base/memory/ptr_util.h"
-#include "base/strings/string_split.h"
-#include "base/trace_event/memory_dump_manager.h"
-#include "base/trace_event/memory_dump_request_args.h"
-#include "base/trace_event/trace_event.h"
-
-namespace base {
-namespace trace_event {
-
-namespace {
-
-// String options that can be used to initialize TraceOptions.
-const char kRecordUntilFull[] = "record-until-full";
-const char kRecordContinuously[] = "record-continuously";
-const char kRecordAsMuchAsPossible[] = "record-as-much-as-possible";
-const char kTraceToConsole[] = "trace-to-console";
-const char kEnableSystrace[] = "enable-systrace";
-const char kEnableArgumentFilter[] = "enable-argument-filter";
-
-// String parameters that can be used to parse the trace config string.
-const char kRecordModeParam[] = "record_mode";
-const char kEnableSystraceParam[] = "enable_systrace";
-const char kEnableArgumentFilterParam[] = "enable_argument_filter";
-
-// String parameters that is used to parse memory dump config in trace config
-// string.
-const char kMemoryDumpConfigParam[] = "memory_dump_config";
-const char kAllowedDumpModesParam[] = "allowed_dump_modes";
-const char kTriggersParam[] = "triggers";
-const char kTriggerModeParam[] = "mode";
-const char kMinTimeBetweenDumps[] = "min_time_between_dumps_ms";
-const char kTriggerTypeParam[] = "type";
-const char kPeriodicIntervalLegacyParam[] = "periodic_interval_ms";
-const char kHeapProfilerOptions[] = "heap_profiler_options";
-const char kBreakdownThresholdBytes[] = "breakdown_threshold_bytes";
-
-// String parameters used to parse category event filters.
-const char kEventFiltersParam[] = "event_filters";
-const char kFilterPredicateParam[] = "filter_predicate";
-const char kFilterArgsParam[] = "filter_args";
-
-class ConvertableTraceConfigToTraceFormat
-    : public base::trace_event::ConvertableToTraceFormat {
- public:
-  explicit ConvertableTraceConfigToTraceFormat(const TraceConfig& trace_config)
-      : trace_config_(trace_config) {}
-
-  ~ConvertableTraceConfigToTraceFormat() override = default;
-
-  void AppendAsTraceFormat(std::string* out) const override {
-    out->append(trace_config_.ToString());
-  }
-
- private:
-  const TraceConfig trace_config_;
-};
-
-std::set<MemoryDumpLevelOfDetail> GetDefaultAllowedMemoryDumpModes() {
-  std::set<MemoryDumpLevelOfDetail> all_modes;
-  for (uint32_t mode = static_cast<uint32_t>(MemoryDumpLevelOfDetail::FIRST);
-       mode <= static_cast<uint32_t>(MemoryDumpLevelOfDetail::LAST); mode++) {
-    all_modes.insert(static_cast<MemoryDumpLevelOfDetail>(mode));
-  }
-  return all_modes;
-}
-
-}  // namespace
-
-TraceConfig::MemoryDumpConfig::HeapProfiler::HeapProfiler()
-    : breakdown_threshold_bytes(kDefaultBreakdownThresholdBytes) {}
-
-void TraceConfig::MemoryDumpConfig::HeapProfiler::Clear() {
-  breakdown_threshold_bytes = kDefaultBreakdownThresholdBytes;
-}
-
-void TraceConfig::ResetMemoryDumpConfig(
-    const TraceConfig::MemoryDumpConfig& memory_dump_config) {
-  memory_dump_config_.Clear();
-  memory_dump_config_ = memory_dump_config;
-}
-
-TraceConfig::MemoryDumpConfig::MemoryDumpConfig() = default;
-
-TraceConfig::MemoryDumpConfig::MemoryDumpConfig(
-    const MemoryDumpConfig& other) = default;
-
-TraceConfig::MemoryDumpConfig::~MemoryDumpConfig() = default;
-
-void TraceConfig::MemoryDumpConfig::Clear() {
-  allowed_dump_modes.clear();
-  triggers.clear();
-  heap_profiler_options.Clear();
-}
-
-void TraceConfig::MemoryDumpConfig::Merge(
-    const TraceConfig::MemoryDumpConfig& config) {
-  triggers.insert(triggers.end(), config.triggers.begin(),
-                  config.triggers.end());
-  allowed_dump_modes.insert(config.allowed_dump_modes.begin(),
-                            config.allowed_dump_modes.end());
-  heap_profiler_options.breakdown_threshold_bytes =
-      std::min(heap_profiler_options.breakdown_threshold_bytes,
-               config.heap_profiler_options.breakdown_threshold_bytes);
-}
-
-TraceConfig::EventFilterConfig::EventFilterConfig(
-    const std::string& predicate_name)
-    : predicate_name_(predicate_name) {}
-
-TraceConfig::EventFilterConfig::~EventFilterConfig() = default;
-
-TraceConfig::EventFilterConfig::EventFilterConfig(const EventFilterConfig& tc) {
-  *this = tc;
-}
-
-TraceConfig::EventFilterConfig& TraceConfig::EventFilterConfig::operator=(
-    const TraceConfig::EventFilterConfig& rhs) {
-  if (this == &rhs)
-    return *this;
-
-  predicate_name_ = rhs.predicate_name_;
-  category_filter_ = rhs.category_filter_;
-
-  if (rhs.args_)
-    args_ = rhs.args_->CreateDeepCopy();
-
-  return *this;
-}
-
-void TraceConfig::EventFilterConfig::InitializeFromConfigDict(
-    const base::DictionaryValue* event_filter) {
-  category_filter_.InitializeFromConfigDict(*event_filter);
-
-  const base::DictionaryValue* args_dict = nullptr;
-  if (event_filter->GetDictionary(kFilterArgsParam, &args_dict))
-    args_ = args_dict->CreateDeepCopy();
-}
-
-void TraceConfig::EventFilterConfig::SetCategoryFilter(
-    const TraceConfigCategoryFilter& category_filter) {
-  category_filter_ = category_filter;
-}
-
-void TraceConfig::EventFilterConfig::ToDict(
-    DictionaryValue* filter_dict) const {
-  filter_dict->SetString(kFilterPredicateParam, predicate_name());
-
-  category_filter_.ToDict(filter_dict);
-
-  if (args_)
-    filter_dict->Set(kFilterArgsParam, args_->CreateDeepCopy());
-}
-
-bool TraceConfig::EventFilterConfig::GetArgAsSet(
-    const char* key,
-    std::unordered_set<std::string>* out_set) const {
-  const ListValue* list = nullptr;
-  if (!args_->GetList(key, &list))
-    return false;
-  for (size_t i = 0; i < list->GetSize(); ++i) {
-    std::string value;
-    if (list->GetString(i, &value))
-      out_set->insert(value);
-  }
-  return true;
-}
-
-bool TraceConfig::EventFilterConfig::IsCategoryGroupEnabled(
-    const StringPiece& category_group_name) const {
-  return category_filter_.IsCategoryGroupEnabled(category_group_name);
-}
-
-// static
-std::string TraceConfig::TraceRecordModeToStr(TraceRecordMode record_mode) {
-  switch (record_mode) {
-    case RECORD_UNTIL_FULL:
-      return kRecordUntilFull;
-    case RECORD_CONTINUOUSLY:
-      return kRecordContinuously;
-    case RECORD_AS_MUCH_AS_POSSIBLE:
-      return kRecordAsMuchAsPossible;
-    case ECHO_TO_CONSOLE:
-      return kTraceToConsole;
-    default:
-      NOTREACHED();
-  }
-  return kRecordUntilFull;
-}
-
-TraceConfig::TraceConfig() {
-  InitializeDefault();
-}
-
-TraceConfig::TraceConfig(StringPiece category_filter_string,
-                         StringPiece trace_options_string) {
-  InitializeFromStrings(category_filter_string, trace_options_string);
-}
-
-TraceConfig::TraceConfig(StringPiece category_filter_string,
-                         TraceRecordMode record_mode) {
-  InitializeFromStrings(category_filter_string,
-                        TraceConfig::TraceRecordModeToStr(record_mode));
-}
-
-TraceConfig::TraceConfig(const DictionaryValue& config) {
-  InitializeFromConfigDict(config);
-}
-
-TraceConfig::TraceConfig(StringPiece config_string) {
-  if (!config_string.empty())
-    InitializeFromConfigString(config_string);
-  else
-    InitializeDefault();
-}
-
-TraceConfig::TraceConfig(const TraceConfig& tc) = default;
-
-TraceConfig::~TraceConfig() = default;
-
-TraceConfig& TraceConfig::operator=(const TraceConfig& rhs) {
-  if (this == &rhs)
-    return *this;
-
-  record_mode_ = rhs.record_mode_;
-  enable_systrace_ = rhs.enable_systrace_;
-  enable_argument_filter_ = rhs.enable_argument_filter_;
-  category_filter_ = rhs.category_filter_;
-  memory_dump_config_ = rhs.memory_dump_config_;
-  event_filters_ = rhs.event_filters_;
-  return *this;
-}
-
-std::string TraceConfig::ToString() const {
-  std::unique_ptr<DictionaryValue> dict = ToDict();
-  std::string json;
-  JSONWriter::Write(*dict, &json);
-  return json;
-}
-
-std::unique_ptr<ConvertableToTraceFormat>
-TraceConfig::AsConvertableToTraceFormat() const {
-  return std::make_unique<ConvertableTraceConfigToTraceFormat>(*this);
-}
-
-std::string TraceConfig::ToCategoryFilterString() const {
-  return category_filter_.ToFilterString();
-}
-
-bool TraceConfig::IsCategoryGroupEnabled(
-    const StringPiece& category_group_name) const {
-  // TraceLog should call this method only as part of enabling/disabling
-  // categories.
-  return category_filter_.IsCategoryGroupEnabled(category_group_name);
-}
-
-void TraceConfig::Merge(const TraceConfig& config) {
-  if (record_mode_ != config.record_mode_
-      || enable_systrace_ != config.enable_systrace_
-      || enable_argument_filter_ != config.enable_argument_filter_) {
-    DLOG(ERROR) << "Attempting to merge trace config with a different "
-                << "set of options.";
-  }
-
-  category_filter_.Merge(config.category_filter_);
-
-  memory_dump_config_.Merge(config.memory_dump_config_);
-
-  event_filters_.insert(event_filters_.end(), config.event_filters().begin(),
-                        config.event_filters().end());
-}
-
-void TraceConfig::Clear() {
-  record_mode_ = RECORD_UNTIL_FULL;
-  enable_systrace_ = false;
-  enable_argument_filter_ = false;
-  category_filter_.Clear();
-  memory_dump_config_.Clear();
-  event_filters_.clear();
-}
-
-void TraceConfig::InitializeDefault() {
-  record_mode_ = RECORD_UNTIL_FULL;
-  enable_systrace_ = false;
-  enable_argument_filter_ = false;
-}
-
-void TraceConfig::InitializeFromConfigDict(const DictionaryValue& dict) {
-  record_mode_ = RECORD_UNTIL_FULL;
-  std::string record_mode;
-  if (dict.GetString(kRecordModeParam, &record_mode)) {
-    if (record_mode == kRecordUntilFull) {
-      record_mode_ = RECORD_UNTIL_FULL;
-    } else if (record_mode == kRecordContinuously) {
-      record_mode_ = RECORD_CONTINUOUSLY;
-    } else if (record_mode == kTraceToConsole) {
-      record_mode_ = ECHO_TO_CONSOLE;
-    } else if (record_mode == kRecordAsMuchAsPossible) {
-      record_mode_ = RECORD_AS_MUCH_AS_POSSIBLE;
-    }
-  }
-
-  bool val;
-  enable_systrace_ = dict.GetBoolean(kEnableSystraceParam, &val) ? val : false;
-  enable_argument_filter_ =
-      dict.GetBoolean(kEnableArgumentFilterParam, &val) ? val : false;
-
-  category_filter_.InitializeFromConfigDict(dict);
-
-  const base::ListValue* category_event_filters = nullptr;
-  if (dict.GetList(kEventFiltersParam, &category_event_filters))
-    SetEventFiltersFromConfigList(*category_event_filters);
-
-  if (category_filter_.IsCategoryEnabled(MemoryDumpManager::kTraceCategory)) {
-    // If dump triggers not set, the client is using the legacy with just
-    // category enabled. So, use the default periodic dump config.
-    const DictionaryValue* memory_dump_config = nullptr;
-    if (dict.GetDictionary(kMemoryDumpConfigParam, &memory_dump_config))
-      SetMemoryDumpConfigFromConfigDict(*memory_dump_config);
-    else
-      SetDefaultMemoryDumpConfig();
-  }
-}
-
-void TraceConfig::InitializeFromConfigString(StringPiece config_string) {
-  auto dict = DictionaryValue::From(JSONReader::Read(config_string));
-  if (dict)
-    InitializeFromConfigDict(*dict);
-  else
-    InitializeDefault();
-}
-
-void TraceConfig::InitializeFromStrings(StringPiece category_filter_string,
-                                        StringPiece trace_options_string) {
-  if (!category_filter_string.empty())
-    category_filter_.InitializeFromString(category_filter_string);
-
-  record_mode_ = RECORD_UNTIL_FULL;
-  enable_systrace_ = false;
-  enable_argument_filter_ = false;
-  if (!trace_options_string.empty()) {
-    std::vector<std::string> split =
-        SplitString(trace_options_string, ",", TRIM_WHITESPACE, SPLIT_WANT_ALL);
-    for (const std::string& token : split) {
-      if (token == kRecordUntilFull) {
-        record_mode_ = RECORD_UNTIL_FULL;
-      } else if (token == kRecordContinuously) {
-        record_mode_ = RECORD_CONTINUOUSLY;
-      } else if (token == kTraceToConsole) {
-        record_mode_ = ECHO_TO_CONSOLE;
-      } else if (token == kRecordAsMuchAsPossible) {
-        record_mode_ = RECORD_AS_MUCH_AS_POSSIBLE;
-      } else if (token == kEnableSystrace) {
-        enable_systrace_ = true;
-      } else if (token == kEnableArgumentFilter) {
-        enable_argument_filter_ = true;
-      }
-    }
-  }
-
-  if (category_filter_.IsCategoryEnabled(MemoryDumpManager::kTraceCategory)) {
-    SetDefaultMemoryDumpConfig();
-  }
-}
-
-void TraceConfig::SetMemoryDumpConfigFromConfigDict(
-    const DictionaryValue& memory_dump_config) {
-  // Set allowed dump modes.
-  memory_dump_config_.allowed_dump_modes.clear();
-  const ListValue* allowed_modes_list;
-  if (memory_dump_config.GetList(kAllowedDumpModesParam, &allowed_modes_list)) {
-    for (size_t i = 0; i < allowed_modes_list->GetSize(); ++i) {
-      std::string level_of_detail_str;
-      allowed_modes_list->GetString(i, &level_of_detail_str);
-      memory_dump_config_.allowed_dump_modes.insert(
-          StringToMemoryDumpLevelOfDetail(level_of_detail_str));
-    }
-  } else {
-    // If allowed modes param is not given then allow all modes by default.
-    memory_dump_config_.allowed_dump_modes = GetDefaultAllowedMemoryDumpModes();
-  }
-
-  // Set triggers
-  memory_dump_config_.triggers.clear();
-  const ListValue* trigger_list = nullptr;
-  if (memory_dump_config.GetList(kTriggersParam, &trigger_list) &&
-      trigger_list->GetSize() > 0) {
-    for (size_t i = 0; i < trigger_list->GetSize(); ++i) {
-      const DictionaryValue* trigger = nullptr;
-      if (!trigger_list->GetDictionary(i, &trigger))
-        continue;
-
-      MemoryDumpConfig::Trigger dump_config;
-      int interval = 0;
-      if (!trigger->GetInteger(kMinTimeBetweenDumps, &interval)) {
-        // If "min_time_between_dumps_ms" param was not given, then the trace
-        // config uses old format where only periodic dumps are supported.
-        trigger->GetInteger(kPeriodicIntervalLegacyParam, &interval);
-        dump_config.trigger_type = MemoryDumpType::PERIODIC_INTERVAL;
-      } else {
-        std::string trigger_type_str;
-        trigger->GetString(kTriggerTypeParam, &trigger_type_str);
-        dump_config.trigger_type = StringToMemoryDumpType(trigger_type_str);
-      }
-      DCHECK_GT(interval, 0);
-      dump_config.min_time_between_dumps_ms = static_cast<uint32_t>(interval);
-
-      std::string level_of_detail_str;
-      trigger->GetString(kTriggerModeParam, &level_of_detail_str);
-      dump_config.level_of_detail =
-          StringToMemoryDumpLevelOfDetail(level_of_detail_str);
-
-      memory_dump_config_.triggers.push_back(dump_config);
-    }
-  }
-
-  // Set heap profiler options
-  const DictionaryValue* heap_profiler_options = nullptr;
-  if (memory_dump_config.GetDictionary(kHeapProfilerOptions,
-                                       &heap_profiler_options)) {
-    int min_size_bytes = 0;
-    if (heap_profiler_options->GetInteger(kBreakdownThresholdBytes,
-                                         &min_size_bytes)
-        && min_size_bytes >= 0) {
-      memory_dump_config_.heap_profiler_options.breakdown_threshold_bytes =
-          static_cast<size_t>(min_size_bytes);
-    } else {
-      memory_dump_config_.heap_profiler_options.breakdown_threshold_bytes =
-          MemoryDumpConfig::HeapProfiler::kDefaultBreakdownThresholdBytes;
-    }
-  }
-}
-
-void TraceConfig::SetDefaultMemoryDumpConfig() {
-  memory_dump_config_.Clear();
-  memory_dump_config_.allowed_dump_modes = GetDefaultAllowedMemoryDumpModes();
-}
-
-void TraceConfig::SetEventFiltersFromConfigList(
-    const base::ListValue& category_event_filters) {
-  event_filters_.clear();
-
-  for (size_t event_filter_index = 0;
-       event_filter_index < category_event_filters.GetSize();
-       ++event_filter_index) {
-    const base::DictionaryValue* event_filter = nullptr;
-    if (!category_event_filters.GetDictionary(event_filter_index,
-                                              &event_filter))
-      continue;
-
-    std::string predicate_name;
-    CHECK(event_filter->GetString(kFilterPredicateParam, &predicate_name))
-        << "Invalid predicate name in category event filter.";
-
-    EventFilterConfig new_config(predicate_name);
-    new_config.InitializeFromConfigDict(event_filter);
-    event_filters_.push_back(new_config);
-  }
-}
-
-std::unique_ptr<DictionaryValue> TraceConfig::ToDict() const {
-  auto dict = std::make_unique<DictionaryValue>();
-  dict->SetString(kRecordModeParam,
-                  TraceConfig::TraceRecordModeToStr(record_mode_));
-  dict->SetBoolean(kEnableSystraceParam, enable_systrace_);
-  dict->SetBoolean(kEnableArgumentFilterParam, enable_argument_filter_);
-
-  category_filter_.ToDict(dict.get());
-
-  if (!event_filters_.empty()) {
-    std::unique_ptr<base::ListValue> filter_list(new base::ListValue());
-    for (const EventFilterConfig& filter : event_filters_) {
-      std::unique_ptr<base::DictionaryValue> filter_dict(
-          new base::DictionaryValue());
-      filter.ToDict(filter_dict.get());
-      filter_list->Append(std::move(filter_dict));
-    }
-    dict->Set(kEventFiltersParam, std::move(filter_list));
-  }
-
-  if (category_filter_.IsCategoryEnabled(MemoryDumpManager::kTraceCategory)) {
-    auto allowed_modes = std::make_unique<ListValue>();
-    for (auto dump_mode : memory_dump_config_.allowed_dump_modes)
-      allowed_modes->AppendString(MemoryDumpLevelOfDetailToString(dump_mode));
-
-    auto memory_dump_config = std::make_unique<DictionaryValue>();
-    memory_dump_config->Set(kAllowedDumpModesParam, std::move(allowed_modes));
-
-    auto triggers_list = std::make_unique<ListValue>();
-    for (const auto& config : memory_dump_config_.triggers) {
-      auto trigger_dict = std::make_unique<DictionaryValue>();
-      trigger_dict->SetString(kTriggerTypeParam,
-                              MemoryDumpTypeToString(config.trigger_type));
-      trigger_dict->SetInteger(
-          kMinTimeBetweenDumps,
-          static_cast<int>(config.min_time_between_dumps_ms));
-      trigger_dict->SetString(
-          kTriggerModeParam,
-          MemoryDumpLevelOfDetailToString(config.level_of_detail));
-      triggers_list->Append(std::move(trigger_dict));
-    }
-
-    // Empty triggers will still be specified explicitly since it means that
-    // the periodic dumps are not enabled.
-    memory_dump_config->Set(kTriggersParam, std::move(triggers_list));
-
-    if (memory_dump_config_.heap_profiler_options.breakdown_threshold_bytes !=
-        MemoryDumpConfig::HeapProfiler::kDefaultBreakdownThresholdBytes) {
-      auto options = std::make_unique<DictionaryValue>();
-      options->SetInteger(
-          kBreakdownThresholdBytes,
-          memory_dump_config_.heap_profiler_options.breakdown_threshold_bytes);
-      memory_dump_config->Set(kHeapProfilerOptions, std::move(options));
-    }
-    dict->Set(kMemoryDumpConfigParam, std::move(memory_dump_config));
-  }
-  return dict;
-}
-
-std::string TraceConfig::ToTraceOptionsString() const {
-  std::string ret;
-  switch (record_mode_) {
-    case RECORD_UNTIL_FULL:
-      ret = kRecordUntilFull;
-      break;
-    case RECORD_CONTINUOUSLY:
-      ret = kRecordContinuously;
-      break;
-    case RECORD_AS_MUCH_AS_POSSIBLE:
-      ret = kRecordAsMuchAsPossible;
-      break;
-    case ECHO_TO_CONSOLE:
-      ret = kTraceToConsole;
-      break;
-    default:
-      NOTREACHED();
-  }
-  if (enable_systrace_)
-    ret = ret + "," + kEnableSystrace;
-  if (enable_argument_filter_)
-    ret = ret + "," + kEnableArgumentFilter;
-  return ret;
-}
-
-}  // namespace trace_event
-}  // namespace base
diff --git a/base/trace_event/trace_config.h b/base/trace_event/trace_config.h
deleted file mode 100644
index decd54d..0000000
--- a/base/trace_event/trace_config.h
+++ /dev/null
@@ -1,289 +0,0 @@
-// Copyright 2015 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_TRACE_EVENT_TRACE_CONFIG_H_
-#define BASE_TRACE_EVENT_TRACE_CONFIG_H_
-
-#include <stdint.h>
-
-#include <memory>
-#include <set>
-#include <string>
-#include <unordered_set>
-#include <vector>
-
-#include "base/base_export.h"
-#include "base/gtest_prod_util.h"
-#include "base/strings/string_piece.h"
-#include "base/trace_event/memory_dump_request_args.h"
-#include "base/trace_event/trace_config_category_filter.h"
-#include "base/values.h"
-
-namespace base {
-namespace trace_event {
-
-class ConvertableToTraceFormat;
-
-// Options determines how the trace buffer stores data.
-// A Java counterpart will be generated for this enum.
-// GENERATED_JAVA_ENUM_PACKAGE: org.chromium.base
-enum TraceRecordMode {
-  // Record until the trace buffer is full.
-  RECORD_UNTIL_FULL,
-
-  // Record until the user ends the trace. The trace buffer is a fixed size
-  // and we use it as a ring buffer during recording.
-  RECORD_CONTINUOUSLY,
-
-  // Record until the trace buffer is full, but with a huge buffer size.
-  RECORD_AS_MUCH_AS_POSSIBLE,
-
-  // Echo to console. Events are discarded.
-  ECHO_TO_CONSOLE,
-};
-
-class BASE_EXPORT TraceConfig {
- public:
-  using StringList = std::vector<std::string>;
-
-  // Specifies the memory dump config for tracing.
-  // Used only when "memory-infra" category is enabled.
-  struct BASE_EXPORT MemoryDumpConfig {
-    MemoryDumpConfig();
-    MemoryDumpConfig(const MemoryDumpConfig& other);
-    ~MemoryDumpConfig();
-
-    // Specifies the triggers in the memory dump config.
-    struct Trigger {
-      uint32_t min_time_between_dumps_ms;
-      MemoryDumpLevelOfDetail level_of_detail;
-      MemoryDumpType trigger_type;
-    };
-
-    // Specifies the configuration options for the heap profiler.
-    struct HeapProfiler {
-      // Default value for |breakdown_threshold_bytes|.
-      enum { kDefaultBreakdownThresholdBytes = 1024 };
-
-      HeapProfiler();
-
-      // Reset the options to default.
-      void Clear();
-
-      uint32_t breakdown_threshold_bytes;
-    };
-
-    // Reset the values in the config.
-    void Clear();
-
-    void Merge(const MemoryDumpConfig& config);
-
-    // Set of memory dump modes allowed for the tracing session. The explicitly
-    // triggered dumps will be successful only if the dump mode is allowed in
-    // the config.
-    std::set<MemoryDumpLevelOfDetail> allowed_dump_modes;
-
-    std::vector<Trigger> triggers;
-    HeapProfiler heap_profiler_options;
-  };
-
-  class BASE_EXPORT EventFilterConfig {
-   public:
-    EventFilterConfig(const std::string& predicate_name);
-    EventFilterConfig(const EventFilterConfig& tc);
-
-    ~EventFilterConfig();
-
-    EventFilterConfig& operator=(const EventFilterConfig& rhs);
-
-    void InitializeFromConfigDict(const base::DictionaryValue* event_filter);
-
-    void SetCategoryFilter(const TraceConfigCategoryFilter& category_filter);
-
-    void ToDict(DictionaryValue* filter_dict) const;
-
-    bool GetArgAsSet(const char* key, std::unordered_set<std::string>*) const;
-
-    bool IsCategoryGroupEnabled(const StringPiece& category_group_name) const;
-
-    const std::string& predicate_name() const { return predicate_name_; }
-    base::DictionaryValue* filter_args() const { return args_.get(); }
-    const TraceConfigCategoryFilter& category_filter() const {
-      return category_filter_;
-    }
-
-   private:
-    std::string predicate_name_;
-    TraceConfigCategoryFilter category_filter_;
-    std::unique_ptr<base::DictionaryValue> args_;
-  };
-  typedef std::vector<EventFilterConfig> EventFilters;
-
-  static std::string TraceRecordModeToStr(TraceRecordMode record_mode);
-
-  TraceConfig();
-
-  // Create TraceConfig object from category filter and trace options strings.
-  //
-  // |category_filter_string| is a comma-delimited list of category wildcards.
-  // A category can have an optional '-' prefix to make it an excluded category.
-  // All the same rules apply above, so for example, having both included and
-  // excluded categories in the same list would not be supported.
-  //
-  // |trace_options_string| is a comma-delimited list of trace options.
-  // Possible options are: "record-until-full", "record-continuously",
-  // "record-as-much-as-possible", "trace-to-console", "enable-systrace" and
-  // "enable-argument-filter".
-  // The first 4 options are trace recoding modes and hence
-  // mutually exclusive. If more than one trace recording modes appear in the
-  // options_string, the last one takes precedence. If none of the trace
-  // recording mode is specified, recording mode is RECORD_UNTIL_FULL.
-  //
-  // The trace option will first be reset to the default option
-  // (record_mode set to RECORD_UNTIL_FULL, enable_systrace and
-  // enable_argument_filter set to false) before options parsed from
-  // |trace_options_string| are applied on it. If |trace_options_string| is
-  // invalid, the final state of trace options is undefined.
-  //
-  // Example: TraceConfig("test_MyTest*", "record-until-full");
-  // Example: TraceConfig("test_MyTest*,test_OtherStuff",
-  //                      "record-continuously");
-  // Example: TraceConfig("-excluded_category1,-excluded_category2",
-  //                      "record-until-full, trace-to-console");
-  //          would set ECHO_TO_CONSOLE as the recording mode.
-  // Example: TraceConfig("-*,webkit", "");
-  //          would disable everything but webkit; and use default options.
-  // Example: TraceConfig("-webkit", "");
-  //          would enable everything but webkit; and use default options.
-  TraceConfig(StringPiece category_filter_string,
-              StringPiece trace_options_string);
-
-  TraceConfig(StringPiece category_filter_string, TraceRecordMode record_mode);
-
-  // Create TraceConfig object from the trace config string.
-  //
-  // |config_string| is a dictionary formatted as a JSON string, containing both
-  // category filters and trace options.
-  //
-  // Example:
-  //   {
-  //     "record_mode": "record-continuously",
-  //     "enable_systrace": true,
-  //     "enable_argument_filter": true,
-  //     "included_categories": ["included",
-  //                             "inc_pattern*",
-  //                             "disabled-by-default-memory-infra"],
-  //     "excluded_categories": ["excluded", "exc_pattern*"],
-  //     "memory_dump_config": {
-  //       "triggers": [
-  //         {
-  //           "mode": "detailed",
-  //           "periodic_interval_ms": 2000
-  //         }
-  //       ]
-  //     }
-  //   }
-  //
-  // Note: memory_dump_config can be specified only if
-  // disabled-by-default-memory-infra category is enabled.
-  explicit TraceConfig(StringPiece config_string);
-
-  // Functionally identical to the above, but takes a parsed dictionary as input
-  // instead of its JSON serialization.
-  explicit TraceConfig(const DictionaryValue& config);
-
-  TraceConfig(const TraceConfig& tc);
-
-  ~TraceConfig();
-
-  TraceConfig& operator=(const TraceConfig& rhs);
-
-  TraceRecordMode GetTraceRecordMode() const { return record_mode_; }
-  bool IsSystraceEnabled() const { return enable_systrace_; }
-  bool IsArgumentFilterEnabled() const { return enable_argument_filter_; }
-
-  void SetTraceRecordMode(TraceRecordMode mode) { record_mode_ = mode; }
-  void EnableSystrace() { enable_systrace_ = true; }
-  void EnableArgumentFilter() { enable_argument_filter_ = true; }
-
-  // Writes the string representation of the TraceConfig. The string is JSON
-  // formatted.
-  std::string ToString() const;
-
-  // Returns a copy of the TraceConfig wrapped in a ConvertableToTraceFormat
-  std::unique_ptr<ConvertableToTraceFormat> AsConvertableToTraceFormat() const;
-
-  // Write the string representation of the CategoryFilter part.
-  std::string ToCategoryFilterString() const;
-
-  // Returns true if at least one category in the list is enabled by this
-  // trace config. This is used to determine if the category filters are
-  // enabled in the TRACE_* macros.
-  bool IsCategoryGroupEnabled(const StringPiece& category_group_name) const;
-
-  // Merges config with the current TraceConfig
-  void Merge(const TraceConfig& config);
-
-  void Clear();
-
-  // Clears and resets the memory dump config.
-  void ResetMemoryDumpConfig(const MemoryDumpConfig& memory_dump_config);
-
-  const TraceConfigCategoryFilter& category_filter() const {
-    return category_filter_;
-  }
-
-  const MemoryDumpConfig& memory_dump_config() const {
-    return memory_dump_config_;
-  }
-
-  const EventFilters& event_filters() const { return event_filters_; }
-  void SetEventFilters(const EventFilters& filter_configs) {
-    event_filters_ = filter_configs;
-  }
-
- private:
-  FRIEND_TEST_ALL_PREFIXES(TraceConfigTest, TraceConfigFromValidLegacyFormat);
-  FRIEND_TEST_ALL_PREFIXES(TraceConfigTest,
-                           TraceConfigFromInvalidLegacyStrings);
-
-  // The default trace config, used when none is provided.
-  // Allows all non-disabled-by-default categories through, except if they end
-  // in the suffix 'Debug' or 'Test'.
-  void InitializeDefault();
-
-  // Initialize from a config dictionary.
-  void InitializeFromConfigDict(const DictionaryValue& dict);
-
-  // Initialize from a config string.
-  void InitializeFromConfigString(StringPiece config_string);
-
-  // Initialize from category filter and trace options strings
-  void InitializeFromStrings(StringPiece category_filter_string,
-                             StringPiece trace_options_string);
-
-  void SetMemoryDumpConfigFromConfigDict(
-      const DictionaryValue& memory_dump_config);
-  void SetDefaultMemoryDumpConfig();
-
-  void SetEventFiltersFromConfigList(const base::ListValue& event_filters);
-  std::unique_ptr<DictionaryValue> ToDict() const;
-
-  std::string ToTraceOptionsString() const;
-
-  TraceRecordMode record_mode_;
-  bool enable_systrace_ : 1;
-  bool enable_argument_filter_ : 1;
-
-  TraceConfigCategoryFilter category_filter_;
-
-  MemoryDumpConfig memory_dump_config_;
-
-  EventFilters event_filters_;
-};
-
-}  // namespace trace_event
-}  // namespace base
-
-#endif  // BASE_TRACE_EVENT_TRACE_CONFIG_H_
diff --git a/base/trace_event/trace_config_category_filter.cc b/base/trace_event/trace_config_category_filter.cc
deleted file mode 100644
index d188430..0000000
--- a/base/trace_event/trace_config_category_filter.cc
+++ /dev/null
@@ -1,235 +0,0 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/trace_event/trace_config_category_filter.h"
-
-#include "base/memory/ptr_util.h"
-#include "base/strings/pattern.h"
-#include "base/strings/string_split.h"
-#include "base/strings/string_tokenizer.h"
-#include "base/strings/string_util.h"
-#include "base/strings/stringprintf.h"
-#include "base/trace_event/trace_event.h"
-
-namespace base {
-namespace trace_event {
-
-namespace {
-const char kIncludedCategoriesParam[] = "included_categories";
-const char kExcludedCategoriesParam[] = "excluded_categories";
-}
-
-TraceConfigCategoryFilter::TraceConfigCategoryFilter() = default;
-
-TraceConfigCategoryFilter::TraceConfigCategoryFilter(
-    const TraceConfigCategoryFilter& other) = default;
-
-TraceConfigCategoryFilter::~TraceConfigCategoryFilter() = default;
-
-TraceConfigCategoryFilter& TraceConfigCategoryFilter::operator=(
-    const TraceConfigCategoryFilter& rhs) = default;
-
-void TraceConfigCategoryFilter::InitializeFromString(
-    const StringPiece& category_filter_string) {
-  std::vector<StringPiece> split = SplitStringPiece(
-      category_filter_string, ",", TRIM_WHITESPACE, SPLIT_WANT_ALL);
-  for (const StringPiece& category : split) {
-    // Ignore empty categories.
-    if (category.empty())
-      continue;
-    if (category.front() == '-') {
-      // Excluded categories start with '-'.
-      // Remove '-' from category string.
-      excluded_categories_.push_back(category.substr(1).as_string());
-    } else if (category.starts_with(TRACE_DISABLED_BY_DEFAULT(""))) {
-      disabled_categories_.push_back(category.as_string());
-    } else {
-      included_categories_.push_back(category.as_string());
-    }
-  }
-}
-
-void TraceConfigCategoryFilter::InitializeFromConfigDict(
-    const DictionaryValue& dict) {
-  const ListValue* category_list = nullptr;
-  if (dict.GetList(kIncludedCategoriesParam, &category_list))
-    SetCategoriesFromIncludedList(*category_list);
-  if (dict.GetList(kExcludedCategoriesParam, &category_list))
-    SetCategoriesFromExcludedList(*category_list);
-}
-
-bool TraceConfigCategoryFilter::IsCategoryGroupEnabled(
-    const StringPiece& category_group_name) const {
-  bool had_enabled_by_default = false;
-  DCHECK(!category_group_name.empty());
-  CStringTokenizer category_group_tokens(category_group_name.begin(),
-                                         category_group_name.end(), ",");
-  while (category_group_tokens.GetNext()) {
-    StringPiece category_group_token = category_group_tokens.token_piece();
-    // Don't allow empty tokens, nor tokens with leading or trailing space.
-    DCHECK(IsCategoryNameAllowed(category_group_token))
-        << "Disallowed category string";
-    if (IsCategoryEnabled(category_group_token))
-      return true;
-
-    if (!MatchPattern(category_group_token, TRACE_DISABLED_BY_DEFAULT("*")))
-      had_enabled_by_default = true;
-  }
-  // Do a second pass to check for explicitly disabled categories
-  // (those explicitly enabled have priority due to first pass).
-  category_group_tokens.Reset();
-  bool category_group_disabled = false;
-  while (category_group_tokens.GetNext()) {
-    StringPiece category_group_token = category_group_tokens.token_piece();
-    for (const std::string& category : excluded_categories_) {
-      if (MatchPattern(category_group_token, category)) {
-        // Current token of category_group_name is present in excluded_list.
-        // Flag the exclusion and proceed further to check if any of the
-        // remaining categories of category_group_name is not present in the
-        // excluded_ list.
-        category_group_disabled = true;
-        break;
-      }
-      // One of the category of category_group_name is not present in
-      // excluded_ list. So, if it's not a disabled-by-default category,
-      // it has to be included_ list. Enable the category_group_name
-      // for recording.
-      if (!MatchPattern(category_group_token, TRACE_DISABLED_BY_DEFAULT("*")))
-        category_group_disabled = false;
-    }
-    // One of the categories present in category_group_name is not present in
-    // excluded_ list. Implies this category_group_name group can be enabled
-    // for recording, since one of its groups is enabled for recording.
-    if (!category_group_disabled)
-      break;
-  }
-  // If the category group is not excluded, and there are no included patterns
-  // we consider this category group enabled, as long as it had categories
-  // other than disabled-by-default.
-  return !category_group_disabled && had_enabled_by_default &&
-         included_categories_.empty();
-}
-
-bool TraceConfigCategoryFilter::IsCategoryEnabled(
-    const StringPiece& category_name) const {
-  // Check the disabled- filters and the disabled-* wildcard first so that a
-  // "*" filter does not include the disabled.
-  for (const std::string& category : disabled_categories_) {
-    if (MatchPattern(category_name, category))
-      return true;
-  }
-
-  if (MatchPattern(category_name, TRACE_DISABLED_BY_DEFAULT("*")))
-    return false;
-
-  for (const std::string& category : included_categories_) {
-    if (MatchPattern(category_name, category))
-      return true;
-  }
-
-  return false;
-}
-
-void TraceConfigCategoryFilter::Merge(const TraceConfigCategoryFilter& config) {
-  // Keep included patterns only if both filters have an included entry.
-  // Otherwise, one of the filter was specifying "*" and we want to honor the
-  // broadest filter.
-  if (!included_categories_.empty() && !config.included_categories_.empty()) {
-    included_categories_.insert(included_categories_.end(),
-                                config.included_categories_.begin(),
-                                config.included_categories_.end());
-  } else {
-    included_categories_.clear();
-  }
-
-  disabled_categories_.insert(disabled_categories_.end(),
-                              config.disabled_categories_.begin(),
-                              config.disabled_categories_.end());
-  excluded_categories_.insert(excluded_categories_.end(),
-                              config.excluded_categories_.begin(),
-                              config.excluded_categories_.end());
-}
-
-void TraceConfigCategoryFilter::Clear() {
-  included_categories_.clear();
-  disabled_categories_.clear();
-  excluded_categories_.clear();
-}
-
-void TraceConfigCategoryFilter::ToDict(DictionaryValue* dict) const {
-  StringList categories(included_categories_);
-  categories.insert(categories.end(), disabled_categories_.begin(),
-                    disabled_categories_.end());
-  AddCategoriesToDict(categories, kIncludedCategoriesParam, dict);
-  AddCategoriesToDict(excluded_categories_, kExcludedCategoriesParam, dict);
-}
-
-std::string TraceConfigCategoryFilter::ToFilterString() const {
-  std::string filter_string;
-  WriteCategoryFilterString(included_categories_, &filter_string, true);
-  WriteCategoryFilterString(disabled_categories_, &filter_string, true);
-  WriteCategoryFilterString(excluded_categories_, &filter_string, false);
-  return filter_string;
-}
-
-void TraceConfigCategoryFilter::SetCategoriesFromIncludedList(
-    const ListValue& included_list) {
-  included_categories_.clear();
-  for (size_t i = 0; i < included_list.GetSize(); ++i) {
-    std::string category;
-    if (!included_list.GetString(i, &category))
-      continue;
-    if (category.compare(0, strlen(TRACE_DISABLED_BY_DEFAULT("")),
-                         TRACE_DISABLED_BY_DEFAULT("")) == 0) {
-      disabled_categories_.push_back(category);
-    } else {
-      included_categories_.push_back(category);
-    }
-  }
-}
-
-void TraceConfigCategoryFilter::SetCategoriesFromExcludedList(
-    const ListValue& excluded_list) {
-  excluded_categories_.clear();
-  for (size_t i = 0; i < excluded_list.GetSize(); ++i) {
-    std::string category;
-    if (excluded_list.GetString(i, &category))
-      excluded_categories_.push_back(category);
-  }
-}
-
-void TraceConfigCategoryFilter::AddCategoriesToDict(
-    const StringList& categories,
-    const char* param,
-    DictionaryValue* dict) const {
-  if (categories.empty())
-    return;
-
-  auto list = std::make_unique<ListValue>();
-  for (const std::string& category : categories)
-    list->AppendString(category);
-  dict->Set(param, std::move(list));
-}
-
-void TraceConfigCategoryFilter::WriteCategoryFilterString(
-    const StringList& values,
-    std::string* out,
-    bool included) const {
-  bool prepend_comma = !out->empty();
-  int token_cnt = 0;
-  for (const std::string& category : values) {
-    if (token_cnt > 0 || prepend_comma)
-      StringAppendF(out, ",");
-    StringAppendF(out, "%s%s", (included ? "" : "-"), category.c_str());
-    ++token_cnt;
-  }
-}
-
-// static
-bool TraceConfigCategoryFilter::IsCategoryNameAllowed(StringPiece str) {
-  return !str.empty() && str.front() != ' ' && str.back() != ' ';
-}
-
-}  // namespace trace_event
-}  // namespace base
diff --git a/base/trace_event/trace_config_category_filter.h b/base/trace_event/trace_config_category_filter.h
deleted file mode 100644
index 0140c1d..0000000
--- a/base/trace_event/trace_config_category_filter.h
+++ /dev/null
@@ -1,81 +0,0 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_TRACE_EVENT_TRACE_CONFIG_CATEGORY_FILTER_H_
-#define BASE_TRACE_EVENT_TRACE_CONFIG_CATEGORY_FILTER_H_
-
-#include <string>
-#include <vector>
-
-#include "base/base_export.h"
-#include "base/strings/string_piece.h"
-#include "base/values.h"
-
-namespace base {
-namespace trace_event {
-
-// Configuration of categories enabled and disabled in TraceConfig.
-class BASE_EXPORT TraceConfigCategoryFilter {
- public:
-  using StringList = std::vector<std::string>;
-
-  TraceConfigCategoryFilter();
-  TraceConfigCategoryFilter(const TraceConfigCategoryFilter& other);
-  ~TraceConfigCategoryFilter();
-
-  TraceConfigCategoryFilter& operator=(const TraceConfigCategoryFilter& rhs);
-
-  // Initializes from category filter string. See TraceConfig constructor for
-  // description of how to write category filter string.
-  void InitializeFromString(const StringPiece& category_filter_string);
-
-  // Initializes TraceConfigCategoryFilter object from the config dictionary.
-  void InitializeFromConfigDict(const DictionaryValue& dict);
-
-  // Merges this with category filter config.
-  void Merge(const TraceConfigCategoryFilter& config);
-  void Clear();
-
-  // Returns true if at least one category in the list is enabled by this
-  // trace config. This is used to determine if the category filters are
-  // enabled in the TRACE_* macros.
-  bool IsCategoryGroupEnabled(const StringPiece& category_group_name) const;
-
-  // Returns true if the category is enabled according to this trace config.
-  // This tells whether a category is enabled from the TraceConfig's
-  // perspective. Please refer to IsCategoryGroupEnabled() to determine if a
-  // category is enabled from the tracing runtime's perspective.
-  bool IsCategoryEnabled(const StringPiece& category_name) const;
-
-  void ToDict(DictionaryValue* dict) const;
-
-  std::string ToFilterString() const;
-
-  // Returns true if category name is a valid string.
-  static bool IsCategoryNameAllowed(StringPiece str);
-
-  const StringList& included_categories() const { return included_categories_; }
-  const StringList& excluded_categories() const { return excluded_categories_; }
-
- private:
-  void SetCategoriesFromIncludedList(const ListValue& included_list);
-  void SetCategoriesFromExcludedList(const ListValue& excluded_list);
-
-  void AddCategoriesToDict(const StringList& categories,
-                           const char* param,
-                           DictionaryValue* dict) const;
-
-  void WriteCategoryFilterString(const StringList& values,
-                                 std::string* out,
-                                 bool included) const;
-
-  StringList included_categories_;
-  StringList disabled_categories_;
-  StringList excluded_categories_;
-};
-
-}  // namespace trace_event
-}  // namespace base
-
-#endif  // BASE_TRACE_EVENT_TRACE_CONFIG_CATEGORY_FILTER_H_
diff --git a/base/trace_event/trace_config_memory_test_util.h b/base/trace_event/trace_config_memory_test_util.h
deleted file mode 100644
index 57608fd..0000000
--- a/base/trace_event/trace_config_memory_test_util.h
+++ /dev/null
@@ -1,178 +0,0 @@
-// Copyright 2015 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_TRACE_EVENT_TRACE_CONFIG_MEMORY_TEST_UTIL_H_
-#define BASE_TRACE_EVENT_TRACE_CONFIG_MEMORY_TEST_UTIL_H_
-
-#include "base/strings/stringprintf.h"
-#include "base/trace_event/memory_dump_manager.h"
-
-namespace base {
-namespace trace_event {
-
-class TraceConfigMemoryTestUtil {
- public:
-  static std::string GetTraceConfig_LegacyPeriodicTriggers(int light_period,
-                                                           int heavy_period) {
-    return StringPrintf(
-        "{"
-        "\"enable_argument_filter\":false,"
-        "\"enable_systrace\":false,"
-        "\"excluded_categories\":["
-        "\"*\""
-        "],"
-        "\"included_categories\":["
-        "\"%s\""
-        "],"
-        "\"memory_dump_config\":{"
-        "\"allowed_dump_modes\":[\"background\",\"light\",\"detailed\"],"
-        "\"heap_profiler_options\":{"
-        "\"breakdown_threshold_bytes\":2048"
-        "},"
-        "\"triggers\":["
-        "{"
-        "\"mode\":\"light\","
-        "\"periodic_interval_ms\":%d"
-        "},"
-        "{"
-        "\"mode\":\"detailed\","
-        "\"periodic_interval_ms\":%d"
-        "}"
-        "]"
-        "},"
-        "\"record_mode\":\"record-until-full\""
-        "}",
-        MemoryDumpManager::kTraceCategory, light_period, heavy_period);
-    ;
-  }
-
-  static std::string GetTraceConfig_PeriodicTriggers(int light_period,
-                                                     int heavy_period) {
-    return StringPrintf(
-        "{"
-        "\"enable_argument_filter\":false,"
-        "\"enable_systrace\":false,"
-        "\"excluded_categories\":["
-        "\"*\""
-        "],"
-        "\"included_categories\":["
-        "\"%s\""
-        "],"
-        "\"memory_dump_config\":{"
-        "\"allowed_dump_modes\":[\"background\",\"light\",\"detailed\"],"
-        "\"heap_profiler_options\":{"
-        "\"breakdown_threshold_bytes\":2048"
-        "},"
-        "\"triggers\":["
-        "{"
-        "\"min_time_between_dumps_ms\":%d,"
-        "\"mode\":\"light\","
-        "\"type\":\"periodic_interval\""
-        "},"
-        "{"
-        "\"min_time_between_dumps_ms\":%d,"
-        "\"mode\":\"detailed\","
-        "\"type\":\"periodic_interval\""
-        "}"
-        "]"
-        "},"
-        "\"record_mode\":\"record-until-full\""
-        "}",
-        MemoryDumpManager::kTraceCategory, light_period, heavy_period);
-  }
-
-  static std::string GetTraceConfig_EmptyTriggers() {
-    return StringPrintf(
-        "{"
-        "\"enable_argument_filter\":false,"
-        "\"enable_systrace\":false,"
-        "\"excluded_categories\":["
-        "\"*\""
-        "],"
-        "\"included_categories\":["
-        "\"%s\""
-        "],"
-        "\"memory_dump_config\":{"
-        "\"allowed_dump_modes\":[\"background\",\"light\",\"detailed\"],"
-        "\"triggers\":["
-        "]"
-        "},"
-        "\"record_mode\":\"record-until-full\""
-        "}",
-        MemoryDumpManager::kTraceCategory);
-  }
-
-  static std::string GetTraceConfig_NoTriggers() {
-    return StringPrintf(
-        "{"
-        "\"enable_argument_filter\":false,"
-        "\"enable_systrace\":false,"
-        "\"excluded_categories\":["
-        "\"*\""
-        "],"
-        "\"included_categories\":["
-        "\"%s\""
-        "],"
-        "\"record_mode\":\"record-until-full\""
-        "}",
-        MemoryDumpManager::kTraceCategory);
-  }
-
-  static std::string GetTraceConfig_BackgroundTrigger(int period_ms) {
-    return StringPrintf(
-        "{"
-        "\"enable_argument_filter\":false,"
-        "\"enable_systrace\":false,"
-        "\"excluded_categories\":["
-        "\"*\""
-        "],"
-        "\"included_categories\":["
-        "\"%s\""
-        "],"
-        "\"memory_dump_config\":{"
-        "\"allowed_dump_modes\":[\"background\"],"
-        "\"triggers\":["
-        "{"
-        "\"min_time_between_dumps_ms\":%d,"
-        "\"mode\":\"background\","
-        "\"type\":\"periodic_interval\""
-        "}"
-        "]"
-        "},"
-        "\"record_mode\":\"record-until-full\""
-        "}",
-        MemoryDumpManager::kTraceCategory, period_ms);
-  }
-
-  static std::string GetTraceConfig_PeakDetectionTrigger(int heavy_period) {
-    return StringPrintf(
-        "{"
-        "\"enable_argument_filter\":false,"
-        "\"enable_systrace\":false,"
-        "\"excluded_categories\":["
-        "\"*\""
-        "],"
-        "\"included_categories\":["
-        "\"%s\""
-        "],"
-        "\"memory_dump_config\":{"
-        "\"allowed_dump_modes\":[\"background\",\"light\",\"detailed\"],"
-        "\"triggers\":["
-        "{"
-        "\"min_time_between_dumps_ms\":%d,"
-        "\"mode\":\"detailed\","
-        "\"type\":\"peak_memory_usage\""
-        "}"
-        "]"
-        "},"
-        "\"record_mode\":\"record-until-full\""
-        "}",
-        MemoryDumpManager::kTraceCategory, heavy_period);
-  }
-};
-
-}  // namespace trace_event
-}  // namespace base
-
-#endif  // BASE_TRACE_EVENT_TRACE_CONFIG_MEMORY_TEST_UTIL_H_
diff --git a/base/trace_event/trace_event.h b/base/trace_event/trace_event.h
deleted file mode 100644
index e3ee400..0000000
--- a/base/trace_event/trace_event.h
+++ /dev/null
@@ -1,1170 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_TRACE_EVENT_TRACE_EVENT_H_
-#define BASE_TRACE_EVENT_TRACE_EVENT_H_
-
-// This header file defines implementation details of how the trace macros in
-// trace_event_common.h collect and store trace events. Anything not
-// implementation-specific should go in trace_event_common.h instead of here.
-
-#include <stddef.h>
-#include <stdint.h>
-
-#include <string>
-
-#include "base/atomicops.h"
-#include "base/macros.h"
-#include "base/time/time.h"
-#include "base/time/time_override.h"
-#include "base/trace_event/common/trace_event_common.h"
-#include "base/trace_event/heap_profiler.h"
-#include "base/trace_event/trace_category.h"
-#include "base/trace_event/trace_event_system_stats_monitor.h"
-#include "base/trace_event/trace_log.h"
-#include "build_config.h"
-
-// By default, const char* argument values are assumed to have long-lived scope
-// and will not be copied. Use this macro to force a const char* to be copied.
-#define TRACE_STR_COPY(str) \
-    trace_event_internal::TraceStringWithCopy(str)
-
-// DEPRECATED: do not use: Consider using TRACE_ID_{GLOBAL, LOCAL} macros,
-// instead. By default, uint64_t ID argument values are not mangled with the
-// Process ID in TRACE_EVENT_ASYNC macros. Use this macro to force Process ID
-// mangling.
-#define TRACE_ID_MANGLE(id) \
-    trace_event_internal::TraceID::ForceMangle(id)
-
-// DEPRECATED: do not use: Consider using TRACE_ID_{GLOBAL, LOCAL} macros,
-// instead. By default, pointers are mangled with the Process ID in
-// TRACE_EVENT_ASYNC macros. Use this macro to prevent Process ID mangling.
-#define TRACE_ID_DONT_MANGLE(id) \
-    trace_event_internal::TraceID::DontMangle(id)
-
-// By default, trace IDs are eventually converted to a single 64-bit number. Use
-// this macro to add a scope string. For example,
-//
-// TRACE_EVENT_NESTABLE_ASYNC_BEGIN0(
-//     "network", "ResourceLoad",
-//     TRACE_ID_WITH_SCOPE("BlinkResourceID", resourceID));
-//
-// Also, it is possible to prepend the ID with another number, like the process
-// ID. This is useful in creating IDs that are unique among all processes. To do
-// that, pass two numbers after the scope string instead of one. For example,
-//
-// TRACE_EVENT_NESTABLE_ASYNC_BEGIN0(
-//     "network", "ResourceLoad",
-//     TRACE_ID_WITH_SCOPE("BlinkResourceID", pid, resourceID));
-#define TRACE_ID_WITH_SCOPE(scope, ...) \
-  trace_event_internal::TraceID::WithScope(scope, ##__VA_ARGS__)
-
-#define TRACE_ID_GLOBAL(id) trace_event_internal::TraceID::GlobalId(id)
-#define TRACE_ID_LOCAL(id) trace_event_internal::TraceID::LocalId(id)
-
-#define TRACE_EVENT_API_CURRENT_THREAD_ID \
-  static_cast<int>(base::PlatformThread::CurrentId())
-
-#define INTERNAL_TRACE_EVENT_CATEGORY_GROUP_ENABLED_FOR_RECORDING_MODE() \
-  UNLIKELY(*INTERNAL_TRACE_EVENT_UID(category_group_enabled) &           \
-           (base::trace_event::TraceCategory::ENABLED_FOR_RECORDING |    \
-            base::trace_event::TraceCategory::ENABLED_FOR_ETW_EXPORT))
-
-#define INTERNAL_TRACE_EVENT_CATEGORY_GROUP_ENABLED()                  \
-  UNLIKELY(*INTERNAL_TRACE_EVENT_UID(category_group_enabled) &         \
-           (base::trace_event::TraceCategory::ENABLED_FOR_RECORDING |  \
-            base::trace_event::TraceCategory::ENABLED_FOR_ETW_EXPORT | \
-            base::trace_event::TraceCategory::ENABLED_FOR_FILTERING))
-
-////////////////////////////////////////////////////////////////////////////////
-// Implementation specific tracing API definitions.
-
-// Get a pointer to the enabled state of the given trace category. Only
-// long-lived literal strings should be given as the category group. The
-// returned pointer can be held permanently in a local static for example. If
-// the unsigned char is non-zero, tracing is enabled. If tracing is enabled,
-// TRACE_EVENT_API_ADD_TRACE_EVENT can be called. It's OK if tracing is disabled
-// between the load of the tracing state and the call to
-// TRACE_EVENT_API_ADD_TRACE_EVENT, because this flag only provides an early out
-// for best performance when tracing is disabled.
-// const unsigned char*
-//     TRACE_EVENT_API_GET_CATEGORY_GROUP_ENABLED(const char* category_group)
-#define TRACE_EVENT_API_GET_CATEGORY_GROUP_ENABLED \
-    base::trace_event::TraceLog::GetCategoryGroupEnabled
-
-// Get the number of times traces have been recorded. This is used to implement
-// the TRACE_EVENT_IS_NEW_TRACE facility.
-// unsigned int TRACE_EVENT_API_GET_NUM_TRACES_RECORDED()
-#define TRACE_EVENT_API_GET_NUM_TRACES_RECORDED \
-    base::trace_event::TraceLog::GetInstance()->GetNumTracesRecorded
-
-// Add a trace event to the platform tracing system.
-// base::trace_event::TraceEventHandle TRACE_EVENT_API_ADD_TRACE_EVENT(
-//                    char phase,
-//                    const unsigned char* category_group_enabled,
-//                    const char* name,
-//                    const char* scope,
-//                    unsigned long long id,
-//                    int num_args,
-//                    const char** arg_names,
-//                    const unsigned char* arg_types,
-//                    const unsigned long long* arg_values,
-//                    std::unique_ptr<ConvertableToTraceFormat>*
-//                    convertable_values,
-//                    unsigned int flags)
-#define TRACE_EVENT_API_ADD_TRACE_EVENT \
-    base::trace_event::TraceLog::GetInstance()->AddTraceEvent
-
-// Add a trace event to the platform tracing system.
-// base::trace_event::TraceEventHandle
-// TRACE_EVENT_API_ADD_TRACE_EVENT_WITH_BIND_ID(
-//                    char phase,
-//                    const unsigned char* category_group_enabled,
-//                    const char* name,
-//                    const char* scope,
-//                    unsigned long long id,
-//                    unsigned long long bind_id,
-//                    int num_args,
-//                    const char** arg_names,
-//                    const unsigned char* arg_types,
-//                    const unsigned long long* arg_values,
-//                    std::unique_ptr<ConvertableToTraceFormat>*
-//                    convertable_values,
-//                    unsigned int flags)
-#define TRACE_EVENT_API_ADD_TRACE_EVENT_WITH_BIND_ID \
-  base::trace_event::TraceLog::GetInstance()->AddTraceEventWithBindId
-
-// Add a trace event to the platform tracing system overriding the pid.
-// The resulting event will have tid = pid == (process_id passed here).
-// base::trace_event::TraceEventHandle
-// TRACE_EVENT_API_ADD_TRACE_EVENT_WITH_PROCESS_ID(
-//                    char phase,
-//                    const unsigned char* category_group_enabled,
-//                    const char* name,
-//                    const char* scope,
-//                    unsigned long long id,
-//                    int process_id,
-//                    int num_args,
-//                    const char** arg_names,
-//                    const unsigned char* arg_types,
-//                    const unsigned long long* arg_values,
-//                    std::unique_ptr<ConvertableToTraceFormat>*
-//                    convertable_values,
-//                    unsigned int flags)
-#define TRACE_EVENT_API_ADD_TRACE_EVENT_WITH_PROCESS_ID \
-  base::trace_event::TraceLog::GetInstance()->AddTraceEventWithProcessId
-
-// Add a trace event to the platform tracing system.
-// base::trace_event::TraceEventHandle
-// TRACE_EVENT_API_ADD_TRACE_EVENT_WITH_TIMESTAMP(
-//                    char phase,
-//                    const unsigned char* category_group_enabled,
-//                    const char* name,
-//                    const char* scope,
-//                    unsigned long long id,
-//                    int thread_id,
-//                    const TimeTicks& timestamp,
-//                    int num_args,
-//                    const char** arg_names,
-//                    const unsigned char* arg_types,
-//                    const unsigned long long* arg_values,
-//                    std::unique_ptr<ConvertableToTraceFormat>*
-//                    convertable_values,
-//                    unsigned int flags)
-#define TRACE_EVENT_API_ADD_TRACE_EVENT_WITH_THREAD_ID_AND_TIMESTAMP \
-    base::trace_event::TraceLog::GetInstance() \
-      ->AddTraceEventWithThreadIdAndTimestamp
-
-// Set the duration field of a COMPLETE trace event.
-// void TRACE_EVENT_API_UPDATE_TRACE_EVENT_DURATION(
-//     const unsigned char* category_group_enabled,
-//     const char* name,
-//     base::trace_event::TraceEventHandle id)
-#define TRACE_EVENT_API_UPDATE_TRACE_EVENT_DURATION \
-    base::trace_event::TraceLog::GetInstance()->UpdateTraceEventDuration
-
-// Set the duration field of a COMPLETE trace event.
-// void TRACE_EVENT_API_UPDATE_TRACE_EVENT_DURATION_EXPLICIT(
-//     const unsigned char* category_group_enabled,
-//     const char* name,
-//     base::trace_event::TraceEventHandle id,
-//     const TimeTicks& now,
-//     const ThreadTicks* thread_now)
-#define TRACE_EVENT_API_UPDATE_TRACE_EVENT_DURATION_EXPLICIT \
-  base::trace_event::TraceLog::GetInstance()->UpdateTraceEventDurationExplicit
-
-// Adds a metadata event to the trace log. The |AppendValueAsTraceFormat| method
-// on the convertable value will be called at flush time.
-// TRACE_EVENT_API_ADD_METADATA_EVENT(
-//     const unsigned char* category_group_enabled,
-//     const char* event_name,
-//     const char* arg_name,
-//     std::unique_ptr<ConvertableToTraceFormat> arg_value)
-#define TRACE_EVENT_API_ADD_METADATA_EVENT \
-    trace_event_internal::AddMetadataEvent
-
-// Defines atomic operations used internally by the tracing system.
-#define TRACE_EVENT_API_ATOMIC_WORD base::subtle::AtomicWord
-#define TRACE_EVENT_API_ATOMIC_LOAD(var) base::subtle::NoBarrier_Load(&(var))
-#define TRACE_EVENT_API_ATOMIC_STORE(var, value) \
-    base::subtle::NoBarrier_Store(&(var), (value))
-
-// Defines visibility for classes in trace_event.h
-#define TRACE_EVENT_API_CLASS_EXPORT BASE_EXPORT
-
-////////////////////////////////////////////////////////////////////////////////
-
-// Implementation detail: trace event macros create temporary variables
-// to keep instrumentation overhead low. These macros give each temporary
-// variable a unique name based on the line number to prevent name collisions.
-#define INTERNAL_TRACE_EVENT_UID3(a,b) \
-    trace_event_unique_##a##b
-#define INTERNAL_TRACE_EVENT_UID2(a,b) \
-    INTERNAL_TRACE_EVENT_UID3(a,b)
-#define INTERNAL_TRACE_EVENT_UID(name_prefix) \
-    INTERNAL_TRACE_EVENT_UID2(name_prefix, __LINE__)
-
-// Implementation detail: internal macro to create static category.
-// No barriers are needed, because this code is designed to operate safely
-// even when the unsigned char* points to garbage data (which may be the case
-// on processors without cache coherency).
-#define INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO_CUSTOM_VARIABLES( \
-    category_group, atomic, category_group_enabled) \
-    category_group_enabled = \
-        reinterpret_cast<const unsigned char*>(TRACE_EVENT_API_ATOMIC_LOAD( \
-            atomic)); \
-    if (UNLIKELY(!category_group_enabled)) { \
-      category_group_enabled = \
-          TRACE_EVENT_API_GET_CATEGORY_GROUP_ENABLED(category_group); \
-      TRACE_EVENT_API_ATOMIC_STORE(atomic, \
-          reinterpret_cast<TRACE_EVENT_API_ATOMIC_WORD>( \
-              category_group_enabled)); \
-    }
-
-#define INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO(category_group) \
-    static TRACE_EVENT_API_ATOMIC_WORD INTERNAL_TRACE_EVENT_UID(atomic) = 0; \
-    const unsigned char* INTERNAL_TRACE_EVENT_UID(category_group_enabled); \
-    INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO_CUSTOM_VARIABLES(category_group, \
-        INTERNAL_TRACE_EVENT_UID(atomic), \
-        INTERNAL_TRACE_EVENT_UID(category_group_enabled));
-
-// Implementation detail: internal macro to return unoverridden
-// base::TimeTicks::Now(). This is important because in headless VirtualTime can
-// override base:TimeTicks::Now().
-#define INTERNAL_TRACE_TIME_TICKS_NOW() \
-  base::subtle::TimeTicksNowIgnoringOverride()
-
-// Implementation detail: internal macro to return unoverridden
-// base::Time::Now(). This is important because in headless VirtualTime can
-// override base:TimeTicks::Now().
-#define INTERNAL_TRACE_TIME_NOW() base::subtle::TimeNowIgnoringOverride()
-
-// Implementation detail: internal macro to create static category and add
-// event if the category is enabled.
-#define INTERNAL_TRACE_EVENT_ADD(phase, category_group, name, flags, ...)  \
-  do {                                                                     \
-    INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO(category_group);                \
-    if (INTERNAL_TRACE_EVENT_CATEGORY_GROUP_ENABLED()) {                   \
-      trace_event_internal::AddTraceEvent(                                 \
-          phase, INTERNAL_TRACE_EVENT_UID(category_group_enabled), name,   \
-          trace_event_internal::kGlobalScope, trace_event_internal::kNoId, \
-          flags, trace_event_internal::kNoId, ##__VA_ARGS__);              \
-    }                                                                      \
-  } while (0)
-
-// Implementation detail: internal macro to create static category and add begin
-// event if the category is enabled. Also adds the end event when the scope
-// ends.
-#define INTERNAL_TRACE_EVENT_ADD_SCOPED(category_group, name, ...)           \
-  INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO(category_group);                    \
-  trace_event_internal::ScopedTracer INTERNAL_TRACE_EVENT_UID(tracer);       \
-  if (INTERNAL_TRACE_EVENT_CATEGORY_GROUP_ENABLED()) {                       \
-    base::trace_event::TraceEventHandle h =                                  \
-        trace_event_internal::AddTraceEvent(                                 \
-            TRACE_EVENT_PHASE_COMPLETE,                                      \
-            INTERNAL_TRACE_EVENT_UID(category_group_enabled), name,          \
-            trace_event_internal::kGlobalScope, trace_event_internal::kNoId, \
-            TRACE_EVENT_FLAG_NONE, trace_event_internal::kNoId,              \
-            ##__VA_ARGS__);                                                  \
-    INTERNAL_TRACE_EVENT_UID(tracer).Initialize(                             \
-        INTERNAL_TRACE_EVENT_UID(category_group_enabled), name, h);          \
-  }
-
-#define INTERNAL_TRACE_EVENT_ADD_SCOPED_WITH_FLOW(category_group, name,      \
-                                                  bind_id, flow_flags, ...)  \
-  INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO(category_group);                    \
-  trace_event_internal::ScopedTracer INTERNAL_TRACE_EVENT_UID(tracer);       \
-  if (INTERNAL_TRACE_EVENT_CATEGORY_GROUP_ENABLED()) {                       \
-    trace_event_internal::TraceID trace_event_bind_id((bind_id));            \
-    unsigned int trace_event_flags =                                         \
-        flow_flags | trace_event_bind_id.id_flags();                         \
-    base::trace_event::TraceEventHandle h =                                  \
-        trace_event_internal::AddTraceEvent(                                 \
-            TRACE_EVENT_PHASE_COMPLETE,                                      \
-            INTERNAL_TRACE_EVENT_UID(category_group_enabled), name,          \
-            trace_event_internal::kGlobalScope, trace_event_internal::kNoId, \
-            trace_event_flags, trace_event_bind_id.raw_id(), ##__VA_ARGS__); \
-    INTERNAL_TRACE_EVENT_UID(tracer).Initialize(                             \
-        INTERNAL_TRACE_EVENT_UID(category_group_enabled), name, h);          \
-  }
-
-// Implementation detail: internal macro to create static category and add
-// event if the category is enabled.
-#define INTERNAL_TRACE_EVENT_ADD_WITH_ID(phase, category_group, name, id, \
-                                         flags, ...)                      \
-  do {                                                                    \
-    INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO(category_group);               \
-    if (INTERNAL_TRACE_EVENT_CATEGORY_GROUP_ENABLED()) {                  \
-      trace_event_internal::TraceID trace_event_trace_id((id));           \
-      unsigned int trace_event_flags =                                    \
-          flags | trace_event_trace_id.id_flags();                        \
-      trace_event_internal::AddTraceEvent(                                \
-          phase, INTERNAL_TRACE_EVENT_UID(category_group_enabled), name,  \
-          trace_event_trace_id.scope(), trace_event_trace_id.raw_id(),    \
-          trace_event_flags, trace_event_internal::kNoId, ##__VA_ARGS__); \
-    }                                                                     \
-  } while (0)
-
-// Implementation detail: internal macro to create static category and add
-// event if the category is enabled.
-#define INTERNAL_TRACE_EVENT_ADD_WITH_TIMESTAMP(phase, category_group, name, \
-                                                timestamp, flags, ...)       \
-  do {                                                                       \
-    INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO(category_group);                  \
-    if (INTERNAL_TRACE_EVENT_CATEGORY_GROUP_ENABLED()) {                     \
-      trace_event_internal::AddTraceEventWithThreadIdAndTimestamp(           \
-          phase, INTERNAL_TRACE_EVENT_UID(category_group_enabled), name,     \
-          trace_event_internal::kGlobalScope, trace_event_internal::kNoId,   \
-          TRACE_EVENT_API_CURRENT_THREAD_ID, timestamp,                      \
-          flags | TRACE_EVENT_FLAG_EXPLICIT_TIMESTAMP,                       \
-          trace_event_internal::kNoId, ##__VA_ARGS__);                       \
-    }                                                                        \
-  } while (0)
-
-// Implementation detail: internal macro to create static category and add
-// event if the category is enabled.
-#define INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP(              \
-    phase, category_group, name, id, thread_id, timestamp, flags, ...)   \
-  do {                                                                   \
-    INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO(category_group);              \
-    if (INTERNAL_TRACE_EVENT_CATEGORY_GROUP_ENABLED()) {                 \
-      trace_event_internal::TraceID trace_event_trace_id((id));          \
-      unsigned int trace_event_flags =                                   \
-          flags | trace_event_trace_id.id_flags();                       \
-      trace_event_internal::AddTraceEventWithThreadIdAndTimestamp(       \
-          phase, INTERNAL_TRACE_EVENT_UID(category_group_enabled), name, \
-          trace_event_trace_id.scope(), trace_event_trace_id.raw_id(),   \
-          thread_id, timestamp,                                          \
-          trace_event_flags | TRACE_EVENT_FLAG_EXPLICIT_TIMESTAMP,       \
-          trace_event_internal::kNoId, ##__VA_ARGS__);                   \
-    }                                                                    \
-  } while (0)
-
-// Implementation detail: internal macro to create static category and add
-// event if the category is enabled.
-#define INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMPS(                \
-    category_group, name, id, thread_id, begin_timestamp, end_timestamp,    \
-    thread_end_timestamp, flags, ...)                                       \
-  do {                                                                      \
-    INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO(category_group);                 \
-    if (INTERNAL_TRACE_EVENT_CATEGORY_GROUP_ENABLED()) {                    \
-      trace_event_internal::TraceID trace_event_trace_id((id));             \
-      unsigned int trace_event_flags =                                      \
-          flags | trace_event_trace_id.id_flags();                          \
-      const unsigned char* uid_category_group_enabled =                     \
-          INTERNAL_TRACE_EVENT_UID(category_group_enabled);                 \
-      auto handle =                                                         \
-          trace_event_internal::AddTraceEventWithThreadIdAndTimestamp(      \
-              TRACE_EVENT_PHASE_COMPLETE, uid_category_group_enabled, name, \
-              trace_event_trace_id.scope(), trace_event_trace_id.raw_id(),  \
-              thread_id, begin_timestamp,                                   \
-              trace_event_flags | TRACE_EVENT_FLAG_EXPLICIT_TIMESTAMP,      \
-              trace_event_internal::kNoId, ##__VA_ARGS__);                  \
-      TRACE_EVENT_API_UPDATE_TRACE_EVENT_DURATION_EXPLICIT(                 \
-          uid_category_group_enabled, name, handle, end_timestamp,          \
-          thread_end_timestamp);                                            \
-    }                                                                       \
-  } while (0)
-
-// The linked ID will not be mangled.
-#define INTERNAL_TRACE_EVENT_ADD_LINK_IDS(category_group, name, id1, id2) \
-  do {                                                                    \
-    INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO(category_group);               \
-    if (INTERNAL_TRACE_EVENT_CATEGORY_GROUP_ENABLED()) {                  \
-      trace_event_internal::TraceID source_id((id1));                     \
-      unsigned int source_flags = source_id.id_flags();                   \
-      trace_event_internal::TraceID target_id((id2));                     \
-      trace_event_internal::AddTraceEvent(                                \
-          TRACE_EVENT_PHASE_LINK_IDS,                                     \
-          INTERNAL_TRACE_EVENT_UID(category_group_enabled), name,         \
-          source_id.scope(), source_id.raw_id(), source_flags,            \
-          trace_event_internal::kNoId, "linked_id",                       \
-          target_id.AsConvertableToTraceFormat());                        \
-    }                                                                     \
-  } while (0)
-
-// Implementation detail: internal macro to create static category and add
-// metadata event if the category is enabled.
-#define INTERNAL_TRACE_EVENT_METADATA_ADD(category_group, name, ...) \
-  do {                                                               \
-    INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO(category_group);          \
-    if (INTERNAL_TRACE_EVENT_CATEGORY_GROUP_ENABLED()) {             \
-      TRACE_EVENT_API_ADD_METADATA_EVENT(                            \
-          INTERNAL_TRACE_EVENT_UID(category_group_enabled), name,    \
-          ##__VA_ARGS__);                                            \
-    }                                                                \
-  } while (0)
-
-// Implementation detail: internal macro to enter and leave a
-// context based on the current scope.
-#define INTERNAL_TRACE_EVENT_SCOPED_CONTEXT(category_group, name, context) \
-  struct INTERNAL_TRACE_EVENT_UID(ScopedContext) {                         \
-   public:                                                                 \
-    INTERNAL_TRACE_EVENT_UID(ScopedContext)(uint64_t cid) : cid_(cid) {    \
-      TRACE_EVENT_ENTER_CONTEXT(category_group, name, cid_);               \
-    }                                                                      \
-    ~INTERNAL_TRACE_EVENT_UID(ScopedContext)() {                           \
-      TRACE_EVENT_LEAVE_CONTEXT(category_group, name, cid_);               \
-    }                                                                      \
-                                                                           \
-   private:                                                                \
-    uint64_t cid_;                                                         \
-    /* Local class friendly DISALLOW_COPY_AND_ASSIGN */                    \
-    INTERNAL_TRACE_EVENT_UID(ScopedContext)                                \
-    (const INTERNAL_TRACE_EVENT_UID(ScopedContext)&) {};                   \
-    void operator=(const INTERNAL_TRACE_EVENT_UID(ScopedContext)&) {};     \
-  };                                                                       \
-  INTERNAL_TRACE_EVENT_UID(ScopedContext)                                  \
-  INTERNAL_TRACE_EVENT_UID(scoped_context)(context);
-
-// TODO(http://crbug.com760702) remove file name and just pass the program
-// counter to the heap profiler macro.
-// TODO(ssid): The program counter of the current task should be added here.
-#define INTERNAL_TRACE_TASK_EXECUTION(run_function, task)                      \
-  TRACE_EVENT1("toplevel", run_function, "src", (task).posted_from.ToString()) \
-  TRACE_HEAP_PROFILER_API_SCOPED_TASK_EXECUTION INTERNAL_TRACE_EVENT_UID(      \
-      task_event)((task).posted_from.file_name());                             \
-  TRACE_HEAP_PROFILER_API_SCOPED_WITH_PROGRAM_COUNTER                          \
-  INTERNAL_TRACE_EVENT_UID(task_pc_event)((task).posted_from.program_counter());
-
-namespace trace_event_internal {
-
-// Specify these values when the corresponding argument of AddTraceEvent is not
-// used.
-const int kZeroNumArgs = 0;
-const std::nullptr_t kGlobalScope = nullptr;
-const unsigned long long kNoId = 0;
-
-// TraceID encapsulates an ID that can either be an integer or pointer. Pointers
-// are by default mangled with the Process ID so that they are unlikely to
-// collide when the same pointer is used on different processes.
-class BASE_EXPORT TraceID {
- public:
-  // Can be combined with WithScope.
-  class LocalId {
-   public:
-    explicit LocalId(const void* raw_id)
-        : raw_id_(static_cast<unsigned long long>(
-              reinterpret_cast<uintptr_t>(raw_id))) {}
-    explicit LocalId(unsigned long long raw_id) : raw_id_(raw_id) {}
-    unsigned long long raw_id() const { return raw_id_; }
-   private:
-    unsigned long long raw_id_;
-  };
-
-  // Can be combined with WithScope.
-  class GlobalId {
-   public:
-    explicit GlobalId(unsigned long long raw_id) : raw_id_(raw_id) {}
-    unsigned long long raw_id() const { return raw_id_; }
-   private:
-    unsigned long long raw_id_;
-  };
-
-  class WithScope {
-   public:
-    WithScope(const char* scope, unsigned long long raw_id)
-        : scope_(scope), raw_id_(raw_id) {}
-    WithScope(const char* scope, LocalId local_id)
-        : scope_(scope), raw_id_(local_id.raw_id()) {
-      id_flags_ = TRACE_EVENT_FLAG_HAS_LOCAL_ID;
-    }
-    WithScope(const char* scope, GlobalId global_id)
-        : scope_(scope), raw_id_(global_id.raw_id()) {
-      id_flags_ = TRACE_EVENT_FLAG_HAS_GLOBAL_ID;
-    }
-    WithScope(const char* scope,
-              unsigned long long prefix,
-              unsigned long long raw_id)
-        : scope_(scope), has_prefix_(true), prefix_(prefix), raw_id_(raw_id) {}
-    WithScope(const char* scope, unsigned long long prefix, GlobalId global_id)
-        : scope_(scope),
-          has_prefix_(true),
-          prefix_(prefix),
-          raw_id_(global_id.raw_id()) {
-      id_flags_ = TRACE_EVENT_FLAG_HAS_GLOBAL_ID;
-    }
-    unsigned long long raw_id() const { return raw_id_; }
-    const char* scope() const { return scope_; }
-    bool has_prefix() const { return has_prefix_; }
-    unsigned long long prefix() const { return prefix_; }
-    unsigned int id_flags() const { return id_flags_; }
-
-   private:
-    const char* scope_ = nullptr;
-    bool has_prefix_ = false;
-    unsigned long long prefix_;
-    unsigned long long raw_id_;
-    unsigned int id_flags_ = TRACE_EVENT_FLAG_HAS_ID;
-  };
-
-  // DEPRECATED: consider using LocalId or GlobalId, instead.
-  class DontMangle {
-   public:
-    explicit DontMangle(const void* raw_id)
-        : raw_id_(static_cast<unsigned long long>(
-              reinterpret_cast<uintptr_t>(raw_id))) {}
-    explicit DontMangle(unsigned long long raw_id) : raw_id_(raw_id) {}
-    explicit DontMangle(unsigned long raw_id) : raw_id_(raw_id) {}
-    explicit DontMangle(unsigned int raw_id) : raw_id_(raw_id) {}
-    explicit DontMangle(unsigned short raw_id) : raw_id_(raw_id) {}
-    explicit DontMangle(unsigned char raw_id) : raw_id_(raw_id) {}
-    explicit DontMangle(long long raw_id)
-        : raw_id_(static_cast<unsigned long long>(raw_id)) {}
-    explicit DontMangle(long raw_id)
-        : raw_id_(static_cast<unsigned long long>(raw_id)) {}
-    explicit DontMangle(int raw_id)
-        : raw_id_(static_cast<unsigned long long>(raw_id)) {}
-    explicit DontMangle(short raw_id)
-        : raw_id_(static_cast<unsigned long long>(raw_id)) {}
-    explicit DontMangle(signed char raw_id)
-        : raw_id_(static_cast<unsigned long long>(raw_id)) {}
-    unsigned long long raw_id() const { return raw_id_; }
-   private:
-    unsigned long long raw_id_;
-  };
-
-  // DEPRECATED: consider using LocalId or GlobalId, instead.
-  class ForceMangle {
-   public:
-    explicit ForceMangle(unsigned long long raw_id) : raw_id_(raw_id) {}
-    explicit ForceMangle(unsigned long raw_id) : raw_id_(raw_id) {}
-    explicit ForceMangle(unsigned int raw_id) : raw_id_(raw_id) {}
-    explicit ForceMangle(unsigned short raw_id) : raw_id_(raw_id) {}
-    explicit ForceMangle(unsigned char raw_id) : raw_id_(raw_id) {}
-    explicit ForceMangle(long long raw_id)
-        : raw_id_(static_cast<unsigned long long>(raw_id)) {}
-    explicit ForceMangle(long raw_id)
-        : raw_id_(static_cast<unsigned long long>(raw_id)) {}
-    explicit ForceMangle(int raw_id)
-        : raw_id_(static_cast<unsigned long long>(raw_id)) {}
-    explicit ForceMangle(short raw_id)
-        : raw_id_(static_cast<unsigned long long>(raw_id)) {}
-    explicit ForceMangle(signed char raw_id)
-        : raw_id_(static_cast<unsigned long long>(raw_id)) {}
-    unsigned long long raw_id() const { return raw_id_; }
-   private:
-    unsigned long long raw_id_;
-  };
-
-  TraceID(const void* raw_id) : raw_id_(static_cast<unsigned long long>(
-                                        reinterpret_cast<uintptr_t>(raw_id))) {
-    id_flags_ = TRACE_EVENT_FLAG_HAS_ID | TRACE_EVENT_FLAG_MANGLE_ID;
-  }
-  TraceID(ForceMangle raw_id) : raw_id_(raw_id.raw_id()) {
-    id_flags_ = TRACE_EVENT_FLAG_HAS_ID | TRACE_EVENT_FLAG_MANGLE_ID;
-  }
-  TraceID(DontMangle raw_id) : raw_id_(raw_id.raw_id()) {}
-  TraceID(unsigned long long raw_id) : raw_id_(raw_id) {}
-  TraceID(unsigned long raw_id) : raw_id_(raw_id) {}
-  TraceID(unsigned int raw_id) : raw_id_(raw_id) {}
-  TraceID(unsigned short raw_id) : raw_id_(raw_id) {}
-  TraceID(unsigned char raw_id) : raw_id_(raw_id) {}
-  TraceID(long long raw_id)
-      : raw_id_(static_cast<unsigned long long>(raw_id)) {}
-  TraceID(long raw_id)
-      : raw_id_(static_cast<unsigned long long>(raw_id)) {}
-  TraceID(int raw_id)
-      : raw_id_(static_cast<unsigned long long>(raw_id)) {}
-  TraceID(short raw_id)
-      : raw_id_(static_cast<unsigned long long>(raw_id)) {}
-  TraceID(signed char raw_id)
-      : raw_id_(static_cast<unsigned long long>(raw_id)) {}
-  TraceID(LocalId raw_id) : raw_id_(raw_id.raw_id()) {
-    id_flags_ = TRACE_EVENT_FLAG_HAS_LOCAL_ID;
-  }
-  TraceID(GlobalId raw_id) : raw_id_(raw_id.raw_id()) {
-    id_flags_ = TRACE_EVENT_FLAG_HAS_GLOBAL_ID;
-  }
-  TraceID(WithScope scoped_id)
-      : scope_(scoped_id.scope()),
-        has_prefix_(scoped_id.has_prefix()),
-        prefix_(scoped_id.prefix()),
-        raw_id_(scoped_id.raw_id()),
-        id_flags_(scoped_id.id_flags()) {}
-
-  unsigned long long raw_id() const { return raw_id_; }
-  const char* scope() const { return scope_; }
-  bool has_prefix() const { return has_prefix_; }
-  unsigned long long prefix() const { return prefix_; }
-  unsigned int id_flags() const { return id_flags_; }
-
-  std::unique_ptr<base::trace_event::ConvertableToTraceFormat>
-  AsConvertableToTraceFormat() const;
-
- private:
-  const char* scope_ = nullptr;
-  bool has_prefix_ = false;
-  unsigned long long prefix_;
-  unsigned long long raw_id_;
-  unsigned int id_flags_ = TRACE_EVENT_FLAG_HAS_ID;
-};
-
-// Simple union to store various types as unsigned long long.
-union TraceValueUnion {
-  bool as_bool;
-  unsigned long long as_uint;
-  long long as_int;
-  double as_double;
-  const void* as_pointer;
-  const char* as_string;
-};
-
-// Simple container for const char* that should be copied instead of retained.
-class TraceStringWithCopy {
- public:
-  explicit TraceStringWithCopy(const char* str) : str_(str) {}
-  const char* str() const { return str_; }
- private:
-  const char* str_;
-};
-
-// Define SetTraceValue for each allowed type. It stores the type and
-// value in the return arguments. This allows this API to avoid declaring any
-// structures so that it is portable to third_party libraries.
-#define INTERNAL_DECLARE_SET_TRACE_VALUE(actual_type, \
-                                         arg_expression, \
-                                         union_member, \
-                                         value_type_id) \
-    static inline void SetTraceValue( \
-        actual_type arg, \
-        unsigned char* type, \
-        unsigned long long* value) { \
-      TraceValueUnion type_value; \
-      type_value.union_member = arg_expression; \
-      *type = value_type_id; \
-      *value = type_value.as_uint; \
-    }
-// Simpler form for int types that can be safely casted.
-#define INTERNAL_DECLARE_SET_TRACE_VALUE_INT(actual_type, \
-                                             value_type_id) \
-    static inline void SetTraceValue( \
-        actual_type arg, \
-        unsigned char* type, \
-        unsigned long long* value) { \
-      *type = value_type_id; \
-      *value = static_cast<unsigned long long>(arg); \
-    }
-
-INTERNAL_DECLARE_SET_TRACE_VALUE_INT(unsigned long long, TRACE_VALUE_TYPE_UINT)
-INTERNAL_DECLARE_SET_TRACE_VALUE_INT(unsigned long, TRACE_VALUE_TYPE_UINT)
-INTERNAL_DECLARE_SET_TRACE_VALUE_INT(unsigned int, TRACE_VALUE_TYPE_UINT)
-INTERNAL_DECLARE_SET_TRACE_VALUE_INT(unsigned short, TRACE_VALUE_TYPE_UINT)
-INTERNAL_DECLARE_SET_TRACE_VALUE_INT(unsigned char, TRACE_VALUE_TYPE_UINT)
-INTERNAL_DECLARE_SET_TRACE_VALUE_INT(long long, TRACE_VALUE_TYPE_INT)
-INTERNAL_DECLARE_SET_TRACE_VALUE_INT(long, TRACE_VALUE_TYPE_INT)
-INTERNAL_DECLARE_SET_TRACE_VALUE_INT(int, TRACE_VALUE_TYPE_INT)
-INTERNAL_DECLARE_SET_TRACE_VALUE_INT(short, TRACE_VALUE_TYPE_INT)
-INTERNAL_DECLARE_SET_TRACE_VALUE_INT(signed char, TRACE_VALUE_TYPE_INT)
-INTERNAL_DECLARE_SET_TRACE_VALUE(bool, arg, as_bool, TRACE_VALUE_TYPE_BOOL)
-INTERNAL_DECLARE_SET_TRACE_VALUE(double, arg, as_double,
-                                 TRACE_VALUE_TYPE_DOUBLE)
-INTERNAL_DECLARE_SET_TRACE_VALUE(const void*, arg, as_pointer,
-                                 TRACE_VALUE_TYPE_POINTER)
-INTERNAL_DECLARE_SET_TRACE_VALUE(const char*, arg, as_string,
-                                 TRACE_VALUE_TYPE_STRING)
-INTERNAL_DECLARE_SET_TRACE_VALUE(const TraceStringWithCopy&, arg.str(),
-                                 as_string, TRACE_VALUE_TYPE_COPY_STRING)
-
-#undef INTERNAL_DECLARE_SET_TRACE_VALUE
-#undef INTERNAL_DECLARE_SET_TRACE_VALUE_INT
-
-// std::string version of SetTraceValue so that trace arguments can be strings.
-static inline void SetTraceValue(const std::string& arg,
-                                 unsigned char* type,
-                                 unsigned long long* value) {
-  TraceValueUnion type_value;
-  type_value.as_string = arg.c_str();
-  *type = TRACE_VALUE_TYPE_COPY_STRING;
-  *value = type_value.as_uint;
-}
-
-// base::Time, base::TimeTicks, etc. versions of SetTraceValue to make it easier
-// to trace these types.
-static inline void SetTraceValue(const base::Time arg,
-                                 unsigned char* type,
-                                 unsigned long long* value) {
-  *type = TRACE_VALUE_TYPE_INT;
-  *value = arg.ToInternalValue();
-}
-
-static inline void SetTraceValue(const base::TimeTicks arg,
-                                 unsigned char* type,
-                                 unsigned long long* value) {
-  *type = TRACE_VALUE_TYPE_INT;
-  *value = arg.ToInternalValue();
-}
-
-static inline void SetTraceValue(const base::ThreadTicks arg,
-                                 unsigned char* type,
-                                 unsigned long long* value) {
-  *type = TRACE_VALUE_TYPE_INT;
-  *value = arg.ToInternalValue();
-}
-
-// These AddTraceEvent and AddTraceEventWithThreadIdAndTimestamp template
-// functions are defined here instead of in the macro, because the arg_values
-// could be temporary objects, such as std::string. In order to store
-// pointers to the internal c_str and pass through to the tracing API,
-// the arg_values must live throughout these procedures.
-
-template <class ARG1_CONVERTABLE_TYPE>
-static inline base::trace_event::TraceEventHandle
-AddTraceEventWithThreadIdAndTimestamp(
-    char phase,
-    const unsigned char* category_group_enabled,
-    const char* name,
-    const char* scope,
-    unsigned long long id,
-    int thread_id,
-    const base::TimeTicks& timestamp,
-    unsigned int flags,
-    unsigned long long bind_id,
-    const char* arg1_name,
-    std::unique_ptr<ARG1_CONVERTABLE_TYPE> arg1_val) {
-  const int num_args = 1;
-  unsigned char arg_types[1] = { TRACE_VALUE_TYPE_CONVERTABLE };
-  std::unique_ptr<base::trace_event::ConvertableToTraceFormat>
-      convertable_values[1] = {std::move(arg1_val)};
-  return TRACE_EVENT_API_ADD_TRACE_EVENT_WITH_THREAD_ID_AND_TIMESTAMP(
-      phase, category_group_enabled, name, scope, id, bind_id, thread_id,
-      timestamp, num_args, &arg1_name, arg_types, NULL, convertable_values,
-      flags);
-}
-
-template <class ARG1_TYPE, class ARG2_CONVERTABLE_TYPE>
-static inline base::trace_event::TraceEventHandle
-AddTraceEventWithThreadIdAndTimestamp(
-    char phase,
-    const unsigned char* category_group_enabled,
-    const char* name,
-    const char* scope,
-    unsigned long long id,
-    int thread_id,
-    const base::TimeTicks& timestamp,
-    unsigned int flags,
-    unsigned long long bind_id,
-    const char* arg1_name,
-    const ARG1_TYPE& arg1_val,
-    const char* arg2_name,
-    std::unique_ptr<ARG2_CONVERTABLE_TYPE> arg2_val) {
-  const int num_args = 2;
-  const char* arg_names[2] = { arg1_name, arg2_name };
-
-  unsigned char arg_types[2];
-  unsigned long long arg_values[2];
-  SetTraceValue(arg1_val, &arg_types[0], &arg_values[0]);
-  arg_types[1] = TRACE_VALUE_TYPE_CONVERTABLE;
-  std::unique_ptr<base::trace_event::ConvertableToTraceFormat>
-      convertable_values[2] = {nullptr, std::move(arg2_val)};
-  return TRACE_EVENT_API_ADD_TRACE_EVENT_WITH_THREAD_ID_AND_TIMESTAMP(
-      phase, category_group_enabled, name, scope, id, bind_id, thread_id,
-      timestamp, num_args, arg_names, arg_types, arg_values, convertable_values,
-      flags);
-}
-
-template <class ARG1_CONVERTABLE_TYPE, class ARG2_TYPE>
-static inline base::trace_event::TraceEventHandle
-AddTraceEventWithThreadIdAndTimestamp(
-    char phase,
-    const unsigned char* category_group_enabled,
-    const char* name,
-    const char* scope,
-    unsigned long long id,
-    int thread_id,
-    const base::TimeTicks& timestamp,
-    unsigned int flags,
-    unsigned long long bind_id,
-    const char* arg1_name,
-    std::unique_ptr<ARG1_CONVERTABLE_TYPE> arg1_val,
-    const char* arg2_name,
-    const ARG2_TYPE& arg2_val) {
-  const int num_args = 2;
-  const char* arg_names[2] = { arg1_name, arg2_name };
-
-  unsigned char arg_types[2];
-  unsigned long long arg_values[2];
-  arg_types[0] = TRACE_VALUE_TYPE_CONVERTABLE;
-  arg_values[0] = 0;
-  SetTraceValue(arg2_val, &arg_types[1], &arg_values[1]);
-  std::unique_ptr<base::trace_event::ConvertableToTraceFormat>
-      convertable_values[2] = {std::move(arg1_val), nullptr};
-  return TRACE_EVENT_API_ADD_TRACE_EVENT_WITH_THREAD_ID_AND_TIMESTAMP(
-      phase, category_group_enabled, name, scope, id, bind_id, thread_id,
-      timestamp, num_args, arg_names, arg_types, arg_values, convertable_values,
-      flags);
-}
-
-template <class ARG1_CONVERTABLE_TYPE, class ARG2_CONVERTABLE_TYPE>
-static inline base::trace_event::TraceEventHandle
-AddTraceEventWithThreadIdAndTimestamp(
-    char phase,
-    const unsigned char* category_group_enabled,
-    const char* name,
-    const char* scope,
-    unsigned long long id,
-    int thread_id,
-    const base::TimeTicks& timestamp,
-    unsigned int flags,
-    unsigned long long bind_id,
-    const char* arg1_name,
-    std::unique_ptr<ARG1_CONVERTABLE_TYPE> arg1_val,
-    const char* arg2_name,
-    std::unique_ptr<ARG2_CONVERTABLE_TYPE> arg2_val) {
-  const int num_args = 2;
-  const char* arg_names[2] = { arg1_name, arg2_name };
-  unsigned char arg_types[2] =
-      { TRACE_VALUE_TYPE_CONVERTABLE, TRACE_VALUE_TYPE_CONVERTABLE };
-  std::unique_ptr<base::trace_event::ConvertableToTraceFormat>
-      convertable_values[2] = {std::move(arg1_val), std::move(arg2_val)};
-  return TRACE_EVENT_API_ADD_TRACE_EVENT_WITH_THREAD_ID_AND_TIMESTAMP(
-      phase, category_group_enabled, name, scope, id, bind_id, thread_id,
-      timestamp, num_args, arg_names, arg_types, NULL, convertable_values,
-      flags);
-}
-
-static inline base::trace_event::TraceEventHandle
-AddTraceEventWithThreadIdAndTimestamp(
-    char phase,
-    const unsigned char* category_group_enabled,
-    const char* name,
-    const char* scope,
-    unsigned long long id,
-    int thread_id,
-    const base::TimeTicks& timestamp,
-    unsigned int flags,
-    unsigned long long bind_id) {
-  return TRACE_EVENT_API_ADD_TRACE_EVENT_WITH_THREAD_ID_AND_TIMESTAMP(
-      phase, category_group_enabled, name, scope, id, bind_id, thread_id,
-      timestamp, kZeroNumArgs, NULL, NULL, NULL, NULL, flags);
-}
-
-static inline base::trace_event::TraceEventHandle AddTraceEvent(
-    char phase,
-    const unsigned char* category_group_enabled,
-    const char* name,
-    const char* scope,
-    unsigned long long id,
-    unsigned int flags,
-    unsigned long long bind_id) {
-  const int thread_id = static_cast<int>(base::PlatformThread::CurrentId());
-  const base::TimeTicks now = TRACE_TIME_TICKS_NOW();
-  return AddTraceEventWithThreadIdAndTimestamp(
-      phase, category_group_enabled, name, scope, id, thread_id, now, flags,
-      bind_id);
-}
-
-template<class ARG1_TYPE>
-static inline base::trace_event::TraceEventHandle
-AddTraceEventWithThreadIdAndTimestamp(
-    char phase,
-    const unsigned char* category_group_enabled,
-    const char* name,
-    const char* scope,
-    unsigned long long id,
-    int thread_id,
-    const base::TimeTicks& timestamp,
-    unsigned int flags,
-    unsigned long long bind_id,
-    const char* arg1_name,
-    const ARG1_TYPE& arg1_val) {
-  const int num_args = 1;
-  unsigned char arg_types[1];
-  unsigned long long arg_values[1];
-  SetTraceValue(arg1_val, &arg_types[0], &arg_values[0]);
-  return TRACE_EVENT_API_ADD_TRACE_EVENT_WITH_THREAD_ID_AND_TIMESTAMP(
-      phase, category_group_enabled, name, scope, id, bind_id, thread_id,
-      timestamp, num_args, &arg1_name, arg_types, arg_values, NULL, flags);
-}
-
-template<class ARG1_TYPE>
-static inline base::trace_event::TraceEventHandle AddTraceEvent(
-    char phase,
-    const unsigned char* category_group_enabled,
-    const char* name,
-    const char* scope,
-    unsigned long long id,
-    unsigned int flags,
-    unsigned long long bind_id,
-    const char* arg1_name,
-    const ARG1_TYPE& arg1_val) {
-  int thread_id = static_cast<int>(base::PlatformThread::CurrentId());
-  base::TimeTicks now = TRACE_TIME_TICKS_NOW();
-  return AddTraceEventWithThreadIdAndTimestamp(
-      phase, category_group_enabled, name, scope, id, thread_id, now, flags,
-      bind_id, arg1_name, arg1_val);
-}
-
-template <class ARG1_CONVERTABLE_TYPE>
-static inline base::trace_event::TraceEventHandle AddTraceEvent(
-    char phase,
-    const unsigned char* category_group_enabled,
-    const char* name,
-    const char* scope,
-    unsigned long long id,
-    unsigned int flags,
-    unsigned long long bind_id,
-    const char* arg1_name,
-    std::unique_ptr<ARG1_CONVERTABLE_TYPE> arg1_val) {
-  int thread_id = static_cast<int>(base::PlatformThread::CurrentId());
-  base::TimeTicks now = TRACE_TIME_TICKS_NOW();
-  return AddTraceEventWithThreadIdAndTimestamp(
-      phase, category_group_enabled, name, scope, id, thread_id, now, flags,
-      bind_id, arg1_name, std::move(arg1_val));
-}
-
-template<class ARG1_TYPE, class ARG2_TYPE>
-static inline base::trace_event::TraceEventHandle
-AddTraceEventWithThreadIdAndTimestamp(
-    char phase,
-    const unsigned char* category_group_enabled,
-    const char* name,
-    const char* scope,
-    unsigned long long id,
-    int thread_id,
-    const base::TimeTicks& timestamp,
-    unsigned int flags,
-    unsigned long long bind_id,
-    const char* arg1_name,
-    const ARG1_TYPE& arg1_val,
-    const char* arg2_name,
-    const ARG2_TYPE& arg2_val) {
-  const int num_args = 2;
-  const char* arg_names[2] = { arg1_name, arg2_name };
-  unsigned char arg_types[2];
-  unsigned long long arg_values[2];
-  SetTraceValue(arg1_val, &arg_types[0], &arg_values[0]);
-  SetTraceValue(arg2_val, &arg_types[1], &arg_values[1]);
-  return TRACE_EVENT_API_ADD_TRACE_EVENT_WITH_THREAD_ID_AND_TIMESTAMP(
-      phase, category_group_enabled, name, scope, id, bind_id, thread_id,
-      timestamp, num_args, arg_names, arg_types, arg_values, NULL, flags);
-}
-
-template <class ARG1_CONVERTABLE_TYPE, class ARG2_TYPE>
-static inline base::trace_event::TraceEventHandle AddTraceEvent(
-    char phase,
-    const unsigned char* category_group_enabled,
-    const char* name,
-    const char* scope,
-    unsigned long long id,
-    unsigned int flags,
-    unsigned long long bind_id,
-    const char* arg1_name,
-    std::unique_ptr<ARG1_CONVERTABLE_TYPE> arg1_val,
-    const char* arg2_name,
-    const ARG2_TYPE& arg2_val) {
-  int thread_id = static_cast<int>(base::PlatformThread::CurrentId());
-  base::TimeTicks now = TRACE_TIME_TICKS_NOW();
-  return AddTraceEventWithThreadIdAndTimestamp(
-      phase, category_group_enabled, name, scope, id, thread_id, now, flags,
-      bind_id, arg1_name, std::move(arg1_val), arg2_name, arg2_val);
-}
-
-template <class ARG1_TYPE, class ARG2_CONVERTABLE_TYPE>
-static inline base::trace_event::TraceEventHandle AddTraceEvent(
-    char phase,
-    const unsigned char* category_group_enabled,
-    const char* name,
-    const char* scope,
-    unsigned long long id,
-    unsigned int flags,
-    unsigned long long bind_id,
-    const char* arg1_name,
-    const ARG1_TYPE& arg1_val,
-    const char* arg2_name,
-    std::unique_ptr<ARG2_CONVERTABLE_TYPE> arg2_val) {
-  int thread_id = static_cast<int>(base::PlatformThread::CurrentId());
-  base::TimeTicks now = TRACE_TIME_TICKS_NOW();
-  return AddTraceEventWithThreadIdAndTimestamp(
-      phase, category_group_enabled, name, scope, id, thread_id, now, flags,
-      bind_id, arg1_name, arg1_val, arg2_name, std::move(arg2_val));
-}
-
-template <class ARG1_CONVERTABLE_TYPE, class ARG2_CONVERTABLE_TYPE>
-static inline base::trace_event::TraceEventHandle AddTraceEvent(
-    char phase,
-    const unsigned char* category_group_enabled,
-    const char* name,
-    const char* scope,
-    unsigned long long id,
-    unsigned int flags,
-    unsigned long long bind_id,
-    const char* arg1_name,
-    std::unique_ptr<ARG1_CONVERTABLE_TYPE> arg1_val,
-    const char* arg2_name,
-    std::unique_ptr<ARG2_CONVERTABLE_TYPE> arg2_val) {
-  int thread_id = static_cast<int>(base::PlatformThread::CurrentId());
-  base::TimeTicks now = TRACE_TIME_TICKS_NOW();
-  return AddTraceEventWithThreadIdAndTimestamp(
-      phase, category_group_enabled, name, scope, id, thread_id, now, flags,
-      bind_id, arg1_name, std::move(arg1_val), arg2_name, std::move(arg2_val));
-}
-
-template<class ARG1_TYPE, class ARG2_TYPE>
-static inline base::trace_event::TraceEventHandle AddTraceEvent(
-    char phase,
-    const unsigned char* category_group_enabled,
-    const char* name,
-    const char* scope,
-    unsigned long long id,
-    unsigned int flags,
-    unsigned long long bind_id,
-    const char* arg1_name,
-    const ARG1_TYPE& arg1_val,
-    const char* arg2_name,
-    const ARG2_TYPE& arg2_val) {
-  int thread_id = static_cast<int>(base::PlatformThread::CurrentId());
-  base::TimeTicks now = TRACE_TIME_TICKS_NOW();
-  return AddTraceEventWithThreadIdAndTimestamp(
-      phase, category_group_enabled, name, scope, id, thread_id, now, flags,
-      bind_id, arg1_name, arg1_val, arg2_name, arg2_val);
-}
-
-template <class ARG1_CONVERTABLE_TYPE>
-static inline void AddMetadataEvent(
-    const unsigned char* category_group_enabled,
-    const char* event_name,
-    const char* arg_name,
-    std::unique_ptr<ARG1_CONVERTABLE_TYPE> arg_value) {
-  const char* arg_names[1] = {arg_name};
-  unsigned char arg_types[1] = {TRACE_VALUE_TYPE_CONVERTABLE};
-  std::unique_ptr<base::trace_event::ConvertableToTraceFormat>
-      convertable_values[1] = {std::move(arg_value)};
-  base::trace_event::TraceLog::GetInstance()->AddMetadataEvent(
-      category_group_enabled, event_name,
-      1,  // num_args
-      arg_names, arg_types,
-      nullptr,  // arg_values
-      convertable_values, TRACE_EVENT_FLAG_NONE);
-}
-
-template <class ARG1_TYPE>
-static void AddMetadataEvent(const unsigned char* category_group_enabled,
-                             const char* event_name,
-                             const char* arg_name,
-                             const ARG1_TYPE& arg_val) {
-  const int num_args = 1;
-  const char* arg_names[1] = {arg_name};
-  unsigned char arg_types[1];
-  unsigned long long arg_values[1];
-  SetTraceValue(arg_val, &arg_types[0], &arg_values[0]);
-
-  base::trace_event::TraceLog::GetInstance()->AddMetadataEvent(
-      category_group_enabled, event_name, num_args, arg_names, arg_types,
-      arg_values, nullptr, TRACE_EVENT_FLAG_NONE);
-}
-
-// Used by TRACE_EVENTx macros. Do not use directly.
-class TRACE_EVENT_API_CLASS_EXPORT ScopedTracer {
- public:
-  // Note: members of data_ intentionally left uninitialized. See Initialize.
-  ScopedTracer() : p_data_(NULL) {}
-
-  ~ScopedTracer() {
-    if (p_data_ && *data_.category_group_enabled) {
-      TRACE_EVENT_API_UPDATE_TRACE_EVENT_DURATION(
-          data_.category_group_enabled, data_.name, data_.event_handle);
-    }
-  }
-
-  void Initialize(const unsigned char* category_group_enabled,
-                  const char* name,
-                  base::trace_event::TraceEventHandle event_handle) {
-    data_.category_group_enabled = category_group_enabled;
-    data_.name = name;
-    data_.event_handle = event_handle;
-    p_data_ = &data_;
-  }
-
- private:
-  // This Data struct workaround is to avoid initializing all the members
-  // in Data during construction of this object, since this object is always
-  // constructed, even when tracing is disabled. If the members of Data were
-  // members of this class instead, compiler warnings occur about potential
-  // uninitialized accesses.
-  struct Data {
-    const unsigned char* category_group_enabled;
-    const char* name;
-    base::trace_event::TraceEventHandle event_handle;
-  };
-  Data* p_data_;
-  Data data_;
-};
-
-// Used by TRACE_EVENT_BINARY_EFFICIENTx macro. Do not use directly.
-class TRACE_EVENT_API_CLASS_EXPORT ScopedTraceBinaryEfficient {
- public:
-  ScopedTraceBinaryEfficient(const char* category_group, const char* name);
-  ~ScopedTraceBinaryEfficient();
-
- private:
-  const unsigned char* category_group_enabled_;
-  const char* name_;
-  base::trace_event::TraceEventHandle event_handle_;
-};
-
-// This macro generates less code then TRACE_EVENT0 but is also
-// slower to execute when tracing is off. It should generally only be
-// used with code that is seldom executed or conditionally executed
-// when debugging.
-// For now the category_group must be "gpu".
-#define TRACE_EVENT_BINARY_EFFICIENT0(category_group, name) \
-    trace_event_internal::ScopedTraceBinaryEfficient \
-        INTERNAL_TRACE_EVENT_UID(scoped_trace)(category_group, name);
-
-}  // namespace trace_event_internal
-
-namespace base {
-namespace trace_event {
-
-template<typename IDType> class TraceScopedTrackableObject {
- public:
-  TraceScopedTrackableObject(const char* category_group, const char* name,
-      IDType id)
-    : category_group_(category_group),
-      name_(name),
-      id_(id) {
-    TRACE_EVENT_OBJECT_CREATED_WITH_ID(category_group_, name_, id_);
-  }
-
-  template <typename ArgType> void snapshot(ArgType snapshot) {
-    TRACE_EVENT_OBJECT_SNAPSHOT_WITH_ID(category_group_, name_, id_, snapshot);
-  }
-
-  ~TraceScopedTrackableObject() {
-    TRACE_EVENT_OBJECT_DELETED_WITH_ID(category_group_, name_, id_);
-  }
-
- private:
-  const char* category_group_;
-  const char* name_;
-  IDType id_;
-
-  DISALLOW_COPY_AND_ASSIGN(TraceScopedTrackableObject);
-};
-
-}  // namespace trace_event
-}  // namespace base
-
-#endif  // BASE_TRACE_EVENT_TRACE_EVENT_H_
diff --git a/base/trace_event/trace_event_android.cc b/base/trace_event/trace_event_android.cc
deleted file mode 100644
index 30d9c74..0000000
--- a/base/trace_event/trace_event_android.cc
+++ /dev/null
@@ -1,216 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/trace_event/trace_event_impl.h"
-
-#include <fcntl.h>
-#include <stddef.h>
-#include <stdint.h>
-
-#include "base/format_macros.h"
-#include "base/logging.h"
-#include "base/posix/eintr_wrapper.h"
-#include "base/strings/stringprintf.h"
-#include "base/synchronization/waitable_event.h"
-#include "base/threading/thread.h"
-#include "base/trace_event/trace_event.h"
-
-namespace base {
-namespace trace_event {
-
-namespace {
-
-int g_atrace_fd = -1;
-const char kATraceMarkerFile[] = "/sys/kernel/debug/tracing/trace_marker";
-
-void WriteToATrace(int fd, const char* buffer, size_t size) {
-  size_t total_written = 0;
-  while (total_written < size) {
-    ssize_t written = HANDLE_EINTR(write(
-        fd, buffer + total_written, size - total_written));
-    if (written <= 0)
-      break;
-    total_written += written;
-  }
-  if (total_written < size) {
-    PLOG(WARNING) << "Failed to write buffer '" << std::string(buffer, size)
-                  << "' to " << kATraceMarkerFile;
-  }
-}
-
-void WriteEvent(
-    char phase,
-    const char* category_group,
-    const char* name,
-    unsigned long long id,
-    const char** arg_names,
-    const unsigned char* arg_types,
-    const TraceEvent::TraceValue* arg_values,
-    const std::unique_ptr<ConvertableToTraceFormat>* convertable_values,
-    unsigned int flags) {
-  std::string out = StringPrintf("%c|%d|%s", phase, getpid(), name);
-  if (flags & TRACE_EVENT_FLAG_HAS_ID)
-    StringAppendF(&out, "-%" PRIx64, static_cast<uint64_t>(id));
-  out += '|';
-
-  for (int i = 0; i < kTraceMaxNumArgs && arg_names[i];
-       ++i) {
-    if (i)
-      out += ';';
-    out += arg_names[i];
-    out += '=';
-    std::string::size_type value_start = out.length();
-    if (arg_types[i] == TRACE_VALUE_TYPE_CONVERTABLE)
-      convertable_values[i]->AppendAsTraceFormat(&out);
-    else
-      TraceEvent::AppendValueAsJSON(arg_types[i], arg_values[i], &out);
-
-    // Remove the quotes which may confuse the atrace script.
-    ReplaceSubstringsAfterOffset(&out, value_start, "\\\"", "'");
-    ReplaceSubstringsAfterOffset(&out, value_start, "\"", "");
-    // Replace chars used for separators with similar chars in the value.
-    std::replace(out.begin() + value_start, out.end(), ';', ',');
-    std::replace(out.begin() + value_start, out.end(), '|', '!');
-  }
-
-  out += '|';
-  out += category_group;
-  WriteToATrace(g_atrace_fd, out.c_str(), out.size());
-}
-
-void NoOpOutputCallback(WaitableEvent* complete_event,
-                        const scoped_refptr<RefCountedString>&,
-                        bool has_more_events) {
-  if (!has_more_events)
-    complete_event->Signal();
-}
-
-void EndChromeTracing(TraceLog* trace_log,
-                      WaitableEvent* complete_event) {
-  trace_log->SetDisabled();
-  // Delete the buffered trace events as they have been sent to atrace.
-  trace_log->Flush(Bind(&NoOpOutputCallback, complete_event));
-}
-
-}  // namespace
-
-// These functions support Android systrace.py when 'webview' category is
-// traced. With the new adb_profile_chrome, we may have two phases:
-// - before WebView is ready for combined tracing, we can use adb_profile_chrome
-//   to trace android categories other than 'webview' and chromium categories.
-//   In this way we can avoid the conflict between StartATrace/StopATrace and
-//   the intents.
-// - TODO(wangxianzhu): after WebView is ready for combined tracing, remove
-//   StartATrace, StopATrace and SendToATrace, and perhaps send Java traces
-//   directly to atrace in trace_event_binding.cc.
-
-void TraceLog::StartATrace() {
-  if (g_atrace_fd != -1)
-    return;
-
-  g_atrace_fd = HANDLE_EINTR(open(kATraceMarkerFile, O_WRONLY));
-  if (g_atrace_fd == -1) {
-    PLOG(WARNING) << "Couldn't open " << kATraceMarkerFile;
-    return;
-  }
-  TraceConfig trace_config;
-  trace_config.SetTraceRecordMode(RECORD_CONTINUOUSLY);
-  SetEnabled(trace_config, TraceLog::RECORDING_MODE);
-}
-
-void TraceLog::StopATrace() {
-  if (g_atrace_fd == -1)
-    return;
-
-  close(g_atrace_fd);
-  g_atrace_fd = -1;
-
-  // TraceLog::Flush() requires the current thread to have a message loop, but
-  // this thread called from Java may not have one, so flush in another thread.
-  Thread end_chrome_tracing_thread("end_chrome_tracing");
-  WaitableEvent complete_event(WaitableEvent::ResetPolicy::AUTOMATIC,
-                               WaitableEvent::InitialState::NOT_SIGNALED);
-  end_chrome_tracing_thread.Start();
-  end_chrome_tracing_thread.task_runner()->PostTask(
-      FROM_HERE, base::Bind(&EndChromeTracing, Unretained(this),
-                            Unretained(&complete_event)));
-  complete_event.Wait();
-}
-
-void TraceEvent::SendToATrace() {
-  if (g_atrace_fd == -1)
-    return;
-
-  const char* category_group =
-      TraceLog::GetCategoryGroupName(category_group_enabled_);
-
-  switch (phase_) {
-    case TRACE_EVENT_PHASE_BEGIN:
-      WriteEvent('B', category_group, name_, id_,
-                 arg_names_, arg_types_, arg_values_, convertable_values_,
-                 flags_);
-      break;
-
-    case TRACE_EVENT_PHASE_COMPLETE:
-      WriteEvent(duration_.ToInternalValue() == -1 ? 'B' : 'E',
-                 category_group, name_, id_,
-                 arg_names_, arg_types_, arg_values_, convertable_values_,
-                 flags_);
-      break;
-
-    case TRACE_EVENT_PHASE_END:
-      // Though a single 'E' is enough, here append pid, name and
-      // category_group etc. So that unpaired events can be found easily.
-      WriteEvent('E', category_group, name_, id_,
-                 arg_names_, arg_types_, arg_values_, convertable_values_,
-                 flags_);
-      break;
-
-    case TRACE_EVENT_PHASE_INSTANT:
-      // Simulate an instance event with a pair of begin/end events.
-      WriteEvent('B', category_group, name_, id_,
-                 arg_names_, arg_types_, arg_values_, convertable_values_,
-                 flags_);
-      WriteToATrace(g_atrace_fd, "E", 1);
-      break;
-
-    case TRACE_EVENT_PHASE_COUNTER:
-      for (int i = 0; i < kTraceMaxNumArgs && arg_names_[i]; ++i) {
-        DCHECK(arg_types_[i] == TRACE_VALUE_TYPE_INT);
-        std::string out = base::StringPrintf(
-            "C|%d|%s-%s", getpid(), name_, arg_names_[i]);
-        if (flags_ & TRACE_EVENT_FLAG_HAS_ID)
-          StringAppendF(&out, "-%" PRIx64, static_cast<uint64_t>(id_));
-        StringAppendF(&out, "|%d|%s",
-                      static_cast<int>(arg_values_[i].as_int), category_group);
-        WriteToATrace(g_atrace_fd, out.c_str(), out.size());
-      }
-      break;
-
-    default:
-      // Do nothing.
-      break;
-  }
-}
-
-void TraceLog::AddClockSyncMetadataEvent() {
-  int atrace_fd = HANDLE_EINTR(open(kATraceMarkerFile, O_WRONLY | O_APPEND));
-  if (atrace_fd == -1) {
-    PLOG(WARNING) << "Couldn't open " << kATraceMarkerFile;
-    return;
-  }
-
-  // Android's kernel trace system has a trace_marker feature: this is a file on
-  // debugfs that takes the written data and pushes it onto the trace
-  // buffer. So, to establish clock sync, we write our monotonic clock into that
-  // trace buffer.
-  double now_in_seconds = (TRACE_TIME_TICKS_NOW() - TimeTicks()).InSecondsF();
-  std::string marker = StringPrintf(
-      "trace_event_clock_sync: parent_ts=%f\n", now_in_seconds);
-  WriteToATrace(atrace_fd, marker.c_str(), marker.size());
-  close(atrace_fd);
-}
-
-}  // namespace trace_event
-}  // namespace base
diff --git a/base/trace_event/trace_event_argument.cc b/base/trace_event/trace_event_argument.cc
deleted file mode 100644
index e614b27..0000000
--- a/base/trace_event/trace_event_argument.cc
+++ /dev/null
@@ -1,576 +0,0 @@
-// Copyright (c) 2014 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/trace_event/trace_event_argument.h"
-
-#include <stdint.h>
-
-#include <utility>
-
-#include "base/bits.h"
-#include "base/containers/circular_deque.h"
-#include "base/json/string_escape.h"
-#include "base/memory/ptr_util.h"
-#include "base/trace_event/trace_event.h"
-#include "base/trace_event/trace_event_impl.h"
-#include "base/trace_event/trace_event_memory_overhead.h"
-#include "base/values.h"
-
-namespace base {
-namespace trace_event {
-
-namespace {
-const char kTypeStartDict = '{';
-const char kTypeEndDict = '}';
-const char kTypeStartArray = '[';
-const char kTypeEndArray = ']';
-const char kTypeBool = 'b';
-const char kTypeInt = 'i';
-const char kTypeDouble = 'd';
-const char kTypeString = 's';
-const char kTypeCStr = '*';  // only used for key names
-
-#ifndef NDEBUG
-const bool kStackTypeDict = false;
-const bool kStackTypeArray = true;
-#define DCHECK_CURRENT_CONTAINER_IS(x) DCHECK_EQ(x, nesting_stack_.back())
-#define DCHECK_CONTAINER_STACK_DEPTH_EQ(x) DCHECK_EQ(x, nesting_stack_.size())
-#define DEBUG_PUSH_CONTAINER(x) nesting_stack_.push_back(x)
-#define DEBUG_POP_CONTAINER() nesting_stack_.pop_back()
-#else
-#define DCHECK_CURRENT_CONTAINER_IS(x) do {} while (0)
-#define DCHECK_CONTAINER_STACK_DEPTH_EQ(x) do {} while (0)
-#define DEBUG_PUSH_CONTAINER(x) do {} while (0)
-#define DEBUG_POP_CONTAINER() do {} while (0)
-#endif
-
-inline void WriteKeyNameAsRawPtr(Pickle& pickle, const char* ptr) {
-  pickle.WriteBytes(&kTypeCStr, 1);
-  pickle.WriteUInt64(static_cast<uint64_t>(reinterpret_cast<uintptr_t>(ptr)));
-}
-
-inline void WriteKeyNameWithCopy(Pickle& pickle, base::StringPiece str) {
-  pickle.WriteBytes(&kTypeString, 1);
-  pickle.WriteString(str);
-}
-
-std::string ReadKeyName(PickleIterator& pickle_iterator) {
-  const char* type = nullptr;
-  bool res = pickle_iterator.ReadBytes(&type, 1);
-  std::string key_name;
-  if (res && *type == kTypeCStr) {
-    uint64_t ptr_value = 0;
-    res = pickle_iterator.ReadUInt64(&ptr_value);
-    key_name = reinterpret_cast<const char*>(static_cast<uintptr_t>(ptr_value));
-  } else if (res && *type == kTypeString) {
-    res = pickle_iterator.ReadString(&key_name);
-  }
-  DCHECK(res);
-  return key_name;
-}
-}  // namespace
-
-TracedValue::TracedValue() : TracedValue(0) {
-}
-
-TracedValue::TracedValue(size_t capacity) {
-  DEBUG_PUSH_CONTAINER(kStackTypeDict);
-  if (capacity)
-    pickle_.Reserve(capacity);
-}
-
-TracedValue::~TracedValue() {
-  DCHECK_CURRENT_CONTAINER_IS(kStackTypeDict);
-  DEBUG_POP_CONTAINER();
-  DCHECK_CONTAINER_STACK_DEPTH_EQ(0u);
-}
-
-void TracedValue::SetInteger(const char* name, int value) {
-  DCHECK_CURRENT_CONTAINER_IS(kStackTypeDict);
-  pickle_.WriteBytes(&kTypeInt, 1);
-  pickle_.WriteInt(value);
-  WriteKeyNameAsRawPtr(pickle_, name);
-}
-
-void TracedValue::SetIntegerWithCopiedName(base::StringPiece name, int value) {
-  DCHECK_CURRENT_CONTAINER_IS(kStackTypeDict);
-  pickle_.WriteBytes(&kTypeInt, 1);
-  pickle_.WriteInt(value);
-  WriteKeyNameWithCopy(pickle_, name);
-}
-
-void TracedValue::SetDouble(const char* name, double value) {
-  DCHECK_CURRENT_CONTAINER_IS(kStackTypeDict);
-  pickle_.WriteBytes(&kTypeDouble, 1);
-  pickle_.WriteDouble(value);
-  WriteKeyNameAsRawPtr(pickle_, name);
-}
-
-void TracedValue::SetDoubleWithCopiedName(base::StringPiece name,
-                                          double value) {
-  DCHECK_CURRENT_CONTAINER_IS(kStackTypeDict);
-  pickle_.WriteBytes(&kTypeDouble, 1);
-  pickle_.WriteDouble(value);
-  WriteKeyNameWithCopy(pickle_, name);
-}
-
-void TracedValue::SetBoolean(const char* name, bool value) {
-  DCHECK_CURRENT_CONTAINER_IS(kStackTypeDict);
-  pickle_.WriteBytes(&kTypeBool, 1);
-  pickle_.WriteBool(value);
-  WriteKeyNameAsRawPtr(pickle_, name);
-}
-
-void TracedValue::SetBooleanWithCopiedName(base::StringPiece name,
-                                           bool value) {
-  DCHECK_CURRENT_CONTAINER_IS(kStackTypeDict);
-  pickle_.WriteBytes(&kTypeBool, 1);
-  pickle_.WriteBool(value);
-  WriteKeyNameWithCopy(pickle_, name);
-}
-
-void TracedValue::SetString(const char* name, base::StringPiece value) {
-  DCHECK_CURRENT_CONTAINER_IS(kStackTypeDict);
-  pickle_.WriteBytes(&kTypeString, 1);
-  pickle_.WriteString(value);
-  WriteKeyNameAsRawPtr(pickle_, name);
-}
-
-void TracedValue::SetStringWithCopiedName(base::StringPiece name,
-                                          base::StringPiece value) {
-  DCHECK_CURRENT_CONTAINER_IS(kStackTypeDict);
-  pickle_.WriteBytes(&kTypeString, 1);
-  pickle_.WriteString(value);
-  WriteKeyNameWithCopy(pickle_, name);
-}
-
-void TracedValue::SetValue(const char* name, const TracedValue& value) {
-  DCHECK_CURRENT_CONTAINER_IS(kStackTypeDict);
-  BeginDictionary(name);
-  pickle_.WriteBytes(value.pickle_.payload(),
-                     static_cast<int>(value.pickle_.payload_size()));
-  EndDictionary();
-}
-
-void TracedValue::SetValueWithCopiedName(base::StringPiece name,
-                                         const TracedValue& value) {
-  DCHECK_CURRENT_CONTAINER_IS(kStackTypeDict);
-  BeginDictionaryWithCopiedName(name);
-  pickle_.WriteBytes(value.pickle_.payload(),
-                     static_cast<int>(value.pickle_.payload_size()));
-  EndDictionary();
-}
-
-void TracedValue::BeginDictionary(const char* name) {
-  DCHECK_CURRENT_CONTAINER_IS(kStackTypeDict);
-  DEBUG_PUSH_CONTAINER(kStackTypeDict);
-  pickle_.WriteBytes(&kTypeStartDict, 1);
-  WriteKeyNameAsRawPtr(pickle_, name);
-}
-
-void TracedValue::BeginDictionaryWithCopiedName(base::StringPiece name) {
-  DCHECK_CURRENT_CONTAINER_IS(kStackTypeDict);
-  DEBUG_PUSH_CONTAINER(kStackTypeDict);
-  pickle_.WriteBytes(&kTypeStartDict, 1);
-  WriteKeyNameWithCopy(pickle_, name);
-}
-
-void TracedValue::BeginArray(const char* name) {
-  DCHECK_CURRENT_CONTAINER_IS(kStackTypeDict);
-  DEBUG_PUSH_CONTAINER(kStackTypeArray);
-  pickle_.WriteBytes(&kTypeStartArray, 1);
-  WriteKeyNameAsRawPtr(pickle_, name);
-}
-
-void TracedValue::BeginArrayWithCopiedName(base::StringPiece name) {
-  DCHECK_CURRENT_CONTAINER_IS(kStackTypeDict);
-  DEBUG_PUSH_CONTAINER(kStackTypeArray);
-  pickle_.WriteBytes(&kTypeStartArray, 1);
-  WriteKeyNameWithCopy(pickle_, name);
-}
-
-void TracedValue::EndDictionary() {
-  DCHECK_CURRENT_CONTAINER_IS(kStackTypeDict);
-  DEBUG_POP_CONTAINER();
-  pickle_.WriteBytes(&kTypeEndDict, 1);
-}
-
-void TracedValue::AppendInteger(int value) {
-  DCHECK_CURRENT_CONTAINER_IS(kStackTypeArray);
-  pickle_.WriteBytes(&kTypeInt, 1);
-  pickle_.WriteInt(value);
-}
-
-void TracedValue::AppendDouble(double value) {
-  DCHECK_CURRENT_CONTAINER_IS(kStackTypeArray);
-  pickle_.WriteBytes(&kTypeDouble, 1);
-  pickle_.WriteDouble(value);
-}
-
-void TracedValue::AppendBoolean(bool value) {
-  DCHECK_CURRENT_CONTAINER_IS(kStackTypeArray);
-  pickle_.WriteBytes(&kTypeBool, 1);
-  pickle_.WriteBool(value);
-}
-
-void TracedValue::AppendString(base::StringPiece value) {
-  DCHECK_CURRENT_CONTAINER_IS(kStackTypeArray);
-  pickle_.WriteBytes(&kTypeString, 1);
-  pickle_.WriteString(value);
-}
-
-void TracedValue::BeginArray() {
-  DCHECK_CURRENT_CONTAINER_IS(kStackTypeArray);
-  DEBUG_PUSH_CONTAINER(kStackTypeArray);
-  pickle_.WriteBytes(&kTypeStartArray, 1);
-}
-
-void TracedValue::BeginDictionary() {
-  DCHECK_CURRENT_CONTAINER_IS(kStackTypeArray);
-  DEBUG_PUSH_CONTAINER(kStackTypeDict);
-  pickle_.WriteBytes(&kTypeStartDict, 1);
-}
-
-void TracedValue::EndArray() {
-  DCHECK_CURRENT_CONTAINER_IS(kStackTypeArray);
-  DEBUG_POP_CONTAINER();
-  pickle_.WriteBytes(&kTypeEndArray, 1);
-}
-
-void TracedValue::SetValue(const char* name,
-                           std::unique_ptr<base::Value> value) {
-  SetBaseValueWithCopiedName(name, *value);
-}
-
-void TracedValue::SetBaseValueWithCopiedName(base::StringPiece name,
-                                             const base::Value& value) {
-  DCHECK_CURRENT_CONTAINER_IS(kStackTypeDict);
-  switch (value.type()) {
-    case base::Value::Type::NONE:
-    case base::Value::Type::BINARY:
-      NOTREACHED();
-      break;
-
-    case base::Value::Type::BOOLEAN: {
-      bool bool_value;
-      value.GetAsBoolean(&bool_value);
-      SetBooleanWithCopiedName(name, bool_value);
-    } break;
-
-    case base::Value::Type::INTEGER: {
-      int int_value;
-      value.GetAsInteger(&int_value);
-      SetIntegerWithCopiedName(name, int_value);
-    } break;
-
-    case base::Value::Type::DOUBLE: {
-      double double_value;
-      value.GetAsDouble(&double_value);
-      SetDoubleWithCopiedName(name, double_value);
-    } break;
-
-    case base::Value::Type::STRING: {
-      const Value* string_value;
-      value.GetAsString(&string_value);
-      SetStringWithCopiedName(name, string_value->GetString());
-    } break;
-
-    case base::Value::Type::DICTIONARY: {
-      const DictionaryValue* dict_value;
-      value.GetAsDictionary(&dict_value);
-      BeginDictionaryWithCopiedName(name);
-      for (DictionaryValue::Iterator it(*dict_value); !it.IsAtEnd();
-           it.Advance()) {
-        SetBaseValueWithCopiedName(it.key(), it.value());
-      }
-      EndDictionary();
-    } break;
-
-    case base::Value::Type::LIST: {
-      const ListValue* list_value;
-      value.GetAsList(&list_value);
-      BeginArrayWithCopiedName(name);
-      for (const auto& base_value : *list_value)
-        AppendBaseValue(base_value);
-      EndArray();
-    } break;
-  }
-}
-
-void TracedValue::AppendBaseValue(const base::Value& value) {
-  DCHECK_CURRENT_CONTAINER_IS(kStackTypeArray);
-  switch (value.type()) {
-    case base::Value::Type::NONE:
-    case base::Value::Type::BINARY:
-      NOTREACHED();
-      break;
-
-    case base::Value::Type::BOOLEAN: {
-      bool bool_value;
-      value.GetAsBoolean(&bool_value);
-      AppendBoolean(bool_value);
-    } break;
-
-    case base::Value::Type::INTEGER: {
-      int int_value;
-      value.GetAsInteger(&int_value);
-      AppendInteger(int_value);
-    } break;
-
-    case base::Value::Type::DOUBLE: {
-      double double_value;
-      value.GetAsDouble(&double_value);
-      AppendDouble(double_value);
-    } break;
-
-    case base::Value::Type::STRING: {
-      const Value* string_value;
-      value.GetAsString(&string_value);
-      AppendString(string_value->GetString());
-    } break;
-
-    case base::Value::Type::DICTIONARY: {
-      const DictionaryValue* dict_value;
-      value.GetAsDictionary(&dict_value);
-      BeginDictionary();
-      for (DictionaryValue::Iterator it(*dict_value); !it.IsAtEnd();
-           it.Advance()) {
-        SetBaseValueWithCopiedName(it.key(), it.value());
-      }
-      EndDictionary();
-    } break;
-
-    case base::Value::Type::LIST: {
-      const ListValue* list_value;
-      value.GetAsList(&list_value);
-      BeginArray();
-      for (const auto& base_value : *list_value)
-        AppendBaseValue(base_value);
-      EndArray();
-    } break;
-  }
-}
-
-std::unique_ptr<base::Value> TracedValue::ToBaseValue() const {
-  base::Value root(base::Value::Type::DICTIONARY);
-  Value* cur_dict = &root;
-  Value* cur_list = nullptr;
-  std::vector<Value*> stack;
-  PickleIterator it(pickle_);
-  const char* type;
-
-  while (it.ReadBytes(&type, 1)) {
-    DCHECK((cur_dict && !cur_list) || (cur_list && !cur_dict));
-    switch (*type) {
-      case kTypeStartDict: {
-        base::Value new_dict(base::Value::Type::DICTIONARY);
-        if (cur_dict) {
-          stack.push_back(cur_dict);
-          cur_dict = cur_dict->SetKey(ReadKeyName(it), std::move(new_dict));
-        } else {
-          cur_list->GetList().push_back(std::move(new_dict));
-          // |new_dict| is invalidated at this point, so |cur_dict| needs to be
-          // reset.
-          cur_dict = &cur_list->GetList().back();
-          stack.push_back(cur_list);
-          cur_list = nullptr;
-        }
-      } break;
-
-      case kTypeEndArray:
-      case kTypeEndDict: {
-        if (stack.back()->is_dict()) {
-          cur_dict = stack.back();
-          cur_list = nullptr;
-        } else if (stack.back()->is_list()) {
-          cur_list = stack.back();
-          cur_dict = nullptr;
-        }
-        stack.pop_back();
-      } break;
-
-      case kTypeStartArray: {
-        base::Value new_list(base::Value::Type::LIST);
-        if (cur_dict) {
-          stack.push_back(cur_dict);
-          cur_list = cur_dict->SetKey(ReadKeyName(it), std::move(new_list));
-          cur_dict = nullptr;
-        } else {
-          cur_list->GetList().push_back(std::move(new_list));
-          stack.push_back(cur_list);
-          // |cur_list| is invalidated at this point by the Append, so it needs
-          // to be reset.
-          cur_list = &cur_list->GetList().back();
-        }
-      } break;
-
-      case kTypeBool: {
-        bool value;
-        CHECK(it.ReadBool(&value));
-        base::Value new_bool(value);
-        if (cur_dict) {
-          cur_dict->SetKey(ReadKeyName(it), std::move(new_bool));
-        } else {
-          cur_list->GetList().push_back(std::move(new_bool));
-        }
-      } break;
-
-      case kTypeInt: {
-        int value;
-        CHECK(it.ReadInt(&value));
-        base::Value new_int(value);
-        if (cur_dict) {
-          cur_dict->SetKey(ReadKeyName(it), std::move(new_int));
-        } else {
-          cur_list->GetList().push_back(std::move(new_int));
-        }
-      } break;
-
-      case kTypeDouble: {
-        double value;
-        CHECK(it.ReadDouble(&value));
-        base::Value new_double(value);
-        if (cur_dict) {
-          cur_dict->SetKey(ReadKeyName(it), std::move(new_double));
-        } else {
-          cur_list->GetList().push_back(std::move(new_double));
-        }
-      } break;
-
-      case kTypeString: {
-        std::string value;
-        CHECK(it.ReadString(&value));
-        base::Value new_str(std::move(value));
-        if (cur_dict) {
-          cur_dict->SetKey(ReadKeyName(it), std::move(new_str));
-        } else {
-          cur_list->GetList().push_back(std::move(new_str));
-        }
-      } break;
-
-      default:
-        NOTREACHED();
-    }
-  }
-  DCHECK(stack.empty());
-  return base::Value::ToUniquePtrValue(std::move(root));
-}
-
-void TracedValue::AppendAsTraceFormat(std::string* out) const {
-  DCHECK_CURRENT_CONTAINER_IS(kStackTypeDict);
-  DCHECK_CONTAINER_STACK_DEPTH_EQ(1u);
-
-  struct State {
-    enum Type { kTypeDict, kTypeArray };
-    Type type;
-    bool needs_comma;
-  };
-
-  auto maybe_append_key_name = [](State current_state, PickleIterator* it,
-                                  std::string* out) {
-    if (current_state.type == State::kTypeDict) {
-      EscapeJSONString(ReadKeyName(*it), true, out);
-      out->append(":");
-    }
-  };
-
-  base::circular_deque<State> state_stack;
-
-  out->append("{");
-  state_stack.push_back({State::kTypeDict});
-
-  PickleIterator it(pickle_);
-  for (const char* type; it.ReadBytes(&type, 1);) {
-    switch (*type) {
-      case kTypeEndDict:
-        out->append("}");
-        state_stack.pop_back();
-        continue;
-
-      case kTypeEndArray:
-        out->append("]");
-        state_stack.pop_back();
-        continue;
-    }
-
-    // Use an index so it will stay valid across resizes.
-    size_t current_state_index = state_stack.size() - 1;
-    if (state_stack[current_state_index].needs_comma)
-      out->append(",");
-
-    switch (*type) {
-      case kTypeStartDict: {
-        maybe_append_key_name(state_stack[current_state_index], &it, out);
-        out->append("{");
-        state_stack.push_back({State::kTypeDict});
-        break;
-      }
-
-      case kTypeStartArray: {
-        maybe_append_key_name(state_stack[current_state_index], &it, out);
-        out->append("[");
-        state_stack.push_back({State::kTypeArray});
-        break;
-      }
-
-      case kTypeBool: {
-        TraceEvent::TraceValue json_value;
-        CHECK(it.ReadBool(&json_value.as_bool));
-        maybe_append_key_name(state_stack[current_state_index], &it, out);
-        TraceEvent::AppendValueAsJSON(TRACE_VALUE_TYPE_BOOL, json_value, out);
-        break;
-      }
-
-      case kTypeInt: {
-        int value;
-        CHECK(it.ReadInt(&value));
-        maybe_append_key_name(state_stack[current_state_index], &it, out);
-        TraceEvent::TraceValue json_value;
-        json_value.as_int = value;
-        TraceEvent::AppendValueAsJSON(TRACE_VALUE_TYPE_INT, json_value, out);
-        break;
-      }
-
-      case kTypeDouble: {
-        TraceEvent::TraceValue json_value;
-        CHECK(it.ReadDouble(&json_value.as_double));
-        maybe_append_key_name(state_stack[current_state_index], &it, out);
-        TraceEvent::AppendValueAsJSON(TRACE_VALUE_TYPE_DOUBLE, json_value, out);
-        break;
-      }
-
-      case kTypeString: {
-        std::string value;
-        CHECK(it.ReadString(&value));
-        maybe_append_key_name(state_stack[current_state_index], &it, out);
-        TraceEvent::TraceValue json_value;
-        json_value.as_string = value.c_str();
-        TraceEvent::AppendValueAsJSON(TRACE_VALUE_TYPE_STRING, json_value, out);
-        break;
-      }
-
-      default:
-        NOTREACHED();
-    }
-
-    state_stack[current_state_index].needs_comma = true;
-  }
-
-  out->append("}");
-  state_stack.pop_back();
-
-  DCHECK(state_stack.empty());
-}
-
-void TracedValue::EstimateTraceMemoryOverhead(
-    TraceEventMemoryOverhead* overhead) {
-  overhead->Add(TraceEventMemoryOverhead::kTracedValue,
-                /* allocated size */
-                pickle_.GetTotalAllocatedSize(),
-                /* resident size */
-                pickle_.size());
-}
-
-}  // namespace trace_event
-}  // namespace base
diff --git a/base/trace_event/trace_event_argument.h b/base/trace_event/trace_event_argument.h
deleted file mode 100644
index 81d8c01..0000000
--- a/base/trace_event/trace_event_argument.h
+++ /dev/null
@@ -1,92 +0,0 @@
-// Copyright 2014 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_TRACE_EVENT_TRACE_EVENT_ARGUMENT_H_
-#define BASE_TRACE_EVENT_TRACE_EVENT_ARGUMENT_H_
-
-#include <stddef.h>
-
-#include <memory>
-#include <string>
-#include <vector>
-
-#include "base/macros.h"
-#include "base/pickle.h"
-#include "base/strings/string_piece.h"
-#include "base/trace_event/trace_event_impl.h"
-
-namespace base {
-
-class Value;
-
-namespace trace_event {
-
-class BASE_EXPORT TracedValue : public ConvertableToTraceFormat {
- public:
-  TracedValue();
-  explicit TracedValue(size_t capacity);
-  ~TracedValue() override;
-
-  void EndDictionary();
-  void EndArray();
-
-  // These methods assume that |name| is a long lived "quoted" string.
-  void SetInteger(const char* name, int value);
-  void SetDouble(const char* name, double value);
-  void SetBoolean(const char* name, bool value);
-  void SetString(const char* name, base::StringPiece value);
-  void SetValue(const char* name, const TracedValue& value);
-  void BeginDictionary(const char* name);
-  void BeginArray(const char* name);
-
-  // These, instead, can be safely passed a temporary string.
-  void SetIntegerWithCopiedName(base::StringPiece name, int value);
-  void SetDoubleWithCopiedName(base::StringPiece name, double value);
-  void SetBooleanWithCopiedName(base::StringPiece name, bool value);
-  void SetStringWithCopiedName(base::StringPiece name,
-                               base::StringPiece value);
-  void SetValueWithCopiedName(base::StringPiece name,
-                              const TracedValue& value);
-  void BeginDictionaryWithCopiedName(base::StringPiece name);
-  void BeginArrayWithCopiedName(base::StringPiece name);
-
-  void AppendInteger(int);
-  void AppendDouble(double);
-  void AppendBoolean(bool);
-  void AppendString(base::StringPiece);
-  void BeginArray();
-  void BeginDictionary();
-
-  // ConvertableToTraceFormat implementation.
-  void AppendAsTraceFormat(std::string* out) const override;
-
-  void EstimateTraceMemoryOverhead(TraceEventMemoryOverhead* overhead) override;
-
-  // DEPRECATED: do not use, here only for legacy reasons. These methods causes
-  // a copy-and-translation of the base::Value into the equivalent TracedValue.
-  // TODO(primiano): migrate the (three) existing clients to the cheaper
-  // SetValue(TracedValue) API. crbug.com/495628.
-  void SetValue(const char* name, std::unique_ptr<base::Value> value);
-  void SetBaseValueWithCopiedName(base::StringPiece name,
-                                  const base::Value& value);
-  void AppendBaseValue(const base::Value& value);
-
-  // Public for tests only.
-  std::unique_ptr<base::Value> ToBaseValue() const;
-
- private:
-  Pickle pickle_;
-
-#ifndef NDEBUG
-  // In debug builds checks the pairings of {Start,End}{Dictionary,Array}
-  std::vector<bool> nesting_stack_;
-#endif
-
-  DISALLOW_COPY_AND_ASSIGN(TracedValue);
-};
-
-}  // namespace trace_event
-}  // namespace base
-
-#endif  // BASE_TRACE_EVENT_TRACE_EVENT_ARGUMENT_H_
diff --git a/base/trace_event/trace_event_filter.cc b/base/trace_event/trace_event_filter.cc
deleted file mode 100644
index d0b116e..0000000
--- a/base/trace_event/trace_event_filter.cc
+++ /dev/null
@@ -1,17 +0,0 @@
-// Copyright 2016 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/trace_event/trace_event_filter.h"
-
-namespace base {
-namespace trace_event {
-
-TraceEventFilter::TraceEventFilter() = default;
-TraceEventFilter::~TraceEventFilter() = default;
-
-void TraceEventFilter::EndEvent(const char* category_name,
-                                const char* event_name) const {}
-
-}  // namespace trace_event
-}  // namespace base
diff --git a/base/trace_event/trace_event_filter.h b/base/trace_event/trace_event_filter.h
deleted file mode 100644
index 48c6711..0000000
--- a/base/trace_event/trace_event_filter.h
+++ /dev/null
@@ -1,51 +0,0 @@
-// Copyright 2016 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_TRACE_EVENT_TRACE_EVENT_FILTER_H_
-#define BASE_TRACE_EVENT_TRACE_EVENT_FILTER_H_
-
-#include <memory>
-
-#include "base/base_export.h"
-#include "base/macros.h"
-
-namespace base {
-namespace trace_event {
-
-class TraceEvent;
-
-// TraceEventFilter is like iptables for TRACE_EVENT macros. Filters can be
-// enabled on a per-category basis, hence a single filter instance can serve
-// more than a TraceCategory. There are two use cases for filters:
-// 1. Snooping TRACE_EVENT macros without adding them to the TraceLog. This is
-//    possible by setting the ENABLED_FOR_FILTERING flag on a category w/o
-//    ENABLED_FOR_RECORDING (see TraceConfig for user-facing configuration).
-// 2. Filtering TRACE_EVENT macros before they are added to the TraceLog. This
-//    requires both the ENABLED_FOR_FILTERING and ENABLED_FOR_RECORDING flags
-//    on the category.
-// More importantly, filters must be thread-safe. The FilterTraceEvent and
-// EndEvent methods can be called concurrently as trace macros are hit on
-// different threads.
-class BASE_EXPORT TraceEventFilter {
- public:
-  TraceEventFilter();
-  virtual ~TraceEventFilter();
-
-  // If the category is ENABLED_FOR_RECORDING, the event is added iff all the
-  // filters enabled for the category return true. false causes the event to be
-  // discarded.
-  virtual bool FilterTraceEvent(const TraceEvent& trace_event) const = 0;
-
-  // Notifies the end of a duration event when the RAII macro goes out of scope.
-  virtual void EndEvent(const char* category_name,
-                        const char* event_name) const;
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(TraceEventFilter);
-};
-
-}  // namespace trace_event
-}  // namespace base
-
-#endif  // BASE_TRACE_EVENT_TRACE_EVENT_FILTER_H_
diff --git a/base/trace_event/trace_event_filter_test_utils.cc b/base/trace_event/trace_event_filter_test_utils.cc
deleted file mode 100644
index 85b4cfa..0000000
--- a/base/trace_event/trace_event_filter_test_utils.cc
+++ /dev/null
@@ -1,61 +0,0 @@
-// Copyright 2016 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/trace_event/trace_event_filter_test_utils.h"
-
-#include "base/logging.h"
-
-namespace base {
-namespace trace_event {
-
-namespace {
-TestEventFilter::HitsCounter* g_hits_counter;
-}  // namespace;
-
-// static
-const char TestEventFilter::kName[] = "testing_predicate";
-bool TestEventFilter::filter_return_value_;
-
-// static
-std::unique_ptr<TraceEventFilter> TestEventFilter::Factory(
-    const std::string& predicate_name) {
-  std::unique_ptr<TraceEventFilter> res;
-  if (predicate_name == kName)
-    res.reset(new TestEventFilter());
-  return res;
-}
-
-TestEventFilter::TestEventFilter() = default;
-TestEventFilter::~TestEventFilter() = default;
-
-bool TestEventFilter::FilterTraceEvent(const TraceEvent& trace_event) const {
-  if (g_hits_counter)
-    g_hits_counter->filter_trace_event_hit_count++;
-  return filter_return_value_;
-}
-
-void TestEventFilter::EndEvent(const char* category_name,
-                               const char* name) const {
-  if (g_hits_counter)
-    g_hits_counter->end_event_hit_count++;
-}
-
-TestEventFilter::HitsCounter::HitsCounter() {
-  Reset();
-  DCHECK(!g_hits_counter);
-  g_hits_counter = this;
-}
-
-TestEventFilter::HitsCounter::~HitsCounter() {
-  DCHECK(g_hits_counter);
-  g_hits_counter = nullptr;
-}
-
-void TestEventFilter::HitsCounter::Reset() {
-  filter_trace_event_hit_count = 0;
-  end_event_hit_count = 0;
-}
-
-}  // namespace trace_event
-}  // namespace base
diff --git a/base/trace_event/trace_event_filter_test_utils.h b/base/trace_event/trace_event_filter_test_utils.h
deleted file mode 100644
index 419068b..0000000
--- a/base/trace_event/trace_event_filter_test_utils.h
+++ /dev/null
@@ -1,53 +0,0 @@
-// Copyright 2016 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_TRACE_EVENT_TRACE_EVENT_FILTER_TEST_UTILS_H_
-#define BASE_TRACE_EVENT_TRACE_EVENT_FILTER_TEST_UTILS_H_
-
-#include <memory>
-#include <string>
-
-#include "base/macros.h"
-#include "base/trace_event/trace_event_filter.h"
-
-namespace base {
-namespace trace_event {
-
-class TestEventFilter : public TraceEventFilter {
- public:
-  struct HitsCounter {
-    HitsCounter();
-    ~HitsCounter();
-    void Reset();
-    size_t filter_trace_event_hit_count;
-    size_t end_event_hit_count;
-  };
-
-  static const char kName[];
-
-  // Factory method for TraceLog::SetFilterFactoryForTesting().
-  static std::unique_ptr<TraceEventFilter> Factory(
-      const std::string& predicate_name);
-
-  TestEventFilter();
-  ~TestEventFilter() override;
-
-  // TraceEventFilter implementation.
-  bool FilterTraceEvent(const TraceEvent& trace_event) const override;
-  void EndEvent(const char* category_name, const char* name) const override;
-
-  static void set_filter_return_value(bool value) {
-    filter_return_value_ = value;
-  }
-
- private:
-  static bool filter_return_value_;
-
-  DISALLOW_COPY_AND_ASSIGN(TestEventFilter);
-};
-
-}  // namespace trace_event
-}  // namespace base
-
-#endif  // BASE_TRACE_EVENT_TRACE_EVENT_FILTER_TEST_UTILS_H_
diff --git a/base/trace_event/trace_event_impl.cc b/base/trace_event/trace_event_impl.cc
deleted file mode 100644
index c72e1fc..0000000
--- a/base/trace_event/trace_event_impl.cc
+++ /dev/null
@@ -1,489 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/trace_event/trace_event_impl.h"
-
-#include <stddef.h>
-
-#include "base/format_macros.h"
-#include "base/json/string_escape.h"
-#include "base/memory/ptr_util.h"
-#include "base/process/process_handle.h"
-#include "base/stl_util.h"
-#include "base/strings/string_number_conversions.h"
-#include "base/strings/string_util.h"
-#include "base/strings/stringprintf.h"
-#include "base/strings/utf_string_conversions.h"
-#include "base/trace_event/trace_event.h"
-#include "base/trace_event/trace_event_argument.h"
-#include "base/trace_event/trace_log.h"
-
-namespace base {
-namespace trace_event {
-
-namespace {
-
-size_t GetAllocLength(const char* str) { return str ? strlen(str) + 1 : 0; }
-
-// Copies |*member| into |*buffer|, sets |*member| to point to this new
-// location, and then advances |*buffer| by the amount written.
-void CopyTraceEventParameter(char** buffer,
-                             const char** member,
-                             const char* end) {
-  if (*member) {
-    size_t written = strlcpy(*buffer, *member, end - *buffer) + 1;
-    DCHECK_LE(static_cast<int>(written), end - *buffer);
-    *member = *buffer;
-    *buffer += written;
-  }
-}
-
-}  // namespace
-
-TraceEvent::TraceEvent()
-    : duration_(TimeDelta::FromInternalValue(-1)),
-      scope_(trace_event_internal::kGlobalScope),
-      id_(0u),
-      category_group_enabled_(nullptr),
-      name_(nullptr),
-      thread_id_(0),
-      flags_(0),
-      phase_(TRACE_EVENT_PHASE_BEGIN) {
-  for (int i = 0; i < kTraceMaxNumArgs; ++i)
-    arg_names_[i] = nullptr;
-  memset(arg_values_, 0, sizeof(arg_values_));
-}
-
-TraceEvent::~TraceEvent() = default;
-
-void TraceEvent::MoveFrom(std::unique_ptr<TraceEvent> other) {
-  timestamp_ = other->timestamp_;
-  thread_timestamp_ = other->thread_timestamp_;
-  duration_ = other->duration_;
-  scope_ = other->scope_;
-  id_ = other->id_;
-  category_group_enabled_ = other->category_group_enabled_;
-  name_ = other->name_;
-  if (other->flags_ & TRACE_EVENT_FLAG_HAS_PROCESS_ID)
-    process_id_ = other->process_id_;
-  else
-    thread_id_ = other->thread_id_;
-  phase_ = other->phase_;
-  flags_ = other->flags_;
-  parameter_copy_storage_ = std::move(other->parameter_copy_storage_);
-
-  for (int i = 0; i < kTraceMaxNumArgs; ++i) {
-    arg_names_[i] = other->arg_names_[i];
-    arg_types_[i] = other->arg_types_[i];
-    arg_values_[i] = other->arg_values_[i];
-    convertable_values_[i] = std::move(other->convertable_values_[i]);
-  }
-}
-
-void TraceEvent::Initialize(
-    int thread_id,
-    TimeTicks timestamp,
-    ThreadTicks thread_timestamp,
-    char phase,
-    const unsigned char* category_group_enabled,
-    const char* name,
-    const char* scope,
-    unsigned long long id,
-    unsigned long long bind_id,
-    int num_args,
-    const char* const* arg_names,
-    const unsigned char* arg_types,
-    const unsigned long long* arg_values,
-    std::unique_ptr<ConvertableToTraceFormat>* convertable_values,
-    unsigned int flags) {
-  timestamp_ = timestamp;
-  thread_timestamp_ = thread_timestamp;
-  duration_ = TimeDelta::FromInternalValue(-1);
-  scope_ = scope;
-  id_ = id;
-  category_group_enabled_ = category_group_enabled;
-  name_ = name;
-  thread_id_ = thread_id;
-  phase_ = phase;
-  flags_ = flags;
-  bind_id_ = bind_id;
-
-  // Clamp num_args since it may have been set by a third_party library.
-  num_args = (num_args > kTraceMaxNumArgs) ? kTraceMaxNumArgs : num_args;
-  int i = 0;
-  for (; i < num_args; ++i) {
-    arg_names_[i] = arg_names[i];
-    arg_types_[i] = arg_types[i];
-
-    if (arg_types[i] == TRACE_VALUE_TYPE_CONVERTABLE) {
-      convertable_values_[i] = std::move(convertable_values[i]);
-    } else {
-      arg_values_[i].as_uint = arg_values[i];
-      convertable_values_[i].reset();
-    }
-  }
-  for (; i < kTraceMaxNumArgs; ++i) {
-    arg_names_[i] = nullptr;
-    arg_values_[i].as_uint = 0u;
-    convertable_values_[i].reset();
-    arg_types_[i] = TRACE_VALUE_TYPE_UINT;
-  }
-
-  bool copy = !!(flags & TRACE_EVENT_FLAG_COPY);
-  size_t alloc_size = 0;
-  if (copy) {
-    alloc_size += GetAllocLength(name) + GetAllocLength(scope);
-    for (i = 0; i < num_args; ++i) {
-      alloc_size += GetAllocLength(arg_names_[i]);
-      if (arg_types_[i] == TRACE_VALUE_TYPE_STRING)
-        arg_types_[i] = TRACE_VALUE_TYPE_COPY_STRING;
-    }
-  }
-
-  bool arg_is_copy[kTraceMaxNumArgs];
-  for (i = 0; i < num_args; ++i) {
-    // No copying of convertable types, we retain ownership.
-    if (arg_types_[i] == TRACE_VALUE_TYPE_CONVERTABLE)
-      continue;
-
-    // We only take a copy of arg_vals if they are of type COPY_STRING.
-    arg_is_copy[i] = (arg_types_[i] == TRACE_VALUE_TYPE_COPY_STRING);
-    if (arg_is_copy[i])
-      alloc_size += GetAllocLength(arg_values_[i].as_string);
-  }
-
-  if (alloc_size) {
-    parameter_copy_storage_.reset(new std::string);
-    parameter_copy_storage_->resize(alloc_size);
-    char* ptr = base::data(*parameter_copy_storage_);
-    const char* end = ptr + alloc_size;
-    if (copy) {
-      CopyTraceEventParameter(&ptr, &name_, end);
-      CopyTraceEventParameter(&ptr, &scope_, end);
-      for (i = 0; i < num_args; ++i) {
-        CopyTraceEventParameter(&ptr, &arg_names_[i], end);
-      }
-    }
-    for (i = 0; i < num_args; ++i) {
-      if (arg_types_[i] == TRACE_VALUE_TYPE_CONVERTABLE)
-        continue;
-      if (arg_is_copy[i])
-        CopyTraceEventParameter(&ptr, &arg_values_[i].as_string, end);
-    }
-    DCHECK_EQ(end, ptr) << "Overrun by " << ptr - end;
-  }
-}
-
-void TraceEvent::Reset() {
-  // Only reset fields that won't be initialized in Initialize(), or that may
-  // hold references to other objects.
-  duration_ = TimeDelta::FromInternalValue(-1);
-  parameter_copy_storage_.reset();
-  for (int i = 0; i < kTraceMaxNumArgs; ++i)
-    convertable_values_[i].reset();
-}
-
-void TraceEvent::UpdateDuration(const TimeTicks& now,
-                                const ThreadTicks& thread_now) {
-  DCHECK_EQ(duration_.ToInternalValue(), -1);
-  duration_ = now - timestamp_;
-
-  // |thread_timestamp_| can be empty if the thread ticks clock wasn't
-  // initialized when it was recorded.
-  if (thread_timestamp_ != ThreadTicks())
-    thread_duration_ = thread_now - thread_timestamp_;
-}
-
-void TraceEvent::EstimateTraceMemoryOverhead(
-    TraceEventMemoryOverhead* overhead) {
-  overhead->Add(TraceEventMemoryOverhead::kTraceEvent, sizeof(*this));
-
-  if (parameter_copy_storage_)
-    overhead->AddString(*parameter_copy_storage_);
-
-  for (size_t i = 0; i < kTraceMaxNumArgs; ++i) {
-    if (arg_types_[i] == TRACE_VALUE_TYPE_CONVERTABLE)
-      convertable_values_[i]->EstimateTraceMemoryOverhead(overhead);
-  }
-}
-
-// static
-void TraceEvent::AppendValueAsJSON(unsigned char type,
-                                   TraceEvent::TraceValue value,
-                                   std::string* out) {
-  switch (type) {
-    case TRACE_VALUE_TYPE_BOOL:
-      *out += value.as_bool ? "true" : "false";
-      break;
-    case TRACE_VALUE_TYPE_UINT:
-      StringAppendF(out, "%" PRIu64, static_cast<uint64_t>(value.as_uint));
-      break;
-    case TRACE_VALUE_TYPE_INT:
-      StringAppendF(out, "%" PRId64, static_cast<int64_t>(value.as_int));
-      break;
-    case TRACE_VALUE_TYPE_DOUBLE: {
-      // FIXME: base/json/json_writer.cc is using the same code,
-      //        should be made into a common method.
-      std::string real;
-      double val = value.as_double;
-      if (std::isfinite(val)) {
-        real = NumberToString(val);
-        // Ensure that the number has a .0 if there's no decimal or 'e'.  This
-        // makes sure that when we read the JSON back, it's interpreted as a
-        // real rather than an int.
-        if (real.find('.') == std::string::npos &&
-            real.find('e') == std::string::npos &&
-            real.find('E') == std::string::npos) {
-          real.append(".0");
-        }
-        // The JSON spec requires that non-integer values in the range (-1,1)
-        // have a zero before the decimal point - ".52" is not valid, "0.52" is.
-        if (real[0] == '.') {
-          real.insert(0, "0");
-        } else if (real.length() > 1 && real[0] == '-' && real[1] == '.') {
-          // "-.1" bad "-0.1" good
-          real.insert(1, "0");
-        }
-      } else if (std::isnan(val)){
-        // The JSON spec doesn't allow NaN and Infinity (since these are
-        // objects in EcmaScript).  Use strings instead.
-        real = "\"NaN\"";
-      } else if (val < 0) {
-        real = "\"-Infinity\"";
-      } else {
-        real = "\"Infinity\"";
-      }
-      StringAppendF(out, "%s", real.c_str());
-      break;
-    }
-    case TRACE_VALUE_TYPE_POINTER:
-      // JSON only supports double and int numbers.
-      // So as not to lose bits from a 64-bit pointer, output as a hex string.
-      StringAppendF(
-          out, "\"0x%" PRIx64 "\"",
-          static_cast<uint64_t>(reinterpret_cast<uintptr_t>(value.as_pointer)));
-      break;
-    case TRACE_VALUE_TYPE_STRING:
-    case TRACE_VALUE_TYPE_COPY_STRING:
-      EscapeJSONString(value.as_string ? value.as_string : "NULL", true, out);
-      break;
-    default:
-      NOTREACHED() << "Don't know how to print this value";
-      break;
-  }
-}
-
-void TraceEvent::AppendAsJSON(
-    std::string* out,
-    const ArgumentFilterPredicate& argument_filter_predicate) const {
-  int64_t time_int64 = timestamp_.ToInternalValue();
-  int process_id;
-  int thread_id;
-  if ((flags_ & TRACE_EVENT_FLAG_HAS_PROCESS_ID) &&
-      process_id_ != kNullProcessId) {
-    process_id = process_id_;
-    thread_id = -1;
-  } else {
-    process_id = TraceLog::GetInstance()->process_id();
-    thread_id = thread_id_;
-  }
-  const char* category_group_name =
-      TraceLog::GetCategoryGroupName(category_group_enabled_);
-
-  // Category group checked at category creation time.
-  DCHECK(!strchr(name_, '"'));
-  StringAppendF(out, "{\"pid\":%i,\"tid\":%i,\"ts\":%" PRId64
-                     ",\"ph\":\"%c\",\"cat\":\"%s\",\"name\":",
-                process_id, thread_id, time_int64, phase_, category_group_name);
-  EscapeJSONString(name_, true, out);
-  *out += ",\"args\":";
-
-  // Output argument names and values, stop at first NULL argument name.
-  // TODO(oysteine): The dual predicates here is a bit ugly; if the filtering
-  // capabilities need to grow even more precise we should rethink this
-  // approach
-  ArgumentNameFilterPredicate argument_name_filter_predicate;
-  bool strip_args =
-      arg_names_[0] && !argument_filter_predicate.is_null() &&
-      !argument_filter_predicate.Run(category_group_name, name_,
-                                     &argument_name_filter_predicate);
-
-  if (strip_args) {
-    *out += "\"__stripped__\"";
-  } else {
-    *out += "{";
-
-    for (int i = 0; i < kTraceMaxNumArgs && arg_names_[i]; ++i) {
-      if (i > 0)
-        *out += ",";
-      *out += "\"";
-      *out += arg_names_[i];
-      *out += "\":";
-
-      if (argument_name_filter_predicate.is_null() ||
-          argument_name_filter_predicate.Run(arg_names_[i])) {
-        if (arg_types_[i] == TRACE_VALUE_TYPE_CONVERTABLE)
-          convertable_values_[i]->AppendAsTraceFormat(out);
-        else
-          AppendValueAsJSON(arg_types_[i], arg_values_[i], out);
-      } else {
-        *out += "\"__stripped__\"";
-      }
-    }
-
-    *out += "}";
-  }
-
-  if (phase_ == TRACE_EVENT_PHASE_COMPLETE) {
-    int64_t duration = duration_.ToInternalValue();
-    if (duration != -1)
-      StringAppendF(out, ",\"dur\":%" PRId64, duration);
-    if (!thread_timestamp_.is_null()) {
-      int64_t thread_duration = thread_duration_.ToInternalValue();
-      if (thread_duration != -1)
-        StringAppendF(out, ",\"tdur\":%" PRId64, thread_duration);
-    }
-  }
-
-  // Output tts if thread_timestamp is valid.
-  if (!thread_timestamp_.is_null()) {
-    int64_t thread_time_int64 = thread_timestamp_.ToInternalValue();
-    StringAppendF(out, ",\"tts\":%" PRId64, thread_time_int64);
-  }
-
-  // Output async tts marker field if flag is set.
-  if (flags_ & TRACE_EVENT_FLAG_ASYNC_TTS) {
-    StringAppendF(out, ", \"use_async_tts\":1");
-  }
-
-  // If id_ is set, print it out as a hex string so we don't loose any
-  // bits (it might be a 64-bit pointer).
-  unsigned int id_flags_ = flags_ & (TRACE_EVENT_FLAG_HAS_ID |
-                                     TRACE_EVENT_FLAG_HAS_LOCAL_ID |
-                                     TRACE_EVENT_FLAG_HAS_GLOBAL_ID);
-  if (id_flags_) {
-    if (scope_ != trace_event_internal::kGlobalScope)
-      StringAppendF(out, ",\"scope\":\"%s\"", scope_);
-
-    switch (id_flags_) {
-      case TRACE_EVENT_FLAG_HAS_ID:
-        StringAppendF(out, ",\"id\":\"0x%" PRIx64 "\"",
-                      static_cast<uint64_t>(id_));
-        break;
-
-      case TRACE_EVENT_FLAG_HAS_LOCAL_ID:
-        StringAppendF(out, ",\"id2\":{\"local\":\"0x%" PRIx64 "\"}",
-                      static_cast<uint64_t>(id_));
-        break;
-
-      case TRACE_EVENT_FLAG_HAS_GLOBAL_ID:
-        StringAppendF(out, ",\"id2\":{\"global\":\"0x%" PRIx64 "\"}",
-                      static_cast<uint64_t>(id_));
-        break;
-
-      default:
-        NOTREACHED() << "More than one of the ID flags are set";
-        break;
-    }
-  }
-
-  if (flags_ & TRACE_EVENT_FLAG_BIND_TO_ENCLOSING)
-    StringAppendF(out, ",\"bp\":\"e\"");
-
-  if ((flags_ & TRACE_EVENT_FLAG_FLOW_OUT) ||
-      (flags_ & TRACE_EVENT_FLAG_FLOW_IN)) {
-    StringAppendF(out, ",\"bind_id\":\"0x%" PRIx64 "\"",
-                  static_cast<uint64_t>(bind_id_));
-  }
-  if (flags_ & TRACE_EVENT_FLAG_FLOW_IN)
-    StringAppendF(out, ",\"flow_in\":true");
-  if (flags_ & TRACE_EVENT_FLAG_FLOW_OUT)
-    StringAppendF(out, ",\"flow_out\":true");
-
-  // Instant events also output their scope.
-  if (phase_ == TRACE_EVENT_PHASE_INSTANT) {
-    char scope = '?';
-    switch (flags_ & TRACE_EVENT_FLAG_SCOPE_MASK) {
-      case TRACE_EVENT_SCOPE_GLOBAL:
-        scope = TRACE_EVENT_SCOPE_NAME_GLOBAL;
-        break;
-
-      case TRACE_EVENT_SCOPE_PROCESS:
-        scope = TRACE_EVENT_SCOPE_NAME_PROCESS;
-        break;
-
-      case TRACE_EVENT_SCOPE_THREAD:
-        scope = TRACE_EVENT_SCOPE_NAME_THREAD;
-        break;
-    }
-    StringAppendF(out, ",\"s\":\"%c\"", scope);
-  }
-
-  *out += "}";
-}
-
-void TraceEvent::AppendPrettyPrinted(std::ostringstream* out) const {
-  *out << name_ << "[";
-  *out << TraceLog::GetCategoryGroupName(category_group_enabled_);
-  *out << "]";
-  if (arg_names_[0]) {
-    *out << ", {";
-    for (int i = 0; i < kTraceMaxNumArgs && arg_names_[i]; ++i) {
-      if (i > 0)
-        *out << ", ";
-      *out << arg_names_[i] << ":";
-      std::string value_as_text;
-
-      if (arg_types_[i] == TRACE_VALUE_TYPE_CONVERTABLE)
-        convertable_values_[i]->AppendAsTraceFormat(&value_as_text);
-      else
-        AppendValueAsJSON(arg_types_[i], arg_values_[i], &value_as_text);
-
-      *out << value_as_text;
-    }
-    *out << "}";
-  }
-}
-
-}  // namespace trace_event
-}  // namespace base
-
-namespace trace_event_internal {
-
-std::unique_ptr<base::trace_event::ConvertableToTraceFormat>
-TraceID::AsConvertableToTraceFormat() const {
-  auto value = std::make_unique<base::trace_event::TracedValue>();
-
-  if (scope_ != kGlobalScope)
-    value->SetString("scope", scope_);
-
-  const char* id_field_name = "id";
-  if (id_flags_ == TRACE_EVENT_FLAG_HAS_GLOBAL_ID) {
-    id_field_name = "global";
-    value->BeginDictionary("id2");
-  } else if (id_flags_ == TRACE_EVENT_FLAG_HAS_LOCAL_ID) {
-    id_field_name = "local";
-    value->BeginDictionary("id2");
-  } else if (id_flags_ != TRACE_EVENT_FLAG_HAS_ID) {
-    NOTREACHED() << "Unrecognized ID flag";
-  }
-
-  if (has_prefix_) {
-    value->SetString(id_field_name,
-                     base::StringPrintf("0x%" PRIx64 "/0x%" PRIx64,
-                                        static_cast<uint64_t>(prefix_),
-                                        static_cast<uint64_t>(raw_id_)));
-  } else {
-    value->SetString(
-        id_field_name,
-        base::StringPrintf("0x%" PRIx64, static_cast<uint64_t>(raw_id_)));
-  }
-
-  if (id_flags_ != TRACE_EVENT_FLAG_HAS_ID)
-    value->EndDictionary();
-
-  return std::move(value);
-}
-
-}  // namespace trace_event_internal
diff --git a/base/trace_event/trace_event_impl.h b/base/trace_event/trace_event_impl.h
deleted file mode 100644
index af47f49..0000000
--- a/base/trace_event/trace_event_impl.h
+++ /dev/null
@@ -1,187 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-
-#ifndef BASE_TRACE_EVENT_TRACE_EVENT_IMPL_H_
-#define BASE_TRACE_EVENT_TRACE_EVENT_IMPL_H_
-
-#include <stdint.h>
-
-#include <memory>
-#include <string>
-#include <vector>
-
-#include "base/atomicops.h"
-#include "base/base_export.h"
-#include "base/callback.h"
-#include "base/containers/hash_tables.h"
-#include "base/macros.h"
-#include "base/observer_list.h"
-#include "base/single_thread_task_runner.h"
-#include "base/strings/string_util.h"
-#include "base/synchronization/condition_variable.h"
-#include "base/synchronization/lock.h"
-#include "base/threading/thread_local.h"
-#include "base/trace_event/trace_event_memory_overhead.h"
-#include "build_config.h"
-
-namespace base {
-namespace trace_event {
-
-typedef base::Callback<bool(const char* arg_name)> ArgumentNameFilterPredicate;
-
-typedef base::Callback<bool(const char* category_group_name,
-                            const char* event_name,
-                            ArgumentNameFilterPredicate*)>
-    ArgumentFilterPredicate;
-
-// For any argument of type TRACE_VALUE_TYPE_CONVERTABLE the provided
-// class must implement this interface.
-class BASE_EXPORT ConvertableToTraceFormat {
- public:
-  ConvertableToTraceFormat() = default;
-  virtual ~ConvertableToTraceFormat() = default;
-
-  // Append the class info to the provided |out| string. The appended
-  // data must be a valid JSON object. Strings must be properly quoted, and
-  // escaped. There is no processing applied to the content after it is
-  // appended.
-  virtual void AppendAsTraceFormat(std::string* out) const = 0;
-
-  virtual void EstimateTraceMemoryOverhead(TraceEventMemoryOverhead* overhead);
-
-  std::string ToString() const {
-    std::string result;
-    AppendAsTraceFormat(&result);
-    return result;
-  }
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(ConvertableToTraceFormat);
-};
-
-const int kTraceMaxNumArgs = 2;
-
-struct TraceEventHandle {
-  uint32_t chunk_seq;
-  // These numbers of bits must be kept consistent with
-  // TraceBufferChunk::kMaxTrunkIndex and
-  // TraceBufferChunk::kTraceBufferChunkSize (in trace_buffer.h).
-  unsigned chunk_index : 26;
-  unsigned event_index : 6;
-};
-
-class BASE_EXPORT TraceEvent {
- public:
-  union TraceValue {
-    bool as_bool;
-    unsigned long long as_uint;
-    long long as_int;
-    double as_double;
-    const void* as_pointer;
-    const char* as_string;
-  };
-
-  TraceEvent();
-  ~TraceEvent();
-
-  void MoveFrom(std::unique_ptr<TraceEvent> other);
-
-  void Initialize(int thread_id,
-                  TimeTicks timestamp,
-                  ThreadTicks thread_timestamp,
-                  char phase,
-                  const unsigned char* category_group_enabled,
-                  const char* name,
-                  const char* scope,
-                  unsigned long long id,
-                  unsigned long long bind_id,
-                  int num_args,
-                  const char* const* arg_names,
-                  const unsigned char* arg_types,
-                  const unsigned long long* arg_values,
-                  std::unique_ptr<ConvertableToTraceFormat>* convertable_values,
-                  unsigned int flags);
-
-  void Reset();
-
-  void UpdateDuration(const TimeTicks& now, const ThreadTicks& thread_now);
-
-  void EstimateTraceMemoryOverhead(TraceEventMemoryOverhead* overhead);
-
-  // Serialize event data to JSON
-  void AppendAsJSON(
-      std::string* out,
-      const ArgumentFilterPredicate& argument_filter_predicate) const;
-  void AppendPrettyPrinted(std::ostringstream* out) const;
-
-  static void AppendValueAsJSON(unsigned char type,
-                                TraceValue value,
-                                std::string* out);
-
-  TimeTicks timestamp() const { return timestamp_; }
-  ThreadTicks thread_timestamp() const { return thread_timestamp_; }
-  char phase() const { return phase_; }
-  int thread_id() const { return thread_id_; }
-  TimeDelta duration() const { return duration_; }
-  TimeDelta thread_duration() const { return thread_duration_; }
-  const char* scope() const { return scope_; }
-  unsigned long long id() const { return id_; }
-  unsigned int flags() const { return flags_; }
-  unsigned long long bind_id() const { return bind_id_; }
-  // Exposed for unittesting:
-
-  const std::string* parameter_copy_storage() const {
-    return parameter_copy_storage_.get();
-  }
-
-  const unsigned char* category_group_enabled() const {
-    return category_group_enabled_;
-  }
-
-  const char* name() const { return name_; }
-
-  unsigned char arg_type(size_t index) const { return arg_types_[index]; }
-  const char* arg_name(size_t index) const { return arg_names_[index]; }
-  const TraceValue& arg_value(size_t index) const { return arg_values_[index]; }
-
-#if defined(OS_ANDROID)
-  void SendToATrace();
-#endif
-
- private:
-  // Note: these are ordered by size (largest first) for optimal packing.
-  TimeTicks timestamp_;
-  ThreadTicks thread_timestamp_;
-  TimeDelta duration_;
-  TimeDelta thread_duration_;
-  // scope_ and id_ can be used to store phase-specific data.
-  const char* scope_;
-  unsigned long long id_;
-  TraceValue arg_values_[kTraceMaxNumArgs];
-  const char* arg_names_[kTraceMaxNumArgs];
-  std::unique_ptr<ConvertableToTraceFormat>
-      convertable_values_[kTraceMaxNumArgs];
-  const unsigned char* category_group_enabled_;
-  const char* name_;
-  std::unique_ptr<std::string> parameter_copy_storage_;
-  // Depending on TRACE_EVENT_FLAG_HAS_PROCESS_ID the event will have either:
-  //  tid: thread_id_, pid: current_process_id (default case).
-  //  tid: -1, pid: process_id_ (when flags_ & TRACE_EVENT_FLAG_HAS_PROCESS_ID).
-  union {
-    int thread_id_;
-    int process_id_;
-  };
-  unsigned int flags_;
-  unsigned long long bind_id_;
-  unsigned char arg_types_[kTraceMaxNumArgs];
-  char phase_;
-
-  DISALLOW_COPY_AND_ASSIGN(TraceEvent);
-};
-
-}  // namespace trace_event
-}  // namespace base
-
-#endif  // BASE_TRACE_EVENT_TRACE_EVENT_IMPL_H_
diff --git a/base/trace_event/trace_event_memory_overhead.cc b/base/trace_event/trace_event_memory_overhead.cc
deleted file mode 100644
index d5875f8..0000000
--- a/base/trace_event/trace_event_memory_overhead.cc
+++ /dev/null
@@ -1,177 +0,0 @@
-// Copyright 2015 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/trace_event/trace_event_memory_overhead.h"
-
-#include <algorithm>
-
-#include "base/bits.h"
-#include "base/memory/ref_counted_memory.h"
-#include "base/strings/stringprintf.h"
-#include "base/trace_event/memory_allocator_dump.h"
-#include "base/trace_event/memory_usage_estimator.h"
-#include "base/trace_event/process_memory_dump.h"
-#include "base/values.h"
-
-namespace base {
-namespace trace_event {
-
-namespace {
-
-const char* ObjectTypeToString(TraceEventMemoryOverhead::ObjectType type) {
-  switch (type) {
-    case TraceEventMemoryOverhead::kOther:
-      return "(Other)";
-    case TraceEventMemoryOverhead::kTraceBuffer:
-      return "TraceBuffer";
-    case TraceEventMemoryOverhead::kTraceBufferChunk:
-      return "TraceBufferChunk";
-    case TraceEventMemoryOverhead::kTraceEvent:
-      return "TraceEvent";
-    case TraceEventMemoryOverhead::kUnusedTraceEvent:
-      return "TraceEvent(Unused)";
-    case TraceEventMemoryOverhead::kTracedValue:
-      return "TracedValue";
-    case TraceEventMemoryOverhead::kConvertableToTraceFormat:
-      return "ConvertableToTraceFormat";
-    case TraceEventMemoryOverhead::kHeapProfilerAllocationRegister:
-      return "AllocationRegister";
-    case TraceEventMemoryOverhead::kHeapProfilerTypeNameDeduplicator:
-      return "TypeNameDeduplicator";
-    case TraceEventMemoryOverhead::kHeapProfilerStackFrameDeduplicator:
-      return "StackFrameDeduplicator";
-    case TraceEventMemoryOverhead::kStdString:
-      return "std::string";
-    case TraceEventMemoryOverhead::kBaseValue:
-      return "base::Value";
-    case TraceEventMemoryOverhead::kTraceEventMemoryOverhead:
-      return "TraceEventMemoryOverhead";
-    case TraceEventMemoryOverhead::kLast:
-      NOTREACHED();
-  }
-  NOTREACHED();
-  return "BUG";
-}
-
-}  // namespace
-
-TraceEventMemoryOverhead::TraceEventMemoryOverhead() : allocated_objects_() {}
-
-TraceEventMemoryOverhead::~TraceEventMemoryOverhead() = default;
-
-void TraceEventMemoryOverhead::AddInternal(ObjectType object_type,
-                                           size_t count,
-                                           size_t allocated_size_in_bytes,
-                                           size_t resident_size_in_bytes) {
-  ObjectCountAndSize& count_and_size =
-      allocated_objects_[static_cast<uint32_t>(object_type)];
-  count_and_size.count += count;
-  count_and_size.allocated_size_in_bytes += allocated_size_in_bytes;
-  count_and_size.resident_size_in_bytes += resident_size_in_bytes;
-}
-
-void TraceEventMemoryOverhead::Add(ObjectType object_type,
-                                   size_t allocated_size_in_bytes) {
-  Add(object_type, allocated_size_in_bytes, allocated_size_in_bytes);
-}
-
-void TraceEventMemoryOverhead::Add(ObjectType object_type,
-                                   size_t allocated_size_in_bytes,
-                                   size_t resident_size_in_bytes) {
-  AddInternal(object_type, 1, allocated_size_in_bytes, resident_size_in_bytes);
-}
-
-void TraceEventMemoryOverhead::AddString(const std::string& str) {
-  Add(kStdString, EstimateMemoryUsage(str));
-}
-
-void TraceEventMemoryOverhead::AddRefCountedString(
-    const RefCountedString& str) {
-  Add(kOther, sizeof(RefCountedString));
-  AddString(str.data());
-}
-
-void TraceEventMemoryOverhead::AddValue(const Value& value) {
-  switch (value.type()) {
-    case Value::Type::NONE:
-    case Value::Type::BOOLEAN:
-    case Value::Type::INTEGER:
-    case Value::Type::DOUBLE:
-      Add(kBaseValue, sizeof(Value));
-      break;
-
-    case Value::Type::STRING: {
-      const Value* string_value = nullptr;
-      value.GetAsString(&string_value);
-      Add(kBaseValue, sizeof(Value));
-      AddString(string_value->GetString());
-    } break;
-
-    case Value::Type::BINARY: {
-      Add(kBaseValue, sizeof(Value) + value.GetBlob().size());
-    } break;
-
-    case Value::Type::DICTIONARY: {
-      const DictionaryValue* dictionary_value = nullptr;
-      value.GetAsDictionary(&dictionary_value);
-      Add(kBaseValue, sizeof(DictionaryValue));
-      for (DictionaryValue::Iterator it(*dictionary_value); !it.IsAtEnd();
-           it.Advance()) {
-        AddString(it.key());
-        AddValue(it.value());
-      }
-    } break;
-
-    case Value::Type::LIST: {
-      const ListValue* list_value = nullptr;
-      value.GetAsList(&list_value);
-      Add(kBaseValue, sizeof(ListValue));
-      for (const auto& v : *list_value)
-        AddValue(v);
-    } break;
-
-    default:
-      NOTREACHED();
-  }
-}
-
-void TraceEventMemoryOverhead::AddSelf() {
-  Add(kTraceEventMemoryOverhead, sizeof(*this));
-}
-
-size_t TraceEventMemoryOverhead::GetCount(ObjectType object_type) const {
-  CHECK(object_type < kLast);
-  return allocated_objects_[static_cast<uint32_t>(object_type)].count;
-}
-
-void TraceEventMemoryOverhead::Update(const TraceEventMemoryOverhead& other) {
-  for (uint32_t i = 0; i < kLast; i++) {
-    const ObjectCountAndSize& other_entry = other.allocated_objects_[i];
-    AddInternal(static_cast<ObjectType>(i), other_entry.count,
-                other_entry.allocated_size_in_bytes,
-                other_entry.resident_size_in_bytes);
-  }
-}
-
-void TraceEventMemoryOverhead::DumpInto(const char* base_name,
-                                        ProcessMemoryDump* pmd) const {
-  for (uint32_t i = 0; i < kLast; i++) {
-    const ObjectCountAndSize& count_and_size = allocated_objects_[i];
-    if (count_and_size.allocated_size_in_bytes == 0)
-      continue;
-    std::string dump_name = StringPrintf(
-        "%s/%s", base_name, ObjectTypeToString(static_cast<ObjectType>(i)));
-    MemoryAllocatorDump* mad = pmd->CreateAllocatorDump(dump_name);
-    mad->AddScalar(MemoryAllocatorDump::kNameSize,
-                   MemoryAllocatorDump::kUnitsBytes,
-                   count_and_size.allocated_size_in_bytes);
-    mad->AddScalar("resident_size", MemoryAllocatorDump::kUnitsBytes,
-                   count_and_size.resident_size_in_bytes);
-    mad->AddScalar(MemoryAllocatorDump::kNameObjectCount,
-                   MemoryAllocatorDump::kUnitsObjects, count_and_size.count);
-  }
-}
-
-}  // namespace trace_event
-}  // namespace base
diff --git a/base/trace_event/trace_event_memory_overhead.h b/base/trace_event/trace_event_memory_overhead.h
deleted file mode 100644
index 1587a30..0000000
--- a/base/trace_event/trace_event_memory_overhead.h
+++ /dev/null
@@ -1,94 +0,0 @@
-// Copyright 2015 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_TRACE_EVENT_TRACE_EVENT_MEMORY_OVERHEAD_H_
-#define BASE_TRACE_EVENT_TRACE_EVENT_MEMORY_OVERHEAD_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-#include <unordered_map>
-
-#include "base/base_export.h"
-#include "base/macros.h"
-
-namespace base {
-
-class RefCountedString;
-class Value;
-
-namespace trace_event {
-
-class ProcessMemoryDump;
-
-// Used to estimate the memory overhead of the tracing infrastructure.
-class BASE_EXPORT TraceEventMemoryOverhead {
- public:
-  enum ObjectType : uint32_t {
-    kOther = 0,
-    kTraceBuffer,
-    kTraceBufferChunk,
-    kTraceEvent,
-    kUnusedTraceEvent,
-    kTracedValue,
-    kConvertableToTraceFormat,
-    kHeapProfilerAllocationRegister,
-    kHeapProfilerTypeNameDeduplicator,
-    kHeapProfilerStackFrameDeduplicator,
-    kStdString,
-    kBaseValue,
-    kTraceEventMemoryOverhead,
-    kLast
-  };
-
-  TraceEventMemoryOverhead();
-  ~TraceEventMemoryOverhead();
-
-  // Use this method to account the overhead of an object for which an estimate
-  // is known for both the allocated and resident memory.
-  void Add(ObjectType object_type,
-           size_t allocated_size_in_bytes,
-           size_t resident_size_in_bytes);
-
-  // Similar to Add() above, but assumes that
-  // |resident_size_in_bytes| == |allocated_size_in_bytes|.
-  void Add(ObjectType object_type, size_t allocated_size_in_bytes);
-
-  // Specialized profiling functions for commonly used object types.
-  void AddString(const std::string& str);
-  void AddValue(const Value& value);
-  void AddRefCountedString(const RefCountedString& str);
-
-  // Call this after all the Add* methods above to account the memory used by
-  // this TraceEventMemoryOverhead instance itself.
-  void AddSelf();
-
-  // Retrieves the count, that is, the count of Add*(|object_type|, ...) calls.
-  size_t GetCount(ObjectType object_type) const;
-
-  // Adds up and merges all the values from |other| to this instance.
-  void Update(const TraceEventMemoryOverhead& other);
-
-  void DumpInto(const char* base_name, ProcessMemoryDump* pmd) const;
-
- private:
-  struct ObjectCountAndSize {
-    size_t count;
-    size_t allocated_size_in_bytes;
-    size_t resident_size_in_bytes;
-  };
-  ObjectCountAndSize allocated_objects_[ObjectType::kLast];
-
-  void AddInternal(ObjectType object_type,
-                   size_t count,
-                   size_t allocated_size_in_bytes,
-                   size_t resident_size_in_bytes);
-
-  DISALLOW_COPY_AND_ASSIGN(TraceEventMemoryOverhead);
-};
-
-}  // namespace trace_event
-}  // namespace base
-
-#endif  // BASE_TRACE_EVENT_TRACE_EVENT_MEMORY_OVERHEAD_H_
diff --git a/base/trace_event/trace_event_system_stats_monitor.cc b/base/trace_event/trace_event_system_stats_monitor.cc
deleted file mode 100644
index 7e082f3..0000000
--- a/base/trace_event/trace_event_system_stats_monitor.cc
+++ /dev/null
@@ -1,132 +0,0 @@
-// Copyright 2013 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/trace_event/trace_event_system_stats_monitor.h"
-
-#include <memory>
-
-#include "base/debug/leak_annotations.h"
-#include "base/json/json_writer.h"
-#include "base/lazy_instance.h"
-#include "base/logging.h"
-#include "base/macros.h"
-#include "base/process/process_metrics.h"
-#include "base/strings/string_number_conversions.h"
-#include "base/strings/string_util.h"
-#include "base/threading/thread_local_storage.h"
-#include "base/threading/thread_task_runner_handle.h"
-#include "base/trace_event/trace_event.h"
-
-namespace base {
-namespace trace_event {
-
-namespace {
-
-/////////////////////////////////////////////////////////////////////////////
-// Holds profiled system stats until the tracing system needs to serialize it.
-class SystemStatsHolder : public base::trace_event::ConvertableToTraceFormat {
- public:
-  SystemStatsHolder() = default;
-  ~SystemStatsHolder() override = default;
-
-  // Fills system_metrics_ with profiled system memory and disk stats.
-  // Uses the previous stats to compute rates if this is not the first profile.
-  void GetSystemProfilingStats();
-
-  // base::trace_event::ConvertableToTraceFormat overrides:
-  void AppendAsTraceFormat(std::string* out) const override {
-    AppendSystemProfileAsTraceFormat(system_stats_, out);
-  }
-
- private:
-  SystemMetrics system_stats_;
-
-  DISALLOW_COPY_AND_ASSIGN(SystemStatsHolder);
-};
-
-void SystemStatsHolder::GetSystemProfilingStats() {
-  system_stats_ = SystemMetrics::Sample();
-}
-
-}  // namespace
-
-//////////////////////////////////////////////////////////////////////////////
-
-TraceEventSystemStatsMonitor::TraceEventSystemStatsMonitor(
-    scoped_refptr<SingleThreadTaskRunner> task_runner)
-    : task_runner_(task_runner),
-      weak_factory_(this) {
-  // Force the "system_stats" category to show up in the trace viewer.
-  TraceLog::GetCategoryGroupEnabled(TRACE_DISABLED_BY_DEFAULT("system_stats"));
-
-  // Allow this to be instantiated on unsupported platforms, but don't run.
-  TraceLog::GetInstance()->AddEnabledStateObserver(this);
-}
-
-TraceEventSystemStatsMonitor::~TraceEventSystemStatsMonitor() {
-  if (dump_timer_.IsRunning())
-    StopProfiling();
-  TraceLog::GetInstance()->RemoveEnabledStateObserver(this);
-}
-
-void TraceEventSystemStatsMonitor::OnTraceLogEnabled() {
-  // Check to see if system tracing is enabled.
-  bool enabled;
-
-  TRACE_EVENT_CATEGORY_GROUP_ENABLED(TRACE_DISABLED_BY_DEFAULT(
-                                     "system_stats"), &enabled);
-  if (!enabled)
-    return;
-  task_runner_->PostTask(
-      FROM_HERE, base::BindOnce(&TraceEventSystemStatsMonitor::StartProfiling,
-                                weak_factory_.GetWeakPtr()));
-}
-
-void TraceEventSystemStatsMonitor::OnTraceLogDisabled() {
-  task_runner_->PostTask(
-      FROM_HERE, base::BindOnce(&TraceEventSystemStatsMonitor::StopProfiling,
-                                weak_factory_.GetWeakPtr()));
-}
-
-void TraceEventSystemStatsMonitor::StartProfiling() {
-  // Watch for the tracing framework sending enabling more than once.
-  if (dump_timer_.IsRunning())
-    return;
-
-  dump_timer_.Start(FROM_HERE,
-                    TimeDelta::FromMilliseconds(TraceEventSystemStatsMonitor::
-                                                kSamplingIntervalMilliseconds),
-                    base::Bind(&TraceEventSystemStatsMonitor::
-                               DumpSystemStats,
-                               weak_factory_.GetWeakPtr()));
-}
-
-// If system tracing is enabled, dumps a profile to the tracing system.
-void TraceEventSystemStatsMonitor::DumpSystemStats() {
-  std::unique_ptr<SystemStatsHolder> dump_holder(new SystemStatsHolder());
-  dump_holder->GetSystemProfilingStats();
-
-  TRACE_EVENT_OBJECT_SNAPSHOT_WITH_ID(
-      TRACE_DISABLED_BY_DEFAULT("system_stats"),
-      "base::TraceEventSystemStatsMonitor::SystemStats", this,
-      std::move(dump_holder));
-}
-
-void TraceEventSystemStatsMonitor::StopProfiling() {
-  dump_timer_.Stop();
-}
-
-bool TraceEventSystemStatsMonitor::IsTimerRunningForTest() const {
-  return dump_timer_.IsRunning();
-}
-
-void AppendSystemProfileAsTraceFormat(const SystemMetrics& system_metrics,
-                                      std::string* output) {
-  std::string tmp;
-  base::JSONWriter::Write(*system_metrics.ToValue(), &tmp);
-  *output += tmp;
-}
-
-}  // namespace trace_event
-}  // namespace base
diff --git a/base/trace_event/trace_event_system_stats_monitor.h b/base/trace_event/trace_event_system_stats_monitor.h
deleted file mode 100644
index 14aa568..0000000
--- a/base/trace_event/trace_event_system_stats_monitor.h
+++ /dev/null
@@ -1,76 +0,0 @@
-// Copyright 2013 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_TRACE_EVENT_TRACE_EVENT_SYSTEM_STATS_MONITOR_H_
-#define BASE_TRACE_EVENT_TRACE_EVENT_SYSTEM_STATS_MONITOR_H_
-
-#include "base/base_export.h"
-#include "base/gtest_prod_util.h"
-#include "base/macros.h"
-#include "base/memory/ref_counted.h"
-#include "base/memory/weak_ptr.h"
-#include "base/process/process_metrics.h"
-#include "base/timer/timer.h"
-#include "base/trace_event/trace_log.h"
-
-namespace base {
-
-class SingleThreadTaskRunner;
-
-namespace trace_event {
-
-// Watches for chrome://tracing to be enabled or disabled. When tracing is
-// enabled, also enables system events profiling. This class is the preferred
-// way to turn system tracing on and off.
-class BASE_EXPORT TraceEventSystemStatsMonitor
-    : public TraceLog::EnabledStateObserver {
- public:
-  // Length of time interval between stat profiles.
-  static const int kSamplingIntervalMilliseconds = 2000;
-
-  // |task_runner| must be the primary thread for the client
-  // process, e.g. the UI thread in a browser.
-  explicit TraceEventSystemStatsMonitor(
-      scoped_refptr<SingleThreadTaskRunner> task_runner);
-
-  ~TraceEventSystemStatsMonitor() override;
-
-  // base::trace_event::TraceLog::EnabledStateChangedObserver overrides:
-  void OnTraceLogEnabled() override;
-  void OnTraceLogDisabled() override;
-
-  // Retrieves system profiling at the current time.
-  void DumpSystemStats();
-
- private:
-  FRIEND_TEST_ALL_PREFIXES(TraceSystemStatsMonitorTest,
-                           TraceEventSystemStatsMonitor);
-
-  bool IsTimerRunningForTest() const;
-
-  void StartProfiling();
-
-  void StopProfiling();
-
-  // Ensures the observer starts and stops tracing on the primary thread.
-  scoped_refptr<SingleThreadTaskRunner> task_runner_;
-
-  // Timer to schedule system profile dumps.
-  RepeatingTimer dump_timer_;
-
-  WeakPtrFactory<TraceEventSystemStatsMonitor> weak_factory_;
-
-  DISALLOW_COPY_AND_ASSIGN(TraceEventSystemStatsMonitor);
-};
-
-// Converts system memory profiling stats in |input| to
-// trace event compatible JSON and appends to |output|. Visible for testing.
-BASE_EXPORT void AppendSystemProfileAsTraceFormat(const SystemMetrics&
-                                                  system_stats,
-                                                  std::string* output);
-
-}  // namespace trace_event
-}  // namespace base
-
-#endif  // BASE_TRACE_EVENT_TRACE_EVENT_SYSTEM_STATS_MONITOR_H_
diff --git a/base/trace_event/trace_log.cc b/base/trace_event/trace_log.cc
deleted file mode 100644
index f608261..0000000
--- a/base/trace_event/trace_log.cc
+++ /dev/null
@@ -1,1743 +0,0 @@
-// Copyright 2015 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/trace_event/trace_log.h"
-
-#include <algorithm>
-#include <cmath>
-#include <memory>
-#include <utility>
-
-#include "base/base_switches.h"
-#include "base/bind.h"
-#include "base/command_line.h"
-#include "base/debug/leak_annotations.h"
-#include "base/location.h"
-#include "base/macros.h"
-#include "base/memory/ptr_util.h"
-#include "base/memory/ref_counted_memory.h"
-#include "base/message_loop/message_loop.h"
-#include "base/message_loop/message_loop_current.h"
-#include "base/no_destructor.h"
-#include "base/process/process_info.h"
-#include "base/process/process_metrics.h"
-#include "base/stl_util.h"
-#include "base/strings/string_piece.h"
-#include "base/strings/string_split.h"
-#include "base/strings/string_tokenizer.h"
-#include "base/strings/stringprintf.h"
-#include "base/sys_info.h"
-#include "base/task_scheduler/post_task.h"
-#include "base/threading/platform_thread.h"
-#include "base/threading/thread_id_name_manager.h"
-#include "base/threading/thread_task_runner_handle.h"
-#include "base/time/time.h"
-#include "base/trace_event/category_registry.h"
-#include "base/trace_event/event_name_filter.h"
-#include "base/trace_event/heap_profiler.h"
-#include "base/trace_event/heap_profiler_allocation_context_tracker.h"
-#include "base/trace_event/heap_profiler_event_filter.h"
-#include "base/trace_event/memory_dump_manager.h"
-#include "base/trace_event/memory_dump_provider.h"
-#include "base/trace_event/process_memory_dump.h"
-#include "base/trace_event/trace_buffer.h"
-#include "base/trace_event/trace_event.h"
-#include "build_config.h"
-
-#if defined(OS_ANDROID)
-// The linker assigns the virtual address of the start of current library to
-// this symbol.
-extern char __executable_start;
-#endif
-
-namespace base {
-namespace trace_event {
-
-namespace {
-
-// Controls the number of trace events we will buffer in-memory
-// before throwing them away.
-const size_t kTraceBufferChunkSize = TraceBufferChunk::kTraceBufferChunkSize;
-
-const size_t kTraceEventVectorBigBufferChunks =
-    512000000 / kTraceBufferChunkSize;
-static_assert(
-    kTraceEventVectorBigBufferChunks <= TraceBufferChunk::kMaxChunkIndex,
-    "Too many big buffer chunks");
-const size_t kTraceEventVectorBufferChunks = 256000 / kTraceBufferChunkSize;
-static_assert(
-    kTraceEventVectorBufferChunks <= TraceBufferChunk::kMaxChunkIndex,
-    "Too many vector buffer chunks");
-const size_t kTraceEventRingBufferChunks = kTraceEventVectorBufferChunks / 4;
-
-// ECHO_TO_CONSOLE needs a small buffer to hold the unfinished COMPLETE events.
-const size_t kEchoToConsoleTraceEventBufferChunks = 256;
-
-const size_t kTraceEventBufferSizeInBytes = 100 * 1024;
-const int kThreadFlushTimeoutMs = 3000;
-
-TraceLog* g_trace_log_for_testing = nullptr;
-
-#define MAX_TRACE_EVENT_FILTERS 32
-
-// List of TraceEventFilter objects from the most recent tracing session.
-std::vector<std::unique_ptr<TraceEventFilter>>& GetCategoryGroupFilters() {
-  static auto* filters = new std::vector<std::unique_ptr<TraceEventFilter>>();
-  return *filters;
-}
-
-ThreadTicks ThreadNow() {
-  return ThreadTicks::IsSupported()
-             ? base::subtle::ThreadTicksNowIgnoringOverride()
-             : ThreadTicks();
-}
-
-template <typename T>
-void InitializeMetadataEvent(TraceEvent* trace_event,
-                             int thread_id,
-                             const char* metadata_name,
-                             const char* arg_name,
-                             const T& value) {
-  if (!trace_event)
-    return;
-
-  int num_args = 1;
-  unsigned char arg_type;
-  unsigned long long arg_value;
-  ::trace_event_internal::SetTraceValue(value, &arg_type, &arg_value);
-  trace_event->Initialize(
-      thread_id,
-      TimeTicks(),
-      ThreadTicks(),
-      TRACE_EVENT_PHASE_METADATA,
-      CategoryRegistry::kCategoryMetadata->state_ptr(),
-      metadata_name,
-      trace_event_internal::kGlobalScope,  // scope
-      trace_event_internal::kNoId,  // id
-      trace_event_internal::kNoId,  // bind_id
-      num_args,
-      &arg_name,
-      &arg_type,
-      &arg_value,
-      nullptr,
-      TRACE_EVENT_FLAG_NONE);
-}
-
-class AutoThreadLocalBoolean {
- public:
-  explicit AutoThreadLocalBoolean(ThreadLocalBoolean* thread_local_boolean)
-      : thread_local_boolean_(thread_local_boolean) {
-    DCHECK(!thread_local_boolean_->Get());
-    thread_local_boolean_->Set(true);
-  }
-  ~AutoThreadLocalBoolean() { thread_local_boolean_->Set(false); }
-
- private:
-  ThreadLocalBoolean* thread_local_boolean_;
-  DISALLOW_COPY_AND_ASSIGN(AutoThreadLocalBoolean);
-};
-
-// Use this function instead of TraceEventHandle constructor to keep the
-// overhead of ScopedTracer (trace_event.h) constructor minimum.
-void MakeHandle(uint32_t chunk_seq,
-                size_t chunk_index,
-                size_t event_index,
-                TraceEventHandle* handle) {
-  DCHECK(chunk_seq);
-  DCHECK(chunk_index <= TraceBufferChunk::kMaxChunkIndex);
-  DCHECK(event_index < TraceBufferChunk::kTraceBufferChunkSize);
-  DCHECK(chunk_index <= std::numeric_limits<uint16_t>::max());
-  handle->chunk_seq = chunk_seq;
-  handle->chunk_index = static_cast<uint16_t>(chunk_index);
-  handle->event_index = static_cast<uint16_t>(event_index);
-}
-
-template <typename Function>
-void ForEachCategoryFilter(const unsigned char* category_group_enabled,
-                           Function filter_fn) {
-  const TraceCategory* category =
-      CategoryRegistry::GetCategoryByStatePtr(category_group_enabled);
-  uint32_t filter_bitmap = category->enabled_filters();
-  for (int index = 0; filter_bitmap != 0; filter_bitmap >>= 1, index++) {
-    if (filter_bitmap & 1 && GetCategoryGroupFilters()[index])
-      filter_fn(GetCategoryGroupFilters()[index].get());
-  }
-}
-
-}  // namespace
-
-// A helper class that allows the lock to be acquired in the middle of the scope
-// and unlocks at the end of scope if locked.
-class TraceLog::OptionalAutoLock {
- public:
-  explicit OptionalAutoLock(Lock* lock) : lock_(lock), locked_(false) {}
-
-  ~OptionalAutoLock() {
-    if (locked_)
-      lock_->Release();
-  }
-
-  void EnsureAcquired() {
-    if (!locked_) {
-      lock_->Acquire();
-      locked_ = true;
-    }
-  }
-
- private:
-  Lock* lock_;
-  bool locked_;
-  DISALLOW_COPY_AND_ASSIGN(OptionalAutoLock);
-};
-
-class TraceLog::ThreadLocalEventBuffer
-    : public MessageLoopCurrent::DestructionObserver,
-      public MemoryDumpProvider {
- public:
-  explicit ThreadLocalEventBuffer(TraceLog* trace_log);
-  ~ThreadLocalEventBuffer() override;
-
-  TraceEvent* AddTraceEvent(TraceEventHandle* handle);
-
-  TraceEvent* GetEventByHandle(TraceEventHandle handle) {
-    if (!chunk_ || handle.chunk_seq != chunk_->seq() ||
-        handle.chunk_index != chunk_index_) {
-      return nullptr;
-    }
-
-    return chunk_->GetEventAt(handle.event_index);
-  }
-
-  int generation() const { return generation_; }
-
- private:
-  // MessageLoopCurrent::DestructionObserver
-  void WillDestroyCurrentMessageLoop() override;
-
-  // MemoryDumpProvider implementation.
-  bool OnMemoryDump(const MemoryDumpArgs& args,
-                    ProcessMemoryDump* pmd) override;
-
-  void FlushWhileLocked();
-
-  void CheckThisIsCurrentBuffer() const {
-    DCHECK(trace_log_->thread_local_event_buffer_.Get() == this);
-  }
-
-  // Since TraceLog is a leaky singleton, trace_log_ will always be valid
-  // as long as the thread exists.
-  TraceLog* trace_log_;
-  std::unique_ptr<TraceBufferChunk> chunk_;
-  size_t chunk_index_;
-  int generation_;
-
-  DISALLOW_COPY_AND_ASSIGN(ThreadLocalEventBuffer);
-};
-
-TraceLog::ThreadLocalEventBuffer::ThreadLocalEventBuffer(TraceLog* trace_log)
-    : trace_log_(trace_log),
-      chunk_index_(0),
-      generation_(trace_log->generation()) {
-  // ThreadLocalEventBuffer is created only if the thread has a message loop, so
-  // the following message_loop won't be NULL.
-  MessageLoop* message_loop = MessageLoop::current();
-  message_loop->AddDestructionObserver(this);
-
-  // This is to report the local memory usage when memory-infra is enabled.
-  MemoryDumpManager::GetInstance()->RegisterDumpProvider(
-      this, "ThreadLocalEventBuffer", ThreadTaskRunnerHandle::Get());
-
-  AutoLock lock(trace_log->lock_);
-  trace_log->thread_message_loops_.insert(message_loop);
-}
-
-TraceLog::ThreadLocalEventBuffer::~ThreadLocalEventBuffer() {
-  CheckThisIsCurrentBuffer();
-  MessageLoop::current()->RemoveDestructionObserver(this);
-  MemoryDumpManager::GetInstance()->UnregisterDumpProvider(this);
-
-  {
-    AutoLock lock(trace_log_->lock_);
-    FlushWhileLocked();
-    trace_log_->thread_message_loops_.erase(MessageLoop::current());
-  }
-  trace_log_->thread_local_event_buffer_.Set(nullptr);
-}
-
-TraceEvent* TraceLog::ThreadLocalEventBuffer::AddTraceEvent(
-    TraceEventHandle* handle) {
-  CheckThisIsCurrentBuffer();
-
-  if (chunk_ && chunk_->IsFull()) {
-    AutoLock lock(trace_log_->lock_);
-    FlushWhileLocked();
-    chunk_.reset();
-  }
-  if (!chunk_) {
-    AutoLock lock(trace_log_->lock_);
-    chunk_ = trace_log_->logged_events_->GetChunk(&chunk_index_);
-    trace_log_->CheckIfBufferIsFullWhileLocked();
-  }
-  if (!chunk_)
-    return nullptr;
-
-  size_t event_index;
-  TraceEvent* trace_event = chunk_->AddTraceEvent(&event_index);
-  if (trace_event && handle)
-    MakeHandle(chunk_->seq(), chunk_index_, event_index, handle);
-
-  return trace_event;
-}
-
-void TraceLog::ThreadLocalEventBuffer::WillDestroyCurrentMessageLoop() {
-  delete this;
-}
-
-bool TraceLog::ThreadLocalEventBuffer::OnMemoryDump(const MemoryDumpArgs& args,
-                                                    ProcessMemoryDump* pmd) {
-  if (!chunk_)
-    return true;
-  std::string dump_base_name = StringPrintf(
-      "tracing/thread_%d", static_cast<int>(PlatformThread::CurrentId()));
-  TraceEventMemoryOverhead overhead;
-  chunk_->EstimateTraceMemoryOverhead(&overhead);
-  overhead.DumpInto(dump_base_name.c_str(), pmd);
-  return true;
-}
-
-void TraceLog::ThreadLocalEventBuffer::FlushWhileLocked() {
-  if (!chunk_)
-    return;
-
-  trace_log_->lock_.AssertAcquired();
-  if (trace_log_->CheckGeneration(generation_)) {
-    // Return the chunk to the buffer only if the generation matches.
-    trace_log_->logged_events_->ReturnChunk(chunk_index_, std::move(chunk_));
-  }
-  // Otherwise this method may be called from the destructor, or TraceLog will
-  // find the generation mismatch and delete this buffer soon.
-}
-
-void TraceLog::SetAddTraceEventOverride(
-    const AddTraceEventOverrideCallback& override) {
-  subtle::NoBarrier_Store(&trace_event_override_,
-                          reinterpret_cast<subtle::AtomicWord>(override));
-}
-
-struct TraceLog::RegisteredAsyncObserver {
-  explicit RegisteredAsyncObserver(WeakPtr<AsyncEnabledStateObserver> observer)
-      : observer(observer), task_runner(ThreadTaskRunnerHandle::Get()) {}
-  ~RegisteredAsyncObserver() = default;
-
-  WeakPtr<AsyncEnabledStateObserver> observer;
-  scoped_refptr<SequencedTaskRunner> task_runner;
-};
-
-TraceLogStatus::TraceLogStatus() : event_capacity(0), event_count(0) {}
-
-TraceLogStatus::~TraceLogStatus() = default;
-
-// static
-TraceLog* TraceLog::GetInstance() {
-  static base::NoDestructor<TraceLog> instance;
-  return instance.get();
-}
-
-// static
-void TraceLog::ResetForTesting() {
-  if (!g_trace_log_for_testing)
-    return;
-  CategoryRegistry::ResetForTesting();
-  g_trace_log_for_testing->~TraceLog();
-  new (g_trace_log_for_testing) TraceLog;
-}
-
-TraceLog::TraceLog()
-    : enabled_modes_(0),
-      num_traces_recorded_(0),
-      dispatching_to_observer_list_(false),
-      process_sort_index_(0),
-      process_id_hash_(0),
-      process_id_(0),
-      trace_options_(kInternalRecordUntilFull),
-      trace_config_(TraceConfig()),
-      thread_shared_chunk_index_(0),
-      generation_(0),
-      use_worker_thread_(false),
-      trace_event_override_(0),
-      filter_factory_for_testing_(nullptr) {
-  CategoryRegistry::Initialize();
-
-#if defined(OS_NACL)  // NaCl shouldn't expose the process id.
-  SetProcessID(0);
-#else
-  SetProcessID(static_cast<int>(GetCurrentProcId()));
-#endif
-
-// Linux renderer processes and Android O processes are not allowed to read
-// "proc/stat" file, crbug.com/788870.
-#if defined(OS_WIN) || (defined(OS_MACOSX) && !defined(OS_IOS))
-  process_creation_time_ = CurrentProcessInfo::CreationTime();
-#else
-  // Use approximate time when creation time is not available.
-  process_creation_time_ = TRACE_TIME_NOW();
-#endif
-
-  logged_events_.reset(CreateTraceBuffer());
-
-  MemoryDumpManager::GetInstance()->RegisterDumpProvider(this, "TraceLog",
-                                                         nullptr);
-  g_trace_log_for_testing = this;
-}
-
-TraceLog::~TraceLog() = default;
-
-void TraceLog::InitializeThreadLocalEventBufferIfSupported() {
-  // A ThreadLocalEventBuffer needs the message loop
-  // - to know when the thread exits;
-  // - to handle the final flush.
-  // For a thread without a message loop or the message loop may be blocked, the
-  // trace events will be added into the main buffer directly.
-  if (thread_blocks_message_loop_.Get() || !MessageLoopCurrent::IsSet())
-    return;
-  HEAP_PROFILER_SCOPED_IGNORE;
-  auto* thread_local_event_buffer = thread_local_event_buffer_.Get();
-  if (thread_local_event_buffer &&
-      !CheckGeneration(thread_local_event_buffer->generation())) {
-    delete thread_local_event_buffer;
-    thread_local_event_buffer = nullptr;
-  }
-  if (!thread_local_event_buffer) {
-    thread_local_event_buffer = new ThreadLocalEventBuffer(this);
-    thread_local_event_buffer_.Set(thread_local_event_buffer);
-  }
-}
-
-bool TraceLog::OnMemoryDump(const MemoryDumpArgs& args,
-                            ProcessMemoryDump* pmd) {
-  // TODO(ssid): Use MemoryDumpArgs to create light dumps when requested
-  // (crbug.com/499731).
-  TraceEventMemoryOverhead overhead;
-  overhead.Add(TraceEventMemoryOverhead::kOther, sizeof(*this));
-  {
-    AutoLock lock(lock_);
-    if (logged_events_)
-      logged_events_->EstimateTraceMemoryOverhead(&overhead);
-
-    for (auto& metadata_event : metadata_events_)
-      metadata_event->EstimateTraceMemoryOverhead(&overhead);
-  }
-  overhead.AddSelf();
-  overhead.DumpInto("tracing/main_trace_log", pmd);
-  return true;
-}
-
-const unsigned char* TraceLog::GetCategoryGroupEnabled(
-    const char* category_group) {
-  TraceLog* tracelog = GetInstance();
-  if (!tracelog) {
-    DCHECK(!CategoryRegistry::kCategoryAlreadyShutdown->is_enabled());
-    return CategoryRegistry::kCategoryAlreadyShutdown->state_ptr();
-  }
-  TraceCategory* category = CategoryRegistry::GetCategoryByName(category_group);
-  if (!category) {
-    // Slow path: in the case of a new category we have to repeat the check
-    // holding the lock, as multiple threads might have reached this point
-    // at the same time.
-    auto category_initializer = [](TraceCategory* category) {
-      TraceLog::GetInstance()->UpdateCategoryState(category);
-    };
-    AutoLock lock(tracelog->lock_);
-    CategoryRegistry::GetOrCreateCategoryLocked(
-        category_group, category_initializer, &category);
-  }
-  DCHECK(category->state_ptr());
-  return category->state_ptr();
-}
-
-const char* TraceLog::GetCategoryGroupName(
-    const unsigned char* category_group_enabled) {
-  return CategoryRegistry::GetCategoryByStatePtr(category_group_enabled)
-      ->name();
-}
-
-void TraceLog::UpdateCategoryState(TraceCategory* category) {
-  lock_.AssertAcquired();
-  DCHECK(category->is_valid());
-  unsigned char state_flags = 0;
-  if (enabled_modes_ & RECORDING_MODE &&
-      trace_config_.IsCategoryGroupEnabled(category->name())) {
-    state_flags |= TraceCategory::ENABLED_FOR_RECORDING;
-  }
-
-  // TODO(primiano): this is a temporary workaround for catapult:#2341,
-  // to guarantee that metadata events are always added even if the category
-  // filter is "-*". See crbug.com/618054 for more details and long-term fix.
-  if (enabled_modes_ & RECORDING_MODE &&
-      category == CategoryRegistry::kCategoryMetadata) {
-    state_flags |= TraceCategory::ENABLED_FOR_RECORDING;
-  }
-
-  uint32_t enabled_filters_bitmap = 0;
-  int index = 0;
-  for (const auto& event_filter : enabled_event_filters_) {
-    if (event_filter.IsCategoryGroupEnabled(category->name())) {
-      state_flags |= TraceCategory::ENABLED_FOR_FILTERING;
-      DCHECK(GetCategoryGroupFilters()[index]);
-      enabled_filters_bitmap |= 1 << index;
-    }
-    if (index++ >= MAX_TRACE_EVENT_FILTERS) {
-      NOTREACHED();
-      break;
-    }
-  }
-  category->set_enabled_filters(enabled_filters_bitmap);
-  category->set_state(state_flags);
-}
-
-void TraceLog::UpdateCategoryRegistry() {
-  lock_.AssertAcquired();
-  CreateFiltersForTraceConfig();
-  for (TraceCategory& category : CategoryRegistry::GetAllCategories()) {
-    UpdateCategoryState(&category);
-  }
-}
-
-void TraceLog::CreateFiltersForTraceConfig() {
-  if (!(enabled_modes_ & FILTERING_MODE))
-    return;
-
-  // Filters were already added and tracing could be enabled. Filters list
-  // cannot be changed when trace events are using them.
-  if (GetCategoryGroupFilters().size())
-    return;
-
-  for (auto& filter_config : enabled_event_filters_) {
-    if (GetCategoryGroupFilters().size() >= MAX_TRACE_EVENT_FILTERS) {
-      NOTREACHED()
-          << "Too many trace event filters installed in the current session";
-      break;
-    }
-
-    std::unique_ptr<TraceEventFilter> new_filter;
-    const std::string& predicate_name = filter_config.predicate_name();
-    if (predicate_name == EventNameFilter::kName) {
-      auto whitelist = std::make_unique<std::unordered_set<std::string>>();
-      CHECK(filter_config.GetArgAsSet("event_name_whitelist", &*whitelist));
-      new_filter = std::make_unique<EventNameFilter>(std::move(whitelist));
-    } else if (predicate_name == HeapProfilerEventFilter::kName) {
-      new_filter = std::make_unique<HeapProfilerEventFilter>();
-    } else {
-      if (filter_factory_for_testing_)
-        new_filter = filter_factory_for_testing_(predicate_name);
-      CHECK(new_filter) << "Unknown trace filter " << predicate_name;
-    }
-    GetCategoryGroupFilters().push_back(std::move(new_filter));
-  }
-}
-
-void TraceLog::GetKnownCategoryGroups(
-    std::vector<std::string>* category_groups) {
-  for (const auto& category : CategoryRegistry::GetAllCategories()) {
-    if (!CategoryRegistry::IsBuiltinCategory(&category))
-      category_groups->push_back(category.name());
-  }
-}
-
-void TraceLog::SetEnabled(const TraceConfig& trace_config,
-                          uint8_t modes_to_enable) {
-  std::vector<EnabledStateObserver*> observer_list;
-  std::map<AsyncEnabledStateObserver*, RegisteredAsyncObserver> observer_map;
-  {
-    AutoLock lock(lock_);
-
-    // Can't enable tracing when Flush() is in progress.
-    DCHECK(!flush_task_runner_);
-
-    InternalTraceOptions new_options =
-        GetInternalOptionsFromTraceConfig(trace_config);
-
-    InternalTraceOptions old_options = trace_options();
-
-    if (dispatching_to_observer_list_) {
-      // TODO(ssid): Change to NOTREACHED after fixing crbug.com/625170.
-      DLOG(ERROR)
-          << "Cannot manipulate TraceLog::Enabled state from an observer.";
-      return;
-    }
-
-    // Clear all filters from previous tracing session. These filters are not
-    // cleared at the end of tracing because some threads which hit trace event
-    // when disabling, could try to use the filters.
-    if (!enabled_modes_)
-      GetCategoryGroupFilters().clear();
-
-    // Update trace config for recording.
-    const bool already_recording = enabled_modes_ & RECORDING_MODE;
-    if (modes_to_enable & RECORDING_MODE) {
-      if (already_recording) {
-        // TODO(ssid): Stop suporting enabling of RECODING_MODE when already
-        // enabled crbug.com/625170.
-        DCHECK_EQ(new_options, old_options) << "Attempting to re-enable "
-                                               "tracing with a different set "
-                                               "of options.";
-        trace_config_.Merge(trace_config);
-      } else {
-        trace_config_ = trace_config;
-      }
-    }
-
-    // Update event filters only if filtering was not enabled.
-    if (modes_to_enable & FILTERING_MODE && enabled_event_filters_.empty()) {
-      DCHECK(!trace_config.event_filters().empty());
-      enabled_event_filters_ = trace_config.event_filters();
-    }
-    // Keep the |trace_config_| updated with only enabled filters in case anyone
-    // tries to read it using |GetCurrentTraceConfig| (even if filters are
-    // empty).
-    trace_config_.SetEventFilters(enabled_event_filters_);
-
-    enabled_modes_ |= modes_to_enable;
-    UpdateCategoryRegistry();
-
-    // Do not notify observers or create trace buffer if only enabled for
-    // filtering or if recording was already enabled.
-    if (!(modes_to_enable & RECORDING_MODE) || already_recording)
-      return;
-
-    if (new_options != old_options) {
-      subtle::NoBarrier_Store(&trace_options_, new_options);
-      UseNextTraceBuffer();
-    }
-
-    num_traces_recorded_++;
-
-    UpdateCategoryRegistry();
-
-    dispatching_to_observer_list_ = true;
-    observer_list = enabled_state_observer_list_;
-    observer_map = async_observers_;
-  }
-  // Notify observers outside the lock in case they trigger trace events.
-  for (EnabledStateObserver* observer : observer_list)
-    observer->OnTraceLogEnabled();
-  for (const auto& it : observer_map) {
-    it.second.task_runner->PostTask(
-        FROM_HERE, BindOnce(&AsyncEnabledStateObserver::OnTraceLogEnabled,
-                            it.second.observer));
-  }
-
-  {
-    AutoLock lock(lock_);
-    dispatching_to_observer_list_ = false;
-  }
-}
-
-void TraceLog::SetArgumentFilterPredicate(
-    const ArgumentFilterPredicate& argument_filter_predicate) {
-  AutoLock lock(lock_);
-  DCHECK(!argument_filter_predicate.is_null());
-  DCHECK(argument_filter_predicate_.is_null());
-  argument_filter_predicate_ = argument_filter_predicate;
-}
-
-TraceLog::InternalTraceOptions TraceLog::GetInternalOptionsFromTraceConfig(
-    const TraceConfig& config) {
-  InternalTraceOptions ret = config.IsArgumentFilterEnabled()
-                                 ? kInternalEnableArgumentFilter
-                                 : kInternalNone;
-  switch (config.GetTraceRecordMode()) {
-    case RECORD_UNTIL_FULL:
-      return ret | kInternalRecordUntilFull;
-    case RECORD_CONTINUOUSLY:
-      return ret | kInternalRecordContinuously;
-    case ECHO_TO_CONSOLE:
-      return ret | kInternalEchoToConsole;
-    case RECORD_AS_MUCH_AS_POSSIBLE:
-      return ret | kInternalRecordAsMuchAsPossible;
-  }
-  NOTREACHED();
-  return kInternalNone;
-}
-
-TraceConfig TraceLog::GetCurrentTraceConfig() const {
-  AutoLock lock(lock_);
-  return trace_config_;
-}
-
-void TraceLog::SetDisabled() {
-  AutoLock lock(lock_);
-  SetDisabledWhileLocked(RECORDING_MODE);
-}
-
-void TraceLog::SetDisabled(uint8_t modes_to_disable) {
-  AutoLock lock(lock_);
-  SetDisabledWhileLocked(modes_to_disable);
-}
-
-void TraceLog::SetDisabledWhileLocked(uint8_t modes_to_disable) {
-  lock_.AssertAcquired();
-
-  if (!(enabled_modes_ & modes_to_disable))
-    return;
-
-  if (dispatching_to_observer_list_) {
-    // TODO(ssid): Change to NOTREACHED after fixing crbug.com/625170.
-    DLOG(ERROR)
-        << "Cannot manipulate TraceLog::Enabled state from an observer.";
-    return;
-  }
-
-  bool is_recording_mode_disabled =
-      (enabled_modes_ & RECORDING_MODE) && (modes_to_disable & RECORDING_MODE);
-  enabled_modes_ &= ~modes_to_disable;
-
-  if (modes_to_disable & FILTERING_MODE)
-    enabled_event_filters_.clear();
-
-  if (modes_to_disable & RECORDING_MODE)
-    trace_config_.Clear();
-
-  UpdateCategoryRegistry();
-
-  // Add metadata events and notify observers only if recording mode was
-  // disabled now.
-  if (!is_recording_mode_disabled)
-    return;
-
-  AddMetadataEventsWhileLocked();
-
-  // Remove metadata events so they will not get added to a subsequent trace.
-  metadata_events_.clear();
-
-  dispatching_to_observer_list_ = true;
-  std::vector<EnabledStateObserver*> observer_list =
-      enabled_state_observer_list_;
-  std::map<AsyncEnabledStateObserver*, RegisteredAsyncObserver> observer_map =
-      async_observers_;
-
-  {
-    // Dispatch to observers outside the lock in case the observer triggers a
-    // trace event.
-    AutoUnlock unlock(lock_);
-    for (EnabledStateObserver* observer : observer_list)
-      observer->OnTraceLogDisabled();
-    for (const auto& it : observer_map) {
-      it.second.task_runner->PostTask(
-          FROM_HERE, BindOnce(&AsyncEnabledStateObserver::OnTraceLogDisabled,
-                              it.second.observer));
-    }
-  }
-  dispatching_to_observer_list_ = false;
-}
-
-int TraceLog::GetNumTracesRecorded() {
-  AutoLock lock(lock_);
-  if (!IsEnabled())
-    return -1;
-  return num_traces_recorded_;
-}
-
-void TraceLog::AddEnabledStateObserver(EnabledStateObserver* listener) {
-  AutoLock lock(lock_);
-  enabled_state_observer_list_.push_back(listener);
-}
-
-void TraceLog::RemoveEnabledStateObserver(EnabledStateObserver* listener) {
-  AutoLock lock(lock_);
-  std::vector<EnabledStateObserver*>::iterator it =
-      std::find(enabled_state_observer_list_.begin(),
-                enabled_state_observer_list_.end(), listener);
-  if (it != enabled_state_observer_list_.end())
-    enabled_state_observer_list_.erase(it);
-}
-
-bool TraceLog::HasEnabledStateObserver(EnabledStateObserver* listener) const {
-  AutoLock lock(lock_);
-  return ContainsValue(enabled_state_observer_list_, listener);
-}
-
-TraceLogStatus TraceLog::GetStatus() const {
-  AutoLock lock(lock_);
-  TraceLogStatus result;
-  result.event_capacity = static_cast<uint32_t>(logged_events_->Capacity());
-  result.event_count = static_cast<uint32_t>(logged_events_->Size());
-  return result;
-}
-
-bool TraceLog::BufferIsFull() const {
-  AutoLock lock(lock_);
-  return logged_events_->IsFull();
-}
-
-TraceEvent* TraceLog::AddEventToThreadSharedChunkWhileLocked(
-    TraceEventHandle* handle,
-    bool check_buffer_is_full) {
-  lock_.AssertAcquired();
-
-  if (thread_shared_chunk_ && thread_shared_chunk_->IsFull()) {
-    logged_events_->ReturnChunk(thread_shared_chunk_index_,
-                                std::move(thread_shared_chunk_));
-  }
-
-  if (!thread_shared_chunk_) {
-    thread_shared_chunk_ =
-        logged_events_->GetChunk(&thread_shared_chunk_index_);
-    if (check_buffer_is_full)
-      CheckIfBufferIsFullWhileLocked();
-  }
-  if (!thread_shared_chunk_)
-    return nullptr;
-
-  size_t event_index;
-  TraceEvent* trace_event = thread_shared_chunk_->AddTraceEvent(&event_index);
-  if (trace_event && handle) {
-    MakeHandle(thread_shared_chunk_->seq(), thread_shared_chunk_index_,
-               event_index, handle);
-  }
-  return trace_event;
-}
-
-void TraceLog::CheckIfBufferIsFullWhileLocked() {
-  lock_.AssertAcquired();
-  if (logged_events_->IsFull()) {
-    if (buffer_limit_reached_timestamp_.is_null()) {
-      buffer_limit_reached_timestamp_ = OffsetNow();
-    }
-    SetDisabledWhileLocked(RECORDING_MODE);
-  }
-}
-
-// Flush() works as the following:
-// 1. Flush() is called in thread A whose task runner is saved in
-//    flush_task_runner_;
-// 2. If thread_message_loops_ is not empty, thread A posts task to each message
-//    loop to flush the thread local buffers; otherwise finish the flush;
-// 3. FlushCurrentThread() deletes the thread local event buffer:
-//    - The last batch of events of the thread are flushed into the main buffer;
-//    - The message loop will be removed from thread_message_loops_;
-//    If this is the last message loop, finish the flush;
-// 4. If any thread hasn't finish its flush in time, finish the flush.
-void TraceLog::Flush(const TraceLog::OutputCallback& cb,
-                     bool use_worker_thread) {
-  FlushInternal(cb, use_worker_thread, false);
-}
-
-void TraceLog::CancelTracing(const OutputCallback& cb) {
-  SetDisabled();
-  FlushInternal(cb, false, true);
-}
-
-void TraceLog::FlushInternal(const TraceLog::OutputCallback& cb,
-                             bool use_worker_thread,
-                             bool discard_events) {
-  use_worker_thread_ = use_worker_thread;
-  if (IsEnabled()) {
-    // Can't flush when tracing is enabled because otherwise PostTask would
-    // - generate more trace events;
-    // - deschedule the calling thread on some platforms causing inaccurate
-    //   timing of the trace events.
-    scoped_refptr<RefCountedString> empty_result = new RefCountedString;
-    if (!cb.is_null())
-      cb.Run(empty_result, false);
-    LOG(WARNING) << "Ignored TraceLog::Flush called when tracing is enabled";
-    return;
-  }
-
-  int gen = generation();
-  // Copy of thread_message_loops_ to be used without locking.
-  std::vector<scoped_refptr<SingleThreadTaskRunner>>
-      thread_message_loop_task_runners;
-  {
-    AutoLock lock(lock_);
-    DCHECK(!flush_task_runner_);
-    flush_task_runner_ = ThreadTaskRunnerHandle::IsSet()
-                             ? ThreadTaskRunnerHandle::Get()
-                             : nullptr;
-    DCHECK(thread_message_loops_.empty() || flush_task_runner_);
-    flush_output_callback_ = cb;
-
-    if (thread_shared_chunk_) {
-      logged_events_->ReturnChunk(thread_shared_chunk_index_,
-                                  std::move(thread_shared_chunk_));
-    }
-
-    for (MessageLoop* loop : thread_message_loops_)
-      thread_message_loop_task_runners.push_back(loop->task_runner());
-  }
-
-  if (!thread_message_loop_task_runners.empty()) {
-    for (auto& task_runner : thread_message_loop_task_runners) {
-      task_runner->PostTask(
-          FROM_HERE, BindOnce(&TraceLog::FlushCurrentThread, Unretained(this),
-                              gen, discard_events));
-    }
-    flush_task_runner_->PostDelayedTask(
-        FROM_HERE,
-        BindOnce(&TraceLog::OnFlushTimeout, Unretained(this), gen,
-                 discard_events),
-        TimeDelta::FromMilliseconds(kThreadFlushTimeoutMs));
-    return;
-  }
-
-  FinishFlush(gen, discard_events);
-}
-
-// Usually it runs on a different thread.
-void TraceLog::ConvertTraceEventsToTraceFormat(
-    std::unique_ptr<TraceBuffer> logged_events,
-    const OutputCallback& flush_output_callback,
-    const ArgumentFilterPredicate& argument_filter_predicate) {
-  if (flush_output_callback.is_null())
-    return;
-
-  HEAP_PROFILER_SCOPED_IGNORE;
-  // The callback need to be called at least once even if there is no events
-  // to let the caller know the completion of flush.
-  scoped_refptr<RefCountedString> json_events_str_ptr = new RefCountedString();
-  const size_t kReserveCapacity = kTraceEventBufferSizeInBytes * 5 / 4;
-  json_events_str_ptr->data().reserve(kReserveCapacity);
-  while (const TraceBufferChunk* chunk = logged_events->NextChunk()) {
-    for (size_t j = 0; j < chunk->size(); ++j) {
-      size_t size = json_events_str_ptr->size();
-      if (size > kTraceEventBufferSizeInBytes) {
-        flush_output_callback.Run(json_events_str_ptr, true);
-        json_events_str_ptr = new RefCountedString();
-        json_events_str_ptr->data().reserve(kReserveCapacity);
-      } else if (size) {
-        json_events_str_ptr->data().append(",\n");
-      }
-      chunk->GetEventAt(j)->AppendAsJSON(&(json_events_str_ptr->data()),
-                                         argument_filter_predicate);
-    }
-  }
-  flush_output_callback.Run(json_events_str_ptr, false);
-}
-
-void TraceLog::FinishFlush(int generation, bool discard_events) {
-  std::unique_ptr<TraceBuffer> previous_logged_events;
-  OutputCallback flush_output_callback;
-  ArgumentFilterPredicate argument_filter_predicate;
-
-  if (!CheckGeneration(generation))
-    return;
-
-  {
-    AutoLock lock(lock_);
-
-    previous_logged_events.swap(logged_events_);
-    UseNextTraceBuffer();
-    thread_message_loops_.clear();
-
-    flush_task_runner_ = nullptr;
-    flush_output_callback = flush_output_callback_;
-    flush_output_callback_.Reset();
-
-    if (trace_options() & kInternalEnableArgumentFilter) {
-      CHECK(!argument_filter_predicate_.is_null());
-      argument_filter_predicate = argument_filter_predicate_;
-    }
-  }
-
-  if (discard_events) {
-    if (!flush_output_callback.is_null()) {
-      scoped_refptr<RefCountedString> empty_result = new RefCountedString;
-      flush_output_callback.Run(empty_result, false);
-    }
-    return;
-  }
-
-  if (use_worker_thread_) {
-    base::PostTaskWithTraits(
-        FROM_HERE,
-        {MayBlock(), TaskPriority::BACKGROUND,
-         TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN},
-        BindOnce(&TraceLog::ConvertTraceEventsToTraceFormat,
-                 std::move(previous_logged_events), flush_output_callback,
-                 argument_filter_predicate));
-    return;
-  }
-
-  ConvertTraceEventsToTraceFormat(std::move(previous_logged_events),
-                                  flush_output_callback,
-                                  argument_filter_predicate);
-}
-
-// Run in each thread holding a local event buffer.
-void TraceLog::FlushCurrentThread(int generation, bool discard_events) {
-  {
-    AutoLock lock(lock_);
-    if (!CheckGeneration(generation) || !flush_task_runner_) {
-      // This is late. The corresponding flush has finished.
-      return;
-    }
-  }
-
-  // This will flush the thread local buffer.
-  delete thread_local_event_buffer_.Get();
-
-  // Scheduler uses TRACE_EVENT macros when posting a task, which can lead
-  // to acquiring a tracing lock. Given that posting a task requires grabbing
-  // a scheduler lock, we need to post this task outside tracing lock to avoid
-  // deadlocks.
-  scoped_refptr<SingleThreadTaskRunner> cached_flush_task_runner;
-  {
-    AutoLock lock(lock_);
-    cached_flush_task_runner = flush_task_runner_;
-    if (!CheckGeneration(generation) || !flush_task_runner_ ||
-        !thread_message_loops_.empty())
-      return;
-  }
-  cached_flush_task_runner->PostTask(
-      FROM_HERE, BindOnce(&TraceLog::FinishFlush, Unretained(this), generation,
-                          discard_events));
-}
-
-void TraceLog::OnFlushTimeout(int generation, bool discard_events) {
-  {
-    AutoLock lock(lock_);
-    if (!CheckGeneration(generation) || !flush_task_runner_) {
-      // Flush has finished before timeout.
-      return;
-    }
-
-    LOG(WARNING)
-        << "The following threads haven't finished flush in time. "
-           "If this happens stably for some thread, please call "
-           "TraceLog::GetInstance()->SetCurrentThreadBlocksMessageLoop() from "
-           "the thread to avoid its trace events from being lost.";
-    for (hash_set<MessageLoop*>::const_iterator it =
-             thread_message_loops_.begin();
-         it != thread_message_loops_.end(); ++it) {
-      LOG(WARNING) << "Thread: " << (*it)->GetThreadName();
-    }
-  }
-  FinishFlush(generation, discard_events);
-}
-
-void TraceLog::UseNextTraceBuffer() {
-  logged_events_.reset(CreateTraceBuffer());
-  subtle::NoBarrier_AtomicIncrement(&generation_, 1);
-  thread_shared_chunk_.reset();
-  thread_shared_chunk_index_ = 0;
-}
-
-TraceEventHandle TraceLog::AddTraceEvent(
-    char phase,
-    const unsigned char* category_group_enabled,
-    const char* name,
-    const char* scope,
-    unsigned long long id,
-    int num_args,
-    const char* const* arg_names,
-    const unsigned char* arg_types,
-    const unsigned long long* arg_values,
-    std::unique_ptr<ConvertableToTraceFormat>* convertable_values,
-    unsigned int flags) {
-  int thread_id = static_cast<int>(base::PlatformThread::CurrentId());
-  base::TimeTicks now = TRACE_TIME_TICKS_NOW();
-  return AddTraceEventWithThreadIdAndTimestamp(
-      phase,
-      category_group_enabled,
-      name,
-      scope,
-      id,
-      trace_event_internal::kNoId,  // bind_id
-      thread_id,
-      now,
-      num_args,
-      arg_names,
-      arg_types,
-      arg_values,
-      convertable_values,
-      flags);
-}
-
-TraceEventHandle TraceLog::AddTraceEventWithBindId(
-    char phase,
-    const unsigned char* category_group_enabled,
-    const char* name,
-    const char* scope,
-    unsigned long long id,
-    unsigned long long bind_id,
-    int num_args,
-    const char* const* arg_names,
-    const unsigned char* arg_types,
-    const unsigned long long* arg_values,
-    std::unique_ptr<ConvertableToTraceFormat>* convertable_values,
-    unsigned int flags) {
-  int thread_id = static_cast<int>(base::PlatformThread::CurrentId());
-  base::TimeTicks now = TRACE_TIME_TICKS_NOW();
-  return AddTraceEventWithThreadIdAndTimestamp(
-      phase,
-      category_group_enabled,
-      name,
-      scope,
-      id,
-      bind_id,
-      thread_id,
-      now,
-      num_args,
-      arg_names,
-      arg_types,
-      arg_values,
-      convertable_values,
-      flags | TRACE_EVENT_FLAG_HAS_CONTEXT_ID);
-}
-
-TraceEventHandle TraceLog::AddTraceEventWithProcessId(
-    char phase,
-    const unsigned char* category_group_enabled,
-    const char* name,
-    const char* scope,
-    unsigned long long id,
-    int process_id,
-    int num_args,
-    const char* const* arg_names,
-    const unsigned char* arg_types,
-    const unsigned long long* arg_values,
-    std::unique_ptr<ConvertableToTraceFormat>* convertable_values,
-    unsigned int flags) {
-  base::TimeTicks now = TRACE_TIME_TICKS_NOW();
-  return AddTraceEventWithThreadIdAndTimestamp(
-      phase,
-      category_group_enabled,
-      name,
-      scope,
-      id,
-      trace_event_internal::kNoId,  // bind_id
-      process_id,
-      now,
-      num_args,
-      arg_names,
-      arg_types,
-      arg_values,
-      convertable_values,
-      flags | TRACE_EVENT_FLAG_HAS_PROCESS_ID);
-}
-
-// Handle legacy calls to AddTraceEventWithThreadIdAndTimestamp
-// with kNoId as bind_id
-TraceEventHandle TraceLog::AddTraceEventWithThreadIdAndTimestamp(
-    char phase,
-    const unsigned char* category_group_enabled,
-    const char* name,
-    const char* scope,
-    unsigned long long id,
-    int thread_id,
-    const TimeTicks& timestamp,
-    int num_args,
-    const char* const* arg_names,
-    const unsigned char* arg_types,
-    const unsigned long long* arg_values,
-    std::unique_ptr<ConvertableToTraceFormat>* convertable_values,
-    unsigned int flags) {
-  return AddTraceEventWithThreadIdAndTimestamp(
-      phase,
-      category_group_enabled,
-      name,
-      scope,
-      id,
-      trace_event_internal::kNoId,  // bind_id
-      thread_id,
-      timestamp,
-      num_args,
-      arg_names,
-      arg_types,
-      arg_values,
-      convertable_values,
-      flags);
-}
-
-TraceEventHandle TraceLog::AddTraceEventWithThreadIdAndTimestamp(
-    char phase,
-    const unsigned char* category_group_enabled,
-    const char* name,
-    const char* scope,
-    unsigned long long id,
-    unsigned long long bind_id,
-    int thread_id,
-    const TimeTicks& timestamp,
-    int num_args,
-    const char* const* arg_names,
-    const unsigned char* arg_types,
-    const unsigned long long* arg_values,
-    std::unique_ptr<ConvertableToTraceFormat>* convertable_values,
-    unsigned int flags) {
-  TraceEventHandle handle = {0, 0, 0};
-  if (!*category_group_enabled)
-    return handle;
-
-  // Avoid re-entrance of AddTraceEvent. This may happen in GPU process when
-  // ECHO_TO_CONSOLE is enabled: AddTraceEvent -> LOG(ERROR) ->
-  // GpuProcessLogMessageHandler -> PostPendingTask -> TRACE_EVENT ...
-  if (thread_is_in_trace_event_.Get())
-    return handle;
-
-  AutoThreadLocalBoolean thread_is_in_trace_event(&thread_is_in_trace_event_);
-
-  DCHECK(name);
-  DCHECK(!timestamp.is_null());
-
-  if (flags & TRACE_EVENT_FLAG_MANGLE_ID) {
-    if ((flags & TRACE_EVENT_FLAG_FLOW_IN) ||
-        (flags & TRACE_EVENT_FLAG_FLOW_OUT))
-      bind_id = MangleEventId(bind_id);
-    id = MangleEventId(id);
-  }
-
-  TimeTicks offset_event_timestamp = OffsetTimestamp(timestamp);
-  ThreadTicks thread_now = ThreadNow();
-
-  ThreadLocalEventBuffer* thread_local_event_buffer = nullptr;
-  if (*category_group_enabled & RECORDING_MODE) {
-    // |thread_local_event_buffer_| can be null if the current thread doesn't
-    // have a message loop or the message loop is blocked.
-    InitializeThreadLocalEventBufferIfSupported();
-    thread_local_event_buffer = thread_local_event_buffer_.Get();
-  }
-
-  // Check and update the current thread name only if the event is for the
-  // current thread to avoid locks in most cases.
-  if (thread_id == static_cast<int>(PlatformThread::CurrentId())) {
-    const char* new_name =
-        ThreadIdNameManager::GetInstance()->GetName(thread_id);
-    // Check if the thread name has been set or changed since the previous
-    // call (if any), but don't bother if the new name is empty. Note this will
-    // not detect a thread name change within the same char* buffer address: we
-    // favor common case performance over corner case correctness.
-    static auto* current_thread_name = new ThreadLocalPointer<const char>();
-    if (new_name != current_thread_name->Get() && new_name && *new_name) {
-      current_thread_name->Set(new_name);
-
-      AutoLock thread_info_lock(thread_info_lock_);
-
-      auto existing_name = thread_names_.find(thread_id);
-      if (existing_name == thread_names_.end()) {
-        // This is a new thread id, and a new name.
-        thread_names_[thread_id] = new_name;
-      } else {
-        // This is a thread id that we've seen before, but potentially with a
-        // new name.
-        std::vector<StringPiece> existing_names = base::SplitStringPiece(
-            existing_name->second, ",", base::KEEP_WHITESPACE,
-            base::SPLIT_WANT_NONEMPTY);
-        if (!ContainsValue(existing_names, new_name)) {
-          if (!existing_names.empty())
-            existing_name->second.push_back(',');
-          existing_name->second.append(new_name);
-        }
-      }
-    }
-  }
-
-  AddTraceEventOverrideCallback trace_event_override =
-      reinterpret_cast<AddTraceEventOverrideCallback>(
-          subtle::NoBarrier_Load(&trace_event_override_));
-  if (trace_event_override) {
-    TraceEvent new_trace_event;
-    // If we have an override in place for events, rather than sending
-    // them to the tracelog, we don't have a way of going back and updating
-    // the duration of _COMPLETE events. Instead, we emit separate _BEGIN
-    // and _END events.
-    if (phase == TRACE_EVENT_PHASE_COMPLETE)
-      phase = TRACE_EVENT_PHASE_BEGIN;
-
-    new_trace_event.Initialize(thread_id, offset_event_timestamp, thread_now,
-                               phase, category_group_enabled, name, scope, id,
-                               bind_id, num_args, arg_names, arg_types,
-                               arg_values, convertable_values, flags);
-
-    trace_event_override(new_trace_event);
-    return handle;
-  }
-
-  std::string console_message;
-  std::unique_ptr<TraceEvent> filtered_trace_event;
-  bool disabled_by_filters = false;
-  if (*category_group_enabled & TraceCategory::ENABLED_FOR_FILTERING) {
-    std::unique_ptr<TraceEvent> new_trace_event(new TraceEvent);
-    new_trace_event->Initialize(thread_id, offset_event_timestamp, thread_now,
-                                phase, category_group_enabled, name, scope, id,
-                                bind_id, num_args, arg_names, arg_types,
-                                arg_values, convertable_values, flags);
-
-    disabled_by_filters = true;
-    ForEachCategoryFilter(
-        category_group_enabled, [&new_trace_event, &disabled_by_filters](
-                                    TraceEventFilter* trace_event_filter) {
-          if (trace_event_filter->FilterTraceEvent(*new_trace_event))
-            disabled_by_filters = false;
-        });
-    if (!disabled_by_filters)
-      filtered_trace_event = std::move(new_trace_event);
-  }
-
-  // If enabled for recording, the event should be added only if one of the
-  // filters indicates or category is not enabled for filtering.
-  if ((*category_group_enabled & TraceCategory::ENABLED_FOR_RECORDING) &&
-      !disabled_by_filters) {
-    OptionalAutoLock lock(&lock_);
-
-    TraceEvent* trace_event = nullptr;
-    if (thread_local_event_buffer) {
-      trace_event = thread_local_event_buffer->AddTraceEvent(&handle);
-    } else {
-      lock.EnsureAcquired();
-      trace_event = AddEventToThreadSharedChunkWhileLocked(&handle, true);
-    }
-
-    if (trace_event) {
-      if (filtered_trace_event) {
-        trace_event->MoveFrom(std::move(filtered_trace_event));
-      } else {
-        trace_event->Initialize(thread_id, offset_event_timestamp, thread_now,
-                                phase, category_group_enabled, name, scope, id,
-                                bind_id, num_args, arg_names, arg_types,
-                                arg_values, convertable_values, flags);
-      }
-
-#if defined(OS_ANDROID)
-      trace_event->SendToATrace();
-#endif
-    }
-
-    if (trace_options() & kInternalEchoToConsole) {
-      console_message = EventToConsoleMessage(
-          phase == TRACE_EVENT_PHASE_COMPLETE ? TRACE_EVENT_PHASE_BEGIN : phase,
-          timestamp, trace_event);
-    }
-  }
-
-  if (!console_message.empty())
-    LOG(ERROR) << console_message;
-
-  return handle;
-}
-
-void TraceLog::AddMetadataEvent(
-    const unsigned char* category_group_enabled,
-    const char* name,
-    int num_args,
-    const char* const* arg_names,
-    const unsigned char* arg_types,
-    const unsigned long long* arg_values,
-    std::unique_ptr<ConvertableToTraceFormat>* convertable_values,
-    unsigned int flags) {
-  HEAP_PROFILER_SCOPED_IGNORE;
-  std::unique_ptr<TraceEvent> trace_event(new TraceEvent);
-  int thread_id = static_cast<int>(base::PlatformThread::CurrentId());
-  ThreadTicks thread_now = ThreadNow();
-  TimeTicks now = OffsetNow();
-  AutoLock lock(lock_);
-  trace_event->Initialize(
-      thread_id, now, thread_now, TRACE_EVENT_PHASE_METADATA,
-      category_group_enabled, name,
-      trace_event_internal::kGlobalScope,  // scope
-      trace_event_internal::kNoId,         // id
-      trace_event_internal::kNoId,         // bind_id
-      num_args, arg_names, arg_types, arg_values, convertable_values, flags);
-  metadata_events_.push_back(std::move(trace_event));
-}
-
-// May be called when a COMPELETE event ends and the unfinished event has been
-// recycled (phase == TRACE_EVENT_PHASE_END and trace_event == NULL).
-std::string TraceLog::EventToConsoleMessage(unsigned char phase,
-                                            const TimeTicks& timestamp,
-                                            TraceEvent* trace_event) {
-  HEAP_PROFILER_SCOPED_IGNORE;
-  AutoLock thread_info_lock(thread_info_lock_);
-
-  // The caller should translate TRACE_EVENT_PHASE_COMPLETE to
-  // TRACE_EVENT_PHASE_BEGIN or TRACE_EVENT_END.
-  DCHECK(phase != TRACE_EVENT_PHASE_COMPLETE);
-
-  TimeDelta duration;
-  int thread_id =
-      trace_event ? trace_event->thread_id() : PlatformThread::CurrentId();
-  if (phase == TRACE_EVENT_PHASE_END) {
-    duration = timestamp - thread_event_start_times_[thread_id].top();
-    thread_event_start_times_[thread_id].pop();
-  }
-
-  std::string thread_name = thread_names_[thread_id];
-  if (thread_colors_.find(thread_name) == thread_colors_.end()) {
-    size_t next_color = (thread_colors_.size() % 6) + 1;
-    thread_colors_[thread_name] = next_color;
-  }
-
-  std::ostringstream log;
-  log << base::StringPrintf("%s: \x1b[0;3%dm", thread_name.c_str(),
-                            thread_colors_[thread_name]);
-
-  size_t depth = 0;
-  auto it = thread_event_start_times_.find(thread_id);
-  if (it != thread_event_start_times_.end())
-    depth = it->second.size();
-
-  for (size_t i = 0; i < depth; ++i)
-    log << "| ";
-
-  if (trace_event)
-    trace_event->AppendPrettyPrinted(&log);
-  if (phase == TRACE_EVENT_PHASE_END)
-    log << base::StringPrintf(" (%.3f ms)", duration.InMillisecondsF());
-
-  log << "\x1b[0;m";
-
-  if (phase == TRACE_EVENT_PHASE_BEGIN)
-    thread_event_start_times_[thread_id].push(timestamp);
-
-  return log.str();
-}
-
-void TraceLog::EndFilteredEvent(const unsigned char* category_group_enabled,
-                                const char* name,
-                                TraceEventHandle handle) {
-  const char* category_name = GetCategoryGroupName(category_group_enabled);
-  ForEachCategoryFilter(
-      category_group_enabled,
-      [name, category_name](TraceEventFilter* trace_event_filter) {
-        trace_event_filter->EndEvent(category_name, name);
-      });
-}
-
-void TraceLog::UpdateTraceEventDuration(
-    const unsigned char* category_group_enabled,
-    const char* name,
-    TraceEventHandle handle) {
-  char category_group_enabled_local = *category_group_enabled;
-  if (!category_group_enabled_local)
-    return;
-
-  UpdateTraceEventDurationExplicit(category_group_enabled, name, handle,
-                                   OffsetNow(), ThreadNow());
-}
-
-void TraceLog::UpdateTraceEventDurationExplicit(
-    const unsigned char* category_group_enabled,
-    const char* name,
-    TraceEventHandle handle,
-    const TimeTicks& now,
-    const ThreadTicks& thread_now) {
-  char category_group_enabled_local = *category_group_enabled;
-  if (!category_group_enabled_local)
-    return;
-
-  // Avoid re-entrance of AddTraceEvent. This may happen in GPU process when
-  // ECHO_TO_CONSOLE is enabled: AddTraceEvent -> LOG(ERROR) ->
-  // GpuProcessLogMessageHandler -> PostPendingTask -> TRACE_EVENT ...
-  if (thread_is_in_trace_event_.Get())
-    return;
-  AutoThreadLocalBoolean thread_is_in_trace_event(&thread_is_in_trace_event_);
-
-  std::string console_message;
-  if (category_group_enabled_local & TraceCategory::ENABLED_FOR_RECORDING) {
-    AddTraceEventOverrideCallback trace_event_override =
-        reinterpret_cast<AddTraceEventOverrideCallback>(
-            subtle::NoBarrier_Load(&trace_event_override_));
-
-    // If we send events off to an override instead of the TraceBuffer,
-    // we don't have way of updating the prior event so we'll emit a
-    // separate _END event instead.
-    if (trace_event_override) {
-      TraceEvent new_trace_event;
-      new_trace_event.Initialize(
-          static_cast<int>(base::PlatformThread::CurrentId()), now, thread_now,
-          TRACE_EVENT_PHASE_END, category_group_enabled, name,
-          trace_event_internal::kGlobalScope,
-          trace_event_internal::kNoId /* id */,
-          trace_event_internal::kNoId /* bind_id */, 0, nullptr, nullptr,
-          nullptr, nullptr, TRACE_EVENT_FLAG_NONE);
-      trace_event_override(new_trace_event);
-      return;
-    }
-
-    OptionalAutoLock lock(&lock_);
-
-    TraceEvent* trace_event = GetEventByHandleInternal(handle, &lock);
-    if (trace_event) {
-      DCHECK(trace_event->phase() == TRACE_EVENT_PHASE_COMPLETE);
-      // TEMP(oysteine) to debug crbug.com/638744
-      if (trace_event->duration().ToInternalValue() != -1) {
-        DVLOG(1) << "TraceHandle: chunk_seq " << handle.chunk_seq
-                 << ", chunk_index " << handle.chunk_index << ", event_index "
-                 << handle.event_index;
-
-        std::string serialized_event;
-        trace_event->AppendAsJSON(&serialized_event, ArgumentFilterPredicate());
-        DVLOG(1) << "TraceEvent: " << serialized_event;
-        lock_.AssertAcquired();
-      }
-
-      trace_event->UpdateDuration(now, thread_now);
-#if defined(OS_ANDROID)
-      trace_event->SendToATrace();
-#endif
-    }
-
-    if (trace_options() & kInternalEchoToConsole) {
-      console_message =
-          EventToConsoleMessage(TRACE_EVENT_PHASE_END, now, trace_event);
-    }
-  }
-
-  if (!console_message.empty())
-    LOG(ERROR) << console_message;
-
-  if (category_group_enabled_local & TraceCategory::ENABLED_FOR_FILTERING)
-    EndFilteredEvent(category_group_enabled, name, handle);
-}
-
-uint64_t TraceLog::MangleEventId(uint64_t id) {
-  return id ^ process_id_hash_;
-}
-
-void TraceLog::AddMetadataEventsWhileLocked() {
-  lock_.AssertAcquired();
-
-  // Move metadata added by |AddMetadataEvent| into the trace log.
-  while (!metadata_events_.empty()) {
-    TraceEvent* event = AddEventToThreadSharedChunkWhileLocked(nullptr, false);
-    event->MoveFrom(std::move(metadata_events_.back()));
-    metadata_events_.pop_back();
-  }
-
-#if !defined(OS_NACL)  // NaCl shouldn't expose the process id.
-  InitializeMetadataEvent(
-      AddEventToThreadSharedChunkWhileLocked(nullptr, false), 0, "num_cpus",
-      "number", base::SysInfo::NumberOfProcessors());
-#endif
-
-  int current_thread_id = static_cast<int>(base::PlatformThread::CurrentId());
-  if (process_sort_index_ != 0) {
-    InitializeMetadataEvent(
-        AddEventToThreadSharedChunkWhileLocked(nullptr, false),
-        current_thread_id, "process_sort_index", "sort_index",
-        process_sort_index_);
-  }
-
-  if (!process_name_.empty()) {
-    InitializeMetadataEvent(
-        AddEventToThreadSharedChunkWhileLocked(nullptr, false),
-        current_thread_id, "process_name", "name", process_name_);
-  }
-
-  TimeDelta process_uptime = TRACE_TIME_NOW() - process_creation_time_;
-  InitializeMetadataEvent(
-      AddEventToThreadSharedChunkWhileLocked(nullptr, false), current_thread_id,
-      "process_uptime_seconds", "uptime", process_uptime.InSeconds());
-
-#if defined(OS_ANDROID)
-  InitializeMetadataEvent(
-      AddEventToThreadSharedChunkWhileLocked(nullptr, false), current_thread_id,
-      "chrome_library_address", "start_address",
-      base::StringPrintf("%p", &__executable_start));
-#endif
-
-  if (!process_labels_.empty()) {
-    std::vector<base::StringPiece> labels;
-    for (const auto& it : process_labels_)
-      labels.push_back(it.second);
-    InitializeMetadataEvent(
-        AddEventToThreadSharedChunkWhileLocked(nullptr, false),
-        current_thread_id, "process_labels", "labels",
-        base::JoinString(labels, ","));
-  }
-
-  // Thread sort indices.
-  for (const auto& it : thread_sort_indices_) {
-    if (it.second == 0)
-      continue;
-    InitializeMetadataEvent(
-        AddEventToThreadSharedChunkWhileLocked(nullptr, false), it.first,
-        "thread_sort_index", "sort_index", it.second);
-  }
-
-  // Thread names.
-  AutoLock thread_info_lock(thread_info_lock_);
-  for (const auto& it : thread_names_) {
-    if (it.second.empty())
-      continue;
-    InitializeMetadataEvent(
-        AddEventToThreadSharedChunkWhileLocked(nullptr, false), it.first,
-        "thread_name", "name", it.second);
-  }
-
-  // If buffer is full, add a metadata record to report this.
-  if (!buffer_limit_reached_timestamp_.is_null()) {
-    InitializeMetadataEvent(
-        AddEventToThreadSharedChunkWhileLocked(nullptr, false),
-        current_thread_id, "trace_buffer_overflowed", "overflowed_at_ts",
-        buffer_limit_reached_timestamp_);
-  }
-}
-
-TraceEvent* TraceLog::GetEventByHandle(TraceEventHandle handle) {
-  return GetEventByHandleInternal(handle, nullptr);
-}
-
-TraceEvent* TraceLog::GetEventByHandleInternal(TraceEventHandle handle,
-                                               OptionalAutoLock* lock) {
-  if (!handle.chunk_seq)
-    return nullptr;
-
-  DCHECK(handle.chunk_seq);
-  DCHECK(handle.chunk_index <= TraceBufferChunk::kMaxChunkIndex);
-  DCHECK(handle.event_index <= TraceBufferChunk::kTraceBufferChunkSize - 1);
-
-  if (thread_local_event_buffer_.Get()) {
-    TraceEvent* trace_event =
-        thread_local_event_buffer_.Get()->GetEventByHandle(handle);
-    if (trace_event)
-      return trace_event;
-  }
-
-  // The event has been out-of-control of the thread local buffer.
-  // Try to get the event from the main buffer with a lock.
-  if (lock)
-    lock->EnsureAcquired();
-
-  if (thread_shared_chunk_ &&
-      handle.chunk_index == thread_shared_chunk_index_) {
-    return handle.chunk_seq == thread_shared_chunk_->seq()
-               ? thread_shared_chunk_->GetEventAt(handle.event_index)
-               : nullptr;
-  }
-
-  return logged_events_->GetEventByHandle(handle);
-}
-
-void TraceLog::SetProcessID(int process_id) {
-  process_id_ = process_id;
-  // Create a FNV hash from the process ID for XORing.
-  // See http://isthe.com/chongo/tech/comp/fnv/ for algorithm details.
-  const unsigned long long kOffsetBasis = 14695981039346656037ull;
-  const unsigned long long kFnvPrime = 1099511628211ull;
-  const unsigned long long pid = static_cast<unsigned long long>(process_id_);
-  process_id_hash_ = (kOffsetBasis ^ pid) * kFnvPrime;
-}
-
-void TraceLog::SetProcessSortIndex(int sort_index) {
-  AutoLock lock(lock_);
-  process_sort_index_ = sort_index;
-}
-
-void TraceLog::UpdateProcessLabel(int label_id,
-                                  const std::string& current_label) {
-  if (!current_label.length())
-    return RemoveProcessLabel(label_id);
-
-  AutoLock lock(lock_);
-  process_labels_[label_id] = current_label;
-}
-
-void TraceLog::RemoveProcessLabel(int label_id) {
-  AutoLock lock(lock_);
-  process_labels_.erase(label_id);
-}
-
-void TraceLog::SetThreadSortIndex(PlatformThreadId thread_id, int sort_index) {
-  AutoLock lock(lock_);
-  thread_sort_indices_[static_cast<int>(thread_id)] = sort_index;
-}
-
-void TraceLog::SetTimeOffset(TimeDelta offset) {
-  time_offset_ = offset;
-}
-
-size_t TraceLog::GetObserverCountForTest() const {
-  return enabled_state_observer_list_.size();
-}
-
-void TraceLog::SetCurrentThreadBlocksMessageLoop() {
-  thread_blocks_message_loop_.Set(true);
-  // This will flush the thread local buffer.
-  delete thread_local_event_buffer_.Get();
-}
-
-TraceBuffer* TraceLog::CreateTraceBuffer() {
-  HEAP_PROFILER_SCOPED_IGNORE;
-  InternalTraceOptions options = trace_options();
-  if (options & kInternalRecordContinuously) {
-    return TraceBuffer::CreateTraceBufferRingBuffer(
-        kTraceEventRingBufferChunks);
-  }
-  if (options & kInternalEchoToConsole) {
-    return TraceBuffer::CreateTraceBufferRingBuffer(
-        kEchoToConsoleTraceEventBufferChunks);
-  }
-  if (options & kInternalRecordAsMuchAsPossible) {
-    return TraceBuffer::CreateTraceBufferVectorOfSize(
-        kTraceEventVectorBigBufferChunks);
-  }
-  return TraceBuffer::CreateTraceBufferVectorOfSize(
-      kTraceEventVectorBufferChunks);
-}
-
-void TraceLog::SetTraceBufferForTesting(
-    std::unique_ptr<TraceBuffer> trace_buffer) {
-  AutoLock lock(lock_);
-  logged_events_ = std::move(trace_buffer);
-}
-
-void ConvertableToTraceFormat::EstimateTraceMemoryOverhead(
-    TraceEventMemoryOverhead* overhead) {
-  overhead->Add(TraceEventMemoryOverhead::kConvertableToTraceFormat,
-                sizeof(*this));
-}
-
-void TraceLog::AddAsyncEnabledStateObserver(
-    WeakPtr<AsyncEnabledStateObserver> listener) {
-  AutoLock lock(lock_);
-  async_observers_.insert(
-      std::make_pair(listener.get(), RegisteredAsyncObserver(listener)));
-}
-
-void TraceLog::RemoveAsyncEnabledStateObserver(
-    AsyncEnabledStateObserver* listener) {
-  AutoLock lock(lock_);
-  async_observers_.erase(listener);
-}
-
-bool TraceLog::HasAsyncEnabledStateObserver(
-    AsyncEnabledStateObserver* listener) const {
-  AutoLock lock(lock_);
-  return ContainsKey(async_observers_, listener);
-}
-
-}  // namespace trace_event
-}  // namespace base
-
-namespace trace_event_internal {
-
-ScopedTraceBinaryEfficient::ScopedTraceBinaryEfficient(
-    const char* category_group,
-    const char* name) {
-  // The single atom works because for now the category_group can only be "gpu".
-  DCHECK_EQ(strcmp(category_group, "gpu"), 0);
-  static TRACE_EVENT_API_ATOMIC_WORD atomic = 0;
-  INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO_CUSTOM_VARIABLES(
-      category_group, atomic, category_group_enabled_);
-  name_ = name;
-  if (*category_group_enabled_) {
-    event_handle_ =
-        TRACE_EVENT_API_ADD_TRACE_EVENT_WITH_THREAD_ID_AND_TIMESTAMP(
-            TRACE_EVENT_PHASE_COMPLETE, category_group_enabled_, name,
-            trace_event_internal::kGlobalScope,                   // scope
-            trace_event_internal::kNoId,                          // id
-            static_cast<int>(base::PlatformThread::CurrentId()),  // thread_id
-            TRACE_TIME_TICKS_NOW(), trace_event_internal::kZeroNumArgs, nullptr,
-            nullptr, nullptr, nullptr, TRACE_EVENT_FLAG_NONE);
-  }
-}
-
-ScopedTraceBinaryEfficient::~ScopedTraceBinaryEfficient() {
-  if (*category_group_enabled_) {
-    TRACE_EVENT_API_UPDATE_TRACE_EVENT_DURATION(category_group_enabled_, name_,
-                                                event_handle_);
-  }
-}
-
-}  // namespace trace_event_internal
diff --git a/base/trace_event/trace_log.h b/base/trace_event/trace_log.h
deleted file mode 100644
index e480323..0000000
--- a/base/trace_event/trace_log.h
+++ /dev/null
@@ -1,521 +0,0 @@
-// Copyright 2015 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_TRACE_EVENT_TRACE_LOG_H_
-#define BASE_TRACE_EVENT_TRACE_LOG_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-#include <memory>
-#include <string>
-#include <unordered_map>
-#include <vector>
-
-#include "base/atomicops.h"
-#include "base/containers/stack.h"
-#include "base/gtest_prod_util.h"
-#include "base/macros.h"
-#include "base/time/time_override.h"
-#include "base/trace_event/memory_dump_provider.h"
-#include "base/trace_event/trace_config.h"
-#include "base/trace_event/trace_event_impl.h"
-#include "build_config.h"
-
-namespace base {
-
-class MessageLoop;
-class RefCountedString;
-
-template <typename T>
-class NoDestructor;
-
-namespace trace_event {
-
-struct TraceCategory;
-class TraceBuffer;
-class TraceBufferChunk;
-class TraceEvent;
-class TraceEventFilter;
-class TraceEventMemoryOverhead;
-
-struct BASE_EXPORT TraceLogStatus {
-  TraceLogStatus();
-  ~TraceLogStatus();
-  uint32_t event_capacity;
-  uint32_t event_count;
-};
-
-class BASE_EXPORT TraceLog : public MemoryDumpProvider {
- public:
-  // Argument passed to TraceLog::SetEnabled.
-  enum Mode : uint8_t {
-    // Enables normal tracing (recording trace events in the trace buffer).
-    RECORDING_MODE = 1 << 0,
-
-    // Trace events are enabled just for filtering but not for recording. Only
-    // event filters config of |trace_config| argument is used.
-    FILTERING_MODE = 1 << 1
-  };
-
-  static TraceLog* GetInstance();
-
-  // Get set of known category groups. This can change as new code paths are
-  // reached. The known category groups are inserted into |category_groups|.
-  void GetKnownCategoryGroups(std::vector<std::string>* category_groups);
-
-  // Retrieves a copy (for thread-safety) of the current TraceConfig.
-  TraceConfig GetCurrentTraceConfig() const;
-
-  // Initializes the thread-local event buffer, if not already initialized and
-  // if the current thread supports that (has a message loop).
-  void InitializeThreadLocalEventBufferIfSupported();
-
-  // See TraceConfig comments for details on how to control which categories
-  // will be traced. SetDisabled must be called distinctly for each mode that is
-  // enabled. If tracing has already been enabled for recording, category filter
-  // (enabled and disabled categories) will be merged into the current category
-  // filter. Enabling RECORDING_MODE does not enable filters. Trace event
-  // filters will be used only if FILTERING_MODE is set on |modes_to_enable|.
-  // Conversely to RECORDING_MODE, FILTERING_MODE doesn't support upgrading,
-  // i.e. filters can only be enabled if not previously enabled.
-  void SetEnabled(const TraceConfig& trace_config, uint8_t modes_to_enable);
-
-  // TODO(ssid): Remove the default SetEnabled and IsEnabled. They should take
-  // Mode as argument.
-
-  // Disables tracing for all categories for the specified |modes_to_disable|
-  // only. Only RECORDING_MODE is taken as default |modes_to_disable|.
-  void SetDisabled();
-  void SetDisabled(uint8_t modes_to_disable);
-
-  // Returns true if TraceLog is enabled on recording mode.
-  // Note: Returns false even if FILTERING_MODE is enabled.
-  bool IsEnabled() { return enabled_modes_ & RECORDING_MODE; }
-
-  // Returns a bitmap of enabled modes from TraceLog::Mode.
-  uint8_t enabled_modes() { return enabled_modes_; }
-
-  // The number of times we have begun recording traces. If tracing is off,
-  // returns -1. If tracing is on, then it returns the number of times we have
-  // recorded a trace. By watching for this number to increment, you can
-  // passively discover when a new trace has begun. This is then used to
-  // implement the TRACE_EVENT_IS_NEW_TRACE() primitive.
-  int GetNumTracesRecorded();
-
-#if defined(OS_ANDROID)
-  void StartATrace();
-  void StopATrace();
-  void AddClockSyncMetadataEvent();
-#endif
-
-  // Enabled state listeners give a callback when tracing is enabled or
-  // disabled. This can be used to tie into other library's tracing systems
-  // on-demand.
-  class BASE_EXPORT EnabledStateObserver {
-   public:
-    virtual ~EnabledStateObserver() = default;
-
-    // Called just after the tracing system becomes enabled, outside of the
-    // |lock_|. TraceLog::IsEnabled() is true at this point.
-    virtual void OnTraceLogEnabled() = 0;
-
-    // Called just after the tracing system disables, outside of the |lock_|.
-    // TraceLog::IsEnabled() is false at this point.
-    virtual void OnTraceLogDisabled() = 0;
-  };
-  void AddEnabledStateObserver(EnabledStateObserver* listener);
-  void RemoveEnabledStateObserver(EnabledStateObserver* listener);
-  bool HasEnabledStateObserver(EnabledStateObserver* listener) const;
-
-  // Asynchronous enabled state listeners. When tracing is enabled or disabled,
-  // for each observer, a task for invoking its appropriate callback is posted
-  // to the thread from which AddAsyncEnabledStateObserver() was called. This
-  // allows the observer to be safely destroyed, provided that it happens on the
-  // same thread that invoked AddAsyncEnabledStateObserver().
-  class BASE_EXPORT AsyncEnabledStateObserver {
-   public:
-    virtual ~AsyncEnabledStateObserver() = default;
-
-    // Posted just after the tracing system becomes enabled, outside |lock_|.
-    // TraceLog::IsEnabled() is true at this point.
-    virtual void OnTraceLogEnabled() = 0;
-
-    // Posted just after the tracing system becomes disabled, outside |lock_|.
-    // TraceLog::IsEnabled() is false at this point.
-    virtual void OnTraceLogDisabled() = 0;
-  };
-  void AddAsyncEnabledStateObserver(
-      WeakPtr<AsyncEnabledStateObserver> listener);
-  void RemoveAsyncEnabledStateObserver(AsyncEnabledStateObserver* listener);
-  bool HasAsyncEnabledStateObserver(AsyncEnabledStateObserver* listener) const;
-
-  TraceLogStatus GetStatus() const;
-  bool BufferIsFull() const;
-
-  // Computes an estimate of the size of the TraceLog including all the retained
-  // objects.
-  void EstimateTraceMemoryOverhead(TraceEventMemoryOverhead* overhead);
-
-  void SetArgumentFilterPredicate(
-      const ArgumentFilterPredicate& argument_filter_predicate);
-
-  // Flush all collected events to the given output callback. The callback will
-  // be called one or more times either synchronously or asynchronously from
-  // the current thread with IPC-bite-size chunks. The string format is
-  // undefined. Use TraceResultBuffer to convert one or more trace strings to
-  // JSON. The callback can be null if the caller doesn't want any data.
-  // Due to the implementation of thread-local buffers, flush can't be
-  // done when tracing is enabled. If called when tracing is enabled, the
-  // callback will be called directly with (empty_string, false) to indicate
-  // the end of this unsuccessful flush. Flush does the serialization
-  // on the same thread if the caller doesn't set use_worker_thread explicitly.
-  typedef base::Callback<void(const scoped_refptr<base::RefCountedString>&,
-                              bool has_more_events)> OutputCallback;
-  void Flush(const OutputCallback& cb, bool use_worker_thread = false);
-
-  // Cancels tracing and discards collected data.
-  void CancelTracing(const OutputCallback& cb);
-
-  typedef void (*AddTraceEventOverrideCallback)(const TraceEvent&);
-  // The callback will be called up until the point where the flush is
-  // finished, i.e. must be callable until OutputCallback is called with
-  // has_more_events==false.
-  void SetAddTraceEventOverride(const AddTraceEventOverrideCallback& override);
-
-  // Called by TRACE_EVENT* macros, don't call this directly.
-  // The name parameter is a category group for example:
-  // TRACE_EVENT0("renderer,webkit", "WebViewImpl::HandleInputEvent")
-  static const unsigned char* GetCategoryGroupEnabled(const char* name);
-  static const char* GetCategoryGroupName(
-      const unsigned char* category_group_enabled);
-
-  // Called by TRACE_EVENT* macros, don't call this directly.
-  // If |copy| is set, |name|, |arg_name1| and |arg_name2| will be deep copied
-  // into the event; see "Memory scoping note" and TRACE_EVENT_COPY_XXX above.
-  TraceEventHandle AddTraceEvent(
-      char phase,
-      const unsigned char* category_group_enabled,
-      const char* name,
-      const char* scope,
-      unsigned long long id,
-      int num_args,
-      const char* const* arg_names,
-      const unsigned char* arg_types,
-      const unsigned long long* arg_values,
-      std::unique_ptr<ConvertableToTraceFormat>* convertable_values,
-      unsigned int flags);
-  TraceEventHandle AddTraceEventWithBindId(
-      char phase,
-      const unsigned char* category_group_enabled,
-      const char* name,
-      const char* scope,
-      unsigned long long id,
-      unsigned long long bind_id,
-      int num_args,
-      const char* const* arg_names,
-      const unsigned char* arg_types,
-      const unsigned long long* arg_values,
-      std::unique_ptr<ConvertableToTraceFormat>* convertable_values,
-      unsigned int flags);
-  TraceEventHandle AddTraceEventWithProcessId(
-      char phase,
-      const unsigned char* category_group_enabled,
-      const char* name,
-      const char* scope,
-      unsigned long long id,
-      int process_id,
-      int num_args,
-      const char* const* arg_names,
-      const unsigned char* arg_types,
-      const unsigned long long* arg_values,
-      std::unique_ptr<ConvertableToTraceFormat>* convertable_values,
-      unsigned int flags);
-  TraceEventHandle AddTraceEventWithThreadIdAndTimestamp(
-      char phase,
-      const unsigned char* category_group_enabled,
-      const char* name,
-      const char* scope,
-      unsigned long long id,
-      int thread_id,
-      const TimeTicks& timestamp,
-      int num_args,
-      const char* const* arg_names,
-      const unsigned char* arg_types,
-      const unsigned long long* arg_values,
-      std::unique_ptr<ConvertableToTraceFormat>* convertable_values,
-      unsigned int flags);
-  TraceEventHandle AddTraceEventWithThreadIdAndTimestamp(
-      char phase,
-      const unsigned char* category_group_enabled,
-      const char* name,
-      const char* scope,
-      unsigned long long id,
-      unsigned long long bind_id,
-      int thread_id,
-      const TimeTicks& timestamp,
-      int num_args,
-      const char* const* arg_names,
-      const unsigned char* arg_types,
-      const unsigned long long* arg_values,
-      std::unique_ptr<ConvertableToTraceFormat>* convertable_values,
-      unsigned int flags);
-
-  // Adds a metadata event that will be written when the trace log is flushed.
-  void AddMetadataEvent(
-      const unsigned char* category_group_enabled,
-      const char* name,
-      int num_args,
-      const char* const* arg_names,
-      const unsigned char* arg_types,
-      const unsigned long long* arg_values,
-      std::unique_ptr<ConvertableToTraceFormat>* convertable_values,
-      unsigned int flags);
-
-  void UpdateTraceEventDuration(const unsigned char* category_group_enabled,
-                                const char* name,
-                                TraceEventHandle handle);
-
-  void UpdateTraceEventDurationExplicit(
-      const unsigned char* category_group_enabled,
-      const char* name,
-      TraceEventHandle handle,
-      const TimeTicks& now,
-      const ThreadTicks& thread_now);
-
-  void EndFilteredEvent(const unsigned char* category_group_enabled,
-                        const char* name,
-                        TraceEventHandle handle);
-
-  int process_id() const { return process_id_; }
-
-  uint64_t MangleEventId(uint64_t id);
-
-  // Exposed for unittesting:
-
-  // Testing factory for TraceEventFilter.
-  typedef std::unique_ptr<TraceEventFilter> (*FilterFactoryForTesting)(
-      const std::string& /* predicate_name */);
-  void SetFilterFactoryForTesting(FilterFactoryForTesting factory) {
-    filter_factory_for_testing_ = factory;
-  }
-
-  // Allows clearing up our singleton instance.
-  static void ResetForTesting();
-
-  // Allow tests to inspect TraceEvents.
-  TraceEvent* GetEventByHandle(TraceEventHandle handle);
-
-  void SetProcessID(int process_id);
-
-  // Process sort indices, if set, override the order of a process will appear
-  // relative to other processes in the trace viewer. Processes are sorted first
-  // on their sort index, ascending, then by their name, and then tid.
-  void SetProcessSortIndex(int sort_index);
-
-  // Sets the name of the process.
-  void set_process_name(const std::string& process_name) {
-    AutoLock lock(lock_);
-    process_name_ = process_name;
-  }
-
-  bool IsProcessNameEmpty() const { return process_name_.empty(); }
-
-  // Processes can have labels in addition to their names. Use labels, for
-  // instance, to list out the web page titles that a process is handling.
-  void UpdateProcessLabel(int label_id, const std::string& current_label);
-  void RemoveProcessLabel(int label_id);
-
-  // Thread sort indices, if set, override the order of a thread will appear
-  // within its process in the trace viewer. Threads are sorted first on their
-  // sort index, ascending, then by their name, and then tid.
-  void SetThreadSortIndex(PlatformThreadId thread_id, int sort_index);
-
-  // Allow setting an offset between the current TimeTicks time and the time
-  // that should be reported.
-  void SetTimeOffset(TimeDelta offset);
-
-  size_t GetObserverCountForTest() const;
-
-  // Call this method if the current thread may block the message loop to
-  // prevent the thread from using the thread-local buffer because the thread
-  // may not handle the flush request in time causing lost of unflushed events.
-  void SetCurrentThreadBlocksMessageLoop();
-
-  // Replaces |logged_events_| with a new TraceBuffer for testing.
-  void SetTraceBufferForTesting(std::unique_ptr<TraceBuffer> trace_buffer);
-
- private:
-  typedef unsigned int InternalTraceOptions;
-
-  FRIEND_TEST_ALL_PREFIXES(TraceEventTestFixture,
-                           TraceBufferRingBufferGetReturnChunk);
-  FRIEND_TEST_ALL_PREFIXES(TraceEventTestFixture,
-                           TraceBufferRingBufferHalfIteration);
-  FRIEND_TEST_ALL_PREFIXES(TraceEventTestFixture,
-                           TraceBufferRingBufferFullIteration);
-  FRIEND_TEST_ALL_PREFIXES(TraceEventTestFixture, TraceBufferVectorReportFull);
-  FRIEND_TEST_ALL_PREFIXES(TraceEventTestFixture,
-                           ConvertTraceConfigToInternalOptions);
-  FRIEND_TEST_ALL_PREFIXES(TraceEventTestFixture,
-                           TraceRecordAsMuchAsPossibleMode);
-
-  friend class base::NoDestructor<TraceLog>;
-
-  // MemoryDumpProvider implementation.
-  bool OnMemoryDump(const MemoryDumpArgs& args,
-                    ProcessMemoryDump* pmd) override;
-
-  // Enable/disable each category group based on the current mode_,
-  // category_filter_ and event_filters_enabled_.
-  // Enable the category group in the recording mode if category_filter_ matches
-  // the category group, is not null. Enable category for filtering if any
-  // filter in event_filters_enabled_ enables it.
-  void UpdateCategoryRegistry();
-  void UpdateCategoryState(TraceCategory* category);
-
-  void CreateFiltersForTraceConfig();
-
-  InternalTraceOptions GetInternalOptionsFromTraceConfig(
-      const TraceConfig& config);
-
-  class ThreadLocalEventBuffer;
-  class OptionalAutoLock;
-  struct RegisteredAsyncObserver;
-
-  TraceLog();
-  ~TraceLog() override;
-  void AddMetadataEventsWhileLocked();
-
-  InternalTraceOptions trace_options() const {
-    return static_cast<InternalTraceOptions>(
-        subtle::NoBarrier_Load(&trace_options_));
-  }
-
-  TraceBuffer* trace_buffer() const { return logged_events_.get(); }
-  TraceBuffer* CreateTraceBuffer();
-
-  std::string EventToConsoleMessage(unsigned char phase,
-                                    const TimeTicks& timestamp,
-                                    TraceEvent* trace_event);
-
-  TraceEvent* AddEventToThreadSharedChunkWhileLocked(TraceEventHandle* handle,
-                                                     bool check_buffer_is_full);
-  void CheckIfBufferIsFullWhileLocked();
-  void SetDisabledWhileLocked(uint8_t modes);
-
-  TraceEvent* GetEventByHandleInternal(TraceEventHandle handle,
-                                       OptionalAutoLock* lock);
-
-  void FlushInternal(const OutputCallback& cb,
-                     bool use_worker_thread,
-                     bool discard_events);
-
-  // |generation| is used in the following callbacks to check if the callback
-  // is called for the flush of the current |logged_events_|.
-  void FlushCurrentThread(int generation, bool discard_events);
-  // Usually it runs on a different thread.
-  static void ConvertTraceEventsToTraceFormat(
-      std::unique_ptr<TraceBuffer> logged_events,
-      const TraceLog::OutputCallback& flush_output_callback,
-      const ArgumentFilterPredicate& argument_filter_predicate);
-  void FinishFlush(int generation, bool discard_events);
-  void OnFlushTimeout(int generation, bool discard_events);
-
-  int generation() const {
-    return static_cast<int>(subtle::NoBarrier_Load(&generation_));
-  }
-  bool CheckGeneration(int generation) const {
-    return generation == this->generation();
-  }
-  void UseNextTraceBuffer();
-
-  TimeTicks OffsetNow() const {
-    // This should be TRACE_TIME_TICKS_NOW but include order makes that hard.
-    return OffsetTimestamp(base::subtle::TimeTicksNowIgnoringOverride());
-  }
-  TimeTicks OffsetTimestamp(const TimeTicks& timestamp) const {
-    return timestamp - time_offset_;
-  }
-
-  // Internal representation of trace options since we store the currently used
-  // trace option as an AtomicWord.
-  static const InternalTraceOptions kInternalNone;
-  static const InternalTraceOptions kInternalRecordUntilFull;
-  static const InternalTraceOptions kInternalRecordContinuously;
-  static const InternalTraceOptions kInternalEchoToConsole;
-  static const InternalTraceOptions kInternalRecordAsMuchAsPossible;
-  static const InternalTraceOptions kInternalEnableArgumentFilter;
-
-  // This lock protects TraceLog member accesses (except for members protected
-  // by thread_info_lock_) from arbitrary threads.
-  mutable Lock lock_;
-  // This lock protects accesses to thread_names_, thread_event_start_times_
-  // and thread_colors_.
-  Lock thread_info_lock_;
-  uint8_t enabled_modes_;  // See TraceLog::Mode.
-  int num_traces_recorded_;
-  std::unique_ptr<TraceBuffer> logged_events_;
-  std::vector<std::unique_ptr<TraceEvent>> metadata_events_;
-  bool dispatching_to_observer_list_;
-  std::vector<EnabledStateObserver*> enabled_state_observer_list_;
-  std::map<AsyncEnabledStateObserver*, RegisteredAsyncObserver>
-      async_observers_;
-
-  std::string process_name_;
-  std::unordered_map<int, std::string> process_labels_;
-  int process_sort_index_;
-  std::unordered_map<int, int> thread_sort_indices_;
-  std::unordered_map<int, std::string> thread_names_;
-  base::Time process_creation_time_;
-
-  // The following two maps are used only when ECHO_TO_CONSOLE.
-  std::unordered_map<int, base::stack<TimeTicks>> thread_event_start_times_;
-  std::unordered_map<std::string, int> thread_colors_;
-
-  TimeTicks buffer_limit_reached_timestamp_;
-
-  // XORed with TraceID to make it unlikely to collide with other processes.
-  unsigned long long process_id_hash_;
-
-  int process_id_;
-
-  TimeDelta time_offset_;
-
-  subtle::AtomicWord /* Options */ trace_options_;
-
-  TraceConfig trace_config_;
-  TraceConfig::EventFilters enabled_event_filters_;
-
-  ThreadLocalPointer<ThreadLocalEventBuffer> thread_local_event_buffer_;
-  ThreadLocalBoolean thread_blocks_message_loop_;
-  ThreadLocalBoolean thread_is_in_trace_event_;
-
-  // Contains the message loops of threads that have had at least one event
-  // added into the local event buffer. Not using SingleThreadTaskRunner
-  // because we need to know the life time of the message loops.
-  hash_set<MessageLoop*> thread_message_loops_;
-
-  // For events which can't be added into the thread local buffer, e.g. events
-  // from threads without a message loop.
-  std::unique_ptr<TraceBufferChunk> thread_shared_chunk_;
-  size_t thread_shared_chunk_index_;
-
-  // Set when asynchronous Flush is in progress.
-  OutputCallback flush_output_callback_;
-  scoped_refptr<SingleThreadTaskRunner> flush_task_runner_;
-  ArgumentFilterPredicate argument_filter_predicate_;
-  subtle::AtomicWord generation_;
-  bool use_worker_thread_;
-  subtle::AtomicWord trace_event_override_;
-
-  FilterFactoryForTesting filter_factory_for_testing_;
-
-  DISALLOW_COPY_AND_ASSIGN(TraceLog);
-};
-
-}  // namespace trace_event
-}  // namespace base
-
-#endif  // BASE_TRACE_EVENT_TRACE_LOG_H_
diff --git a/base/trace_event/trace_log_constants.cc b/base/trace_event/trace_log_constants.cc
deleted file mode 100644
index 65dca2e..0000000
--- a/base/trace_event/trace_log_constants.cc
+++ /dev/null
@@ -1,26 +0,0 @@
-// Copyright (c) 2013 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/trace_event/trace_log.h"
-
-namespace base {
-namespace trace_event {
-
-// Constant used by TraceLog's internal implementation of trace_option.
-const TraceLog::InternalTraceOptions
-    TraceLog::kInternalNone = 0;
-const TraceLog::InternalTraceOptions
-    TraceLog::kInternalRecordUntilFull = 1 << 0;
-const TraceLog::InternalTraceOptions
-    TraceLog::kInternalRecordContinuously = 1 << 1;
-// 1 << 2 is reserved for the DEPRECATED kInternalEnableSampling. DO NOT USE.
-const TraceLog::InternalTraceOptions
-    TraceLog::kInternalEchoToConsole = 1 << 3;
-const TraceLog::InternalTraceOptions
-    TraceLog::kInternalRecordAsMuchAsPossible = 1 << 4;
-const TraceLog::InternalTraceOptions
-    TraceLog::kInternalEnableArgumentFilter = 1 << 5;
-
-}  // namespace trace_event
-}  // namespace base
diff --git a/base/trace_event/tracing_agent.cc b/base/trace_event/tracing_agent.cc
deleted file mode 100644
index e48feff..0000000
--- a/base/trace_event/tracing_agent.cc
+++ /dev/null
@@ -1,24 +0,0 @@
-// Copyright 2015 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/trace_event/tracing_agent.h"
-
-namespace base {
-namespace trace_event {
-
-TracingAgent::~TracingAgent() = default;
-
-bool TracingAgent::SupportsExplicitClockSync() {
-  return false;
-}
-
-void TracingAgent::RecordClockSyncMarker(
-    const std::string& sync_id,
-    RecordClockSyncMarkerCallback callback) {
-  DCHECK(SupportsExplicitClockSync());
-}
-
-
-}  // namespace trace_event
-}  // namespace base
diff --git a/base/trace_event/tracing_agent.h b/base/trace_event/tracing_agent.h
deleted file mode 100644
index f818457..0000000
--- a/base/trace_event/tracing_agent.h
+++ /dev/null
@@ -1,96 +0,0 @@
-// Copyright 2015 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_TRACE_EVENT_TRACING_AGENT_H_
-#define BASE_TRACE_EVENT_TRACING_AGENT_H_
-
-#include "base/base_export.h"
-#include "base/callback.h"
-#include "base/memory/ref_counted_memory.h"
-#include "base/values.h"
-
-namespace base {
-
-class TimeTicks;
-
-namespace trace_event {
-
-class TraceConfig;
-
-// A tracing agent is an entity that records its own sort of trace. Each
-// tracing method that produces its own trace log should implement this
-// interface. All tracing agents must only be controlled by TracingController.
-// Some existing examples include TracingControllerImpl for Chrome trace events,
-// DebugDaemonClient for CrOs system trace, EtwTracingAgent for Windows system
-// trace and PowerTracingAgent for BattOr power trace.
-class BASE_EXPORT TracingAgent {
- public:
-  using StartAgentTracingCallback =
-      base::OnceCallback<void(const std::string& agent_name, bool success)>;
-  // Passing a null or empty events_str_ptr indicates that no trace data is
-  // available for the specified agent.
-  using StopAgentTracingCallback = base::OnceCallback<void(
-      const std::string& agent_name,
-      const std::string& events_label,
-      const scoped_refptr<base::RefCountedString>& events_str_ptr)>;
-  using RecordClockSyncMarkerCallback =
-      base::OnceCallback<void(const std::string& sync_id,
-                              const TimeTicks& issue_ts,
-                              const TimeTicks& issue_end_ts)>;
-
-  virtual ~TracingAgent();
-
-  // Gets the name of the tracing agent. Each tracing agent's name should be
-  // unique.
-  virtual std::string GetTracingAgentName() = 0;
-
-  // Gets the trace event label of this tracing agent. The label will be used to
-  // label this agent's trace when all traces from different tracing agents are
-  // combined. Multiple tracing agents could have the same label. The tracing
-  // agents using the same label should not be able to run at the same time. For
-  // example, ETW on Windows and CrOS system tracing both use
-  // "systemTraceEvents" as the label. Those two agents never run at the same
-  // time because they are for different platforms.
-  virtual std::string GetTraceEventLabel() = 0;
-
-  // Starts tracing on the tracing agent with the trace configuration.
-  virtual void StartAgentTracing(const TraceConfig& trace_config,
-                                 StartAgentTracingCallback callback) = 0;
-
-  // Stops tracing on the tracing agent. The trace data will be passed back to
-  // the TracingController via the callback.
-  virtual void StopAgentTracing(StopAgentTracingCallback callback) = 0;
-
-  // Checks if the tracing agent supports explicit clock synchronization.
-  virtual bool SupportsExplicitClockSync();
-
-  // Records a clock sync marker issued by another tracing agent. This is only
-  // used if the tracing agent supports explicit clock synchronization.
-  //
-  // Two things need to be done:
-  // 1. The issuer asks the receiver to record the clock sync marker.
-  // 2. The issuer records how long the receiver takes to do the recording.
-  //
-  // In Chrome, the receiver thread also runs in Chrome and it will talk to the
-  // real receiver entity, e.g., power monitor or Android device system, via
-  // different communication methods, e.g., through USB or file reading/writing.
-  // The 2nd task measures that communication latency.
-  //
-  // Having a reliable timing measurement for the 2nd task requires synchronous
-  // function call without any cross-thread or cross-process activity. However,
-  // tracing agents in Chrome run in their own threads. Therefore, the issuer
-  // needs to dedicate the 2nd task to the receiver to take time measurements
-  // in the receiver thread, and the receiver thread needs to pass them back to
-  // the issuer in the callback.
-  //
-  // The assumption is that the receiver thread knows the issuer's clock, which
-  // is true in Chrome because all agent threads' clocks are Chrome clock.
-  virtual void RecordClockSyncMarker(const std::string& sync_id,
-                                     RecordClockSyncMarkerCallback callback);
-};
-
-}  // namespace trace_event
-}  // namespace base
-
-#endif  // BASE_TRACE_EVENT_TRACING_AGENT_H_
diff --git a/base/values.cc b/base/values.cc
index 085f0f0..df12c29 100644
--- a/base/values.cc
+++ b/base/values.cc
@@ -18,7 +18,6 @@
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
-#include "base/trace_event/memory_usage_estimator.h"
 
 namespace base {
 
@@ -632,21 +631,6 @@
   return *this == *other;
 }
 
-size_t Value::EstimateMemoryUsage() const {
-  switch (type_) {
-    case Type::STRING:
-      return base::trace_event::EstimateMemoryUsage(string_value_);
-    case Type::BINARY:
-      return base::trace_event::EstimateMemoryUsage(binary_value_);
-    case Type::DICTIONARY:
-      return base::trace_event::EstimateMemoryUsage(dict_);
-    case Type::LIST:
-      return base::trace_event::EstimateMemoryUsage(list_);
-    default:
-      return 0;
-  }
-}
-
 void Value::InternalMoveConstructFrom(Value&& that) {
   type_ = that.type_;
 
diff --git a/build/gen.py b/build/gen.py
index 0534e1a..5b81ca6 100755
--- a/build/gen.py
+++ b/build/gen.py
@@ -370,36 +370,6 @@
         'base/time/time.cc',
         'base/timer/elapsed_timer.cc',
         'base/timer/timer.cc',
-        'base/trace_event/category_registry.cc',
-        'base/trace_event/event_name_filter.cc',
-        'base/trace_event/heap_profiler_allocation_context.cc',
-        'base/trace_event/heap_profiler_allocation_context_tracker.cc',
-        'base/trace_event/heap_profiler_event_filter.cc',
-        'base/trace_event/heap_profiler_heap_dump_writer.cc',
-        'base/trace_event/heap_profiler_serialization_state.cc',
-        'base/trace_event/heap_profiler_stack_frame_deduplicator.cc',
-        'base/trace_event/heap_profiler_type_name_deduplicator.cc',
-        'base/trace_event/malloc_dump_provider.cc',
-        'base/trace_event/memory_allocator_dump.cc',
-        'base/trace_event/memory_allocator_dump_guid.cc',
-        'base/trace_event/memory_dump_manager.cc',
-        'base/trace_event/memory_dump_provider_info.cc',
-        'base/trace_event/memory_dump_request_args.cc',
-        'base/trace_event/memory_dump_scheduler.cc',
-        'base/trace_event/memory_infra_background_whitelist.cc',
-        'base/trace_event/memory_peak_detector.cc',
-        'base/trace_event/memory_usage_estimator.cc',
-        'base/trace_event/process_memory_dump.cc',
-        'base/trace_event/trace_buffer.cc',
-        'base/trace_event/trace_config.cc',
-        'base/trace_event/trace_config_category_filter.cc',
-        'base/trace_event/trace_event_argument.cc',
-        'base/trace_event/trace_event_filter.cc',
-        'base/trace_event/trace_event_impl.cc',
-        'base/trace_event/trace_event_memory_overhead.cc',
-        'base/trace_event/trace_log.cc',
-        'base/trace_event/trace_log_constants.cc',
-        'base/trace_event/tracing_agent.cc',
         'base/unguessable_token.cc',
         'base/value_iterators.cc',
         'base/values.cc',