diff --git a/base/debug/OWNERS b/base/debug/OWNERS
deleted file mode 100644
index 6150257..0000000
--- a/base/debug/OWNERS
+++ /dev/null
@@ -1,2 +0,0 @@
-# For activity tracking:
-per-file activity_*=bcwhite@chromium.org
diff --git a/base/debug/activity_analyzer.cc b/base/debug/activity_analyzer.cc
deleted file mode 100644
index d787829..0000000
--- a/base/debug/activity_analyzer.cc
+++ /dev/null
@@ -1,412 +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/debug/activity_analyzer.h"
-
-#include <algorithm>
-#include <utility>
-
-#include "base/files/file.h"
-#include "base/files/file_path.h"
-#include "base/files/memory_mapped_file.h"
-#include "base/lazy_instance.h"
-#include "base/logging.h"
-#include "base/memory/ptr_util.h"
-#include "base/metrics/histogram_macros.h"
-#include "base/stl_util.h"
-#include "base/strings/string_util.h"
-
-namespace base {
-namespace debug {
-
-namespace {
-// An empty snapshot that can be returned when there otherwise is none.
-LazyInstance<ActivityUserData::Snapshot>::Leaky g_empty_user_data_snapshot;
-
-// DO NOT CHANGE VALUES. This is logged persistently in a histogram.
-enum AnalyzerCreationError {
-  kInvalidMemoryMappedFile,
-  kPmaBadFile,
-  kPmaUninitialized,
-  kPmaDeleted,
-  kPmaCorrupt,
-  kAnalyzerCreationErrorMax  // Keep this last.
-};
-
-void LogAnalyzerCreationError(AnalyzerCreationError error) {
-  UMA_HISTOGRAM_ENUMERATION("ActivityTracker.Collect.AnalyzerCreationError",
-                            error, kAnalyzerCreationErrorMax);
-}
-
-}  // namespace
-
-ThreadActivityAnalyzer::Snapshot::Snapshot() = default;
-ThreadActivityAnalyzer::Snapshot::~Snapshot() = default;
-
-ThreadActivityAnalyzer::ThreadActivityAnalyzer(
-    const ThreadActivityTracker& tracker)
-    : activity_snapshot_valid_(tracker.CreateSnapshot(&activity_snapshot_)) {}
-
-ThreadActivityAnalyzer::ThreadActivityAnalyzer(void* base, size_t size)
-    : ThreadActivityAnalyzer(ThreadActivityTracker(base, size)) {}
-
-ThreadActivityAnalyzer::ThreadActivityAnalyzer(
-    PersistentMemoryAllocator* allocator,
-    PersistentMemoryAllocator::Reference reference)
-    : ThreadActivityAnalyzer(allocator->GetAsArray<char>(
-                                 reference,
-                                 GlobalActivityTracker::kTypeIdActivityTracker,
-                                 PersistentMemoryAllocator::kSizeAny),
-                             allocator->GetAllocSize(reference)) {}
-
-ThreadActivityAnalyzer::~ThreadActivityAnalyzer() = default;
-
-void ThreadActivityAnalyzer::AddGlobalInformation(
-    GlobalActivityAnalyzer* global) {
-  if (!IsValid())
-    return;
-
-  // User-data is held at the global scope even though it's referenced at the
-  // thread scope.
-  activity_snapshot_.user_data_stack.clear();
-  for (auto& activity : activity_snapshot_.activity_stack) {
-    // The global GetUserDataSnapshot will return an empty snapshot if the ref
-    // or id is not valid.
-    activity_snapshot_.user_data_stack.push_back(global->GetUserDataSnapshot(
-        activity_snapshot_.process_id, activity.user_data_ref,
-        activity.user_data_id));
-  }
-}
-
-GlobalActivityAnalyzer::GlobalActivityAnalyzer(
-    std::unique_ptr<PersistentMemoryAllocator> allocator)
-    : allocator_(std::move(allocator)),
-      analysis_stamp_(0LL),
-      allocator_iterator_(allocator_.get()) {
-  DCHECK(allocator_);
-}
-
-GlobalActivityAnalyzer::~GlobalActivityAnalyzer() = default;
-
-// static
-std::unique_ptr<GlobalActivityAnalyzer>
-GlobalActivityAnalyzer::CreateWithAllocator(
-    std::unique_ptr<PersistentMemoryAllocator> allocator) {
-  if (allocator->GetMemoryState() ==
-      PersistentMemoryAllocator::MEMORY_UNINITIALIZED) {
-    LogAnalyzerCreationError(kPmaUninitialized);
-    return nullptr;
-  }
-  if (allocator->GetMemoryState() ==
-      PersistentMemoryAllocator::MEMORY_DELETED) {
-    LogAnalyzerCreationError(kPmaDeleted);
-    return nullptr;
-  }
-  if (allocator->IsCorrupt()) {
-    LogAnalyzerCreationError(kPmaCorrupt);
-    return nullptr;
-  }
-
-  return WrapUnique(new GlobalActivityAnalyzer(std::move(allocator)));
-}
-
-#if !defined(OS_NACL)
-// static
-std::unique_ptr<GlobalActivityAnalyzer> GlobalActivityAnalyzer::CreateWithFile(
-    const FilePath& file_path) {
-  // Map the file read-write so it can guarantee consistency between
-  // the analyzer and any trackers that my still be active.
-  std::unique_ptr<MemoryMappedFile> mmfile(new MemoryMappedFile());
-  mmfile->Initialize(file_path, MemoryMappedFile::READ_WRITE);
-  if (!mmfile->IsValid()) {
-    LogAnalyzerCreationError(kInvalidMemoryMappedFile);
-    return nullptr;
-  }
-
-  if (!FilePersistentMemoryAllocator::IsFileAcceptable(*mmfile, true)) {
-    LogAnalyzerCreationError(kPmaBadFile);
-    return nullptr;
-  }
-
-  return CreateWithAllocator(std::make_unique<FilePersistentMemoryAllocator>(
-      std::move(mmfile), 0, 0, StringPiece(), /*readonly=*/true));
-}
-#endif  // !defined(OS_NACL)
-
-// static
-std::unique_ptr<GlobalActivityAnalyzer>
-GlobalActivityAnalyzer::CreateWithSharedMemory(
-    std::unique_ptr<SharedMemory> shm) {
-  if (shm->mapped_size() == 0 ||
-      !SharedPersistentMemoryAllocator::IsSharedMemoryAcceptable(*shm)) {
-    return nullptr;
-  }
-  return CreateWithAllocator(std::make_unique<SharedPersistentMemoryAllocator>(
-      std::move(shm), 0, StringPiece(), /*readonly=*/true));
-}
-
-// static
-std::unique_ptr<GlobalActivityAnalyzer>
-GlobalActivityAnalyzer::CreateWithSharedMemoryHandle(
-    const SharedMemoryHandle& handle,
-    size_t size) {
-  std::unique_ptr<SharedMemory> shm(
-      new SharedMemory(handle, /*readonly=*/true));
-  if (!shm->Map(size))
-    return nullptr;
-  return CreateWithSharedMemory(std::move(shm));
-}
-
-int64_t GlobalActivityAnalyzer::GetFirstProcess() {
-  PrepareAllAnalyzers();
-  return GetNextProcess();
-}
-
-int64_t GlobalActivityAnalyzer::GetNextProcess() {
-  if (process_ids_.empty())
-    return 0;
-  int64_t pid = process_ids_.back();
-  process_ids_.pop_back();
-  return pid;
-}
-
-ThreadActivityAnalyzer* GlobalActivityAnalyzer::GetFirstAnalyzer(int64_t pid) {
-  analyzers_iterator_ = analyzers_.begin();
-  analyzers_iterator_pid_ = pid;
-  if (analyzers_iterator_ == analyzers_.end())
-    return nullptr;
-  int64_t create_stamp;
-  if (analyzers_iterator_->second->GetProcessId(&create_stamp) == pid &&
-      create_stamp <= analysis_stamp_) {
-    return analyzers_iterator_->second.get();
-  }
-  return GetNextAnalyzer();
-}
-
-ThreadActivityAnalyzer* GlobalActivityAnalyzer::GetNextAnalyzer() {
-  DCHECK(analyzers_iterator_ != analyzers_.end());
-  int64_t create_stamp;
-  do {
-    ++analyzers_iterator_;
-    if (analyzers_iterator_ == analyzers_.end())
-      return nullptr;
-  } while (analyzers_iterator_->second->GetProcessId(&create_stamp) !=
-               analyzers_iterator_pid_ ||
-           create_stamp > analysis_stamp_);
-  return analyzers_iterator_->second.get();
-}
-
-ThreadActivityAnalyzer* GlobalActivityAnalyzer::GetAnalyzerForThread(
-    const ThreadKey& key) {
-  auto found = analyzers_.find(key);
-  if (found == analyzers_.end())
-    return nullptr;
-  return found->second.get();
-}
-
-ActivityUserData::Snapshot GlobalActivityAnalyzer::GetUserDataSnapshot(
-    int64_t pid,
-    uint32_t ref,
-    uint32_t id) {
-  ActivityUserData::Snapshot snapshot;
-
-  void* memory = allocator_->GetAsArray<char>(
-      ref, GlobalActivityTracker::kTypeIdUserDataRecord,
-      PersistentMemoryAllocator::kSizeAny);
-  if (memory) {
-    size_t size = allocator_->GetAllocSize(ref);
-    const ActivityUserData user_data(memory, size);
-    user_data.CreateSnapshot(&snapshot);
-    int64_t process_id;
-    int64_t create_stamp;
-    if (!ActivityUserData::GetOwningProcessId(memory, &process_id,
-                                              &create_stamp) ||
-        process_id != pid || user_data.id() != id) {
-      // This allocation has been overwritten since it was created. Return an
-      // empty snapshot because whatever was captured is incorrect.
-      snapshot.clear();
-    }
-  }
-
-  return snapshot;
-}
-
-const ActivityUserData::Snapshot&
-GlobalActivityAnalyzer::GetProcessDataSnapshot(int64_t pid) {
-  auto iter = process_data_.find(pid);
-  if (iter == process_data_.end())
-    return g_empty_user_data_snapshot.Get();
-  if (iter->second.create_stamp > analysis_stamp_)
-    return g_empty_user_data_snapshot.Get();
-  DCHECK_EQ(pid, iter->second.process_id);
-  return iter->second.data;
-}
-
-std::vector<std::string> GlobalActivityAnalyzer::GetLogMessages() {
-  std::vector<std::string> messages;
-  PersistentMemoryAllocator::Reference ref;
-
-  PersistentMemoryAllocator::Iterator iter(allocator_.get());
-  while ((ref = iter.GetNextOfType(
-              GlobalActivityTracker::kTypeIdGlobalLogMessage)) != 0) {
-    const char* message = allocator_->GetAsArray<char>(
-        ref, GlobalActivityTracker::kTypeIdGlobalLogMessage,
-        PersistentMemoryAllocator::kSizeAny);
-    if (message)
-      messages.push_back(message);
-  }
-
-  return messages;
-}
-
-std::vector<GlobalActivityTracker::ModuleInfo>
-GlobalActivityAnalyzer::GetModules(int64_t pid) {
-  std::vector<GlobalActivityTracker::ModuleInfo> modules;
-
-  PersistentMemoryAllocator::Iterator iter(allocator_.get());
-  const GlobalActivityTracker::ModuleInfoRecord* record;
-  while (
-      (record =
-           iter.GetNextOfObject<GlobalActivityTracker::ModuleInfoRecord>()) !=
-      nullptr) {
-    int64_t process_id;
-    int64_t create_stamp;
-    if (!OwningProcess::GetOwningProcessId(&record->owner, &process_id,
-                                           &create_stamp) ||
-        pid != process_id || create_stamp > analysis_stamp_) {
-      continue;
-    }
-    GlobalActivityTracker::ModuleInfo info;
-    if (record->DecodeTo(&info, allocator_->GetAllocSize(
-                                    allocator_->GetAsReference(record)))) {
-      modules.push_back(std::move(info));
-    }
-  }
-
-  return modules;
-}
-
-GlobalActivityAnalyzer::ProgramLocation
-GlobalActivityAnalyzer::GetProgramLocationFromAddress(uint64_t address) {
-  // TODO(bcwhite): Implement this.
-  return { 0, 0 };
-}
-
-bool GlobalActivityAnalyzer::IsDataComplete() const {
-  DCHECK(allocator_);
-  return !allocator_->IsFull();
-}
-
-GlobalActivityAnalyzer::UserDataSnapshot::UserDataSnapshot() = default;
-GlobalActivityAnalyzer::UserDataSnapshot::UserDataSnapshot(
-    const UserDataSnapshot& rhs) = default;
-GlobalActivityAnalyzer::UserDataSnapshot::UserDataSnapshot(
-    UserDataSnapshot&& rhs) = default;
-GlobalActivityAnalyzer::UserDataSnapshot::~UserDataSnapshot() = default;
-
-void GlobalActivityAnalyzer::PrepareAllAnalyzers() {
-  // Record the time when analysis started.
-  analysis_stamp_ = base::Time::Now().ToInternalValue();
-
-  // Fetch all the records. This will retrieve only ones created since the
-  // last run since the PMA iterator will continue from where it left off.
-  uint32_t type;
-  PersistentMemoryAllocator::Reference ref;
-  while ((ref = allocator_iterator_.GetNext(&type)) != 0) {
-    switch (type) {
-      case GlobalActivityTracker::kTypeIdActivityTracker:
-      case GlobalActivityTracker::kTypeIdActivityTrackerFree:
-      case GlobalActivityTracker::kTypeIdProcessDataRecord:
-      case GlobalActivityTracker::kTypeIdProcessDataRecordFree:
-      case PersistentMemoryAllocator::kTypeIdTransitioning:
-        // Active, free, or transitioning: add it to the list of references
-        // for later analysis.
-        memory_references_.insert(ref);
-        break;
-    }
-  }
-
-  // Clear out any old information.
-  analyzers_.clear();
-  process_data_.clear();
-  process_ids_.clear();
-  std::set<int64_t> seen_pids;
-
-  // Go through all the known references and create objects for them with
-  // snapshots of the current state.
-  for (PersistentMemoryAllocator::Reference memory_ref : memory_references_) {
-    // Get the actual data segment for the tracker. Any type will do since it
-    // is checked below.
-    void* const base = allocator_->GetAsArray<char>(
-        memory_ref, PersistentMemoryAllocator::kTypeIdAny,
-        PersistentMemoryAllocator::kSizeAny);
-    const size_t size = allocator_->GetAllocSize(memory_ref);
-    if (!base)
-      continue;
-
-    switch (allocator_->GetType(memory_ref)) {
-      case GlobalActivityTracker::kTypeIdActivityTracker: {
-        // Create the analyzer on the data. This will capture a snapshot of the
-        // tracker state. This can fail if the tracker is somehow corrupted or
-        // is in the process of shutting down.
-        std::unique_ptr<ThreadActivityAnalyzer> analyzer(
-            new ThreadActivityAnalyzer(base, size));
-        if (!analyzer->IsValid())
-          continue;
-        analyzer->AddGlobalInformation(this);
-
-        // Track PIDs.
-        int64_t pid = analyzer->GetProcessId();
-        if (seen_pids.find(pid) == seen_pids.end()) {
-          process_ids_.push_back(pid);
-          seen_pids.insert(pid);
-        }
-
-        // Add this analyzer to the map of known ones, indexed by a unique
-        // thread
-        // identifier.
-        DCHECK(!base::ContainsKey(analyzers_, analyzer->GetThreadKey()));
-        analyzer->allocator_reference_ = ref;
-        analyzers_[analyzer->GetThreadKey()] = std::move(analyzer);
-      } break;
-
-      case GlobalActivityTracker::kTypeIdProcessDataRecord: {
-        // Get the PID associated with this data record.
-        int64_t process_id;
-        int64_t create_stamp;
-        ActivityUserData::GetOwningProcessId(base, &process_id, &create_stamp);
-        DCHECK(!base::ContainsKey(process_data_, process_id));
-
-        // Create a snapshot of the data. This can fail if the data is somehow
-        // corrupted or the process shutdown and the memory being released.
-        UserDataSnapshot& snapshot = process_data_[process_id];
-        snapshot.process_id = process_id;
-        snapshot.create_stamp = create_stamp;
-        const ActivityUserData process_data(base, size);
-        if (!process_data.CreateSnapshot(&snapshot.data))
-          break;
-
-        // Check that nothing changed. If it did, forget what was recorded.
-        ActivityUserData::GetOwningProcessId(base, &process_id, &create_stamp);
-        if (process_id != snapshot.process_id ||
-            create_stamp != snapshot.create_stamp) {
-          process_data_.erase(process_id);
-          break;
-        }
-
-        // Track PIDs.
-        if (seen_pids.find(process_id) == seen_pids.end()) {
-          process_ids_.push_back(process_id);
-          seen_pids.insert(process_id);
-        }
-      } break;
-    }
-  }
-
-  // Reverse the list of PIDs so that they get popped in the order found.
-  std::reverse(process_ids_.begin(), process_ids_.end());
-}
-
-}  // namespace debug
-}  // namespace base
diff --git a/base/debug/activity_analyzer.h b/base/debug/activity_analyzer.h
deleted file mode 100644
index 9add85a..0000000
--- a/base/debug/activity_analyzer.h
+++ /dev/null
@@ -1,262 +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_DEBUG_ACTIVITY_ANALYZER_H_
-#define BASE_DEBUG_ACTIVITY_ANALYZER_H_
-
-#include <map>
-#include <memory>
-#include <set>
-#include <string>
-#include <vector>
-
-#include "base/base_export.h"
-#include "base/debug/activity_tracker.h"
-
-namespace base {
-namespace debug {
-
-class GlobalActivityAnalyzer;
-
-// This class provides analysis of data captured from a ThreadActivityTracker.
-// When created, it takes a snapshot of the data held by the tracker and
-// makes that information available to other code.
-class BASE_EXPORT ThreadActivityAnalyzer {
- public:
-  struct BASE_EXPORT Snapshot : ThreadActivityTracker::Snapshot {
-    Snapshot();
-    ~Snapshot();
-
-    // The user-data snapshot for an activity, matching the |activity_stack|
-    // of ThreadActivityTracker::Snapshot, if any.
-    std::vector<ActivityUserData::Snapshot> user_data_stack;
-  };
-
-  // This class provides keys that uniquely identify a thread, even across
-  // multiple processes.
-  class ThreadKey {
-   public:
-    ThreadKey(int64_t pid, int64_t tid) : pid_(pid), tid_(tid) {}
-
-    bool operator<(const ThreadKey& rhs) const {
-      if (pid_ != rhs.pid_)
-        return pid_ < rhs.pid_;
-      return tid_ < rhs.tid_;
-    }
-
-    bool operator==(const ThreadKey& rhs) const {
-      return (pid_ == rhs.pid_ && tid_ == rhs.tid_);
-    }
-
-   private:
-    int64_t pid_;
-    int64_t tid_;
-  };
-
-  // Creates an analyzer for an existing activity |tracker|. A snapshot is taken
-  // immediately and the tracker is not referenced again.
-  explicit ThreadActivityAnalyzer(const ThreadActivityTracker& tracker);
-
-  // Creates an analyzer for a block of memory currently or previously in-use
-  // by an activity-tracker. A snapshot is taken immediately and the memory
-  // is not referenced again.
-  ThreadActivityAnalyzer(void* base, size_t size);
-
-  // Creates an analyzer for a block of memory held within a persistent-memory
-  // |allocator| at the given |reference|. A snapshot is taken immediately and
-  // the memory is not referenced again.
-  ThreadActivityAnalyzer(PersistentMemoryAllocator* allocator,
-                         PersistentMemoryAllocator::Reference reference);
-
-  ~ThreadActivityAnalyzer();
-
-  // Adds information from the global analyzer.
-  void AddGlobalInformation(GlobalActivityAnalyzer* global);
-
-  // Returns true iff the contained data is valid. Results from all other
-  // methods are undefined if this returns false.
-  bool IsValid() { return activity_snapshot_valid_; }
-
-  // Gets the process id and its creation stamp.
-  int64_t GetProcessId(int64_t* out_stamp = nullptr) {
-    if (out_stamp)
-      *out_stamp = activity_snapshot_.create_stamp;
-    return activity_snapshot_.process_id;
-  }
-
-  // Gets the name of the thread.
-  const std::string& GetThreadName() {
-    return activity_snapshot_.thread_name;
-  }
-
-  // Gets the TheadKey for this thread.
-  ThreadKey GetThreadKey() {
-    return ThreadKey(activity_snapshot_.process_id,
-                     activity_snapshot_.thread_id);
-  }
-
-  const Snapshot& activity_snapshot() { return activity_snapshot_; }
-
- private:
-  friend class GlobalActivityAnalyzer;
-
-  // The snapshot of the activity tracker taken at the moment of construction.
-  Snapshot activity_snapshot_;
-
-  // Flag indicating if the snapshot data is valid.
-  bool activity_snapshot_valid_;
-
-  // A reference into a persistent memory allocator, used by the global
-  // analyzer to know where this tracker came from.
-  PersistentMemoryAllocator::Reference allocator_reference_ = 0;
-
-  DISALLOW_COPY_AND_ASSIGN(ThreadActivityAnalyzer);
-};
-
-
-// This class manages analyzers for all known processes and threads as stored
-// in a persistent memory allocator. It supports retrieval of them through
-// iteration and directly using a ThreadKey, which allows for cross-references
-// to be resolved.
-// Note that though atomic snapshots are used and everything has its snapshot
-// taken at the same time, the multi-snapshot itself is not atomic and thus may
-// show small inconsistencies between threads if attempted on a live system.
-class BASE_EXPORT GlobalActivityAnalyzer {
- public:
-  struct ProgramLocation {
-    int module;
-    uintptr_t offset;
-  };
-
-  using ThreadKey = ThreadActivityAnalyzer::ThreadKey;
-
-  // Creates a global analyzer from a persistent memory allocator.
-  explicit GlobalActivityAnalyzer(
-      std::unique_ptr<PersistentMemoryAllocator> allocator);
-
-  ~GlobalActivityAnalyzer();
-
-  // Creates a global analyzer using a given persistent-memory |allocator|.
-  static std::unique_ptr<GlobalActivityAnalyzer> CreateWithAllocator(
-      std::unique_ptr<PersistentMemoryAllocator> allocator);
-
-#if !defined(OS_NACL)
-  // Creates a global analyzer using the contents of a file given in
-  // |file_path|.
-  static std::unique_ptr<GlobalActivityAnalyzer> CreateWithFile(
-      const FilePath& file_path);
-#endif  // !defined(OS_NACL)
-
-  // Like above but accesses an allocator in a mapped shared-memory segment.
-  static std::unique_ptr<GlobalActivityAnalyzer> CreateWithSharedMemory(
-      std::unique_ptr<SharedMemory> shm);
-
-  // Like above but takes a handle to an existing shared memory segment and
-  // maps it before creating the tracker.
-  static std::unique_ptr<GlobalActivityAnalyzer> CreateWithSharedMemoryHandle(
-      const SharedMemoryHandle& handle,
-      size_t size);
-
-  // Iterates over all known valid processes and returns their PIDs or zero
-  // if there are no more. Calls to GetFirstProcess() will perform a global
-  // snapshot in order to provide a relatively consistent state across the
-  // future calls to GetNextProcess() and GetFirst/NextAnalyzer(). PIDs are
-  // returned in the order they're found meaning that a first-launched
-  // controlling process will be found first. Note, however, that space
-  // freed by an exiting process may be re-used by a later process.
-  int64_t GetFirstProcess();
-  int64_t GetNextProcess();
-
-  // Iterates over all known valid analyzers for the a given process or returns
-  // null if there are no more.
-  //
-  // GetFirstProcess() must be called first in order to capture a global
-  // snapshot! Ownership stays with the global analyzer object and all existing
-  // analyzer pointers are invalidated when GetFirstProcess() is called.
-  ThreadActivityAnalyzer* GetFirstAnalyzer(int64_t pid);
-  ThreadActivityAnalyzer* GetNextAnalyzer();
-
-  // Gets the analyzer for a specific thread or null if there is none.
-  // Ownership stays with the global analyzer object.
-  ThreadActivityAnalyzer* GetAnalyzerForThread(const ThreadKey& key);
-
-  // Extract user data based on a reference and its identifier.
-  ActivityUserData::Snapshot GetUserDataSnapshot(int64_t pid,
-                                                 uint32_t ref,
-                                                 uint32_t id);
-
-  // Extract the data for a specific process. An empty snapshot will be
-  // returned if the process is not known.
-  const ActivityUserData::Snapshot& GetProcessDataSnapshot(int64_t pid);
-
-  // Gets all log messages stored within.
-  std::vector<std::string> GetLogMessages();
-
-  // Gets modules corresponding to a pid. This pid must come from a call to
-  // GetFirst/NextProcess. Only modules that were first registered prior to
-  // GetFirstProcess's snapshot are returned.
-  std::vector<GlobalActivityTracker::ModuleInfo> GetModules(int64_t pid);
-
-  // Gets the corresponding "program location" for a given "program counter".
-  // This will return {0,0} if no mapping could be found.
-  ProgramLocation GetProgramLocationFromAddress(uint64_t address);
-
-  // Returns whether the data is complete. Data can be incomplete if the
-  // recording size quota is hit.
-  bool IsDataComplete() const;
-
- private:
-  using AnalyzerMap =
-      std::map<ThreadKey, std::unique_ptr<ThreadActivityAnalyzer>>;
-
-  struct UserDataSnapshot {
-    // Complex class needs out-of-line ctor/dtor.
-    UserDataSnapshot();
-    UserDataSnapshot(const UserDataSnapshot& rhs);
-    UserDataSnapshot(UserDataSnapshot&& rhs);
-    ~UserDataSnapshot();
-
-    int64_t process_id;
-    int64_t create_stamp;
-    ActivityUserData::Snapshot data;
-  };
-
-  // Finds, creates, and indexes analyzers for all known processes and threads.
-  void PrepareAllAnalyzers();
-
-  // The persistent memory allocator holding all tracking data.
-  std::unique_ptr<PersistentMemoryAllocator> allocator_;
-
-  // The time stamp when analysis began. This is used to prevent looking into
-  // process IDs that get reused when analyzing a live system.
-  int64_t analysis_stamp_;
-
-  // The iterator for finding tracking information in the allocator.
-  PersistentMemoryAllocator::Iterator allocator_iterator_;
-
-  // A set of all interesting memory references found within the allocator.
-  std::set<PersistentMemoryAllocator::Reference> memory_references_;
-
-  // A set of all process-data memory references found within the allocator.
-  std::map<int64_t, UserDataSnapshot> process_data_;
-
-  // A set of all process IDs collected during PrepareAllAnalyzers. These are
-  // popped and returned one-by-one with calls to GetFirst/NextProcess().
-  std::vector<int64_t> process_ids_;
-
-  // A map, keyed by ThreadKey, of all valid activity analyzers.
-  AnalyzerMap analyzers_;
-
-  // The iterator within the analyzers_ map for returning analyzers through
-  // first/next iteration.
-  AnalyzerMap::iterator analyzers_iterator_;
-  int64_t analyzers_iterator_pid_;
-
-  DISALLOW_COPY_AND_ASSIGN(GlobalActivityAnalyzer);
-};
-
-}  // namespace debug
-}  // namespace base
-
-#endif  // BASE_DEBUG_ACTIVITY_ANALYZER_H_
diff --git a/base/debug/alias.cc b/base/debug/alias.cc
deleted file mode 100644
index d93d495..0000000
--- a/base/debug/alias.cc
+++ /dev/null
@@ -1,23 +0,0 @@
-// Copyright (c) 2011 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/debug/alias.h"
-#include "build_config.h"
-
-namespace base {
-namespace debug {
-
-#if defined(COMPILER_MSVC)
-#pragma optimize("", off)
-#endif
-
-void Alias(const void* var) {
-}
-
-#if defined(COMPILER_MSVC)
-#pragma optimize("", on)
-#endif
-
-}  // namespace debug
-}  // namespace base
diff --git a/base/debug/alias.h b/base/debug/alias.h
deleted file mode 100644
index 128fdaa..0000000
--- a/base/debug/alias.h
+++ /dev/null
@@ -1,43 +0,0 @@
-// Copyright (c) 2011 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_DEBUG_ALIAS_H_
-#define BASE_DEBUG_ALIAS_H_
-
-#include "base/base_export.h"
-#include "base/strings/string_util.h"
-
-namespace base {
-namespace debug {
-
-// Make the optimizer think that var is aliased. This is to prevent it from
-// optimizing out local variables that would not otherwise be live at the point
-// of a potential crash.
-// base::debug::Alias should only be used for local variables, not globals,
-// object members, or function return values - these must be copied to locals if
-// you want to ensure they are recorded in crash dumps.
-// Note that if the local variable is a pointer then its value will be retained
-// but the memory that it points to will probably not be saved in the crash
-// dump - by default only stack memory is saved. Therefore the aliasing
-// technique is usually only worthwhile with non-pointer variables. If you have
-// a pointer to an object and you want to retain the object's state you need to
-// copy the object or its fields to local variables. Example usage:
-//   int last_error = err_;
-//   base::debug::Alias(&last_error);
-//   DEBUG_ALIAS_FOR_CSTR(name_copy, p->name, 16);
-//   CHECK(false);
-void BASE_EXPORT Alias(const void* var);
-
-}  // namespace debug
-}  // namespace base
-
-// Convenience macro that copies the null-terminated string from |c_str| into a
-// stack-allocated char array named |var_name| that holds up to |char_count|
-// characters and should be preserved in memory dumps.
-#define DEBUG_ALIAS_FOR_CSTR(var_name, c_str, char_count)  \
-  char var_name[char_count];                               \
-  ::base::strlcpy(var_name, (c_str), arraysize(var_name)); \
-  ::base::debug::Alias(var_name);
-
-#endif  // BASE_DEBUG_ALIAS_H_
diff --git a/base/debug/asan_invalid_access.cc b/base/debug/asan_invalid_access.cc
deleted file mode 100644
index d5d43d5..0000000
--- a/base/debug/asan_invalid_access.cc
+++ /dev/null
@@ -1,101 +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.
-
-#include "base/debug/asan_invalid_access.h"
-
-#include <stddef.h>
-
-#include <memory>
-
-#include "base/debug/alias.h"
-#include "base/logging.h"
-#include "build_config.h"
-
-#if defined(OS_WIN)
-#include <windows.h>
-#endif
-
-namespace base {
-namespace debug {
-
-namespace {
-
-#if defined(OS_WIN) && defined(ADDRESS_SANITIZER)
-// Corrupt a memory block and make sure that the corruption gets detected either
-// when we free it or when another crash happens (if |induce_crash| is set to
-// true).
-NOINLINE void CorruptMemoryBlock(bool induce_crash) {
-  // NOTE(sebmarchand): We intentionally corrupt a memory block here in order to
-  //     trigger an Address Sanitizer (ASAN) error report.
-  static const int kArraySize = 5;
-  LONG* array = new LONG[kArraySize];
-
-  // Explicitly call out to a kernel32 function to perform the memory access.
-  // This way the underflow won't be detected but the corruption will (as the
-  // allocator will still be hooked).
-  auto InterlockedIncrementFn =
-      reinterpret_cast<LONG (*)(LONG volatile * addend)>(
-          GetProcAddress(GetModuleHandle(L"kernel32"), "InterlockedIncrement"));
-  CHECK(InterlockedIncrementFn);
-
-  LONG volatile dummy = InterlockedIncrementFn(array - 1);
-  base::debug::Alias(const_cast<LONG*>(&dummy));
-
-  if (induce_crash)
-    CHECK(false);
-  delete[] array;
-}
-#endif  // OS_WIN && ADDRESS_SANITIZER
-
-}  // namespace
-
-#if defined(ADDRESS_SANITIZER)
-// NOTE(sebmarchand): We intentionally perform some invalid heap access here in
-//     order to trigger an AddressSanitizer (ASan) error report.
-
-static const size_t kArraySize = 5;
-
-void AsanHeapOverflow() {
-  // Declares the array as volatile to make sure it doesn't get optimized away.
-  std::unique_ptr<volatile int[]> array(
-      const_cast<volatile int*>(new int[kArraySize]));
-  int dummy = array[kArraySize];
-  base::debug::Alias(&dummy);
-}
-
-void AsanHeapUnderflow() {
-  // Declares the array as volatile to make sure it doesn't get optimized away.
-  std::unique_ptr<volatile int[]> array(
-      const_cast<volatile int*>(new int[kArraySize]));
-  // We need to store the underflow address in a temporary variable as trying to
-  // access array[-1] will trigger a warning C4245: "conversion from 'int' to
-  // 'size_t', signed/unsigned mismatch".
-  volatile int* underflow_address = &array[0] - 1;
-  int dummy = *underflow_address;
-  base::debug::Alias(&dummy);
-}
-
-void AsanHeapUseAfterFree() {
-  // Declares the array as volatile to make sure it doesn't get optimized away.
-  std::unique_ptr<volatile int[]> array(
-      const_cast<volatile int*>(new int[kArraySize]));
-  volatile int* dangling = array.get();
-  array.reset();
-  int dummy = dangling[kArraySize / 2];
-  base::debug::Alias(&dummy);
-}
-
-#if defined(OS_WIN)
-void AsanCorruptHeapBlock() {
-  CorruptMemoryBlock(false);
-}
-
-void AsanCorruptHeap() {
-  CorruptMemoryBlock(true);
-}
-#endif  // OS_WIN
-#endif  // ADDRESS_SANITIZER
-
-}  // namespace debug
-}  // namespace base
diff --git a/base/debug/asan_invalid_access.h b/base/debug/asan_invalid_access.h
deleted file mode 100644
index f8b078a..0000000
--- a/base/debug/asan_invalid_access.h
+++ /dev/null
@@ -1,46 +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.
-//
-// Defines some functions that intentionally do an invalid memory access in
-// order to trigger an AddressSanitizer (ASan) error report.
-
-#ifndef BASE_DEBUG_ASAN_INVALID_ACCESS_H_
-#define BASE_DEBUG_ASAN_INVALID_ACCESS_H_
-
-#include "base/base_export.h"
-#include "base/compiler_specific.h"
-#include "build_config.h"
-
-namespace base {
-namespace debug {
-
-#if defined(ADDRESS_SANITIZER)
-
-// Generates an heap buffer overflow.
-BASE_EXPORT NOINLINE void AsanHeapOverflow();
-
-// Generates an heap buffer underflow.
-BASE_EXPORT NOINLINE void AsanHeapUnderflow();
-
-// Generates an use after free.
-BASE_EXPORT NOINLINE void AsanHeapUseAfterFree();
-
-// The "corrupt-block" and "corrupt-heap" classes of bugs is specific to
-// Windows.
-#if defined(OS_WIN)
-// Corrupts a memory block and makes sure that the corruption gets detected when
-// we try to free this block.
-BASE_EXPORT NOINLINE void AsanCorruptHeapBlock();
-
-// Corrupts the heap and makes sure that the corruption gets detected when a
-// crash occur.
-BASE_EXPORT NOINLINE void AsanCorruptHeap();
-
-#endif  // OS_WIN
-#endif  // ADDRESS_SANITIZER
-
-}  // namespace debug
-}  // namespace base
-
-#endif  // BASE_DEBUG_ASAN_INVALID_ACCESS_H_
diff --git a/base/debug/close_handle_hook_win.cc b/base/debug/close_handle_hook_win.cc
deleted file mode 100644
index 35afdf5..0000000
--- a/base/debug/close_handle_hook_win.cc
+++ /dev/null
@@ -1,263 +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/debug/close_handle_hook_win.h"
-
-#include <Windows.h>
-#include <psapi.h>
-#include <stddef.h>
-
-#include <algorithm>
-#include <memory>
-#include <vector>
-
-#include "base/macros.h"
-#include "base/win/iat_patch_function.h"
-#include "base/win/pe_image.h"
-#include "base/win/scoped_handle.h"
-#include "build_config.h"
-
-namespace {
-
-typedef BOOL (WINAPI* CloseHandleType) (HANDLE handle);
-
-typedef BOOL (WINAPI* DuplicateHandleType)(HANDLE source_process,
-                                           HANDLE source_handle,
-                                           HANDLE target_process,
-                                           HANDLE* target_handle,
-                                           DWORD desired_access,
-                                           BOOL inherit_handle,
-                                           DWORD options);
-
-CloseHandleType g_close_function = NULL;
-DuplicateHandleType g_duplicate_function = NULL;
-
-// The entry point for CloseHandle interception. This function notifies the
-// verifier about the handle that is being closed, and calls the original
-// function.
-BOOL WINAPI CloseHandleHook(HANDLE handle) {
-  base::win::OnHandleBeingClosed(handle);
-  return g_close_function(handle);
-}
-
-BOOL WINAPI DuplicateHandleHook(HANDLE source_process,
-                                HANDLE source_handle,
-                                HANDLE target_process,
-                                HANDLE* target_handle,
-                                DWORD desired_access,
-                                BOOL inherit_handle,
-                                DWORD options) {
-  if ((options & DUPLICATE_CLOSE_SOURCE) &&
-      (GetProcessId(source_process) == ::GetCurrentProcessId())) {
-    base::win::OnHandleBeingClosed(source_handle);
-  }
-
-  return g_duplicate_function(source_process, source_handle, target_process,
-                              target_handle, desired_access, inherit_handle,
-                              options);
-}
-
-}  // namespace
-
-namespace base {
-namespace debug {
-
-namespace {
-
-// Provides a simple way to temporarily change the protection of a memory page.
-class AutoProtectMemory {
- public:
-  AutoProtectMemory()
-      : changed_(false), address_(NULL), bytes_(0), old_protect_(0) {}
-
-  ~AutoProtectMemory() {
-    RevertProtection();
-  }
-
-  // Grants write access to a given memory range.
-  bool ChangeProtection(void* address, size_t bytes);
-
-  // Restores the original page protection.
-  void RevertProtection();
-
- private:
-  bool changed_;
-  void* address_;
-  size_t bytes_;
-  DWORD old_protect_;
-
-  DISALLOW_COPY_AND_ASSIGN(AutoProtectMemory);
-};
-
-bool AutoProtectMemory::ChangeProtection(void* address, size_t bytes) {
-  DCHECK(!changed_);
-  DCHECK(address);
-
-  // Change the page protection so that we can write.
-  MEMORY_BASIC_INFORMATION memory_info;
-  if (!VirtualQuery(address, &memory_info, sizeof(memory_info)))
-    return false;
-
-  DWORD is_executable = (PAGE_EXECUTE | PAGE_EXECUTE_READ |
-                        PAGE_EXECUTE_READWRITE | PAGE_EXECUTE_WRITECOPY) &
-                        memory_info.Protect;
-
-  DWORD protect = is_executable ? PAGE_EXECUTE_READWRITE : PAGE_READWRITE;
-  if (!VirtualProtect(address, bytes, protect, &old_protect_))
-    return false;
-
-  changed_ = true;
-  address_ = address;
-  bytes_ = bytes;
-  return true;
-}
-
-void AutoProtectMemory::RevertProtection() {
-  if (!changed_)
-    return;
-
-  DCHECK(address_);
-  DCHECK(bytes_);
-
-  VirtualProtect(address_, bytes_, old_protect_, &old_protect_);
-  changed_ = false;
-  address_ = NULL;
-  bytes_ = 0;
-  old_protect_ = 0;
-}
-
-// Performs an EAT interception.
-void EATPatch(HMODULE module, const char* function_name,
-              void* new_function, void** old_function) {
-  if (!module)
-    return;
-
-  base::win::PEImage pe(module);
-  if (!pe.VerifyMagic())
-    return;
-
-  DWORD* eat_entry = pe.GetExportEntry(function_name);
-  if (!eat_entry)
-    return;
-
-  if (!(*old_function))
-    *old_function = pe.RVAToAddr(*eat_entry);
-
-  AutoProtectMemory memory;
-  if (!memory.ChangeProtection(eat_entry, sizeof(DWORD)))
-    return;
-
-  // Perform the patch.
-#pragma warning(push)
-#pragma warning(disable : 4311 4302)
-  // These casts generate truncation warnings because they are 32 bit specific.
-  *eat_entry = reinterpret_cast<DWORD>(new_function) -
-               reinterpret_cast<DWORD>(module);
-#pragma warning(pop)
-}
-
-// Performs an IAT interception.
-base::win::IATPatchFunction* IATPatch(HMODULE module, const char* function_name,
-                                      void* new_function, void** old_function) {
-  if (!module)
-    return NULL;
-
-  base::win::IATPatchFunction* patch = new base::win::IATPatchFunction;
-  __try {
-    // There is no guarantee that |module| is still loaded at this point.
-    if (patch->PatchFromModule(module, "kernel32.dll", function_name,
-                               new_function)) {
-      delete patch;
-      return NULL;
-    }
-  } __except((GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION ||
-              GetExceptionCode() == EXCEPTION_GUARD_PAGE ||
-              GetExceptionCode() == EXCEPTION_IN_PAGE_ERROR) ?
-             EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
-    // Leak the patch.
-    return NULL;
-  }
-
-  if (!(*old_function)) {
-    // Things are probably messed up if each intercepted function points to
-    // a different place, but we need only one function to call.
-    *old_function = patch->original_function();
-  }
-  return patch;
-}
-
-// Keeps track of all the hooks needed to intercept functions which could
-// possibly close handles.
-class HandleHooks {
- public:
-  HandleHooks() {}
-  ~HandleHooks() {}
-
-  void AddIATPatch(HMODULE module);
-  void AddEATPatch();
-
- private:
-  std::vector<base::win::IATPatchFunction*> hooks_;
-  DISALLOW_COPY_AND_ASSIGN(HandleHooks);
-};
-
-void HandleHooks::AddIATPatch(HMODULE module) {
-  if (!module)
-    return;
-
-  base::win::IATPatchFunction* patch = NULL;
-  patch =
-      IATPatch(module, "CloseHandle", reinterpret_cast<void*>(&CloseHandleHook),
-               reinterpret_cast<void**>(&g_close_function));
-  if (!patch)
-    return;
-  hooks_.push_back(patch);
-
-  patch = IATPatch(module, "DuplicateHandle",
-                   reinterpret_cast<void*>(&DuplicateHandleHook),
-                   reinterpret_cast<void**>(&g_duplicate_function));
-  if (!patch)
-    return;
-  hooks_.push_back(patch);
-}
-
-void HandleHooks::AddEATPatch() {
-  // An attempt to restore the entry on the table at destruction is not safe.
-  EATPatch(GetModuleHandleA("kernel32.dll"), "CloseHandle",
-           reinterpret_cast<void*>(&CloseHandleHook),
-           reinterpret_cast<void**>(&g_close_function));
-  EATPatch(GetModuleHandleA("kernel32.dll"), "DuplicateHandle",
-           reinterpret_cast<void*>(&DuplicateHandleHook),
-           reinterpret_cast<void**>(&g_duplicate_function));
-}
-
-void PatchLoadedModules(HandleHooks* hooks) {
-  const DWORD kSize = 256;
-  DWORD returned;
-  std::unique_ptr<HMODULE[]> modules(new HMODULE[kSize]);
-  if (!EnumProcessModules(GetCurrentProcess(), modules.get(),
-                          kSize * sizeof(HMODULE), &returned)) {
-    return;
-  }
-  returned /= sizeof(HMODULE);
-  returned = std::min(kSize, returned);
-
-  for (DWORD current = 0; current < returned; current++) {
-    hooks->AddIATPatch(modules[current]);
-  }
-}
-
-}  // namespace
-
-void InstallHandleHooks() {
-  static HandleHooks* hooks = new HandleHooks();
-
-  // Performing EAT interception first is safer in the presence of other
-  // threads attempting to call CloseHandle.
-  hooks->AddEATPatch();
-  PatchLoadedModules(hooks);
-}
-
-}  // namespace debug
-}  // namespace base
diff --git a/base/debug/close_handle_hook_win.h b/base/debug/close_handle_hook_win.h
deleted file mode 100644
index c775d75..0000000
--- a/base/debug/close_handle_hook_win.h
+++ /dev/null
@@ -1,19 +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_DEBUG_CLOSE_HANDLE_HOOK_WIN_H_
-#define BASE_DEBUG_CLOSE_HANDLE_HOOK_WIN_H_
-
-#include "base/base_export.h"
-
-namespace base {
-namespace debug {
-
-// Installs the hooks required to debug use of improper handles.
-BASE_EXPORT void InstallHandleHooks();
-
-}  // namespace debug
-}  // namespace base
-
-#endif  // BASE_DEBUG_CLOSE_HANDLE_HOOK_WIN_H_
diff --git a/base/debug/crash_logging.cc b/base/debug/crash_logging.cc
deleted file mode 100644
index 1dabb6b..0000000
--- a/base/debug/crash_logging.cc
+++ /dev/null
@@ -1,54 +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/debug/crash_logging.h"
-
-namespace base {
-namespace debug {
-
-namespace {
-
-CrashKeyImplementation* g_crash_key_impl = nullptr;
-
-}  // namespace
-
-CrashKeyString* AllocateCrashKeyString(const char name[],
-                                       CrashKeySize value_length) {
-  if (!g_crash_key_impl)
-    return nullptr;
-
-  return g_crash_key_impl->Allocate(name, value_length);
-}
-
-void SetCrashKeyString(CrashKeyString* crash_key, base::StringPiece value) {
-  if (!g_crash_key_impl || !crash_key)
-    return;
-
-  g_crash_key_impl->Set(crash_key, value);
-}
-
-void ClearCrashKeyString(CrashKeyString* crash_key) {
-  if (!g_crash_key_impl || !crash_key)
-    return;
-
-  g_crash_key_impl->Clear(crash_key);
-}
-
-ScopedCrashKeyString::ScopedCrashKeyString(CrashKeyString* crash_key,
-                                           base::StringPiece value)
-    : crash_key_(crash_key) {
-  SetCrashKeyString(crash_key_, value);
-}
-
-ScopedCrashKeyString::~ScopedCrashKeyString() {
-  ClearCrashKeyString(crash_key_);
-}
-
-void SetCrashKeyImplementation(std::unique_ptr<CrashKeyImplementation> impl) {
-  delete g_crash_key_impl;
-  g_crash_key_impl = impl.release();
-}
-
-}  // namespace debug
-}  // namespace base
diff --git a/base/debug/crash_logging.h b/base/debug/crash_logging.h
deleted file mode 100644
index 9c6cd75..0000000
--- a/base/debug/crash_logging.h
+++ /dev/null
@@ -1,104 +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_DEBUG_CRASH_LOGGING_H_
-#define BASE_DEBUG_CRASH_LOGGING_H_
-
-#include <stddef.h>
-
-#include <memory>
-
-#include "base/base_export.h"
-#include "base/macros.h"
-#include "base/strings/string_piece.h"
-
-namespace base {
-namespace debug {
-
-// A crash key is an annotation that is carried along with a crash report, to
-// provide additional debugging information beyond a stack trace. Crash keys
-// have a name and a string value.
-//
-// The preferred API is //components/crash/core/common:crash_key, however not
-// all clients can hold a direct dependency on that target. The API provided
-// in this file indirects the dependency.
-//
-// Example usage:
-//   static CrashKeyString* crash_key =
-//       AllocateCrashKeyString("name", CrashKeySize::Size32);
-//   SetCrashKeyString(crash_key, "value");
-//   ClearCrashKeyString(crash_key);
-
-// The maximum length for a crash key's value must be one of the following
-// pre-determined values.
-enum class CrashKeySize {
-  Size32 = 32,
-  Size64 = 64,
-  Size256 = 256,
-};
-
-struct CrashKeyString;
-
-// Allocates a new crash key with the specified |name| with storage for a
-// value up to length |size|. This will return null if the crash key system is
-// not initialized.
-BASE_EXPORT CrashKeyString* AllocateCrashKeyString(const char name[],
-                                                   CrashKeySize size);
-
-// Stores |value| into the specified |crash_key|. The |crash_key| may be null
-// if AllocateCrashKeyString() returned null. If |value| is longer than the
-// size with which the key was allocated, it will be truncated.
-BASE_EXPORT void SetCrashKeyString(CrashKeyString* crash_key,
-                                   base::StringPiece value);
-
-// Clears any value that was stored in |crash_key|. The |crash_key| may be
-// null.
-BASE_EXPORT void ClearCrashKeyString(CrashKeyString* crash_key);
-
-// A scoper that sets the specified key to value for the lifetime of the
-// object, and clears it on destruction.
-class BASE_EXPORT ScopedCrashKeyString {
- public:
-  ScopedCrashKeyString(CrashKeyString* crash_key, base::StringPiece value);
-  ~ScopedCrashKeyString();
-
- private:
-  CrashKeyString* const crash_key_;
-
-  DISALLOW_COPY_AND_ASSIGN(ScopedCrashKeyString);
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// The following declarations are used to initialize the crash key system
-// in //base by providing implementations for the above functions.
-
-// The virtual interface that provides the implementation for the crash key
-// API. This is implemented by a higher-layer component, and the instance is
-// set using the function below.
-class CrashKeyImplementation {
- public:
-  virtual ~CrashKeyImplementation() = default;
-
-  virtual CrashKeyString* Allocate(const char name[], CrashKeySize size) = 0;
-  virtual void Set(CrashKeyString* crash_key, base::StringPiece value) = 0;
-  virtual void Clear(CrashKeyString* crash_key) = 0;
-};
-
-// Initializes the crash key system in base by replacing the existing
-// implementation, if it exists, with |impl|. The |impl| is copied into base.
-BASE_EXPORT void SetCrashKeyImplementation(
-    std::unique_ptr<CrashKeyImplementation> impl);
-
-// The base structure for a crash key, storing the allocation metadata.
-struct CrashKeyString {
-  constexpr CrashKeyString(const char name[], CrashKeySize size)
-      : name(name), size(size) {}
-  const char* const name;
-  const CrashKeySize size;
-};
-
-}  // namespace debug
-}  // namespace base
-
-#endif  // BASE_DEBUG_CRASH_LOGGING_H_
diff --git a/base/debug/debugger.cc b/base/debug/debugger.cc
deleted file mode 100644
index 025bc54..0000000
--- a/base/debug/debugger.cc
+++ /dev/null
@@ -1,42 +0,0 @@
-// Copyright (c) 2011 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/debug/debugger.h"
-#include "base/logging.h"
-#include "base/threading/platform_thread.h"
-#include "build_config.h"
-
-namespace base {
-namespace debug {
-
-static bool is_debug_ui_suppressed = false;
-
-bool WaitForDebugger(int wait_seconds, bool silent) {
-#if defined(OS_ANDROID)
-  // The pid from which we know which process to attach to are not output by
-  // android ddms, so we have to print it out explicitly.
-  DLOG(INFO) << "DebugUtil::WaitForDebugger(pid=" << static_cast<int>(getpid())
-             << ")";
-#endif
-  for (int i = 0; i < wait_seconds * 10; ++i) {
-    if (BeingDebugged()) {
-      if (!silent)
-        BreakDebugger();
-      return true;
-    }
-    PlatformThread::Sleep(TimeDelta::FromMilliseconds(100));
-  }
-  return false;
-}
-
-void SetSuppressDebugUI(bool suppress) {
-  is_debug_ui_suppressed = suppress;
-}
-
-bool IsDebugUISuppressed() {
-  return is_debug_ui_suppressed;
-}
-
-}  // namespace debug
-}  // namespace base
diff --git a/base/debug/debugger.h b/base/debug/debugger.h
deleted file mode 100644
index 8680e28..0000000
--- a/base/debug/debugger.h
+++ /dev/null
@@ -1,44 +0,0 @@
-// Copyright (c) 2011 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.
-
-// This is a cross platform interface for helper functions related to
-// debuggers.  You should use this to test if you're running under a debugger,
-// and if you would like to yield (breakpoint) into the debugger.
-
-#ifndef BASE_DEBUG_DEBUGGER_H_
-#define BASE_DEBUG_DEBUGGER_H_
-
-#include "base/base_export.h"
-
-namespace base {
-namespace debug {
-
-// Waits wait_seconds seconds for a debugger to attach to the current process.
-// When silent is false, an exception is thrown when a debugger is detected.
-BASE_EXPORT bool WaitForDebugger(int wait_seconds, bool silent);
-
-// Returns true if the given process is being run under a debugger.
-//
-// On OS X, the underlying mechanism doesn't work when the sandbox is enabled.
-// To get around this, this function caches its value.
-//
-// WARNING: Because of this, on OS X, a call MUST be made to this function
-// BEFORE the sandbox is enabled.
-BASE_EXPORT bool BeingDebugged();
-
-// Break into the debugger, assumes a debugger is present.
-BASE_EXPORT void BreakDebugger();
-
-// Used in test code, this controls whether showing dialogs and breaking into
-// the debugger is suppressed for debug errors, even in debug mode (normally
-// release mode doesn't do this stuff --  this is controlled separately).
-// Normally UI is not suppressed.  This is normally used when running automated
-// tests where we want a crash rather than a dialog or a debugger.
-BASE_EXPORT void SetSuppressDebugUI(bool suppress);
-BASE_EXPORT bool IsDebugUISuppressed();
-
-}  // namespace debug
-}  // namespace base
-
-#endif  // BASE_DEBUG_DEBUGGER_H_
diff --git a/base/debug/debugger_posix.cc b/base/debug/debugger_posix.cc
deleted file mode 100644
index 63d9d52..0000000
--- a/base/debug/debugger_posix.cc
+++ /dev/null
@@ -1,272 +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/debug/debugger.h"
-
-#include <errno.h>
-#include <fcntl.h>
-#include <stddef.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <sys/param.h>
-#include <sys/stat.h>
-#include <sys/types.h>
-#include <unistd.h>
-
-#include <memory>
-#include <vector>
-
-#include "base/macros.h"
-#include "base/threading/platform_thread.h"
-#include "base/time/time.h"
-#include "build_config.h"
-
-#if defined(__GLIBCXX__)
-#include <cxxabi.h>
-#endif
-
-#if defined(OS_MACOSX)
-#include <AvailabilityMacros.h>
-#endif
-
-#if defined(OS_MACOSX) || defined(OS_BSD)
-#include <sys/sysctl.h>
-#endif
-
-#if defined(OS_FREEBSD)
-#include <sys/user.h>
-#endif
-
-#include <ostream>
-
-#include "base/debug/alias.h"
-#include "base/logging.h"
-#include "base/posix/eintr_wrapper.h"
-#include "base/strings/string_piece.h"
-
-#if defined(USE_SYMBOLIZE)
-#include "base/third_party/symbolize/symbolize.h"
-#endif
-
-#if defined(OS_ANDROID)
-#include "base/threading/platform_thread.h"
-#endif
-
-namespace base {
-namespace debug {
-
-#if defined(OS_MACOSX) || defined(OS_BSD)
-
-// Based on Apple's recommended method as described in
-// http://developer.apple.com/qa/qa2004/qa1361.html
-bool BeingDebugged() {
-  // NOTE: This code MUST be async-signal safe (it's used by in-process
-  // stack dumping signal handler). NO malloc or stdio is allowed here.
-  //
-  // While some code used below may be async-signal unsafe, note how
-  // the result is cached (see |is_set| and |being_debugged| static variables
-  // right below). If this code is properly warmed-up early
-  // in the start-up process, it should be safe to use later.
-
-  // If the process is sandboxed then we can't use the sysctl, so cache the
-  // value.
-  static bool is_set = false;
-  static bool being_debugged = false;
-
-  if (is_set)
-    return being_debugged;
-
-  // Initialize mib, which tells sysctl what info we want.  In this case,
-  // we're looking for information about a specific process ID.
-  int mib[] = {
-    CTL_KERN,
-    KERN_PROC,
-    KERN_PROC_PID,
-    getpid()
-#if defined(OS_OPENBSD)
-    , sizeof(struct kinfo_proc),
-    0
-#endif
-  };
-
-  // Caution: struct kinfo_proc is marked __APPLE_API_UNSTABLE.  The source and
-  // binary interfaces may change.
-  struct kinfo_proc info;
-  size_t info_size = sizeof(info);
-
-#if defined(OS_OPENBSD)
-  if (sysctl(mib, arraysize(mib), NULL, &info_size, NULL, 0) < 0)
-    return -1;
-
-  mib[5] = (info_size / sizeof(struct kinfo_proc));
-#endif
-
-  int sysctl_result = sysctl(mib, arraysize(mib), &info, &info_size, NULL, 0);
-  DCHECK_EQ(sysctl_result, 0);
-  if (sysctl_result != 0) {
-    is_set = true;
-    being_debugged = false;
-    return being_debugged;
-  }
-
-  // This process is being debugged if the P_TRACED flag is set.
-  is_set = true;
-#if defined(OS_FREEBSD)
-  being_debugged = (info.ki_flag & P_TRACED) != 0;
-#elif defined(OS_BSD)
-  being_debugged = (info.p_flag & P_TRACED) != 0;
-#else
-  being_debugged = (info.kp_proc.p_flag & P_TRACED) != 0;
-#endif
-  return being_debugged;
-}
-
-#elif defined(OS_LINUX) || defined(OS_ANDROID) || defined(OS_AIX)
-
-// We can look in /proc/self/status for TracerPid.  We are likely used in crash
-// handling, so we are careful not to use the heap or have side effects.
-// Another option that is common is to try to ptrace yourself, but then we
-// can't detach without forking(), and that's not so great.
-// static
-bool BeingDebugged() {
-  // NOTE: This code MUST be async-signal safe (it's used by in-process
-  // stack dumping signal handler). NO malloc or stdio is allowed here.
-
-  int status_fd = open("/proc/self/status", O_RDONLY);
-  if (status_fd == -1)
-    return false;
-
-  // We assume our line will be in the first 1024 characters and that we can
-  // read this much all at once.  In practice this will generally be true.
-  // This simplifies and speeds up things considerably.
-  char buf[1024];
-
-  ssize_t num_read = HANDLE_EINTR(read(status_fd, buf, sizeof(buf)));
-  if (IGNORE_EINTR(close(status_fd)) < 0)
-    return false;
-
-  if (num_read <= 0)
-    return false;
-
-  StringPiece status(buf, num_read);
-  StringPiece tracer("TracerPid:\t");
-
-  StringPiece::size_type pid_index = status.find(tracer);
-  if (pid_index == StringPiece::npos)
-    return false;
-
-  // Our pid is 0 without a debugger, assume this for any pid starting with 0.
-  pid_index += tracer.size();
-  return pid_index < status.size() && status[pid_index] != '0';
-}
-
-#elif defined(OS_FUCHSIA)
-
-bool BeingDebugged() {
-  // TODO(fuchsia): No gdb/gdbserver in the SDK yet.
-  return false;
-}
-
-#else
-
-bool BeingDebugged() {
-  NOTIMPLEMENTED();
-  return false;
-}
-
-#endif
-
-// We want to break into the debugger in Debug mode, and cause a crash dump in
-// Release mode. Breakpad behaves as follows:
-//
-// +-------+-----------------+-----------------+
-// | OS    | Dump on SIGTRAP | Dump on SIGABRT |
-// +-------+-----------------+-----------------+
-// | Linux |       N         |        Y        |
-// | Mac   |       Y         |        N        |
-// +-------+-----------------+-----------------+
-//
-// Thus we do the following:
-// Linux: Debug mode if a debugger is attached, send SIGTRAP; otherwise send
-//        SIGABRT
-// Mac: Always send SIGTRAP.
-
-#if defined(ARCH_CPU_ARMEL)
-#define DEBUG_BREAK_ASM() asm("bkpt 0")
-#elif defined(ARCH_CPU_ARM64)
-#define DEBUG_BREAK_ASM() asm("brk 0")
-#elif defined(ARCH_CPU_MIPS_FAMILY)
-#define DEBUG_BREAK_ASM() asm("break 2")
-#elif defined(ARCH_CPU_X86_FAMILY)
-#define DEBUG_BREAK_ASM() asm("int3")
-#endif
-
-#if defined(NDEBUG) && !defined(OS_MACOSX) && !defined(OS_ANDROID)
-#define DEBUG_BREAK() abort()
-#elif defined(OS_NACL)
-// The NaCl verifier doesn't let use use int3.  For now, we call abort().  We
-// should ask for advice from some NaCl experts about the optimum thing here.
-// http://code.google.com/p/nativeclient/issues/detail?id=645
-#define DEBUG_BREAK() abort()
-#elif !defined(OS_MACOSX)
-// Though Android has a "helpful" process called debuggerd to catch native
-// signals on the general assumption that they are fatal errors. If no debugger
-// is attached, we call abort since Breakpad needs SIGABRT to create a dump.
-// When debugger is attached, for ARM platform the bkpt instruction appears
-// to cause SIGBUS which is trapped by debuggerd, and we've had great
-// difficulty continuing in a debugger once we stop from SIG triggered by native
-// code, use GDB to set |go| to 1 to resume execution; for X86 platform, use
-// "int3" to setup breakpiont and raise SIGTRAP.
-//
-// On other POSIX architectures, except Mac OS X, we use the same logic to
-// ensure that breakpad creates a dump on crashes while it is still possible to
-// use a debugger.
-namespace {
-void DebugBreak() {
-  if (!BeingDebugged()) {
-    abort();
-  } else {
-#if defined(DEBUG_BREAK_ASM)
-    DEBUG_BREAK_ASM();
-#else
-    volatile int go = 0;
-    while (!go) {
-      base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(100));
-    }
-#endif
-  }
-}
-}  // namespace
-#define DEBUG_BREAK() DebugBreak()
-#elif defined(DEBUG_BREAK_ASM)
-#define DEBUG_BREAK() DEBUG_BREAK_ASM()
-#else
-#error "Don't know how to debug break on this architecture/OS"
-#endif
-
-void BreakDebugger() {
-  // NOTE: This code MUST be async-signal safe (it's used by in-process
-  // stack dumping signal handler). NO malloc or stdio is allowed here.
-
-  // Linker's ICF feature may merge this function with other functions with the
-  // same definition (e.g. any function whose sole job is to call abort()) and
-  // it may confuse the crash report processing system. http://crbug.com/508489
-  static int static_variable_to_make_this_function_unique = 0;
-  base::debug::Alias(&static_variable_to_make_this_function_unique);
-
-  DEBUG_BREAK();
-#if defined(OS_ANDROID) && !defined(OFFICIAL_BUILD)
-  // For Android development we always build release (debug builds are
-  // unmanageably large), so the unofficial build is used for debugging. It is
-  // helpful to be able to insert BreakDebugger() statements in the source,
-  // attach the debugger, inspect the state of the program and then resume it by
-  // setting the 'go' variable above.
-#elif defined(NDEBUG)
-  // Terminate the program after signaling the debug break.
-  _exit(1);
-#endif
-}
-
-}  // namespace debug
-}  // namespace base
diff --git a/base/debug/debugger_win.cc b/base/debug/debugger_win.cc
deleted file mode 100644
index a1d86e4..0000000
--- a/base/debug/debugger_win.cc
+++ /dev/null
@@ -1,25 +0,0 @@
-// Copyright (c) 2010 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/debug/debugger.h"
-
-#include <stdlib.h>
-#include <windows.h>
-
-namespace base {
-namespace debug {
-
-bool BeingDebugged() {
-  return ::IsDebuggerPresent() != 0;
-}
-
-void BreakDebugger() {
-  if (IsDebugUISuppressed())
-    _exit(1);
-
-  __debugbreak();
-}
-
-}  // namespace debug
-}  // namespace base
diff --git a/base/debug/dump_without_crashing.cc b/base/debug/dump_without_crashing.cc
deleted file mode 100644
index 1ab8c9c..0000000
--- a/base/debug/dump_without_crashing.cc
+++ /dev/null
@@ -1,41 +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/debug/dump_without_crashing.h"
-
-#include "base/logging.h"
-
-namespace {
-
-// Pointer to the function that's called by DumpWithoutCrashing() to dump the
-// process's memory.
-void(CDECL* dump_without_crashing_function_)() = nullptr;
-
-}  // namespace
-
-namespace base {
-
-namespace debug {
-
-bool DumpWithoutCrashing() {
-  if (dump_without_crashing_function_) {
-    (*dump_without_crashing_function_)();
-    return true;
-  }
-  return false;
-}
-
-void SetDumpWithoutCrashingFunction(void (CDECL *function)()) {
-#if !defined(COMPONENT_BUILD)
-  // In component builds, the same base is shared between modules
-  // so might be initialized several times. However in non-
-  // component builds this should never happen.
-  DCHECK(!dump_without_crashing_function_);
-#endif
-  dump_without_crashing_function_ = function;
-}
-
-}  // namespace debug
-
-}  // namespace base
diff --git a/base/debug/dump_without_crashing.h b/base/debug/dump_without_crashing.h
deleted file mode 100644
index c36973f..0000000
--- a/base/debug/dump_without_crashing.h
+++ /dev/null
@@ -1,37 +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_DEBUG_DUMP_WITHOUT_CRASHING_H_
-#define BASE_DEBUG_DUMP_WITHOUT_CRASHING_H_
-
-#include "base/base_export.h"
-#include "base/compiler_specific.h"
-#include "build_config.h"
-
-namespace base {
-
-namespace debug {
-
-// Handler to silently dump the current process without crashing.
-// Before calling this function, call SetDumpWithoutCrashingFunction to pass a
-// function pointer.
-// Windows:
-// This must be done for each instance of base (i.e. module) and is normally
-// chrome_elf!DumpProcessWithoutCrash. See example code in chrome_main.cc that
-// does this for chrome.dll and chrome_child.dll. Note: Crashpad sets this up
-// for main chrome.exe as part of calling crash_reporter::InitializeCrashpad.
-// Mac/Linux:
-// Crashpad does this as part of crash_reporter::InitializeCrashpad.
-// Returns false if called before SetDumpWithoutCrashingFunction.
-BASE_EXPORT bool DumpWithoutCrashing();
-
-// Sets a function that'll be invoked to dump the current process when
-// DumpWithoutCrashing() is called.
-BASE_EXPORT void SetDumpWithoutCrashingFunction(void (CDECL *function)());
-
-}  // namespace debug
-
-}  // namespace base
-
-#endif  // BASE_DEBUG_DUMP_WITHOUT_CRASHING_H_
diff --git a/base/debug/elf_reader_linux.cc b/base/debug/elf_reader_linux.cc
deleted file mode 100644
index cdf8193..0000000
--- a/base/debug/elf_reader_linux.cc
+++ /dev/null
@@ -1,132 +0,0 @@
-// Copyright 2018 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/debug/elf_reader_linux.h"
-
-#include <arpa/inet.h>
-#include <elf.h>
-
-#include <vector>
-
-#include "base/bits.h"
-#include "base/containers/span.h"
-#include "base/sha1.h"
-#include "base/strings/stringprintf.h"
-
-namespace base {
-namespace debug {
-
-namespace {
-
-#if __SIZEOF_POINTER__ == 4
-using Ehdr = Elf32_Ehdr;
-using Dyn = Elf32_Dyn;
-using Half = Elf32_Half;
-using Nhdr = Elf32_Nhdr;
-using Phdr = Elf32_Phdr;
-using Word = Elf32_Word;
-#else
-using Ehdr = Elf64_Ehdr;
-using Dyn = Elf64_Dyn;
-using Half = Elf64_Half;
-using Nhdr = Elf64_Nhdr;
-using Phdr = Elf64_Phdr;
-using Word = Elf64_Word;
-#endif
-
-using ElfSegment = span<const char>;
-
-Optional<std::string> ElfSegmentBuildIDNoteAsString(const ElfSegment& segment) {
-  const void* section_end = segment.data() + segment.size_bytes();
-  const Nhdr* note_header = reinterpret_cast<const Nhdr*>(segment.data());
-  while (note_header < section_end) {
-    if (note_header->n_type == NT_GNU_BUILD_ID)
-      break;
-    note_header = reinterpret_cast<const Nhdr*>(
-        reinterpret_cast<const char*>(note_header) + sizeof(Nhdr) +
-        bits::Align(note_header->n_namesz, 4) +
-        bits::Align(note_header->n_descsz, 4));
-  }
-
-  if (note_header >= section_end || note_header->n_descsz != kSHA1Length)
-    return nullopt;
-
-  const uint8_t* guid = reinterpret_cast<const uint8_t*>(note_header) +
-                        sizeof(Nhdr) + bits::Align(note_header->n_namesz, 4);
-
-  uint32_t dword = htonl(*reinterpret_cast<const int32_t*>(guid));
-  uint16_t word1 = htons(*reinterpret_cast<const int16_t*>(guid + 4));
-  uint16_t word2 = htons(*reinterpret_cast<const int16_t*>(guid + 6));
-  std::string identifier;
-  identifier.reserve(kSHA1Length * 2);  // as hex string
-  SStringPrintf(&identifier, "%08X%04X%04X", dword, word1, word2);
-  for (size_t i = 8; i < note_header->n_descsz; ++i)
-    StringAppendF(&identifier, "%02X", guid[i]);
-
-  return identifier;
-}
-
-std::vector<ElfSegment> FindElfSegments(const void* elf_mapped_base,
-                                        uint32_t segment_type) {
-  const char* elf_base = reinterpret_cast<const char*>(elf_mapped_base);
-  if (strncmp(elf_base, ELFMAG, SELFMAG) != 0)
-    return std::vector<ElfSegment>();
-
-  const Ehdr* elf_header = reinterpret_cast<const Ehdr*>(elf_base);
-  const Phdr* phdrs =
-      reinterpret_cast<const Phdr*>(elf_base + elf_header->e_phoff);
-  std::vector<ElfSegment> segments;
-  for (Half i = 0; i < elf_header->e_phnum; ++i) {
-    if (phdrs[i].p_type == segment_type)
-      segments.push_back({elf_base + phdrs[i].p_offset, phdrs[i].p_filesz});
-  }
-  return segments;
-}
-
-}  // namespace
-
-Optional<std::string> ReadElfBuildId(const void* elf_base) {
-  // Elf program headers can have multiple PT_NOTE arrays.
-  std::vector<ElfSegment> segs = FindElfSegments(elf_base, PT_NOTE);
-  if (segs.empty())
-    return nullopt;
-  Optional<std::string> id;
-  for (const ElfSegment& seg : segs) {
-    id = ElfSegmentBuildIDNoteAsString(seg);
-    if (id)
-      return id;
-  }
-
-  return nullopt;
-}
-
-Optional<std::string> ReadElfLibraryName(const void* elf_base) {
-  std::vector<ElfSegment> segs = FindElfSegments(elf_base, PT_DYNAMIC);
-  if (segs.empty())
-    return nullopt;
-  DCHECK_EQ(1u, segs.size());
-
-  const ElfSegment& dynamic_seg = segs.front();
-  const Dyn* dynamic_start = reinterpret_cast<const Dyn*>(dynamic_seg.data());
-  const Dyn* dynamic_end = reinterpret_cast<const Dyn*>(
-      dynamic_seg.data() + dynamic_seg.size_bytes());
-  Optional<std::string> soname;
-  Word soname_strtab_offset = 0;
-  const char* strtab_addr = 0;
-  for (const Dyn* dynamic_iter = dynamic_start; dynamic_iter < dynamic_end;
-       ++dynamic_iter) {
-    if (dynamic_iter->d_tag == DT_STRTAB) {
-      strtab_addr =
-          dynamic_iter->d_un.d_ptr + reinterpret_cast<const char*>(elf_base);
-    } else if (dynamic_iter->d_tag == DT_SONAME) {
-      soname_strtab_offset = dynamic_iter->d_un.d_val;
-    }
-  }
-  if (soname_strtab_offset && strtab_addr)
-    return std::string(strtab_addr + soname_strtab_offset);
-  return nullopt;
-}
-
-}  // namespace debug
-}  // namespace base
diff --git a/base/debug/elf_reader_linux.h b/base/debug/elf_reader_linux.h
deleted file mode 100644
index 4086dfb..0000000
--- a/base/debug/elf_reader_linux.h
+++ /dev/null
@@ -1,28 +0,0 @@
-// Copyright 2018 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_DEBUG_ELF_READER_LINUX_H_
-#define BASE_DEBUG_ELF_READER_LINUX_H_
-
-#include <string>
-
-#include "base/base_export.h"
-#include "base/optional.h"
-
-namespace base {
-namespace debug {
-
-// Returns the ELF section .note.gnu.build-id from the ELF file mapped at
-// |elf_base|, if present. The caller must ensure that the file is fully mapped
-// in memory.
-Optional<std::string> BASE_EXPORT ReadElfBuildId(const void* elf_base);
-
-// Returns the library name from the ELF file mapped at |elf_base|, if present.
-// The caller must ensure that the file is fully mapped in memory.
-Optional<std::string> BASE_EXPORT ReadElfLibraryName(const void* elf_base);
-
-}  // namespace debug
-}  // namespace base
-
-#endif  // BASE_DEBUG_ELF_READER_LINUX_H_
diff --git a/base/debug/gdi_debug_util_win.cc b/base/debug/gdi_debug_util_win.cc
deleted file mode 100644
index bf9827c..0000000
--- a/base/debug/gdi_debug_util_win.cc
+++ /dev/null
@@ -1,141 +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.
-#include "base/debug/gdi_debug_util_win.h"
-
-#include <algorithm>
-#include <cmath>
-
-#include <psapi.h>
-#include <stddef.h>
-#include <TlHelp32.h>
-
-#include "base/debug/alias.h"
-#include "base/logging.h"
-#include "base/win/scoped_handle.h"
-#include "base/win/win_util.h"
-
-namespace {
-
-void CollectChildGDIUsageAndDie(DWORD parent_pid) {
-  HANDLE snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
-  CHECK_NE(INVALID_HANDLE_VALUE, snapshot);
-
-  int total_process_count = 0;
-  base::debug::Alias(&total_process_count);
-  int total_peak_gdi_count = 0;
-  base::debug::Alias(&total_peak_gdi_count);
-  int total_gdi_count = 0;
-  base::debug::Alias(&total_gdi_count);
-  int total_user_count = 0;
-  base::debug::Alias(&total_user_count);
-
-  int child_count = 0;
-  base::debug::Alias(&child_count);
-  int peak_gdi_count = 0;
-  base::debug::Alias(&peak_gdi_count);
-  int sum_gdi_count = 0;
-  base::debug::Alias(&sum_gdi_count);
-  int sum_user_count = 0;
-  base::debug::Alias(&sum_user_count);
-
-  PROCESSENTRY32 proc_entry = {0};
-  proc_entry.dwSize = sizeof(PROCESSENTRY32);
-  CHECK(Process32First(snapshot, &proc_entry));
-
-  do {
-    base::win::ScopedHandle process(
-        OpenProcess(PROCESS_QUERY_INFORMATION,
-                    FALSE,
-                    proc_entry.th32ProcessID));
-    if (!process.IsValid())
-      continue;
-
-    int num_gdi_handles = GetGuiResources(process.Get(), GR_GDIOBJECTS);
-    int num_user_handles = GetGuiResources(process.Get(), GR_USEROBJECTS);
-
-    // Compute sum and peak counts for all processes.
-    ++total_process_count;
-    total_user_count += num_user_handles;
-    total_gdi_count += num_gdi_handles;
-    total_peak_gdi_count = std::max(total_peak_gdi_count, num_gdi_handles);
-
-    if (parent_pid != proc_entry.th32ParentProcessID)
-      continue;
-
-    // Compute sum and peak counts for child processes.
-    ++child_count;
-    sum_user_count += num_user_handles;
-    sum_gdi_count += num_gdi_handles;
-    peak_gdi_count = std::max(peak_gdi_count, num_gdi_handles);
-
-  } while (Process32Next(snapshot, &proc_entry));
-
-  CloseHandle(snapshot);
-  CHECK(false);
-}
-
-}  // namespace
-
-namespace base {
-namespace debug {
-
-void CollectGDIUsageAndDie(BITMAPINFOHEADER* header, HANDLE shared_section) {
-  // Make sure parameters are saved in the minidump.
-  DWORD last_error = GetLastError();
-  bool is_gdi_available = base::win::IsUser32AndGdi32Available();
-
-  LONG width = header ? header->biWidth : 0;
-  LONG height = header ? header->biHeight : 0;
-
-  base::debug::Alias(&last_error);
-  base::debug::Alias(&is_gdi_available);
-  base::debug::Alias(&width);
-  base::debug::Alias(&height);
-  base::debug::Alias(&shared_section);
-
-  DWORD num_user_handles = GetGuiResources(GetCurrentProcess(), GR_USEROBJECTS);
-
-  DWORD num_gdi_handles = GetGuiResources(GetCurrentProcess(), GR_GDIOBJECTS);
-  if (num_gdi_handles == 0) {
-    DWORD get_gui_resources_error = GetLastError();
-    base::debug::Alias(&get_gui_resources_error);
-    CHECK(false);
-  }
-
-  base::debug::Alias(&num_gdi_handles);
-  base::debug::Alias(&num_user_handles);
-
-  const DWORD kLotsOfHandles = 9990;
-  CHECK_LE(num_gdi_handles, kLotsOfHandles);
-
-  PROCESS_MEMORY_COUNTERS_EX pmc;
-  pmc.cb = sizeof(pmc);
-  CHECK(GetProcessMemoryInfo(GetCurrentProcess(),
-                             reinterpret_cast<PROCESS_MEMORY_COUNTERS*>(&pmc),
-                             sizeof(pmc)));
-  const size_t kLotsOfMemory = 1500 * 1024 * 1024; // 1.5GB
-  CHECK_LE(pmc.PagefileUsage, kLotsOfMemory);
-  CHECK_LE(pmc.PrivateUsage, kLotsOfMemory);
-
-  void* small_data = nullptr;
-  base::debug::Alias(&small_data);
-
-  if (std::abs(height) * width > 100) {
-    // Huh, that's weird.  We don't have crazy handle count, we don't have
-    // ridiculous memory usage. Try to allocate a small bitmap and see if that
-    // fails too.
-    header->biWidth = 5;
-    header->biHeight = -5;
-    HBITMAP small_bitmap = CreateDIBSection(
-        nullptr, reinterpret_cast<BITMAPINFO*>(&header),
-        0, &small_data, shared_section, 0);
-    CHECK(small_bitmap != nullptr);
-    DeleteObject(small_bitmap);
-  }
-  // Maybe the child processes are the ones leaking GDI or USER resouces.
-  CollectChildGDIUsageAndDie(GetCurrentProcessId());
-}
-
-}  // namespace debug
-}  // namespace base
diff --git a/base/debug/gdi_debug_util_win.h b/base/debug/gdi_debug_util_win.h
deleted file mode 100644
index 3383a4d..0000000
--- a/base/debug/gdi_debug_util_win.h
+++ /dev/null
@@ -1,25 +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_DEBUG_GDI_DEBUG_UTIL_WIN_H_
-#define BASE_DEBUG_GDI_DEBUG_UTIL_WIN_H_
-
-#include <windows.h>
-
-#include "base/base_export.h"
-
-namespace base {
-namespace debug {
-
-// Crashes the process, using base::debug::Alias to leave valuable debugging
-// information in the crash dump. Pass values for |header| and |shared_section|
-// in the event of a bitmap allocation failure, to gather information about
-// those as well.
-void BASE_EXPORT CollectGDIUsageAndDie(BITMAPINFOHEADER* header = nullptr,
-                                       HANDLE shared_section = nullptr);
-
-}  // namespace debug
-}  // namespace base
-
-#endif  // BASE_DEBUG_GDI_DEBUG_UTIL_WIN_H_
diff --git a/base/debug/leak_annotations.h b/base/debug/leak_annotations.h
deleted file mode 100644
index f1a2d07..0000000
--- a/base/debug/leak_annotations.h
+++ /dev/null
@@ -1,46 +0,0 @@
-// Copyright (c) 2011 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_DEBUG_LEAK_ANNOTATIONS_H_
-#define BASE_DEBUG_LEAK_ANNOTATIONS_H_
-
-#include "base/macros.h"
-#include "build_config.h"
-
-// This file defines macros which can be used to annotate intentional memory
-// leaks. Support for annotations is implemented in LeakSanitizer. Annotated
-// objects will be treated as a source of live pointers, i.e. any heap objects
-// reachable by following pointers from an annotated object will not be
-// reported as leaks.
-//
-// ANNOTATE_SCOPED_MEMORY_LEAK: all allocations made in the current scope
-// will be annotated as leaks.
-// ANNOTATE_LEAKING_OBJECT_PTR(X): the heap object referenced by pointer X will
-// be annotated as a leak.
-
-#if defined(LEAK_SANITIZER) && !defined(OS_NACL)
-
-#include <sanitizer/lsan_interface.h>
-
-class ScopedLeakSanitizerDisabler {
- public:
-  ScopedLeakSanitizerDisabler() { __lsan_disable(); }
-  ~ScopedLeakSanitizerDisabler() { __lsan_enable(); }
- private:
-  DISALLOW_COPY_AND_ASSIGN(ScopedLeakSanitizerDisabler);
-};
-
-#define ANNOTATE_SCOPED_MEMORY_LEAK \
-    ScopedLeakSanitizerDisabler leak_sanitizer_disabler; static_cast<void>(0)
-
-#define ANNOTATE_LEAKING_OBJECT_PTR(X) __lsan_ignore_object(X);
-
-#else
-
-#define ANNOTATE_SCOPED_MEMORY_LEAK ((void)0)
-#define ANNOTATE_LEAKING_OBJECT_PTR(X) ((void)0)
-
-#endif
-
-#endif  // BASE_DEBUG_LEAK_ANNOTATIONS_H_
diff --git a/base/debug/leak_tracker.h b/base/debug/leak_tracker.h
deleted file mode 100644
index 43f2102..0000000
--- a/base/debug/leak_tracker.h
+++ /dev/null
@@ -1,142 +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_DEBUG_LEAK_TRACKER_H_
-#define BASE_DEBUG_LEAK_TRACKER_H_
-
-#include <stddef.h>
-
-#include "build_config.h"
-
-// Only enable leak tracking in non-uClibc debug builds.
-#if !defined(NDEBUG) && !defined(__UCLIBC__)
-#define ENABLE_LEAK_TRACKER
-#endif
-
-#ifdef ENABLE_LEAK_TRACKER
-#include "base/containers/linked_list.h"
-#include "base/debug/stack_trace.h"
-#include "base/logging.h"
-#endif  // ENABLE_LEAK_TRACKER
-
-// LeakTracker is a helper to verify that all instances of a class
-// have been destroyed.
-//
-// It is particularly useful for classes that are bound to a single thread --
-// before destroying that thread, one can check that there are no remaining
-// instances of that class.
-//
-// For example, to enable leak tracking for class net::URLRequest, start by
-// adding a member variable of type LeakTracker<net::URLRequest>.
-//
-//   class URLRequest {
-//     ...
-//    private:
-//     base::LeakTracker<URLRequest> leak_tracker_;
-//   };
-//
-//
-// Next, when we believe all instances of net::URLRequest have been deleted:
-//
-//   LeakTracker<net::URLRequest>::CheckForLeaks();
-//
-// Should the check fail (because there are live instances of net::URLRequest),
-// then the allocation callstack for each leaked instances is dumped to
-// the error log.
-//
-// If ENABLE_LEAK_TRACKER is not defined, then the check has no effect.
-
-namespace base {
-namespace debug {
-
-#ifndef ENABLE_LEAK_TRACKER
-
-// If leak tracking is disabled, do nothing.
-template<typename T>
-class LeakTracker {
- public:
-  // This destructor suppresses warnings about instances of this class not being
-  // used.
-  ~LeakTracker() {}
-  static void CheckForLeaks() {}
-  static int NumLiveInstances() { return -1; }
-};
-
-#else
-
-// If leak tracking is enabled we track where the object was allocated from.
-
-template<typename T>
-class LeakTracker : public LinkNode<LeakTracker<T> > {
- public:
-  LeakTracker() {
-    instances()->Append(this);
-  }
-
-  ~LeakTracker() {
-    this->RemoveFromList();
-  }
-
-  static void CheckForLeaks() {
-    // Walk the allocation list and print each entry it contains.
-    size_t count = 0;
-
-    // Copy the first 3 leak allocation callstacks onto the stack.
-    // This way if we hit the CHECK() in a release build, the leak
-    // information will be available in mini-dump.
-    const size_t kMaxStackTracesToCopyOntoStack = 3;
-    StackTrace stacktraces[kMaxStackTracesToCopyOntoStack];
-
-    for (LinkNode<LeakTracker<T> >* node = instances()->head();
-         node != instances()->end();
-         node = node->next()) {
-      StackTrace& allocation_stack = node->value()->allocation_stack_;
-
-      if (count < kMaxStackTracesToCopyOntoStack)
-        stacktraces[count] = allocation_stack;
-
-      ++count;
-      if (LOG_IS_ON(ERROR)) {
-        LOG_STREAM(ERROR) << "Leaked " << node << " which was allocated by:";
-        allocation_stack.OutputToStream(&LOG_STREAM(ERROR));
-      }
-    }
-
-    CHECK_EQ(0u, count);
-
-    // Hack to keep |stacktraces| and |count| alive (so compiler
-    // doesn't optimize it out, and it will appear in mini-dumps).
-    if (count == 0x1234) {
-      for (size_t i = 0; i < kMaxStackTracesToCopyOntoStack; ++i)
-        stacktraces[i].Print();
-    }
-  }
-
-  static int NumLiveInstances() {
-    // Walk the allocation list and count how many entries it has.
-    int count = 0;
-    for (LinkNode<LeakTracker<T> >* node = instances()->head();
-         node != instances()->end();
-         node = node->next()) {
-      ++count;
-    }
-    return count;
-  }
-
- private:
-  // Each specialization of LeakTracker gets its own static storage.
-  static LinkedList<LeakTracker<T> >* instances() {
-    static LinkedList<LeakTracker<T> > list;
-    return &list;
-  }
-
-  StackTrace allocation_stack_;
-};
-
-#endif  // ENABLE_LEAK_TRACKER
-
-}  // namespace debug
-}  // namespace base
-
-#endif  // BASE_DEBUG_LEAK_TRACKER_H_
diff --git a/base/debug/proc_maps_linux.cc b/base/debug/proc_maps_linux.cc
deleted file mode 100644
index 1a9476f..0000000
--- a/base/debug/proc_maps_linux.cc
+++ /dev/null
@@ -1,169 +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/debug/proc_maps_linux.h"
-
-#include <fcntl.h>
-#include <stddef.h>
-
-#include "base/files/file_util.h"
-#include "base/files/scoped_file.h"
-#include "base/strings/string_split.h"
-#include "build_config.h"
-
-#if defined(OS_LINUX) || defined(OS_ANDROID)
-#include <inttypes.h>
-#endif
-
-#if defined(OS_ANDROID) && !defined(__LP64__)
-// In 32-bit mode, Bionic's inttypes.h defines PRI/SCNxPTR as an
-// unsigned long int, which is incompatible with Bionic's stdint.h
-// defining uintptr_t as an unsigned int:
-// https://code.google.com/p/android/issues/detail?id=57218
-#undef SCNxPTR
-#define SCNxPTR "x"
-#endif
-
-namespace base {
-namespace debug {
-
-// Scans |proc_maps| starting from |pos| returning true if the gate VMA was
-// found, otherwise returns false.
-static bool ContainsGateVMA(std::string* proc_maps, size_t pos) {
-#if defined(ARCH_CPU_ARM_FAMILY)
-  // The gate VMA on ARM kernels is the interrupt vectors page.
-  return proc_maps->find(" [vectors]\n", pos) != std::string::npos;
-#elif defined(ARCH_CPU_X86_64)
-  // The gate VMA on x86 64-bit kernels is the virtual system call page.
-  return proc_maps->find(" [vsyscall]\n", pos) != std::string::npos;
-#else
-  // Otherwise assume there is no gate VMA in which case we shouldn't
-  // get duplicate entires.
-  return false;
-#endif
-}
-
-bool ReadProcMaps(std::string* proc_maps) {
-  // seq_file only writes out a page-sized amount on each call. Refer to header
-  // file for details.
-  const long kReadSize = sysconf(_SC_PAGESIZE);
-
-  base::ScopedFD fd(HANDLE_EINTR(open("/proc/self/maps", O_RDONLY)));
-  if (!fd.is_valid()) {
-    DPLOG(ERROR) << "Couldn't open /proc/self/maps";
-    return false;
-  }
-  proc_maps->clear();
-
-  while (true) {
-    // To avoid a copy, resize |proc_maps| so read() can write directly into it.
-    // Compute |buffer| afterwards since resize() may reallocate.
-    size_t pos = proc_maps->size();
-    proc_maps->resize(pos + kReadSize);
-    void* buffer = &(*proc_maps)[pos];
-
-    ssize_t bytes_read = HANDLE_EINTR(read(fd.get(), buffer, kReadSize));
-    if (bytes_read < 0) {
-      DPLOG(ERROR) << "Couldn't read /proc/self/maps";
-      proc_maps->clear();
-      return false;
-    }
-
-    // ... and don't forget to trim off excess bytes.
-    proc_maps->resize(pos + bytes_read);
-
-    if (bytes_read == 0)
-      break;
-
-    // The gate VMA is handled as a special case after seq_file has finished
-    // iterating through all entries in the virtual memory table.
-    //
-    // Unfortunately, if additional entries are added at this point in time
-    // seq_file gets confused and the next call to read() will return duplicate
-    // entries including the gate VMA again.
-    //
-    // Avoid this by searching for the gate VMA and breaking early.
-    if (ContainsGateVMA(proc_maps, pos))
-      break;
-  }
-
-  return true;
-}
-
-bool ParseProcMaps(const std::string& input,
-                   std::vector<MappedMemoryRegion>* regions_out) {
-  CHECK(regions_out);
-  std::vector<MappedMemoryRegion> regions;
-
-  // This isn't async safe nor terribly efficient, but it doesn't need to be at
-  // this point in time.
-  std::vector<std::string> lines = SplitString(
-      input, "\n", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
-
-  for (size_t i = 0; i < lines.size(); ++i) {
-    // Due to splitting on '\n' the last line should be empty.
-    if (i == lines.size() - 1) {
-      if (!lines[i].empty()) {
-        DLOG(WARNING) << "Last line not empty";
-        return false;
-      }
-      break;
-    }
-
-    MappedMemoryRegion region;
-    const char* line = lines[i].c_str();
-    char permissions[5] = {'\0'};  // Ensure NUL-terminated string.
-    uint8_t dev_major = 0;
-    uint8_t dev_minor = 0;
-    long inode = 0;
-    int path_index = 0;
-
-    // Sample format from man 5 proc:
-    //
-    // address           perms offset  dev   inode   pathname
-    // 08048000-08056000 r-xp 00000000 03:0c 64593   /usr/sbin/gpm
-    //
-    // The final %n term captures the offset in the input string, which is used
-    // to determine the path name. It *does not* increment the return value.
-    // Refer to man 3 sscanf for details.
-    if (sscanf(line, "%" SCNxPTR "-%" SCNxPTR " %4c %llx %hhx:%hhx %ld %n",
-               &region.start, &region.end, permissions, &region.offset,
-               &dev_major, &dev_minor, &inode, &path_index) < 7) {
-      DPLOG(WARNING) << "sscanf failed for line: " << line;
-      return false;
-    }
-
-    region.permissions = 0;
-
-    if (permissions[0] == 'r')
-      region.permissions |= MappedMemoryRegion::READ;
-    else if (permissions[0] != '-')
-      return false;
-
-    if (permissions[1] == 'w')
-      region.permissions |= MappedMemoryRegion::WRITE;
-    else if (permissions[1] != '-')
-      return false;
-
-    if (permissions[2] == 'x')
-      region.permissions |= MappedMemoryRegion::EXECUTE;
-    else if (permissions[2] != '-')
-      return false;
-
-    if (permissions[3] == 'p')
-      region.permissions |= MappedMemoryRegion::PRIVATE;
-    else if (permissions[3] != 's' && permissions[3] != 'S')  // Shared memory.
-      return false;
-
-    // Pushing then assigning saves us a string copy.
-    regions.push_back(region);
-    regions.back().path.assign(line + path_index);
-  }
-
-  regions_out->swap(regions);
-  return true;
-}
-
-}  // namespace debug
-}  // namespace base
diff --git a/base/debug/proc_maps_linux.h b/base/debug/proc_maps_linux.h
deleted file mode 100644
index f5f8a59..0000000
--- a/base/debug/proc_maps_linux.h
+++ /dev/null
@@ -1,94 +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.
-
-#ifndef BASE_DEBUG_PROC_MAPS_LINUX_H_
-#define BASE_DEBUG_PROC_MAPS_LINUX_H_
-
-#include <stdint.h>
-
-#include <string>
-#include <vector>
-
-#include "base/base_export.h"
-
-namespace base {
-namespace debug {
-
-// Describes a region of mapped memory and the path of the file mapped.
-struct MappedMemoryRegion {
-  enum Permission {
-    READ = 1 << 0,
-    WRITE = 1 << 1,
-    EXECUTE = 1 << 2,
-    PRIVATE = 1 << 3,  // If set, region is private, otherwise it is shared.
-  };
-
-  // The address range [start,end) of mapped memory.
-  uintptr_t start;
-  uintptr_t end;
-
-  // Byte offset into |path| of the range mapped into memory.
-  unsigned long long offset;
-
-  // Image base, if this mapping corresponds to an ELF image.
-  uintptr_t base;
-
-  // Bitmask of read/write/execute/private/shared permissions.
-  uint8_t permissions;
-
-  // Name of the file mapped into memory.
-  //
-  // NOTE: path names aren't guaranteed to point at valid files. For example,
-  // "[heap]" and "[stack]" are used to represent the location of the process'
-  // heap and stack, respectively.
-  std::string path;
-};
-
-// Reads the data from /proc/self/maps and stores the result in |proc_maps|.
-// Returns true if successful, false otherwise.
-//
-// There is *NO* guarantee that the resulting contents will be free of
-// duplicates or even contain valid entries by time the method returns.
-//
-//
-// THE GORY DETAILS
-//
-// Did you know it's next-to-impossible to atomically read the whole contents
-// of /proc/<pid>/maps? You would think that if we passed in a large-enough
-// buffer to read() that It Should Just Work(tm), but sadly that's not the case.
-//
-// Linux's procfs uses seq_file [1] for handling iteration, text formatting,
-// and dealing with resulting data that is larger than the size of a page. That
-// last bit is especially important because it means that seq_file will never
-// return more than the size of a page in a single call to read().
-//
-// Unfortunately for a program like Chrome the size of /proc/self/maps is
-// larger than the size of page so we're forced to call read() multiple times.
-// If the virtual memory table changed in any way between calls to read() (e.g.,
-// a different thread calling mprotect()), it can make seq_file generate
-// duplicate entries or skip entries.
-//
-// Even if seq_file was changed to keep flushing the contents of its page-sized
-// buffer to the usermode buffer inside a single call to read(), it has to
-// release its lock on the virtual memory table to handle page faults while
-// copying data to usermode. This puts us in the same situation where the table
-// can change while we're copying data.
-//
-// Alternatives such as fork()-and-suspend-the-parent-while-child-reads were
-// attempted, but they present more subtle problems than it's worth. Depending
-// on your use case your best bet may be to read /proc/<pid>/maps prior to
-// starting other threads.
-//
-// [1] http://kernelnewbies.org/Documents/SeqFileHowTo
-BASE_EXPORT bool ReadProcMaps(std::string* proc_maps);
-
-// Parses /proc/<pid>/maps input data and stores in |regions|. Returns true
-// and updates |regions| if and only if all of |input| was successfully parsed.
-BASE_EXPORT bool ParseProcMaps(const std::string& input,
-                               std::vector<MappedMemoryRegion>* regions);
-
-}  // namespace debug
-}  // namespace base
-
-#endif  // BASE_DEBUG_PROC_MAPS_LINUX_H_
diff --git a/base/debug/profiler.cc b/base/debug/profiler.cc
deleted file mode 100644
index 82e5229..0000000
--- a/base/debug/profiler.cc
+++ /dev/null
@@ -1,142 +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/debug/profiler.h"
-
-#include <string>
-
-#include "base/process/process_handle.h"
-#include "base/strings/string_number_conversions.h"
-#include "base/strings/string_util.h"
-#include "build_config.h"
-
-#if defined(OS_WIN)
-#include "base/win/current_module.h"
-#include "base/win/pe_image.h"
-#endif  // defined(OS_WIN)
-
-namespace base {
-namespace debug {
-
-void StartProfiling(const std::string& name) {
-}
-
-void StopProfiling() {
-}
-
-void FlushProfiling() {
-}
-
-bool BeingProfiled() {
-  return false;
-}
-
-void RestartProfilingAfterFork() {
-}
-
-bool IsProfilingSupported() {
-  return false;
-}
-
-#if !defined(OS_WIN)
-
-ReturnAddressLocationResolver GetProfilerReturnAddrResolutionFunc() {
-  return nullptr;
-}
-
-DynamicFunctionEntryHook GetProfilerDynamicFunctionEntryHookFunc() {
-  return nullptr;
-}
-
-AddDynamicSymbol GetProfilerAddDynamicSymbolFunc() {
-  return nullptr;
-}
-
-MoveDynamicSymbol GetProfilerMoveDynamicSymbolFunc() {
-  return nullptr;
-}
-
-#else  // defined(OS_WIN)
-
-namespace {
-
-struct FunctionSearchContext {
-  const char* name;
-  FARPROC function;
-};
-
-// Callback function to PEImage::EnumImportChunks.
-bool FindResolutionFunctionInImports(
-    const base::win::PEImage &image, const char* module_name,
-    PIMAGE_THUNK_DATA unused_name_table, PIMAGE_THUNK_DATA import_address_table,
-    PVOID cookie) {
-  FunctionSearchContext* context =
-      reinterpret_cast<FunctionSearchContext*>(cookie);
-
-  DCHECK(context);
-  DCHECK(!context->function);
-
-  // Our import address table contains pointers to the functions we import
-  // at this point. Let's retrieve the first such function and use it to
-  // find the module this import was resolved to by the loader.
-  const wchar_t* function_in_module =
-      reinterpret_cast<const wchar_t*>(import_address_table->u1.Function);
-
-  // Retrieve the module by a function in the module.
-  const DWORD kFlags = GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS |
-                       GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT;
-  HMODULE module = NULL;
-  if (!::GetModuleHandleEx(kFlags, function_in_module, &module)) {
-    // This can happen if someone IAT patches us to a thunk.
-    return true;
-  }
-
-  // See whether this module exports the function we're looking for.
-  FARPROC exported_func = ::GetProcAddress(module, context->name);
-  if (exported_func != NULL) {
-    // We found it, return the function and terminate the enumeration.
-    context->function = exported_func;
-    return false;
-  }
-
-  // Keep going.
-  return true;
-}
-
-template <typename FunctionType>
-FunctionType FindFunctionInImports(const char* function_name) {
-  base::win::PEImage image(CURRENT_MODULE());
-
-  FunctionSearchContext ctx = { function_name, NULL };
-  image.EnumImportChunks(FindResolutionFunctionInImports, &ctx);
-
-  return reinterpret_cast<FunctionType>(ctx.function);
-}
-
-}  // namespace
-
-ReturnAddressLocationResolver GetProfilerReturnAddrResolutionFunc() {
-  return FindFunctionInImports<ReturnAddressLocationResolver>(
-      "ResolveReturnAddressLocation");
-}
-
-DynamicFunctionEntryHook GetProfilerDynamicFunctionEntryHookFunc() {
-  return FindFunctionInImports<DynamicFunctionEntryHook>(
-      "OnDynamicFunctionEntry");
-}
-
-AddDynamicSymbol GetProfilerAddDynamicSymbolFunc() {
-  return FindFunctionInImports<AddDynamicSymbol>(
-      "AddDynamicSymbol");
-}
-
-MoveDynamicSymbol GetProfilerMoveDynamicSymbolFunc() {
-  return FindFunctionInImports<MoveDynamicSymbol>(
-      "MoveDynamicSymbol");
-}
-
-#endif  // defined(OS_WIN)
-
-}  // namespace debug
-}  // namespace base
diff --git a/base/debug/profiler.h b/base/debug/profiler.h
deleted file mode 100644
index f706a1a..0000000
--- a/base/debug/profiler.h
+++ /dev/null
@@ -1,91 +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_DEBUG_PROFILER_H_
-#define BASE_DEBUG_PROFILER_H_
-
-#include <stddef.h>
-
-#include <string>
-
-#include "base/base_export.h"
-
-// The Profiler functions allow usage of the underlying sampling based
-// profiler. If the application has not been built with the necessary
-// flags (-DENABLE_PROFILING and not -DNO_TCMALLOC) then these functions
-// are noops.
-namespace base {
-namespace debug {
-
-// Start profiling with the supplied name.
-// {pid} will be replaced by the process' pid and {count} will be replaced
-// by the count of the profile run (starts at 1 with each process).
-BASE_EXPORT void StartProfiling(const std::string& name);
-
-// Stop profiling and write out data.
-BASE_EXPORT void StopProfiling();
-
-// Force data to be written to file.
-BASE_EXPORT void FlushProfiling();
-
-// Returns true if process is being profiled.
-BASE_EXPORT bool BeingProfiled();
-
-// Reset profiling after a fork, which disables timers.
-BASE_EXPORT void RestartProfilingAfterFork();
-
-// Returns true iff this executable supports profiling.
-BASE_EXPORT bool IsProfilingSupported();
-
-// There's a class of profilers that use "return address swizzling" to get a
-// hook on function exits. This class of profilers uses some form of entry hook,
-// like e.g. binary instrumentation, or a compiler flag, that calls a hook each
-// time a function is invoked. The hook then switches the return address on the
-// stack for the address of an exit hook function, and pushes the original
-// return address to a shadow stack of some type. When in due course the CPU
-// executes a return to the exit hook, the exit hook will do whatever work it
-// does on function exit, then arrange to return to the original return address.
-// This class of profiler does not play well with programs that look at the
-// return address, as does e.g. V8. V8 uses the return address to certain
-// runtime functions to find the JIT code that called it, and from there finds
-// the V8 data structures associated to the JS function involved.
-// A return address resolution function is used to fix this. It allows such
-// programs to resolve a location on stack where a return address originally
-// resided, to the shadow stack location where the profiler stashed it.
-typedef uintptr_t (*ReturnAddressLocationResolver)(
-    uintptr_t return_addr_location);
-
-// This type declaration must match V8's FunctionEntryHook.
-typedef void (*DynamicFunctionEntryHook)(uintptr_t function,
-                                         uintptr_t return_addr_location);
-
-// The functions below here are to support profiling V8-generated code.
-// V8 has provisions for generating a call to an entry hook for newly generated
-// JIT code, and it can push symbol information on code generation and advise
-// when the garbage collector moves code. The functions declarations below here
-// make glue between V8's facilities and a profiler.
-
-// This type declaration must match V8's FunctionEntryHook.
-typedef void (*DynamicFunctionEntryHook)(uintptr_t function,
-                                         uintptr_t return_addr_location);
-
-typedef void (*AddDynamicSymbol)(const void* address,
-                                 size_t length,
-                                 const char* name,
-                                 size_t name_len);
-typedef void (*MoveDynamicSymbol)(const void* address, const void* new_address);
-
-
-// If this binary is instrumented and the instrumentation supplies a function
-// for each of those purposes, find and return the function in question.
-// Otherwise returns NULL.
-BASE_EXPORT ReturnAddressLocationResolver GetProfilerReturnAddrResolutionFunc();
-BASE_EXPORT DynamicFunctionEntryHook GetProfilerDynamicFunctionEntryHookFunc();
-BASE_EXPORT AddDynamicSymbol GetProfilerAddDynamicSymbolFunc();
-BASE_EXPORT MoveDynamicSymbol GetProfilerMoveDynamicSymbolFunc();
-
-}  // namespace debug
-}  // namespace base
-
-#endif  // BASE_DEBUG_PROFILER_H_
diff --git a/base/debug/stack_trace.cc b/base/debug/stack_trace.cc
deleted file mode 100644
index 3a63dae..0000000
--- a/base/debug/stack_trace.cc
+++ /dev/null
@@ -1,43 +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/debug/stack_trace.h"
-
-#include <string.h>
-
-#include <algorithm>
-#include <sstream>
-
-#include "base/logging.h"
-#include "base/macros.h"
-
-namespace base {
-namespace debug {
-
-StackTrace::StackTrace() : StackTrace(arraysize(trace_)) {}
-
-StackTrace::StackTrace(const void* const* trace, size_t count) {
-  count = std::min(count, arraysize(trace_));
-  if (count)
-    memcpy(trace_, trace, count * sizeof(trace_[0]));
-  count_ = count;
-}
-
-const void *const *StackTrace::Addresses(size_t* count) const {
-  *count = count_;
-  if (count_)
-    return trace_;
-  return nullptr;
-}
-
-std::string StackTrace::ToString() const {
-  std::stringstream stream;
-#if !defined(__UCLIBC__) && !defined(_AIX)
-  OutputToStream(&stream);
-#endif
-  return stream.str();
-}
-
-}  // namespace debug
-}  // namespace base
diff --git a/base/debug/stack_trace.h b/base/debug/stack_trace.h
deleted file mode 100644
index 33023fe..0000000
--- a/base/debug/stack_trace.h
+++ /dev/null
@@ -1,126 +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_DEBUG_STACK_TRACE_H_
-#define BASE_DEBUG_STACK_TRACE_H_
-
-#include <stddef.h>
-
-#include <iosfwd>
-#include <string>
-
-#include "base/base_export.h"
-#include "base/macros.h"
-#include "build_config.h"
-
-#if defined(OS_POSIX)
-#include <unistd.h>
-#endif
-
-#if defined(OS_WIN)
-struct _EXCEPTION_POINTERS;
-struct _CONTEXT;
-#endif
-
-namespace base {
-namespace debug {
-
-// Enables stack dump to console output on exception and signals.
-// When enabled, the process will quit immediately. This is meant to be used in
-// unit_tests only! This is not thread-safe: only call from main thread.
-// In sandboxed processes, this has to be called before the sandbox is turned
-// on.
-// Calling this function on Linux opens /proc/self/maps and caches its
-// contents. In non-official builds, this function also opens the object files
-// that are loaded in memory and caches their file descriptors (this cannot be
-// done in official builds because it has security implications).
-BASE_EXPORT bool EnableInProcessStackDumping();
-
-#if defined(OS_POSIX)
-BASE_EXPORT void SetStackDumpFirstChanceCallback(bool (*handler)(int,
-                                                                 void*,
-                                                                 void*));
-#endif
-
-// A stacktrace can be helpful in debugging. For example, you can include a
-// stacktrace member in a object (probably around #ifndef NDEBUG) so that you
-// can later see where the given object was created from.
-class BASE_EXPORT StackTrace {
- public:
-  // Creates a stacktrace from the current location.
-  StackTrace();
-
-  // Creates a stacktrace from the current location, of up to |count| entries.
-  // |count| will be limited to at most |kMaxTraces|.
-  explicit StackTrace(size_t count);
-
-  // Creates a stacktrace from an existing array of instruction
-  // pointers (such as returned by Addresses()).  |count| will be
-  // limited to at most |kMaxTraces|.
-  StackTrace(const void* const* trace, size_t count);
-
-#if defined(OS_WIN)
-  // Creates a stacktrace for an exception.
-  // Note: this function will throw an import not found (StackWalk64) exception
-  // on system without dbghelp 5.1.
-  StackTrace(_EXCEPTION_POINTERS* exception_pointers);
-  StackTrace(const _CONTEXT* context);
-#endif
-
-  // Copying and assignment are allowed with the default functions.
-
-  // Gets an array of instruction pointer values. |*count| will be set to the
-  // number of elements in the returned array.
-  const void* const* Addresses(size_t* count) const;
-
-  // Prints the stack trace to stderr.
-  void Print() const;
-
-#if !defined(__UCLIBC__) & !defined(_AIX)
-  // Resolves backtrace to symbols and write to stream.
-  void OutputToStream(std::ostream* os) const;
-#endif
-
-  // Resolves backtrace to symbols and returns as string.
-  std::string ToString() const;
-
- private:
-#if defined(OS_WIN)
-  void InitTrace(const _CONTEXT* context_record);
-#endif
-
-  // From http://msdn.microsoft.com/en-us/library/bb204633.aspx,
-  // the sum of FramesToSkip and FramesToCapture must be less than 63,
-  // so set it to 62. Even if on POSIX it could be a larger value, it usually
-  // doesn't give much more information.
-  static const int kMaxTraces = 62;
-
-  void* trace_[kMaxTraces];
-
-  // The number of valid frames in |trace_|.
-  size_t count_;
-};
-
-namespace internal {
-
-#if defined(OS_POSIX) && !defined(OS_ANDROID)
-// POSIX doesn't define any async-signal safe function for converting
-// an integer to ASCII. We'll have to define our own version.
-// itoa_r() converts a (signed) integer to ASCII. It returns "buf", if the
-// conversion was successful or NULL otherwise. It never writes more than "sz"
-// bytes. Output will be truncated as needed, and a NUL character is always
-// appended.
-BASE_EXPORT char *itoa_r(intptr_t i,
-                         char *buf,
-                         size_t sz,
-                         int base,
-                         size_t padding);
-#endif  // defined(OS_POSIX) && !defined(OS_ANDROID)
-
-}  // namespace internal
-
-}  // namespace debug
-}  // namespace base
-
-#endif  // BASE_DEBUG_STACK_TRACE_H_
diff --git a/base/debug/stack_trace_posix.cc b/base/debug/stack_trace_posix.cc
deleted file mode 100644
index c67fd62..0000000
--- a/base/debug/stack_trace_posix.cc
+++ /dev/null
@@ -1,887 +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/debug/stack_trace.h"
-
-#include <errno.h>
-#include <fcntl.h>
-#include <signal.h>
-#include <stddef.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <sys/param.h>
-#include <sys/stat.h>
-#include <sys/types.h>
-#include <unistd.h>
-
-#include <algorithm>
-#include <map>
-#include <memory>
-#include <ostream>
-#include <string>
-#include <vector>
-
-#if !defined(USE_SYMBOLIZE)
-#include <cxxabi.h>
-#endif
-#if !defined(__UCLIBC__) && !defined(_AIX)
-#include <execinfo.h>
-#endif
-
-#if defined(OS_MACOSX)
-#include <AvailabilityMacros.h>
-#endif
-
-#if defined(OS_LINUX)
-#include "base/debug/proc_maps_linux.h"
-#endif
-
-#include "base/debug/debugger.h"
-#include "base/files/scoped_file.h"
-#include "base/logging.h"
-#include "base/macros.h"
-#include "base/memory/free_deleter.h"
-#include "base/memory/singleton.h"
-#include "base/numerics/safe_conversions.h"
-#include "base/posix/eintr_wrapper.h"
-#include "base/strings/string_number_conversions.h"
-#include "build_config.h"
-
-#if defined(USE_SYMBOLIZE)
-#include "base/third_party/symbolize/symbolize.h"
-#endif
-
-namespace base {
-namespace debug {
-
-namespace {
-
-volatile sig_atomic_t in_signal_handler = 0;
-
-bool (*try_handle_signal)(int, void*, void*) = nullptr;
-
-#if !defined(USE_SYMBOLIZE)
-// The prefix used for mangled symbols, per the Itanium C++ ABI:
-// http://www.codesourcery.com/cxx-abi/abi.html#mangling
-const char kMangledSymbolPrefix[] = "_Z";
-
-// Characters that can be used for symbols, generated by Ruby:
-// (('a'..'z').to_a+('A'..'Z').to_a+('0'..'9').to_a + ['_']).join
-const char kSymbolCharacters[] =
-    "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_";
-#endif  // !defined(USE_SYMBOLIZE)
-
-#if !defined(USE_SYMBOLIZE)
-// Demangles C++ symbols in the given text. Example:
-//
-// "out/Debug/base_unittests(_ZN10StackTraceC1Ev+0x20) [0x817778c]"
-// =>
-// "out/Debug/base_unittests(StackTrace::StackTrace()+0x20) [0x817778c]"
-void DemangleSymbols(std::string* text) {
-  // Note: code in this function is NOT async-signal safe (std::string uses
-  // malloc internally).
-
-#if !defined(__UCLIBC__) && !defined(_AIX)
-  std::string::size_type search_from = 0;
-  while (search_from < text->size()) {
-    // Look for the start of a mangled symbol, from search_from.
-    std::string::size_type mangled_start =
-        text->find(kMangledSymbolPrefix, search_from);
-    if (mangled_start == std::string::npos) {
-      break;  // Mangled symbol not found.
-    }
-
-    // Look for the end of the mangled symbol.
-    std::string::size_type mangled_end =
-        text->find_first_not_of(kSymbolCharacters, mangled_start);
-    if (mangled_end == std::string::npos) {
-      mangled_end = text->size();
-    }
-    std::string mangled_symbol =
-        text->substr(mangled_start, mangled_end - mangled_start);
-
-    // Try to demangle the mangled symbol candidate.
-    int status = 0;
-    std::unique_ptr<char, base::FreeDeleter> demangled_symbol(
-        abi::__cxa_demangle(mangled_symbol.c_str(), nullptr, 0, &status));
-    if (status == 0) {  // Demangling is successful.
-      // Remove the mangled symbol.
-      text->erase(mangled_start, mangled_end - mangled_start);
-      // Insert the demangled symbol.
-      text->insert(mangled_start, demangled_symbol.get());
-      // Next time, we'll start right after the demangled symbol we inserted.
-      search_from = mangled_start + strlen(demangled_symbol.get());
-    } else {
-      // Failed to demangle.  Retry after the "_Z" we just found.
-      search_from = mangled_start + 2;
-    }
-  }
-#endif  // !defined(__UCLIBC__) && !defined(_AIX)
-}
-#endif  // !defined(USE_SYMBOLIZE)
-
-class BacktraceOutputHandler {
- public:
-  virtual void HandleOutput(const char* output) = 0;
-
- protected:
-  virtual ~BacktraceOutputHandler() = default;
-};
-
-#if !defined(__UCLIBC__) && !defined(_AIX)
-void OutputPointer(void* pointer, BacktraceOutputHandler* handler) {
-  // This should be more than enough to store a 64-bit number in hex:
-  // 16 hex digits + 1 for null-terminator.
-  char buf[17] = { '\0' };
-  handler->HandleOutput("0x");
-  internal::itoa_r(reinterpret_cast<intptr_t>(pointer),
-                   buf, sizeof(buf), 16, 12);
-  handler->HandleOutput(buf);
-}
-
-#if defined(USE_SYMBOLIZE)
-void OutputFrameId(intptr_t frame_id, BacktraceOutputHandler* handler) {
-  // Max unsigned 64-bit number in decimal has 20 digits (18446744073709551615).
-  // Hence, 30 digits should be more than enough to represent it in decimal
-  // (including the null-terminator).
-  char buf[30] = { '\0' };
-  handler->HandleOutput("#");
-  internal::itoa_r(frame_id, buf, sizeof(buf), 10, 1);
-  handler->HandleOutput(buf);
-}
-#endif  // defined(USE_SYMBOLIZE)
-
-void ProcessBacktrace(void *const *trace,
-                      size_t size,
-                      BacktraceOutputHandler* handler) {
-  // NOTE: This code MUST be async-signal safe (it's used by in-process
-  // stack dumping signal handler). NO malloc or stdio is allowed here.
-
-#if defined(USE_SYMBOLIZE)
-  for (size_t i = 0; i < size; ++i) {
-    OutputFrameId(i, handler);
-    handler->HandleOutput(" ");
-    OutputPointer(trace[i], handler);
-    handler->HandleOutput(" ");
-
-    char buf[1024] = { '\0' };
-
-    // Subtract by one as return address of function may be in the next
-    // function when a function is annotated as noreturn.
-    void* address = static_cast<char*>(trace[i]) - 1;
-    if (google::Symbolize(address, buf, sizeof(buf)))
-      handler->HandleOutput(buf);
-    else
-      handler->HandleOutput("<unknown>");
-
-    handler->HandleOutput("\n");
-  }
-#else
-  bool printed = false;
-
-  // Below part is async-signal unsafe (uses malloc), so execute it only
-  // when we are not executing the signal handler.
-  if (in_signal_handler == 0) {
-    std::unique_ptr<char*, FreeDeleter> trace_symbols(
-        backtrace_symbols(trace, size));
-    if (trace_symbols.get()) {
-      for (size_t i = 0; i < size; ++i) {
-        std::string trace_symbol = trace_symbols.get()[i];
-        DemangleSymbols(&trace_symbol);
-        handler->HandleOutput(trace_symbol.c_str());
-        handler->HandleOutput("\n");
-      }
-
-      printed = true;
-    }
-  }
-
-  if (!printed) {
-    for (size_t i = 0; i < size; ++i) {
-      handler->HandleOutput(" [");
-      OutputPointer(trace[i], handler);
-      handler->HandleOutput("]\n");
-    }
-  }
-#endif  // defined(USE_SYMBOLIZE)
-}
-#endif  // !defined(__UCLIBC__) && !defined(_AIX)
-
-void PrintToStderr(const char* output) {
-  // NOTE: This code MUST be async-signal safe (it's used by in-process
-  // stack dumping signal handler). NO malloc or stdio is allowed here.
-  ignore_result(HANDLE_EINTR(write(STDERR_FILENO, output, strlen(output))));
-}
-
-void StackDumpSignalHandler(int signal, siginfo_t* info, void* void_context) {
-  // NOTE: This code MUST be async-signal safe.
-  // NO malloc or stdio is allowed here.
-
-  // Give a registered callback a chance to recover from this signal
-  //
-  // V8 uses guard regions to guarantee memory safety in WebAssembly. This means
-  // some signals might be expected if they originate from Wasm code while
-  // accessing the guard region. We give V8 the chance to handle and recover
-  // from these signals first.
-  if (try_handle_signal != nullptr &&
-      try_handle_signal(signal, info, void_context)) {
-    // The first chance handler took care of this. The SA_RESETHAND flag
-    // replaced this signal handler upon entry, but we want to stay
-    // installed. Thus, we reinstall ourselves before returning.
-    struct sigaction action;
-    memset(&action, 0, sizeof(action));
-    action.sa_flags = SA_RESETHAND | SA_SIGINFO;
-    action.sa_sigaction = &StackDumpSignalHandler;
-    sigemptyset(&action.sa_mask);
-
-    sigaction(signal, &action, nullptr);
-    return;
-  }
-
-// Do not take the "in signal handler" code path on Mac in a DCHECK-enabled
-// build, as this prevents seeing a useful (symbolized) stack trace on a crash
-// or DCHECK() failure. While it may not be fully safe to run the stack symbol
-// printing code, in practice it's better to provide meaningful stack traces -
-// and the risk is low given we're likely crashing already.
-#if !defined(OS_MACOSX) || !DCHECK_IS_ON()
-  // Record the fact that we are in the signal handler now, so that the rest
-  // of StackTrace can behave in an async-signal-safe manner.
-  in_signal_handler = 1;
-#endif
-
-  if (BeingDebugged())
-    BreakDebugger();
-
-  PrintToStderr("Received signal ");
-  char buf[1024] = { 0 };
-  internal::itoa_r(signal, buf, sizeof(buf), 10, 0);
-  PrintToStderr(buf);
-  if (signal == SIGBUS) {
-    if (info->si_code == BUS_ADRALN)
-      PrintToStderr(" BUS_ADRALN ");
-    else if (info->si_code == BUS_ADRERR)
-      PrintToStderr(" BUS_ADRERR ");
-    else if (info->si_code == BUS_OBJERR)
-      PrintToStderr(" BUS_OBJERR ");
-    else
-      PrintToStderr(" <unknown> ");
-  } else if (signal == SIGFPE) {
-    if (info->si_code == FPE_FLTDIV)
-      PrintToStderr(" FPE_FLTDIV ");
-    else if (info->si_code == FPE_FLTINV)
-      PrintToStderr(" FPE_FLTINV ");
-    else if (info->si_code == FPE_FLTOVF)
-      PrintToStderr(" FPE_FLTOVF ");
-    else if (info->si_code == FPE_FLTRES)
-      PrintToStderr(" FPE_FLTRES ");
-    else if (info->si_code == FPE_FLTSUB)
-      PrintToStderr(" FPE_FLTSUB ");
-    else if (info->si_code == FPE_FLTUND)
-      PrintToStderr(" FPE_FLTUND ");
-    else if (info->si_code == FPE_INTDIV)
-      PrintToStderr(" FPE_INTDIV ");
-    else if (info->si_code == FPE_INTOVF)
-      PrintToStderr(" FPE_INTOVF ");
-    else
-      PrintToStderr(" <unknown> ");
-  } else if (signal == SIGILL) {
-    if (info->si_code == ILL_BADSTK)
-      PrintToStderr(" ILL_BADSTK ");
-    else if (info->si_code == ILL_COPROC)
-      PrintToStderr(" ILL_COPROC ");
-    else if (info->si_code == ILL_ILLOPN)
-      PrintToStderr(" ILL_ILLOPN ");
-    else if (info->si_code == ILL_ILLADR)
-      PrintToStderr(" ILL_ILLADR ");
-    else if (info->si_code == ILL_ILLTRP)
-      PrintToStderr(" ILL_ILLTRP ");
-    else if (info->si_code == ILL_PRVOPC)
-      PrintToStderr(" ILL_PRVOPC ");
-    else if (info->si_code == ILL_PRVREG)
-      PrintToStderr(" ILL_PRVREG ");
-    else
-      PrintToStderr(" <unknown> ");
-  } else if (signal == SIGSEGV) {
-    if (info->si_code == SEGV_MAPERR)
-      PrintToStderr(" SEGV_MAPERR ");
-    else if (info->si_code == SEGV_ACCERR)
-      PrintToStderr(" SEGV_ACCERR ");
-    else
-      PrintToStderr(" <unknown> ");
-  }
-  if (signal == SIGBUS || signal == SIGFPE ||
-      signal == SIGILL || signal == SIGSEGV) {
-    internal::itoa_r(reinterpret_cast<intptr_t>(info->si_addr),
-                     buf, sizeof(buf), 16, 12);
-    PrintToStderr(buf);
-  }
-  PrintToStderr("\n");
-
-  debug::StackTrace().Print();
-
-#if defined(OS_LINUX)
-#if ARCH_CPU_X86_FAMILY
-  ucontext_t* context = reinterpret_cast<ucontext_t*>(void_context);
-  const struct {
-    const char* label;
-    greg_t value;
-  } registers[] = {
-#if ARCH_CPU_32_BITS
-    { "  gs: ", context->uc_mcontext.gregs[REG_GS] },
-    { "  fs: ", context->uc_mcontext.gregs[REG_FS] },
-    { "  es: ", context->uc_mcontext.gregs[REG_ES] },
-    { "  ds: ", context->uc_mcontext.gregs[REG_DS] },
-    { " edi: ", context->uc_mcontext.gregs[REG_EDI] },
-    { " esi: ", context->uc_mcontext.gregs[REG_ESI] },
-    { " ebp: ", context->uc_mcontext.gregs[REG_EBP] },
-    { " esp: ", context->uc_mcontext.gregs[REG_ESP] },
-    { " ebx: ", context->uc_mcontext.gregs[REG_EBX] },
-    { " edx: ", context->uc_mcontext.gregs[REG_EDX] },
-    { " ecx: ", context->uc_mcontext.gregs[REG_ECX] },
-    { " eax: ", context->uc_mcontext.gregs[REG_EAX] },
-    { " trp: ", context->uc_mcontext.gregs[REG_TRAPNO] },
-    { " err: ", context->uc_mcontext.gregs[REG_ERR] },
-    { "  ip: ", context->uc_mcontext.gregs[REG_EIP] },
-    { "  cs: ", context->uc_mcontext.gregs[REG_CS] },
-    { " efl: ", context->uc_mcontext.gregs[REG_EFL] },
-    { " usp: ", context->uc_mcontext.gregs[REG_UESP] },
-    { "  ss: ", context->uc_mcontext.gregs[REG_SS] },
-#elif ARCH_CPU_64_BITS
-    { "  r8: ", context->uc_mcontext.gregs[REG_R8] },
-    { "  r9: ", context->uc_mcontext.gregs[REG_R9] },
-    { " r10: ", context->uc_mcontext.gregs[REG_R10] },
-    { " r11: ", context->uc_mcontext.gregs[REG_R11] },
-    { " r12: ", context->uc_mcontext.gregs[REG_R12] },
-    { " r13: ", context->uc_mcontext.gregs[REG_R13] },
-    { " r14: ", context->uc_mcontext.gregs[REG_R14] },
-    { " r15: ", context->uc_mcontext.gregs[REG_R15] },
-    { "  di: ", context->uc_mcontext.gregs[REG_RDI] },
-    { "  si: ", context->uc_mcontext.gregs[REG_RSI] },
-    { "  bp: ", context->uc_mcontext.gregs[REG_RBP] },
-    { "  bx: ", context->uc_mcontext.gregs[REG_RBX] },
-    { "  dx: ", context->uc_mcontext.gregs[REG_RDX] },
-    { "  ax: ", context->uc_mcontext.gregs[REG_RAX] },
-    { "  cx: ", context->uc_mcontext.gregs[REG_RCX] },
-    { "  sp: ", context->uc_mcontext.gregs[REG_RSP] },
-    { "  ip: ", context->uc_mcontext.gregs[REG_RIP] },
-    { " efl: ", context->uc_mcontext.gregs[REG_EFL] },
-    { " cgf: ", context->uc_mcontext.gregs[REG_CSGSFS] },
-    { " erf: ", context->uc_mcontext.gregs[REG_ERR] },
-    { " trp: ", context->uc_mcontext.gregs[REG_TRAPNO] },
-    { " msk: ", context->uc_mcontext.gregs[REG_OLDMASK] },
-    { " cr2: ", context->uc_mcontext.gregs[REG_CR2] },
-#endif  // ARCH_CPU_32_BITS
-  };
-
-#if ARCH_CPU_32_BITS
-  const int kRegisterPadding = 8;
-#elif ARCH_CPU_64_BITS
-  const int kRegisterPadding = 16;
-#endif
-
-  for (size_t i = 0; i < arraysize(registers); i++) {
-    PrintToStderr(registers[i].label);
-    internal::itoa_r(registers[i].value, buf, sizeof(buf),
-                     16, kRegisterPadding);
-    PrintToStderr(buf);
-
-    if ((i + 1) % 4 == 0)
-      PrintToStderr("\n");
-  }
-  PrintToStderr("\n");
-#endif  // ARCH_CPU_X86_FAMILY
-#endif  // defined(OS_LINUX)
-
-  PrintToStderr("[end of stack trace]\n");
-
-#if defined(OS_MACOSX) && !defined(OS_IOS)
-  if (::signal(signal, SIG_DFL) == SIG_ERR)
-    _exit(1);
-#else
-  // Non-Mac OSes should probably reraise the signal as well, but the Linux
-  // sandbox tests break on CrOS devices.
-  // https://code.google.com/p/chromium/issues/detail?id=551681
-  PrintToStderr("Calling _exit(1). Core file will not be generated.\n");
-  _exit(1);
-#endif  // defined(OS_MACOSX) && !defined(OS_IOS)
-}
-
-class PrintBacktraceOutputHandler : public BacktraceOutputHandler {
- public:
-  PrintBacktraceOutputHandler() = default;
-
-  void HandleOutput(const char* output) override {
-    // NOTE: This code MUST be async-signal safe (it's used by in-process
-    // stack dumping signal handler). NO malloc or stdio is allowed here.
-    PrintToStderr(output);
-  }
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(PrintBacktraceOutputHandler);
-};
-
-class StreamBacktraceOutputHandler : public BacktraceOutputHandler {
- public:
-  explicit StreamBacktraceOutputHandler(std::ostream* os) : os_(os) {
-  }
-
-  void HandleOutput(const char* output) override { (*os_) << output; }
-
- private:
-  std::ostream* os_;
-
-  DISALLOW_COPY_AND_ASSIGN(StreamBacktraceOutputHandler);
-};
-
-void WarmUpBacktrace() {
-  // Warm up stack trace infrastructure. It turns out that on the first
-  // call glibc initializes some internal data structures using pthread_once,
-  // and even backtrace() can call malloc(), leading to hangs.
-  //
-  // Example stack trace snippet (with tcmalloc):
-  //
-  // #8  0x0000000000a173b5 in tc_malloc
-  //             at ./third_party/tcmalloc/chromium/src/debugallocation.cc:1161
-  // #9  0x00007ffff7de7900 in _dl_map_object_deps at dl-deps.c:517
-  // #10 0x00007ffff7ded8a9 in dl_open_worker at dl-open.c:262
-  // #11 0x00007ffff7de9176 in _dl_catch_error at dl-error.c:178
-  // #12 0x00007ffff7ded31a in _dl_open (file=0x7ffff625e298 "libgcc_s.so.1")
-  //             at dl-open.c:639
-  // #13 0x00007ffff6215602 in do_dlopen at dl-libc.c:89
-  // #14 0x00007ffff7de9176 in _dl_catch_error at dl-error.c:178
-  // #15 0x00007ffff62156c4 in dlerror_run at dl-libc.c:48
-  // #16 __GI___libc_dlopen_mode at dl-libc.c:165
-  // #17 0x00007ffff61ef8f5 in init
-  //             at ../sysdeps/x86_64/../ia64/backtrace.c:53
-  // #18 0x00007ffff6aad400 in pthread_once
-  //             at ../nptl/sysdeps/unix/sysv/linux/x86_64/pthread_once.S:104
-  // #19 0x00007ffff61efa14 in __GI___backtrace
-  //             at ../sysdeps/x86_64/../ia64/backtrace.c:104
-  // #20 0x0000000000752a54 in base::debug::StackTrace::StackTrace
-  //             at base/debug/stack_trace_posix.cc:175
-  // #21 0x00000000007a4ae5 in
-  //             base::(anonymous namespace)::StackDumpSignalHandler
-  //             at base/process_util_posix.cc:172
-  // #22 <signal handler called>
-  StackTrace stack_trace;
-}
-
-#if defined(USE_SYMBOLIZE)
-
-// class SandboxSymbolizeHelper.
-//
-// The purpose of this class is to prepare and install a "file open" callback
-// needed by the stack trace symbolization code
-// (base/third_party/symbolize/symbolize.h) so that it can function properly
-// in a sandboxed process.  The caveat is that this class must be instantiated
-// before the sandboxing is enabled so that it can get the chance to open all
-// the object files that are loaded in the virtual address space of the current
-// process.
-class SandboxSymbolizeHelper {
- public:
-  // Returns the singleton instance.
-  static SandboxSymbolizeHelper* GetInstance() {
-    return Singleton<SandboxSymbolizeHelper,
-                     LeakySingletonTraits<SandboxSymbolizeHelper>>::get();
-  }
-
- private:
-  friend struct DefaultSingletonTraits<SandboxSymbolizeHelper>;
-
-  SandboxSymbolizeHelper()
-      : is_initialized_(false) {
-    Init();
-  }
-
-  ~SandboxSymbolizeHelper() {
-    UnregisterCallback();
-    CloseObjectFiles();
-  }
-
-  // Returns a O_RDONLY file descriptor for |file_path| if it was opened
-  // successfully during the initialization.  The file is repositioned at
-  // offset 0.
-  // IMPORTANT: This function must be async-signal-safe because it can be
-  // called from a signal handler (symbolizing stack frames for a crash).
-  int GetFileDescriptor(const char* file_path) {
-    int fd = -1;
-
-#if !defined(OFFICIAL_BUILD)
-    if (file_path) {
-      // The assumption here is that iterating over std::map<std::string, int>
-      // using a const_iterator does not allocate dynamic memory, hense it is
-      // async-signal-safe.
-      std::map<std::string, int>::const_iterator it;
-      for (it = modules_.begin(); it != modules_.end(); ++it) {
-        if (strcmp((it->first).c_str(), file_path) == 0) {
-          // POSIX.1-2004 requires an implementation to guarantee that dup()
-          // is async-signal-safe.
-          fd = HANDLE_EINTR(dup(it->second));
-          break;
-        }
-      }
-      // POSIX.1-2004 requires an implementation to guarantee that lseek()
-      // is async-signal-safe.
-      if (fd >= 0 && lseek(fd, 0, SEEK_SET) < 0) {
-        // Failed to seek.
-        fd = -1;
-      }
-    }
-#endif  // !defined(OFFICIAL_BUILD)
-
-    return fd;
-  }
-
-  // Searches for the object file (from /proc/self/maps) that contains
-  // the specified pc.  If found, sets |start_address| to the start address
-  // of where this object file is mapped in memory, sets the module base
-  // address into |base_address|, copies the object file name into
-  // |out_file_name|, and attempts to open the object file.  If the object
-  // file is opened successfully, returns the file descriptor.  Otherwise,
-  // returns -1.  |out_file_name_size| is the size of the file name buffer
-  // (including the null terminator).
-  // IMPORTANT: This function must be async-signal-safe because it can be
-  // called from a signal handler (symbolizing stack frames for a crash).
-  static int OpenObjectFileContainingPc(uint64_t pc, uint64_t& start_address,
-                                        uint64_t& base_address, char* file_path,
-                                        int file_path_size) {
-    // This method can only be called after the singleton is instantiated.
-    // This is ensured by the following facts:
-    // * This is the only static method in this class, it is private, and
-    //   the class has no friends (except for the DefaultSingletonTraits).
-    //   The compiler guarantees that it can only be called after the
-    //   singleton is instantiated.
-    // * This method is used as a callback for the stack tracing code and
-    //   the callback registration is done in the constructor, so logically
-    //   it cannot be called before the singleton is created.
-    SandboxSymbolizeHelper* instance = GetInstance();
-
-    // The assumption here is that iterating over
-    // std::vector<MappedMemoryRegion> using a const_iterator does not allocate
-    // dynamic memory, hence it is async-signal-safe.
-    for (const MappedMemoryRegion& region : instance->regions_) {
-      if (region.start <= pc && pc < region.end) {
-        start_address = region.start;
-        base_address = region.base;
-        if (file_path && file_path_size > 0) {
-          strncpy(file_path, region.path.c_str(), file_path_size);
-          // Ensure null termination.
-          file_path[file_path_size - 1] = '\0';
-        }
-        return instance->GetFileDescriptor(region.path.c_str());
-      }
-    }
-    return -1;
-  }
-
-  // Set the base address for each memory region by reading ELF headers in
-  // process memory.
-  void SetBaseAddressesForMemoryRegions() {
-    base::ScopedFD mem_fd(
-        HANDLE_EINTR(open("/proc/self/mem", O_RDONLY | O_CLOEXEC)));
-    if (!mem_fd.is_valid())
-      return;
-
-    auto safe_memcpy = [&mem_fd](void* dst, uintptr_t src, size_t size) {
-      return HANDLE_EINTR(pread(mem_fd.get(), dst, size, src)) == ssize_t(size);
-    };
-
-    uintptr_t cur_base = 0;
-    for (auto& r : regions_) {
-      ElfW(Ehdr) ehdr;
-      static_assert(SELFMAG <= sizeof(ElfW(Ehdr)), "SELFMAG too large");
-      if ((r.permissions & MappedMemoryRegion::READ) &&
-          safe_memcpy(&ehdr, r.start, sizeof(ElfW(Ehdr))) &&
-          memcmp(ehdr.e_ident, ELFMAG, SELFMAG) == 0) {
-        switch (ehdr.e_type) {
-          case ET_EXEC:
-            cur_base = 0;
-            break;
-          case ET_DYN:
-            // Find the segment containing file offset 0. This will correspond
-            // to the ELF header that we just read. Normally this will have
-            // virtual address 0, but this is not guaranteed. We must subtract
-            // the virtual address from the address where the ELF header was
-            // mapped to get the base address.
-            //
-            // If we fail to find a segment for file offset 0, use the address
-            // of the ELF header as the base address.
-            cur_base = r.start;
-            for (unsigned i = 0; i != ehdr.e_phnum; ++i) {
-              ElfW(Phdr) phdr;
-              if (safe_memcpy(&phdr, r.start + ehdr.e_phoff + i * sizeof(phdr),
-                              sizeof(phdr)) &&
-                  phdr.p_type == PT_LOAD && phdr.p_offset == 0) {
-                cur_base = r.start - phdr.p_vaddr;
-                break;
-              }
-            }
-            break;
-          default:
-            // ET_REL or ET_CORE. These aren't directly executable, so they
-            // don't affect the base address.
-            break;
-        }
-      }
-
-      r.base = cur_base;
-    }
-  }
-
-  // Parses /proc/self/maps in order to compile a list of all object file names
-  // for the modules that are loaded in the current process.
-  // Returns true on success.
-  bool CacheMemoryRegions() {
-    // Reads /proc/self/maps.
-    std::string contents;
-    if (!ReadProcMaps(&contents)) {
-      LOG(ERROR) << "Failed to read /proc/self/maps";
-      return false;
-    }
-
-    // Parses /proc/self/maps.
-    if (!ParseProcMaps(contents, &regions_)) {
-      LOG(ERROR) << "Failed to parse the contents of /proc/self/maps";
-      return false;
-    }
-
-    SetBaseAddressesForMemoryRegions();
-
-    is_initialized_ = true;
-    return true;
-  }
-
-  // Opens all object files and caches their file descriptors.
-  void OpenSymbolFiles() {
-    // Pre-opening and caching the file descriptors of all loaded modules is
-    // not safe for production builds.  Hence it is only done in non-official
-    // builds.  For more details, take a look at: http://crbug.com/341966.
-#if !defined(OFFICIAL_BUILD)
-    // Open the object files for all read-only executable regions and cache
-    // their file descriptors.
-    std::vector<MappedMemoryRegion>::const_iterator it;
-    for (it = regions_.begin(); it != regions_.end(); ++it) {
-      const MappedMemoryRegion& region = *it;
-      // Only interesed in read-only executable regions.
-      if ((region.permissions & MappedMemoryRegion::READ) ==
-              MappedMemoryRegion::READ &&
-          (region.permissions & MappedMemoryRegion::WRITE) == 0 &&
-          (region.permissions & MappedMemoryRegion::EXECUTE) ==
-              MappedMemoryRegion::EXECUTE) {
-        if (region.path.empty()) {
-          // Skip regions with empty file names.
-          continue;
-        }
-        if (region.path[0] == '[') {
-          // Skip pseudo-paths, like [stack], [vdso], [heap], etc ...
-          continue;
-        }
-        // Avoid duplicates.
-        if (modules_.find(region.path) == modules_.end()) {
-          int fd = open(region.path.c_str(), O_RDONLY | O_CLOEXEC);
-          if (fd >= 0) {
-            modules_.insert(std::make_pair(region.path, fd));
-          } else {
-            LOG(WARNING) << "Failed to open file: " << region.path
-                         << "\n  Error: " << strerror(errno);
-          }
-        }
-      }
-    }
-#endif  // !defined(OFFICIAL_BUILD)
-  }
-
-  // Initializes and installs the symbolization callback.
-  void Init() {
-    if (CacheMemoryRegions()) {
-      OpenSymbolFiles();
-      google::InstallSymbolizeOpenObjectFileCallback(
-          &OpenObjectFileContainingPc);
-    }
-  }
-
-  // Unregister symbolization callback.
-  void UnregisterCallback() {
-    if (is_initialized_) {
-      google::InstallSymbolizeOpenObjectFileCallback(nullptr);
-      is_initialized_ = false;
-    }
-  }
-
-  // Closes all file descriptors owned by this instance.
-  void CloseObjectFiles() {
-#if !defined(OFFICIAL_BUILD)
-    std::map<std::string, int>::iterator it;
-    for (it = modules_.begin(); it != modules_.end(); ++it) {
-      int ret = IGNORE_EINTR(close(it->second));
-      DCHECK(!ret);
-      it->second = -1;
-    }
-    modules_.clear();
-#endif  // !defined(OFFICIAL_BUILD)
-  }
-
-  // Set to true upon successful initialization.
-  bool is_initialized_;
-
-#if !defined(OFFICIAL_BUILD)
-  // Mapping from file name to file descriptor.  Includes file descriptors
-  // for all successfully opened object files and the file descriptor for
-  // /proc/self/maps.  This code is not safe for production builds.
-  std::map<std::string, int> modules_;
-#endif  // !defined(OFFICIAL_BUILD)
-
-  // Cache for the process memory regions.  Produced by parsing the contents
-  // of /proc/self/maps cache.
-  std::vector<MappedMemoryRegion> regions_;
-
-  DISALLOW_COPY_AND_ASSIGN(SandboxSymbolizeHelper);
-};
-#endif  // USE_SYMBOLIZE
-
-}  // namespace
-
-bool EnableInProcessStackDumping() {
-#if defined(USE_SYMBOLIZE)
-  SandboxSymbolizeHelper::GetInstance();
-#endif  // USE_SYMBOLIZE
-
-  // When running in an application, our code typically expects SIGPIPE
-  // to be ignored.  Therefore, when testing that same code, it should run
-  // with SIGPIPE ignored as well.
-  struct sigaction sigpipe_action;
-  memset(&sigpipe_action, 0, sizeof(sigpipe_action));
-  sigpipe_action.sa_handler = SIG_IGN;
-  sigemptyset(&sigpipe_action.sa_mask);
-  bool success = (sigaction(SIGPIPE, &sigpipe_action, nullptr) == 0);
-
-  // Avoid hangs during backtrace initialization, see above.
-  WarmUpBacktrace();
-
-  struct sigaction action;
-  memset(&action, 0, sizeof(action));
-  action.sa_flags = SA_RESETHAND | SA_SIGINFO;
-  action.sa_sigaction = &StackDumpSignalHandler;
-  sigemptyset(&action.sa_mask);
-
-  success &= (sigaction(SIGILL, &action, nullptr) == 0);
-  success &= (sigaction(SIGABRT, &action, nullptr) == 0);
-  success &= (sigaction(SIGFPE, &action, nullptr) == 0);
-  success &= (sigaction(SIGBUS, &action, nullptr) == 0);
-  success &= (sigaction(SIGSEGV, &action, nullptr) == 0);
-// On Linux, SIGSYS is reserved by the kernel for seccomp-bpf sandboxing.
-#if !defined(OS_LINUX)
-  success &= (sigaction(SIGSYS, &action, nullptr) == 0);
-#endif  // !defined(OS_LINUX)
-
-  return success;
-}
-
-void SetStackDumpFirstChanceCallback(bool (*handler)(int, void*, void*)) {
-  DCHECK(try_handle_signal == nullptr || handler == nullptr);
-  try_handle_signal = handler;
-}
-
-StackTrace::StackTrace(size_t count) {
-// NOTE: This code MUST be async-signal safe (it's used by in-process
-// stack dumping signal handler). NO malloc or stdio is allowed here.
-
-#if !defined(__UCLIBC__) && !defined(_AIX)
-  count = std::min(arraysize(trace_), count);
-
-  // Though the backtrace API man page does not list any possible negative
-  // return values, we take no chance.
-  count_ = base::saturated_cast<size_t>(backtrace(trace_, count));
-#else
-  count_ = 0;
-#endif
-}
-
-void StackTrace::Print() const {
-  // NOTE: This code MUST be async-signal safe (it's used by in-process
-  // stack dumping signal handler). NO malloc or stdio is allowed here.
-
-#if !defined(__UCLIBC__) && !defined(_AIX)
-  PrintBacktraceOutputHandler handler;
-  ProcessBacktrace(trace_, count_, &handler);
-#endif
-}
-
-#if !defined(__UCLIBC__) && !defined(_AIX)
-void StackTrace::OutputToStream(std::ostream* os) const {
-  StreamBacktraceOutputHandler handler(os);
-  ProcessBacktrace(trace_, count_, &handler);
-}
-#endif
-
-namespace internal {
-
-// NOTE: code from sandbox/linux/seccomp-bpf/demo.cc.
-char* itoa_r(intptr_t i, char* buf, size_t sz, int base, size_t padding) {
-  // Make sure we can write at least one NUL byte.
-  size_t n = 1;
-  if (n > sz)
-    return nullptr;
-
-  if (base < 2 || base > 16) {
-    buf[0] = '\000';
-    return nullptr;
-  }
-
-  char* start = buf;
-
-  uintptr_t j = i;
-
-  // Handle negative numbers (only for base 10).
-  if (i < 0 && base == 10) {
-    // This does "j = -i" while avoiding integer overflow.
-    j = static_cast<uintptr_t>(-(i + 1)) + 1;
-
-    // Make sure we can write the '-' character.
-    if (++n > sz) {
-      buf[0] = '\000';
-      return nullptr;
-    }
-    *start++ = '-';
-  }
-
-  // Loop until we have converted the entire number. Output at least one
-  // character (i.e. '0').
-  char* ptr = start;
-  do {
-    // Make sure there is still enough space left in our output buffer.
-    if (++n > sz) {
-      buf[0] = '\000';
-      return nullptr;
-    }
-
-    // Output the next digit.
-    *ptr++ = "0123456789abcdef"[j % base];
-    j /= base;
-
-    if (padding > 0)
-      padding--;
-  } while (j > 0 || padding > 0);
-
-  // Terminate the output with a NUL character.
-  *ptr = '\000';
-
-  // Conversion to ASCII actually resulted in the digits being in reverse
-  // order. We can't easily generate them in forward order, as we can't tell
-  // the number of characters needed until we are done converting.
-  // So, now, we reverse the string (except for the possible "-" sign).
-  while (--ptr > start) {
-    char ch = *ptr;
-    *ptr = *start;
-    *start++ = ch;
-  }
-  return buf;
-}
-
-}  // namespace internal
-
-}  // namespace debug
-}  // namespace base
diff --git a/base/debug/stack_trace_win.cc b/base/debug/stack_trace_win.cc
deleted file mode 100644
index 1ef2a06..0000000
--- a/base/debug/stack_trace_win.cc
+++ /dev/null
@@ -1,365 +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/debug/stack_trace.h"
-
-#include <windows.h>
-#include <dbghelp.h>
-#include <stddef.h>
-
-#include <algorithm>
-#include <iostream>
-#include <memory>
-
-#include "base/files/file_path.h"
-#include "base/logging.h"
-#include "base/macros.h"
-#include "base/memory/singleton.h"
-#include "base/synchronization/lock.h"
-
-namespace base {
-namespace debug {
-
-namespace {
-
-// Previous unhandled filter. Will be called if not NULL when we intercept an
-// exception. Only used in unit tests.
-LPTOP_LEVEL_EXCEPTION_FILTER g_previous_filter = NULL;
-
-bool g_initialized_symbols = false;
-DWORD g_init_error = ERROR_SUCCESS;
-
-// Prints the exception call stack.
-// This is the unit tests exception filter.
-long WINAPI StackDumpExceptionFilter(EXCEPTION_POINTERS* info) {
-  DWORD exc_code = info->ExceptionRecord->ExceptionCode;
-  std::cerr << "Received fatal exception ";
-  switch (exc_code) {
-    case EXCEPTION_ACCESS_VIOLATION:
-      std::cerr << "EXCEPTION_ACCESS_VIOLATION";
-      break;
-    case EXCEPTION_ARRAY_BOUNDS_EXCEEDED:
-      std::cerr << "EXCEPTION_ARRAY_BOUNDS_EXCEEDED";
-      break;
-    case EXCEPTION_BREAKPOINT:
-      std::cerr << "EXCEPTION_BREAKPOINT";
-      break;
-    case EXCEPTION_DATATYPE_MISALIGNMENT:
-      std::cerr << "EXCEPTION_DATATYPE_MISALIGNMENT";
-      break;
-    case EXCEPTION_FLT_DENORMAL_OPERAND:
-      std::cerr << "EXCEPTION_FLT_DENORMAL_OPERAND";
-      break;
-    case EXCEPTION_FLT_DIVIDE_BY_ZERO:
-      std::cerr << "EXCEPTION_FLT_DIVIDE_BY_ZERO";
-      break;
-    case EXCEPTION_FLT_INEXACT_RESULT:
-      std::cerr << "EXCEPTION_FLT_INEXACT_RESULT";
-      break;
-    case EXCEPTION_FLT_INVALID_OPERATION:
-      std::cerr << "EXCEPTION_FLT_INVALID_OPERATION";
-      break;
-    case EXCEPTION_FLT_OVERFLOW:
-      std::cerr << "EXCEPTION_FLT_OVERFLOW";
-      break;
-    case EXCEPTION_FLT_STACK_CHECK:
-      std::cerr << "EXCEPTION_FLT_STACK_CHECK";
-      break;
-    case EXCEPTION_FLT_UNDERFLOW:
-      std::cerr << "EXCEPTION_FLT_UNDERFLOW";
-      break;
-    case EXCEPTION_ILLEGAL_INSTRUCTION:
-      std::cerr << "EXCEPTION_ILLEGAL_INSTRUCTION";
-      break;
-    case EXCEPTION_IN_PAGE_ERROR:
-      std::cerr << "EXCEPTION_IN_PAGE_ERROR";
-      break;
-    case EXCEPTION_INT_DIVIDE_BY_ZERO:
-      std::cerr << "EXCEPTION_INT_DIVIDE_BY_ZERO";
-      break;
-    case EXCEPTION_INT_OVERFLOW:
-      std::cerr << "EXCEPTION_INT_OVERFLOW";
-      break;
-    case EXCEPTION_INVALID_DISPOSITION:
-      std::cerr << "EXCEPTION_INVALID_DISPOSITION";
-      break;
-    case EXCEPTION_NONCONTINUABLE_EXCEPTION:
-      std::cerr << "EXCEPTION_NONCONTINUABLE_EXCEPTION";
-      break;
-    case EXCEPTION_PRIV_INSTRUCTION:
-      std::cerr << "EXCEPTION_PRIV_INSTRUCTION";
-      break;
-    case EXCEPTION_SINGLE_STEP:
-      std::cerr << "EXCEPTION_SINGLE_STEP";
-      break;
-    case EXCEPTION_STACK_OVERFLOW:
-      std::cerr << "EXCEPTION_STACK_OVERFLOW";
-      break;
-    default:
-      std::cerr << "0x" << std::hex << exc_code;
-      break;
-  }
-  std::cerr << "\n";
-
-  debug::StackTrace(info).Print();
-  if (g_previous_filter)
-    return g_previous_filter(info);
-  return EXCEPTION_CONTINUE_SEARCH;
-}
-
-FilePath GetExePath() {
-  wchar_t system_buffer[MAX_PATH];
-  GetModuleFileName(NULL, system_buffer, MAX_PATH);
-  system_buffer[MAX_PATH - 1] = L'\0';
-  return FilePath(system_buffer);
-}
-
-bool InitializeSymbols() {
-  if (g_initialized_symbols)
-    return g_init_error == ERROR_SUCCESS;
-  g_initialized_symbols = true;
-  // Defer symbol load until they're needed, use undecorated names, and get line
-  // numbers.
-  SymSetOptions(SYMOPT_DEFERRED_LOADS |
-                SYMOPT_UNDNAME |
-                SYMOPT_LOAD_LINES);
-  if (!SymInitialize(GetCurrentProcess(), NULL, TRUE)) {
-    g_init_error = GetLastError();
-    // TODO(awong): Handle error: SymInitialize can fail with
-    // ERROR_INVALID_PARAMETER.
-    // When it fails, we should not call debugbreak since it kills the current
-    // process (prevents future tests from running or kills the browser
-    // process).
-    DLOG(ERROR) << "SymInitialize failed: " << g_init_error;
-    return false;
-  }
-
-  // When transferring the binaries e.g. between bots, path put
-  // into the executable will get off. To still retrieve symbols correctly,
-  // add the directory of the executable to symbol search path.
-  // All following errors are non-fatal.
-  const size_t kSymbolsArraySize = 1024;
-  std::unique_ptr<wchar_t[]> symbols_path(new wchar_t[kSymbolsArraySize]);
-
-  // Note: The below function takes buffer size as number of characters,
-  // not number of bytes!
-  if (!SymGetSearchPathW(GetCurrentProcess(),
-                         symbols_path.get(),
-                         kSymbolsArraySize)) {
-    g_init_error = GetLastError();
-    DLOG(WARNING) << "SymGetSearchPath failed: " << g_init_error;
-    return false;
-  }
-
-  std::wstring new_path(std::wstring(symbols_path.get()) +
-                        L";" + GetExePath().DirName().value());
-  if (!SymSetSearchPathW(GetCurrentProcess(), new_path.c_str())) {
-    g_init_error = GetLastError();
-    DLOG(WARNING) << "SymSetSearchPath failed." << g_init_error;
-    return false;
-  }
-
-  g_init_error = ERROR_SUCCESS;
-  return true;
-}
-
-// SymbolContext is a threadsafe singleton that wraps the DbgHelp Sym* family
-// of functions.  The Sym* family of functions may only be invoked by one
-// thread at a time.  SymbolContext code may access a symbol server over the
-// network while holding the lock for this singleton.  In the case of high
-// latency, this code will adversely affect performance.
-//
-// There is also a known issue where this backtrace code can interact
-// badly with breakpad if breakpad is invoked in a separate thread while
-// we are using the Sym* functions.  This is because breakpad does now
-// share a lock with this function.  See this related bug:
-//
-//   https://crbug.com/google-breakpad/311
-//
-// This is a very unlikely edge case, and the current solution is to
-// just ignore it.
-class SymbolContext {
- public:
-  static SymbolContext* GetInstance() {
-    // We use a leaky singleton because code may call this during process
-    // termination.
-    return
-      Singleton<SymbolContext, LeakySingletonTraits<SymbolContext> >::get();
-  }
-
-  // For the given trace, attempts to resolve the symbols, and output a trace
-  // to the ostream os.  The format for each line of the backtrace is:
-  //
-  //    <tab>SymbolName[0xAddress+Offset] (FileName:LineNo)
-  //
-  // This function should only be called if Init() has been called.  We do not
-  // LOG(FATAL) here because this code is called might be triggered by a
-  // LOG(FATAL) itself. Also, it should not be calling complex code that is
-  // extensible like PathService since that can in turn fire CHECKs.
-  void OutputTraceToStream(const void* const* trace,
-                           size_t count,
-                           std::ostream* os) {
-    base::AutoLock lock(lock_);
-
-    for (size_t i = 0; (i < count) && os->good(); ++i) {
-      const int kMaxNameLength = 256;
-      DWORD_PTR frame = reinterpret_cast<DWORD_PTR>(trace[i]);
-
-      // Code adapted from MSDN example:
-      // http://msdn.microsoft.com/en-us/library/ms680578(VS.85).aspx
-      ULONG64 buffer[
-        (sizeof(SYMBOL_INFO) +
-          kMaxNameLength * sizeof(wchar_t) +
-          sizeof(ULONG64) - 1) /
-        sizeof(ULONG64)];
-      memset(buffer, 0, sizeof(buffer));
-
-      // Initialize symbol information retrieval structures.
-      DWORD64 sym_displacement = 0;
-      PSYMBOL_INFO symbol = reinterpret_cast<PSYMBOL_INFO>(&buffer[0]);
-      symbol->SizeOfStruct = sizeof(SYMBOL_INFO);
-      symbol->MaxNameLen = kMaxNameLength - 1;
-      BOOL has_symbol = SymFromAddr(GetCurrentProcess(), frame,
-                                    &sym_displacement, symbol);
-
-      // Attempt to retrieve line number information.
-      DWORD line_displacement = 0;
-      IMAGEHLP_LINE64 line = {};
-      line.SizeOfStruct = sizeof(IMAGEHLP_LINE64);
-      BOOL has_line = SymGetLineFromAddr64(GetCurrentProcess(), frame,
-                                           &line_displacement, &line);
-
-      // Output the backtrace line.
-      (*os) << "\t";
-      if (has_symbol) {
-        (*os) << symbol->Name << " [0x" << trace[i] << "+"
-              << sym_displacement << "]";
-      } else {
-        // If there is no symbol information, add a spacer.
-        (*os) << "(No symbol) [0x" << trace[i] << "]";
-      }
-      if (has_line) {
-        (*os) << " (" << line.FileName << ":" << line.LineNumber << ")";
-      }
-      (*os) << "\n";
-    }
-  }
-
- private:
-  friend struct DefaultSingletonTraits<SymbolContext>;
-
-  SymbolContext() {
-    InitializeSymbols();
-  }
-
-  base::Lock lock_;
-  DISALLOW_COPY_AND_ASSIGN(SymbolContext);
-};
-
-}  // namespace
-
-bool EnableInProcessStackDumping() {
-  // Add stack dumping support on exception on windows. Similar to OS_POSIX
-  // signal() handling in process_util_posix.cc.
-  g_previous_filter = SetUnhandledExceptionFilter(&StackDumpExceptionFilter);
-
-  // Need to initialize symbols early in the process or else this fails on
-  // swarming (since symbols are in different directory than in the exes) and
-  // also release x64.
-  return InitializeSymbols();
-}
-
-// Disable optimizations for the StackTrace::StackTrace function. It is
-// important to disable at least frame pointer optimization ("y"), since
-// that breaks CaptureStackBackTrace() and prevents StackTrace from working
-// in Release builds (it may still be janky if other frames are using FPO,
-// but at least it will make it further).
-#if defined(COMPILER_MSVC)
-#pragma optimize("", off)
-#endif
-
-StackTrace::StackTrace(size_t count) {
-  count = std::min(arraysize(trace_), count);
-
-  // When walking our own stack, use CaptureStackBackTrace().
-  count_ = CaptureStackBackTrace(0, count, trace_, NULL);
-}
-
-#if defined(COMPILER_MSVC)
-#pragma optimize("", on)
-#endif
-
-StackTrace::StackTrace(EXCEPTION_POINTERS* exception_pointers) {
-  InitTrace(exception_pointers->ContextRecord);
-}
-
-StackTrace::StackTrace(const CONTEXT* context) {
-  InitTrace(context);
-}
-
-void StackTrace::InitTrace(const CONTEXT* context_record) {
-  // StackWalk64 modifies the register context in place, so we have to copy it
-  // so that downstream exception handlers get the right context.  The incoming
-  // context may have had more register state (YMM, etc) than we need to unwind
-  // the stack. Typically StackWalk64 only needs integer and control registers.
-  CONTEXT context_copy;
-  memcpy(&context_copy, context_record, sizeof(context_copy));
-  context_copy.ContextFlags = CONTEXT_INTEGER | CONTEXT_CONTROL;
-
-  // When walking an exception stack, we need to use StackWalk64().
-  count_ = 0;
-  // Initialize stack walking.
-  STACKFRAME64 stack_frame;
-  memset(&stack_frame, 0, sizeof(stack_frame));
-#if defined(_WIN64)
-  int machine_type = IMAGE_FILE_MACHINE_AMD64;
-  stack_frame.AddrPC.Offset = context_record->Rip;
-  stack_frame.AddrFrame.Offset = context_record->Rbp;
-  stack_frame.AddrStack.Offset = context_record->Rsp;
-#else
-  int machine_type = IMAGE_FILE_MACHINE_I386;
-  stack_frame.AddrPC.Offset = context_record->Eip;
-  stack_frame.AddrFrame.Offset = context_record->Ebp;
-  stack_frame.AddrStack.Offset = context_record->Esp;
-#endif
-  stack_frame.AddrPC.Mode = AddrModeFlat;
-  stack_frame.AddrFrame.Mode = AddrModeFlat;
-  stack_frame.AddrStack.Mode = AddrModeFlat;
-  while (StackWalk64(machine_type,
-                     GetCurrentProcess(),
-                     GetCurrentThread(),
-                     &stack_frame,
-                     &context_copy,
-                     NULL,
-                     &SymFunctionTableAccess64,
-                     &SymGetModuleBase64,
-                     NULL) &&
-         count_ < arraysize(trace_)) {
-    trace_[count_++] = reinterpret_cast<void*>(stack_frame.AddrPC.Offset);
-  }
-
-  for (size_t i = count_; i < arraysize(trace_); ++i)
-    trace_[i] = NULL;
-}
-
-void StackTrace::Print() const {
-  OutputToStream(&std::cerr);
-}
-
-void StackTrace::OutputToStream(std::ostream* os) const {
-  SymbolContext* context = SymbolContext::GetInstance();
-  if (g_init_error != ERROR_SUCCESS) {
-    (*os) << "Error initializing symbols (" << g_init_error
-          << ").  Dumping unresolved backtrace:\n";
-    for (size_t i = 0; (i < count_) && os->good(); ++i) {
-      (*os) << "\t" << trace_[i] << "\n";
-    }
-  } else {
-    (*os) << "Backtrace:\n";
-    context->OutputTraceToStream(trace_, count_, os);
-  }
-}
-
-}  // namespace debug
-}  // namespace base
diff --git a/base/debug/task_annotator.cc b/base/debug/task_annotator.cc
deleted file mode 100644
index 69b9c04..0000000
--- a/base/debug/task_annotator.cc
+++ /dev/null
@@ -1,106 +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.
-
-#include "base/debug/task_annotator.h"
-
-#include <array>
-
-#include "base/debug/alias.h"
-#include "base/no_destructor.h"
-#include "base/pending_task.h"
-#include "base/threading/thread_local.h"
-
-namespace base {
-namespace debug {
-
-namespace {
-
-TaskAnnotator::ObserverForTesting* g_task_annotator_observer = nullptr;
-
-// Returns the TLS slot that stores the PendingTask currently in progress on
-// each thread. Used to allow creating a breadcrumb of program counters on the
-// stack to help identify a task's origin in crashes.
-ThreadLocalPointer<const PendingTask>* GetTLSForCurrentPendingTask() {
-  static NoDestructor<ThreadLocalPointer<const PendingTask>>
-      tls_for_current_pending_task;
-  return tls_for_current_pending_task.get();
-}
-
-}  // namespace
-
-TaskAnnotator::TaskAnnotator() = default;
-
-TaskAnnotator::~TaskAnnotator() = default;
-
-void TaskAnnotator::DidQueueTask(const char* queue_function,
-                                 const PendingTask& pending_task) {
-  // TODO(https://crbug.com/826902): Fix callers that invoke DidQueueTask()
-  // twice for the same PendingTask.
-  // DCHECK(!pending_task.task_backtrace[0])
-  //     << "Task backtrace was already set, task posted twice??";
-  if (!pending_task.task_backtrace[0]) {
-    const PendingTask* parent_task = GetTLSForCurrentPendingTask()->Get();
-    if (parent_task) {
-      pending_task.task_backtrace[0] =
-          parent_task->posted_from.program_counter();
-      std::copy(parent_task->task_backtrace.begin(),
-                parent_task->task_backtrace.end() - 1,
-                pending_task.task_backtrace.begin() + 1);
-    }
-  }
-}
-
-void TaskAnnotator::RunTask(const char* queue_function,
-                            PendingTask* pending_task) {
-  // 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
-  // variable itself will have the expected value when displayed by the
-  // optimizer in an optimized build. Look at a memory dump of the stack.
-  static constexpr int kStackTaskTraceSnapshotSize =
-      std::tuple_size<decltype(pending_task->task_backtrace)>::value + 3;
-  std::array<const void*, kStackTaskTraceSnapshotSize> task_backtrace;
-
-  // Store a marker to locate |task_backtrace| content easily on a memory
-  // dump.
-  task_backtrace.front() = reinterpret_cast<void*>(0xefefefefefefefef);
-  task_backtrace.back() = reinterpret_cast<void*>(0xfefefefefefefefe);
-
-  task_backtrace[1] = pending_task->posted_from.program_counter();
-  std::copy(pending_task->task_backtrace.begin(),
-            pending_task->task_backtrace.end(), task_backtrace.begin() + 2);
-  debug::Alias(&task_backtrace);
-
-  ThreadLocalPointer<const PendingTask>* tls_for_current_pending_task =
-      GetTLSForCurrentPendingTask();
-  const PendingTask* previous_pending_task =
-      tls_for_current_pending_task->Get();
-  tls_for_current_pending_task->Set(pending_task);
-
-  if (g_task_annotator_observer)
-    g_task_annotator_observer->BeforeRunTask(pending_task);
-  std::move(pending_task->task).Run();
-
-  tls_for_current_pending_task->Set(previous_pending_task);
-}
-
-uint64_t TaskAnnotator::GetTaskTraceID(const PendingTask& task) const {
-  return (static_cast<uint64_t>(task.sequence_num) << 32) |
-         ((static_cast<uint64_t>(reinterpret_cast<intptr_t>(this)) << 32) >>
-          32);
-}
-
-// static
-void TaskAnnotator::RegisterObserverForTesting(ObserverForTesting* observer) {
-  DCHECK(!g_task_annotator_observer);
-  g_task_annotator_observer = observer;
-}
-
-// static
-void TaskAnnotator::ClearObserverForTesting() {
-  g_task_annotator_observer = nullptr;
-}
-
-}  // namespace debug
-}  // namespace base
diff --git a/base/debug/task_annotator.h b/base/debug/task_annotator.h
deleted file mode 100644
index f53d02c..0000000
--- a/base/debug/task_annotator.h
+++ /dev/null
@@ -1,64 +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_DEBUG_TASK_ANNOTATOR_H_
-#define BASE_DEBUG_TASK_ANNOTATOR_H_
-
-#include <stdint.h>
-
-#include "base/base_export.h"
-#include "base/macros.h"
-
-namespace base {
-struct PendingTask;
-namespace debug {
-
-// Implements common debug annotations for posted tasks. This includes data
-// such as task origins, queueing durations and memory usage.
-class BASE_EXPORT TaskAnnotator {
- public:
-  class ObserverForTesting {
-   public:
-    // Invoked just before RunTask() in the scope in which the task is about to
-    // be executed.
-    virtual void BeforeRunTask(const PendingTask* pending_task) = 0;
-  };
-
-  TaskAnnotator();
-  ~TaskAnnotator();
-
-  // Called to indicate that a task has been queued to run in the future.
-  // |queue_function| is used as the trace flow event name. |queue_function| can
-  // be null if the caller doesn't want trace flow events logged to
-  // toplevel.flow.
-  void DidQueueTask(const char* queue_function,
-                    const PendingTask& pending_task);
-
-  // Run a previously queued task. |queue_function| should match what was
-  // passed into |DidQueueTask| for this task.
-  void RunTask(const char* queue_function, PendingTask* pending_task);
-
-  // Creates a process-wide unique ID to represent this task in trace events.
-  // This will be mangled with a Process ID hash to reduce the likelyhood of
-  // colliding with TaskAnnotator pointers on other processes. Callers may use
-  // this when generating their own flow events (i.e. when passing
-  // |queue_function == nullptr| in above methods).
-  uint64_t GetTaskTraceID(const PendingTask& task) const;
-
- private:
-  friend class TaskAnnotatorBacktraceIntegrationTest;
-
-  // Registers an ObserverForTesting that will be invoked by all TaskAnnotators'
-  // RunTask(). This registration and the implementation of BeforeRunTask() are
-  // responsible to ensure thread-safety.
-  static void RegisterObserverForTesting(ObserverForTesting* observer);
-  static void ClearObserverForTesting();
-
-  DISALLOW_COPY_AND_ASSIGN(TaskAnnotator);
-};
-
-}  // namespace debug
-}  // namespace base
-
-#endif  // BASE_DEBUG_TASK_ANNOTATOR_H_
diff --git a/base/lazy_instance.h b/base/lazy_instance.h
index 36d3158..456b431 100644
--- a/base/lazy_instance.h
+++ b/base/lazy_instance.h
@@ -48,7 +48,6 @@
 #include <new>  // For placement new.
 
 #include "base/atomicops.h"
-#include "base/debug/leak_annotations.h"
 #include "base/lazy_instance_helpers.h"
 #include "base/logging.h"
 #include "base/threading/thread_restrictions.h"
@@ -113,7 +112,6 @@
 #endif
 
   static Type* New(void* instance) {
-    ANNOTATE_SCOPED_MEMORY_LEAK;
     return LazyInstanceTraitsBase<Type>::New(instance);
   }
   static void Delete(Type* instance) {
diff --git a/base/logging.cc b/base/logging.cc
index 72ca87a..78f1aa0 100644
--- a/base/logging.cc
+++ b/base/logging.cc
@@ -88,9 +88,6 @@
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/containers/stack.h"
-#include "base/debug/alias.h"
-#include "base/debug/debugger.h"
-#include "base/debug/stack_trace.h"
 #include "base/lazy_instance.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/strings/string_piece.h"
@@ -586,11 +583,8 @@
   size_t stack_start = stream_.tellp();
 #if !defined(OFFICIAL_BUILD) && !defined(OS_NACL) && !defined(__UCLIBC__) && \
     !defined(OS_AIX)
-  if (severity_ == LOG_FATAL && !base::debug::BeingDebugged()) {
-    // Include a stack trace on a fatal, unless a debugger is attached.
-    base::debug::StackTrace trace;
+  if (severity_ == LOG_FATAL) {
     stream_ << std::endl;  // Newline to separate from log message.
-    trace.OutputToStream(&stream_);
   }
 #endif
   stream_ << std::endl;
@@ -815,10 +809,6 @@
   }
 
   if (severity_ == LOG_FATAL) {
-    // Ensure the first characters of the string are on the stack so they
-    // are contained in minidumps for diagnostic purposes.
-    DEBUG_ALIAS_FOR_CSTR(str_stack, str_newline.c_str(), 1024);
-
     if (log_assert_handler_stack.IsCreated() &&
         !log_assert_handler_stack.Get().empty()) {
       LogAssertHandlerFunction log_assert_handler =
@@ -838,14 +828,12 @@
       // information, and displaying message boxes when the application is
       // hosed can cause additional problems.
 #ifndef NDEBUG
-      if (!base::debug::BeingDebugged()) {
-        // Displaying a dialog is unnecessary when debugging and can complicate
-        // debugging.
-        DisplayDebugMessageInDialog(stream_.str());
-      }
+      // Displaying a dialog is unnecessary when debugging and can complicate
+      // debugging.
+      DisplayDebugMessageInDialog(stream_.str());
 #endif
       // Crash the process to generate a dump.
-      base::debug::BreakDebugger();
+      abort();
     }
   }
 }
@@ -959,10 +947,6 @@
 
 Win32ErrorLogMessage::~Win32ErrorLogMessage() {
   stream() << ": " << SystemErrorCodeToString(err_);
-  // We're about to crash (CHECK). Put |err_| on the stack (by placing it in a
-  // field) and use Alias in hopes that it makes it into crash dumps.
-  DWORD last_error = err_;
-  base::debug::Alias(&last_error);
 }
 #elif defined(OS_POSIX) || defined(OS_FUCHSIA)
 ErrnoLogMessage::ErrnoLogMessage(const char* file,
@@ -975,10 +959,6 @@
 
 ErrnoLogMessage::~ErrnoLogMessage() {
   stream() << ": " << SystemErrorCodeToString(err_);
-  // We're about to crash (CHECK). Put |err_| on the stack (by placing it in a
-  // field) and use Alias in hopes that it makes it into crash dumps.
-  int last_error = err_;
-  base::debug::Alias(&last_error);
 }
 #endif  // defined(OS_WIN)
 
@@ -1017,7 +997,7 @@
   }
 
   if (level == LOG_FATAL)
-    base::debug::BreakDebugger();
+    abort();
 }
 
 // This was defined at the beginning of this file.
diff --git a/base/logging.h b/base/logging.h
index 39b17ff..59e2fcf 100644
--- a/base/logging.h
+++ b/base/logging.h
@@ -17,7 +17,6 @@
 #include "base/base_export.h"
 #include "base/callback_forward.h"
 #include "base/compiler_specific.h"
-#include "base/debug/debugger.h"
 #include "base/macros.h"
 #include "base/strings/string_piece_forward.h"
 #include "base/template_util.h"
diff --git a/base/message_loop/incoming_task_queue.cc b/base/message_loop/incoming_task_queue.cc
index 0dd1272..7a43e92 100644
--- a/base/message_loop/incoming_task_queue.cc
+++ b/base/message_loop/incoming_task_queue.cc
@@ -121,7 +121,7 @@
 
 void IncomingTaskQueue::RunTask(PendingTask* pending_task) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
-  task_annotator_.RunTask("MessageLoop::PostTask", pending_task);
+  std::move(pending_task->task).Run();
 }
 
 IncomingTaskQueue::TriageQueue::TriageQueue(IncomingTaskQueue* outer)
@@ -329,8 +329,6 @@
   // delayed_run_time value) and for identifying the task in about:tracing.
   pending_task->sequence_num = next_sequence_num_++;
 
-  task_annotator_.DidQueueTask("MessageLoop::PostTask", *pending_task);
-
   bool was_empty = incoming_queue_.empty();
   incoming_queue_.push(std::move(*pending_task));
 
diff --git a/base/message_loop/incoming_task_queue.h b/base/message_loop/incoming_task_queue.h
index f158d2a..b4d8185 100644
--- a/base/message_loop/incoming_task_queue.h
+++ b/base/message_loop/incoming_task_queue.h
@@ -7,7 +7,6 @@
 
 #include "base/base_export.h"
 #include "base/callback.h"
-#include "base/debug/task_annotator.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/pending_task.h"
@@ -206,8 +205,6 @@
   // Checks calls made only on the MessageLoop thread.
   SEQUENCE_CHECKER(sequence_checker_);
 
-  debug::TaskAnnotator task_annotator_;
-
   // True if we always need to call ScheduleWork when receiving a new task, even
   // if the incoming queue was not empty.
   const bool always_schedule_work_;
diff --git a/base/message_loop/message_pump_win.cc b/base/message_loop/message_pump_win.cc
index 47cf477..af0c7db 100644
--- a/base/message_loop/message_pump_win.cc
+++ b/base/message_loop/message_pump_win.cc
@@ -9,7 +9,6 @@
 
 #include <limits>
 
-#include "base/debug/alias.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/stringprintf.h"
@@ -209,8 +208,6 @@
       delay = INFINITE;
 
     // Tell the optimizer to retain these values to simplify analyzing hangs.
-    base::debug::Alias(&delay);
-    base::debug::Alias(&wait_flags);
     DWORD result = MsgWaitForMultipleObjectsEx(0, nullptr, delay, QS_ALLINPUT,
                                                wait_flags);
 
@@ -313,8 +310,6 @@
     if (delay_msec < USER_TIMER_MINIMUM)
       delay_msec = USER_TIMER_MINIMUM;
 
-    // Tell the optimizer to retain these values to simplify analyzing hangs.
-    base::debug::Alias(&delay_msec);
     // Create a WM_TIMER event that will wake us up to check for any pending
     // timers (in case we are running within a nested, external sub-pump).
     UINT_PTR ret = SetTimer(message_window_.hwnd(), 0, delay_msec, nullptr);
@@ -510,8 +505,6 @@
   if (timeout < 0)  // Negative value means no timers waiting.
     timeout = INFINITE;
 
-  // Tell the optimizer to retain these values to simplify analyzing hangs.
-  base::debug::Alias(&timeout);
   WaitForIOCompletion(timeout, nullptr);
 }
 
diff --git a/base/process/launch_posix.cc b/base/process/launch_posix.cc
index 1004012..fc9d188 100644
--- a/base/process/launch_posix.cc
+++ b/base/process/launch_posix.cc
@@ -27,8 +27,6 @@
 
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
-#include "base/debug/debugger.h"
-#include "base/debug/stack_trace.h"
 #include "base/files/dir_reader_posix.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_file.h"
diff --git a/base/process/launch_win.cc b/base/process/launch_win.cc
index 0ae6820..3ee81b1 100644
--- a/base/process/launch_win.cc
+++ b/base/process/launch_win.cc
@@ -17,8 +17,6 @@
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
-#include "base/debug/activity_tracker.h"
-#include "base/debug/stack_trace.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/process/kill.h"
diff --git a/base/process/memory.cc b/base/process/memory.cc
index a98e309..84305e0 100644
--- a/base/process/memory.cc
+++ b/base/process/memory.cc
@@ -2,7 +2,6 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "base/debug/alias.h"
 #include "base/logging.h"
 #include "base/process/memory.h"
 #include "build_config.h"
@@ -17,9 +16,7 @@
 // Breakpad server classifies base::`anonymous namespace'::OnNoMemory as
 // out-of-memory crash.
 NOINLINE void OnNoMemory(size_t size) {
-  size_t tmp_size = size;
-  base::debug::Alias(&tmp_size);
-  LOG(FATAL) << "Out of memory. size=" << tmp_size;
+  LOG(FATAL) << "Out of memory. size=" << size;
 }
 
 }  // namespace
diff --git a/base/process/process_win.cc b/base/process/process_win.cc
index a2e614c..2ef4daf 100644
--- a/base/process/process_win.cc
+++ b/base/process/process_win.cc
@@ -4,7 +4,6 @@
 
 #include "base/process/process.h"
 
-#include "base/debug/activity_tracker.h"
 #include "base/logging.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/process/kill.h"
diff --git a/base/profiler/OWNERS b/base/profiler/OWNERS
deleted file mode 100644
index 81ff9fa..0000000
--- a/base/profiler/OWNERS
+++ /dev/null
@@ -1,5 +0,0 @@
-# Stack sampling profiler
-per-file native_stack_sampler*=wittman@chromium.org
-per-file stack_sampling_profiler*=wittman@chromium.org
-per-file test_support_library*=wittman@chromium.org
-per-file win32_stack_frame_unwinder*=wittman@chromium.org
diff --git a/base/profiler/native_stack_sampler.cc b/base/profiler/native_stack_sampler.cc
deleted file mode 100644
index 6eed54f..0000000
--- a/base/profiler/native_stack_sampler.cc
+++ /dev/null
@@ -1,34 +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/profiler/native_stack_sampler.h"
-
-#include "base/memory/ptr_util.h"
-
-namespace base {
-
-NativeStackSampler::StackBuffer::StackBuffer(size_t buffer_size)
-    : buffer_(new uintptr_t[(buffer_size + sizeof(uintptr_t) - 1) /
-                            sizeof(uintptr_t)]),
-      size_(buffer_size) {}
-
-NativeStackSampler::StackBuffer::~StackBuffer() = default;
-
-NativeStackSampler::NativeStackSampler() = default;
-
-NativeStackSampler::~NativeStackSampler() = default;
-
-std::unique_ptr<NativeStackSampler::StackBuffer>
-NativeStackSampler::CreateStackBuffer() {
-  size_t size = GetStackBufferSize();
-  if (size == 0)
-    return nullptr;
-  return std::make_unique<StackBuffer>(size);
-}
-
-NativeStackSamplerTestDelegate::~NativeStackSamplerTestDelegate() = default;
-
-NativeStackSamplerTestDelegate::NativeStackSamplerTestDelegate() = default;
-
-}  // namespace base
diff --git a/base/profiler/native_stack_sampler.h b/base/profiler/native_stack_sampler.h
deleted file mode 100644
index ebd7c3c..0000000
--- a/base/profiler/native_stack_sampler.h
+++ /dev/null
@@ -1,112 +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_PROFILER_NATIVE_STACK_SAMPLER_H_
-#define BASE_PROFILER_NATIVE_STACK_SAMPLER_H_
-
-#include <memory>
-
-#include "base/base_export.h"
-#include "base/macros.h"
-#include "base/profiler/stack_sampling_profiler.h"
-#include "base/threading/platform_thread.h"
-
-namespace base {
-
-class NativeStackSamplerTestDelegate;
-
-// NativeStackSampler is an implementation detail of StackSamplingProfiler. It
-// abstracts the native implementation required to record a stack sample for a
-// given thread.
-class NativeStackSampler {
- public:
-  // This class contains a buffer for stack copies that can be shared across
-  // multiple instances of NativeStackSampler.
-  class StackBuffer {
-   public:
-    StackBuffer(size_t buffer_size);
-    ~StackBuffer();
-
-    void* buffer() const { return buffer_.get(); }
-    size_t size() const { return size_; }
-
-   private:
-    // The word-aligned buffer.
-    const std::unique_ptr<uintptr_t[]> buffer_;
-
-    // The size of the buffer.
-    const size_t size_;
-
-    DISALLOW_COPY_AND_ASSIGN(StackBuffer);
-  };
-
-  // The callback type used to add annotations to a sample during collection.
-  // This is passed to the native sampler to be applied at the most appropriate
-  // time. It is a simple function-pointer because the generated code must be
-  // completely predictable and do nothing that could acquire a mutex; a
-  // Callback object is code outside the control of this object and could,
-  // for example, acquire a mutex as part of allocating memory for a LOG
-  // message.
-  using AnnotateCallback = void (*)(StackSamplingProfiler::Sample*);
-
-  virtual ~NativeStackSampler();
-
-  // Creates a stack sampler that records samples for |thread_handle|. Returns
-  // null if this platform does not support stack sampling.
-  static std::unique_ptr<NativeStackSampler> Create(
-      PlatformThreadId thread_id,
-      AnnotateCallback annotator,
-      NativeStackSamplerTestDelegate* test_delegate);
-
-  // Gets the required size of the stack buffer.
-  static size_t GetStackBufferSize();
-
-  // Creates an instance of the a stack buffer that can be used for calls to
-  // any NativeStackSampler object.
-  static std::unique_ptr<StackBuffer> CreateStackBuffer();
-
-  // The following functions are all called on the SamplingThread (not the
-  // thread being sampled).
-
-  // Notifies the sampler that we're starting to record a new profile. Modules
-  // shared across samples in the profile should be recorded in |modules|.
-  virtual void ProfileRecordingStarting(
-      std::vector<StackSamplingProfiler::Module>* modules) = 0;
-
-  // Records a stack sample to |sample|.
-  virtual void RecordStackSample(StackBuffer* stackbuffer,
-                                 StackSamplingProfiler::Sample* sample) = 0;
-
-  // Notifies the sampler that we've stopped recording the current
-  // profile.
-  virtual void ProfileRecordingStopped(StackBuffer* stackbuffer) = 0;
-
- protected:
-  NativeStackSampler();
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(NativeStackSampler);
-};
-
-// NativeStackSamplerTestDelegate provides seams for test code to execute during
-// stack collection.
-class BASE_EXPORT NativeStackSamplerTestDelegate {
- public:
-  virtual ~NativeStackSamplerTestDelegate();
-
-  // Called after copying the stack and resuming the target thread, but prior to
-  // walking the stack. Invoked on the SamplingThread.
-  virtual void OnPreStackWalk() = 0;
-
- protected:
-  NativeStackSamplerTestDelegate();
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(NativeStackSamplerTestDelegate);
-};
-
-}  // namespace base
-
-#endif  // BASE_PROFILER_NATIVE_STACK_SAMPLER_H_
-
diff --git a/base/profiler/native_stack_sampler_mac.cc b/base/profiler/native_stack_sampler_mac.cc
deleted file mode 100644
index a161173..0000000
--- a/base/profiler/native_stack_sampler_mac.cc
+++ /dev/null
@@ -1,666 +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/profiler/native_stack_sampler.h"
-
-#include <dlfcn.h>
-#include <libkern/OSByteOrder.h>
-#include <libunwind.h>
-#include <mach-o/compact_unwind_encoding.h>
-#include <mach-o/getsect.h>
-#include <mach-o/swap.h>
-#include <mach/kern_return.h>
-#include <mach/mach.h>
-#include <mach/thread_act.h>
-#include <mach/vm_map.h>
-#include <pthread.h>
-#include <sys/resource.h>
-#include <sys/syslimits.h>
-
-#include <algorithm>
-#include <map>
-#include <memory>
-
-#include "base/logging.h"
-#include "base/mac/mach_logging.h"
-#include "base/macros.h"
-#include "base/memory/ptr_util.h"
-#include "base/strings/string_number_conversions.h"
-
-extern "C" {
-void _sigtramp(int, int, struct sigset*);
-}
-
-namespace base {
-
-namespace {
-
-// Maps a module's address range (half-open) in memory to an index in a separate
-// data structure.
-struct ModuleIndex {
-  ModuleIndex(uintptr_t start, uintptr_t end, size_t idx)
-      : base_address(start), end_address(end), index(idx){};
-  // Base address of the represented module.
-  uintptr_t base_address;
-  // First address off the end of the represented module.
-  uintptr_t end_address;
-  // An index to the represented module in a separate container.
-  size_t index;
-};
-
-// Module identifiers ---------------------------------------------------------
-
-// Returns the unique build ID for a module loaded at |module_addr|. Returns the
-// empty string if the function fails to get the build ID.
-//
-// Build IDs are created by the concatenation of the module's GUID (Windows) /
-// UUID (Mac) and an "age" field that indicates how many times that GUID/UUID
-// has been reused. In Windows binaries, the "age" field is present in the
-// module header, but on the Mac, UUIDs are never reused and so the "age" value
-// appended to the UUID is always 0.
-std::string GetUniqueId(const void* module_addr) {
-  const mach_header_64* mach_header =
-      reinterpret_cast<const mach_header_64*>(module_addr);
-  DCHECK_EQ(MH_MAGIC_64, mach_header->magic);
-
-  size_t offset = sizeof(mach_header_64);
-  size_t offset_limit = sizeof(mach_header_64) + mach_header->sizeofcmds;
-  for (uint32_t i = 0; (i < mach_header->ncmds) &&
-                       (offset + sizeof(load_command) < offset_limit);
-       ++i) {
-    const load_command* current_cmd = reinterpret_cast<const load_command*>(
-        reinterpret_cast<const uint8_t*>(mach_header) + offset);
-
-    if (offset + current_cmd->cmdsize > offset_limit) {
-      // This command runs off the end of the command list. This is malformed.
-      return std::string();
-    }
-
-    if (current_cmd->cmd == LC_UUID) {
-      if (current_cmd->cmdsize < sizeof(uuid_command)) {
-        // This "UUID command" is too small. This is malformed.
-        return std::string();
-      }
-
-      const uuid_command* uuid_cmd =
-          reinterpret_cast<const uuid_command*>(current_cmd);
-      static_assert(sizeof(uuid_cmd->uuid) == sizeof(uuid_t),
-                    "UUID field of UUID command should be 16 bytes.");
-      // The ID is comprised of the UUID concatenated with the Mac's "age" value
-      // which is always 0.
-      return HexEncode(&uuid_cmd->uuid, sizeof(uuid_cmd->uuid)) + "0";
-    }
-    offset += current_cmd->cmdsize;
-  }
-  return std::string();
-}
-
-// Returns the size of the _TEXT segment of the module loaded at |module_addr|.
-size_t GetModuleTextSize(const void* module_addr) {
-  const mach_header_64* mach_header =
-      reinterpret_cast<const mach_header_64*>(module_addr);
-  DCHECK_EQ(MH_MAGIC_64, mach_header->magic);
-
-  unsigned long module_size;
-  getsegmentdata(mach_header, SEG_TEXT, &module_size);
-
-  return module_size;
-}
-
-// Gets the index for the Module containing |instruction_pointer| in
-// |modules|, adding it if it's not already present. Returns
-// StackSamplingProfiler::Frame::kUnknownModuleIndex if no Module can be
-// determined for |module|.
-size_t GetModuleIndex(const uintptr_t instruction_pointer,
-                      std::vector<StackSamplingProfiler::Module>* modules,
-                      std::vector<ModuleIndex>* profile_module_index) {
-  // Check if |instruction_pointer| is in the address range of a module we've
-  // already seen.
-  auto module_index =
-      std::find_if(profile_module_index->begin(), profile_module_index->end(),
-                   [instruction_pointer](const ModuleIndex& index) {
-                     return instruction_pointer >= index.base_address &&
-                            instruction_pointer < index.end_address;
-                   });
-  if (module_index != profile_module_index->end()) {
-    return module_index->index;
-  }
-  Dl_info inf;
-  if (!dladdr(reinterpret_cast<const void*>(instruction_pointer), &inf))
-    return StackSamplingProfiler::Frame::kUnknownModuleIndex;
-
-  StackSamplingProfiler::Module module(
-      reinterpret_cast<uintptr_t>(inf.dli_fbase), GetUniqueId(inf.dli_fbase),
-      base::FilePath(inf.dli_fname));
-  modules->push_back(module);
-
-  uintptr_t base_module_address = reinterpret_cast<uintptr_t>(inf.dli_fbase);
-  size_t index = modules->size() - 1;
-  profile_module_index->emplace_back(
-      base_module_address,
-      base_module_address + GetModuleTextSize(inf.dli_fbase), index);
-  return index;
-}
-
-// Stack walking --------------------------------------------------------------
-
-// Fills |state| with |target_thread|'s context.
-//
-// Note that this is called while a thread is suspended. Make very very sure
-// that no shared resources (e.g. memory allocators) are used for the duration
-// of this function.
-bool GetThreadState(thread_act_t target_thread, x86_thread_state64_t* state) {
-  mach_msg_type_number_t count =
-      static_cast<mach_msg_type_number_t>(x86_THREAD_STATE64_COUNT);
-  return thread_get_state(target_thread, x86_THREAD_STATE64,
-                          reinterpret_cast<thread_state_t>(state),
-                          &count) == KERN_SUCCESS;
-}
-
-// If the value at |pointer| points to the original stack, rewrites it to point
-// to the corresponding location in the copied stack.
-//
-// Note that this is called while a thread is suspended. Make very very sure
-// that no shared resources (e.g. memory allocators) are used for the duration
-// of this function.
-uintptr_t RewritePointerIfInOriginalStack(
-    const uintptr_t* original_stack_bottom,
-    const uintptr_t* original_stack_top,
-    uintptr_t* stack_copy_bottom,
-    uintptr_t pointer) {
-  uintptr_t original_stack_bottom_int =
-      reinterpret_cast<uintptr_t>(original_stack_bottom);
-  uintptr_t original_stack_top_int =
-      reinterpret_cast<uintptr_t>(original_stack_top);
-  uintptr_t stack_copy_bottom_int =
-      reinterpret_cast<uintptr_t>(stack_copy_bottom);
-
-  if ((pointer < original_stack_bottom_int) ||
-      (pointer >= original_stack_top_int)) {
-    return pointer;
-  }
-
-  return stack_copy_bottom_int + (pointer - original_stack_bottom_int);
-}
-
-// Copies the stack to a buffer while rewriting possible pointers to locations
-// within the stack to point to the corresponding locations in the copy. This is
-// necessary to handle stack frames with dynamic stack allocation, where a
-// pointer to the beginning of the dynamic allocation area is stored on the
-// stack and/or in a non-volatile register.
-//
-// Eager rewriting of anything that looks like a pointer to the stack, as done
-// in this function, does not adversely affect the stack unwinding. The only
-// other values on the stack the unwinding depends on are return addresses,
-// which should not point within the stack memory. The rewriting is guaranteed
-// to catch all pointers because the stacks are guaranteed by the ABI to be
-// sizeof(void*) aligned.
-//
-// Note that this is called while a thread is suspended. Make very very sure
-// that no shared resources (e.g. memory allocators) are used for the duration
-// of this function.
-void CopyStackAndRewritePointers(uintptr_t* stack_copy_bottom,
-                                 const uintptr_t* original_stack_bottom,
-                                 const uintptr_t* original_stack_top,
-                                 x86_thread_state64_t* thread_state)
-    NO_SANITIZE("address") {
-  size_t count = original_stack_top - original_stack_bottom;
-  for (size_t pos = 0; pos < count; ++pos) {
-    stack_copy_bottom[pos] = RewritePointerIfInOriginalStack(
-        original_stack_bottom, original_stack_top, stack_copy_bottom,
-        original_stack_bottom[pos]);
-  }
-
-  uint64_t* rewrite_registers[] = {&thread_state->__rbx, &thread_state->__rbp,
-                                   &thread_state->__rsp, &thread_state->__r12,
-                                   &thread_state->__r13, &thread_state->__r14,
-                                   &thread_state->__r15};
-  for (auto* reg : rewrite_registers) {
-    *reg = RewritePointerIfInOriginalStack(
-        original_stack_bottom, original_stack_top, stack_copy_bottom, *reg);
-  }
-}
-
-// Extracts the "frame offset" for a given frame from the compact unwind info.
-// A frame offset indicates the location of saved non-volatile registers in
-// relation to the frame pointer. See |mach-o/compact_unwind_encoding.h| for
-// details.
-uint32_t GetFrameOffset(int compact_unwind_info) {
-  // The frame offset lives in bytes 16-23. This shifts it down by the number of
-  // leading zeroes in the mask, then masks with (1 << number of one bits in the
-  // mask) - 1, turning 0x00FF0000 into 0x000000FF. Adapted from |EXTRACT_BITS|
-  // in libunwind's CompactUnwinder.hpp.
-  return (
-      (compact_unwind_info >> __builtin_ctz(UNWIND_X86_64_RBP_FRAME_OFFSET)) &
-      (((1 << __builtin_popcount(UNWIND_X86_64_RBP_FRAME_OFFSET))) - 1));
-}
-
-// True if the unwind from |leaf_frame_rip| may trigger a crash bug in
-// unw_init_local. If so, the stack walk should be aborted at the leaf frame.
-bool MayTriggerUnwInitLocalCrash(uint64_t leaf_frame_rip) {
-  // The issue here is a bug in unw_init_local that, in some unwinds, results in
-  // attempts to access memory at the address immediately following the address
-  // range of the library. When the library is the last of the mapped libraries
-  // that address is in a different memory region. Starting with 10.13.4 beta
-  // releases it appears that this region is sometimes either unmapped or mapped
-  // without read access, resulting in crashes on the attempted access. It's not
-  // clear what circumstances result in this situation; attempts to reproduce on
-  // a 10.13.4 beta did not trigger the issue.
-  //
-  // The workaround is to check if the memory address that would be accessed is
-  // readable, and if not, abort the stack walk before calling unw_init_local.
-  // As of 2018/03/19 about 0.1% of non-idle stacks on the UI and GPU main
-  // threads have a leaf frame in the last library. Since the issue appears to
-  // only occur some of the time it's expected that the quantity of lost samples
-  // will be lower than 0.1%, possibly significantly lower.
-  //
-  // TODO(lgrey): Add references above to LLVM/Radar bugs on unw_init_local once
-  // filed.
-  Dl_info info;
-  if (dladdr(reinterpret_cast<const void*>(leaf_frame_rip), &info) == 0)
-    return false;
-  uint64_t unused;
-  vm_size_t size = sizeof(unused);
-  return vm_read_overwrite(current_task(),
-                           reinterpret_cast<vm_address_t>(info.dli_fbase) +
-                               GetModuleTextSize(info.dli_fbase),
-                           sizeof(unused),
-                           reinterpret_cast<vm_address_t>(&unused), &size) != 0;
-}
-
-// Check if the cursor contains a valid-looking frame pointer for frame pointer
-// unwinds. If the stack frame has a frame pointer, stepping the cursor will
-// involve indexing memory access off of that pointer. In that case,
-// sanity-check the frame pointer register to ensure it's within bounds.
-//
-// Additionally, the stack frame might be in a prologue or epilogue, which can
-// cause a crash when the unwinder attempts to access non-volatile registers
-// that have not yet been pushed, or have already been popped from the
-// stack. libwunwind will try to restore those registers using an offset from
-// the frame pointer. However, since we copy the stack from RSP up, any
-// locations below the stack pointer are before the beginning of the stack
-// buffer. Account for this by checking that the expected location is above the
-// stack pointer, and rejecting the sample if it isn't.
-bool HasValidRbp(unw_cursor_t* unwind_cursor, uintptr_t stack_top) {
-  unw_proc_info_t proc_info;
-  unw_get_proc_info(unwind_cursor, &proc_info);
-  if ((proc_info.format & UNWIND_X86_64_MODE_MASK) ==
-      UNWIND_X86_64_MODE_RBP_FRAME) {
-    unw_word_t rsp, rbp;
-    unw_get_reg(unwind_cursor, UNW_X86_64_RSP, &rsp);
-    unw_get_reg(unwind_cursor, UNW_X86_64_RBP, &rbp);
-    uint32_t offset = GetFrameOffset(proc_info.format) * sizeof(unw_word_t);
-    if (rbp < offset || (rbp - offset) < rsp || rbp > stack_top) {
-      return false;
-    }
-  }
-  return true;
-}
-
-// Walks the stack represented by |unwind_context|, calling back to the provided
-// lambda for each frame. Returns false if an error occurred, otherwise returns
-// true.
-template <typename StackFrameCallback, typename ContinueUnwindPredicate>
-bool WalkStackFromContext(
-    unw_context_t* unwind_context,
-    size_t* frame_count,
-    std::vector<StackSamplingProfiler::Module>* current_modules,
-    std::vector<ModuleIndex>* profile_module_index,
-    const StackFrameCallback& callback,
-    const ContinueUnwindPredicate& continue_unwind) {
-  unw_cursor_t unwind_cursor;
-  unw_init_local(&unwind_cursor, unwind_context);
-
-  int step_result;
-  unw_word_t rip;
-  do {
-    ++(*frame_count);
-    unw_get_reg(&unwind_cursor, UNW_REG_IP, &rip);
-
-    // Ensure IP is in a module.
-    //
-    // Frameless unwinding (non-DWARF) works by fetching the function's
-    // stack size from the unwind encoding or stack, and adding it to the
-    // stack pointer to determine the function's return address.
-    //
-    // If we're in a function prologue or epilogue, the actual stack size
-    // may be smaller than it will be during the normal course of execution.
-    // When libunwind adds the expected stack size, it will look for the
-    // return address in the wrong place. This check should ensure that we
-    // bail before trying to deref a bad IP obtained this way in the previous
-    // frame.
-    size_t module_index =
-        GetModuleIndex(rip, current_modules, profile_module_index);
-    if (module_index == StackSamplingProfiler::Frame::kUnknownModuleIndex) {
-      return false;
-    }
-
-    callback(static_cast<uintptr_t>(rip), module_index);
-
-    if (!continue_unwind(&unwind_cursor))
-      return false;
-
-    step_result = unw_step(&unwind_cursor);
-  } while (step_result > 0);
-
-  if (step_result != 0)
-    return false;
-
-  return true;
-}
-
-const char* LibSystemKernelName() {
-  static char path[PATH_MAX];
-  static char* name = nullptr;
-  if (name)
-    return name;
-
-  Dl_info info;
-  dladdr(reinterpret_cast<void*>(_exit), &info);
-  strlcpy(path, info.dli_fname, PATH_MAX);
-  name = path;
-
-#if !defined(ADDRESS_SANITIZER)
-  DCHECK_EQ(std::string(name),
-            std::string("/usr/lib/system/libsystem_kernel.dylib"));
-#endif
-  return name;
-}
-
-void GetSigtrampRange(uintptr_t* start, uintptr_t* end) {
-  uintptr_t address = reinterpret_cast<uintptr_t>(&_sigtramp);
-  DCHECK(address != 0);
-
-  *start = address;
-
-  unw_context_t context;
-  unw_cursor_t cursor;
-  unw_proc_info_t info;
-
-  unw_getcontext(&context);
-  // Set the context's RIP to the beginning of sigtramp,
-  // +1 byte to work around a bug in 10.11 (crbug.com/764468).
-  context.data[16] = address + 1;
-  unw_init_local(&cursor, &context);
-  unw_get_proc_info(&cursor, &info);
-
-  DCHECK_EQ(info.start_ip, address);
-  *end = info.end_ip;
-}
-
-// Walks the stack represented by |thread_state|, calling back to the provided
-// lambda for each frame.
-template <typename StackFrameCallback, typename ContinueUnwindPredicate>
-void WalkStack(const x86_thread_state64_t& thread_state,
-               std::vector<StackSamplingProfiler::Module>* current_modules,
-               std::vector<ModuleIndex>* profile_module_index,
-               const StackFrameCallback& callback,
-               const ContinueUnwindPredicate& continue_unwind) {
-  size_t frame_count = 0;
-  // This uses libunwind to walk the stack. libunwind is designed to be used for
-  // a thread to walk its own stack. This creates two problems.
-
-  // Problem 1: There is no official way to create a unw_context other than to
-  // create it from the current state of the current thread's stack. To get
-  // around this, forge a context. A unw_context is just a copy of the 16 main
-  // registers followed by the instruction pointer, nothing more.
-  // Coincidentally, the first 17 items of the x86_thread_state64_t type are
-  // exactly those registers in exactly the same order, so just bulk copy them
-  // over.
-  unw_context_t unwind_context;
-  memcpy(&unwind_context, &thread_state, sizeof(uintptr_t) * 17);
-  bool result =
-      WalkStackFromContext(&unwind_context, &frame_count, current_modules,
-                           profile_module_index, callback, continue_unwind);
-
-  if (!result)
-    return;
-
-  if (frame_count == 1) {
-    // Problem 2: Because libunwind is designed to be triggered by user code on
-    // their own thread, if it hits a library that has no unwind info for the
-    // function that is being executed, it just stops. This isn't a problem in
-    // the normal case, but in this case, it's quite possible that the stack
-    // being walked is stopped in a function that bridges to the kernel and thus
-    // is missing the unwind info.
-
-    // For now, just unwind the single case where the thread is stopped in a
-    // function in libsystem_kernel.
-    uint64_t& rsp = unwind_context.data[7];
-    uint64_t& rip = unwind_context.data[16];
-    Dl_info info;
-    if (dladdr(reinterpret_cast<void*>(rip), &info) != 0 &&
-      strcmp(info.dli_fname, LibSystemKernelName()) == 0) {
-      rip = *reinterpret_cast<uint64_t*>(rsp);
-      rsp += 8;
-      WalkStackFromContext(&unwind_context, &frame_count, current_modules,
-                           profile_module_index, callback, continue_unwind);
-    }
-  }
-}
-
-// ScopedSuspendThread --------------------------------------------------------
-
-// Suspends a thread for the lifetime of the object.
-class ScopedSuspendThread {
- public:
-  explicit ScopedSuspendThread(mach_port_t thread_port)
-      : thread_port_(thread_suspend(thread_port) == KERN_SUCCESS
-                         ? thread_port
-                         : MACH_PORT_NULL) {}
-
-  ~ScopedSuspendThread() {
-    if (!was_successful())
-      return;
-
-    kern_return_t kr = thread_resume(thread_port_);
-    MACH_CHECK(kr == KERN_SUCCESS, kr) << "thread_resume";
-  }
-
-  bool was_successful() const { return thread_port_ != MACH_PORT_NULL; }
-
- private:
-  mach_port_t thread_port_;
-
-  DISALLOW_COPY_AND_ASSIGN(ScopedSuspendThread);
-};
-
-// NativeStackSamplerMac ------------------------------------------------------
-
-class NativeStackSamplerMac : public NativeStackSampler {
- public:
-  NativeStackSamplerMac(mach_port_t thread_port,
-                        AnnotateCallback annotator,
-                        NativeStackSamplerTestDelegate* test_delegate);
-  ~NativeStackSamplerMac() override;
-
-  // StackSamplingProfiler::NativeStackSampler:
-  void ProfileRecordingStarting(
-      std::vector<StackSamplingProfiler::Module>* modules) override;
-  void RecordStackSample(StackBuffer* stack_buffer,
-                         StackSamplingProfiler::Sample* sample) override;
-  void ProfileRecordingStopped(StackBuffer* stack_buffer) override;
-
- private:
-  // Suspends the thread with |thread_port_|, copies its stack and resumes the
-  // thread, then records the stack frames and associated modules into |sample|.
-  void SuspendThreadAndRecordStack(StackBuffer* stack_buffer,
-                                   StackSamplingProfiler::Sample* sample);
-
-  // Weak reference: Mach port for thread being profiled.
-  mach_port_t thread_port_;
-
-  const AnnotateCallback annotator_;
-
-  NativeStackSamplerTestDelegate* const test_delegate_;
-
-  // The stack base address corresponding to |thread_handle_|.
-  const void* const thread_stack_base_address_;
-
-  // Weak. Points to the modules associated with the profile being recorded
-  // between ProfileRecordingStarting() and ProfileRecordingStopped().
-  std::vector<StackSamplingProfiler::Module>* current_modules_ = nullptr;
-
-  // Maps a module's address range to the corresponding Module's index within
-  // current_modules_.
-  std::vector<ModuleIndex> profile_module_index_;
-
-  // The address range of |_sigtramp|, the signal trampoline function.
-  uintptr_t sigtramp_start_;
-  uintptr_t sigtramp_end_;
-
-  DISALLOW_COPY_AND_ASSIGN(NativeStackSamplerMac);
-};
-
-NativeStackSamplerMac::NativeStackSamplerMac(
-    mach_port_t thread_port,
-    AnnotateCallback annotator,
-    NativeStackSamplerTestDelegate* test_delegate)
-    : thread_port_(thread_port),
-      annotator_(annotator),
-      test_delegate_(test_delegate),
-      thread_stack_base_address_(
-          pthread_get_stackaddr_np(pthread_from_mach_thread_np(thread_port))) {
-  DCHECK(annotator_);
-
-  GetSigtrampRange(&sigtramp_start_, &sigtramp_end_);
-  // This class suspends threads, and those threads might be suspended in dyld.
-  // Therefore, for all the system functions that might be linked in dynamically
-  // that are used while threads are suspended, make calls to them to make sure
-  // that they are linked up.
-  x86_thread_state64_t thread_state;
-  GetThreadState(thread_port_, &thread_state);
-}
-
-NativeStackSamplerMac::~NativeStackSamplerMac() {}
-
-void NativeStackSamplerMac::ProfileRecordingStarting(
-    std::vector<StackSamplingProfiler::Module>* modules) {
-  current_modules_ = modules;
-  profile_module_index_.clear();
-}
-
-void NativeStackSamplerMac::RecordStackSample(
-    StackBuffer* stack_buffer,
-    StackSamplingProfiler::Sample* sample) {
-  DCHECK(current_modules_);
-
-  SuspendThreadAndRecordStack(stack_buffer, sample);
-}
-
-void NativeStackSamplerMac::ProfileRecordingStopped(StackBuffer* stack_buffer) {
-  current_modules_ = nullptr;
-}
-
-void NativeStackSamplerMac::SuspendThreadAndRecordStack(
-    StackBuffer* stack_buffer,
-    StackSamplingProfiler::Sample* sample) {
-  x86_thread_state64_t thread_state;
-
-  // Copy the stack.
-
-  uintptr_t new_stack_top = 0;
-  {
-    // IMPORTANT NOTE: Do not do ANYTHING in this in this scope that might
-    // allocate memory, including indirectly via use of DCHECK/CHECK or other
-    // logging statements. Otherwise this code can deadlock on heap locks in the
-    // default heap acquired by the target thread before it was suspended.
-    ScopedSuspendThread suspend_thread(thread_port_);
-    if (!suspend_thread.was_successful())
-      return;
-
-    if (!GetThreadState(thread_port_, &thread_state))
-      return;
-    uintptr_t stack_top =
-        reinterpret_cast<uintptr_t>(thread_stack_base_address_);
-    uintptr_t stack_bottom = thread_state.__rsp;
-    if (stack_bottom >= stack_top)
-      return;
-    uintptr_t stack_size = stack_top - stack_bottom;
-
-    if (stack_size > stack_buffer->size())
-      return;
-
-    (*annotator_)(sample);
-
-    CopyStackAndRewritePointers(
-        reinterpret_cast<uintptr_t*>(stack_buffer->buffer()),
-        reinterpret_cast<uintptr_t*>(stack_bottom),
-        reinterpret_cast<uintptr_t*>(stack_top), &thread_state);
-
-    new_stack_top =
-        reinterpret_cast<uintptr_t>(stack_buffer->buffer()) + stack_size;
-  }  // ScopedSuspendThread
-
-  if (test_delegate_)
-    test_delegate_->OnPreStackWalk();
-
-  // Walk the stack and record it.
-
-  // Reserve enough memory for most stacks, to avoid repeated allocations.
-  // Approximately 99.9% of recorded stacks are 128 frames or fewer.
-  sample->frames.reserve(128);
-
-  auto* current_modules = current_modules_;
-  auto* profile_module_index = &profile_module_index_;
-
-  // Avoid an out-of-bounds read bug in libunwind that can crash us in some
-  // circumstances. If we're subject to that case, just record the first frame
-  // and bail. See MayTriggerUnwInitLocalCrash for details.
-  uintptr_t rip = thread_state.__rip;
-  if (MayTriggerUnwInitLocalCrash(rip)) {
-    sample->frames.emplace_back(
-        rip, GetModuleIndex(rip, current_modules, profile_module_index));
-    return;
-  }
-
-  const auto continue_predicate = [this,
-                                   new_stack_top](unw_cursor_t* unwind_cursor) {
-    // Don't continue if we're in sigtramp. Unwinding this from another thread
-    // is very fragile. It's a complex DWARF unwind that needs to restore the
-    // entire thread context which was saved by the kernel when the interrupt
-    // occurred.
-    unw_word_t rip;
-    unw_get_reg(unwind_cursor, UNW_REG_IP, &rip);
-    if (rip >= sigtramp_start_ && rip < sigtramp_end_)
-      return false;
-
-    // Don't continue if rbp appears to be invalid (due to a previous bad
-    // unwind).
-    return HasValidRbp(unwind_cursor, new_stack_top);
-  };
-
-  WalkStack(thread_state, current_modules, profile_module_index,
-            [sample, current_modules, profile_module_index](
-                uintptr_t frame_ip, size_t module_index) {
-              sample->frames.emplace_back(frame_ip, module_index);
-            },
-            continue_predicate);
-}
-
-}  // namespace
-
-std::unique_ptr<NativeStackSampler> NativeStackSampler::Create(
-    PlatformThreadId thread_id,
-    AnnotateCallback annotator,
-    NativeStackSamplerTestDelegate* test_delegate) {
-  return std::make_unique<NativeStackSamplerMac>(thread_id, annotator,
-                                                 test_delegate);
-}
-
-size_t NativeStackSampler::GetStackBufferSize() {
-  // In platform_thread_mac's GetDefaultThreadStackSize(), RLIMIT_STACK is used
-  // for all stacks, not just the main thread's, so it is good for use here.
-  struct rlimit stack_rlimit;
-  if (getrlimit(RLIMIT_STACK, &stack_rlimit) == 0 &&
-      stack_rlimit.rlim_cur != RLIM_INFINITY) {
-    return stack_rlimit.rlim_cur;
-  }
-
-  // If getrlimit somehow fails, return the default macOS main thread stack size
-  // of 8 MB (DFLSSIZ in <i386/vmparam.h>) with extra wiggle room.
-  return 12 * 1024 * 1024;
-}
-
-}  // namespace base
diff --git a/base/profiler/native_stack_sampler_posix.cc b/base/profiler/native_stack_sampler_posix.cc
deleted file mode 100644
index 1055d44..0000000
--- a/base/profiler/native_stack_sampler_posix.cc
+++ /dev/null
@@ -1,20 +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/profiler/native_stack_sampler.h"
-
-namespace base {
-
-std::unique_ptr<NativeStackSampler> NativeStackSampler::Create(
-    PlatformThreadId thread_id,
-    AnnotateCallback annotator,
-    NativeStackSamplerTestDelegate* test_delegate) {
-  return std::unique_ptr<NativeStackSampler>();
-}
-
-size_t NativeStackSampler::GetStackBufferSize() {
-  return 0;
-}
-
-}  // namespace base
diff --git a/base/profiler/native_stack_sampler_win.cc b/base/profiler/native_stack_sampler_win.cc
deleted file mode 100644
index b53197d..0000000
--- a/base/profiler/native_stack_sampler_win.cc
+++ /dev/null
@@ -1,562 +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/profiler/native_stack_sampler.h"
-
-#include <objbase.h>
-#include <windows.h>
-#include <stddef.h>
-#include <winternl.h>
-
-#include <cstdlib>
-#include <map>
-#include <memory>
-#include <utility>
-#include <vector>
-
-#include "base/lazy_instance.h"
-#include "base/logging.h"
-#include "base/macros.h"
-#include "base/memory/ptr_util.h"
-#include "base/profiler/win32_stack_frame_unwinder.h"
-#include "base/strings/string_util.h"
-#include "base/strings/stringprintf.h"
-#include "base/strings/utf_string_conversions.h"
-#include "base/time/time.h"
-#include "base/win/pe_image.h"
-#include "base/win/scoped_handle.h"
-
-namespace base {
-
-// Stack recording functions --------------------------------------------------
-
-namespace {
-
-// The thread environment block internal type.
-struct TEB {
-  NT_TIB Tib;
-  // Rest of struct is ignored.
-};
-
-// Returns the thread environment block pointer for |thread_handle|.
-const TEB* GetThreadEnvironmentBlock(HANDLE thread_handle) {
-  // Define the internal types we need to invoke NtQueryInformationThread.
-  enum THREAD_INFORMATION_CLASS { ThreadBasicInformation };
-
-  struct CLIENT_ID {
-    HANDLE UniqueProcess;
-    HANDLE UniqueThread;
-  };
-
-  struct THREAD_BASIC_INFORMATION {
-    NTSTATUS ExitStatus;
-    TEB* Teb;
-    CLIENT_ID ClientId;
-    KAFFINITY AffinityMask;
-    LONG Priority;
-    LONG BasePriority;
-  };
-
-  using NtQueryInformationThreadFunction =
-      NTSTATUS (WINAPI*)(HANDLE, THREAD_INFORMATION_CLASS, PVOID, ULONG,
-                         PULONG);
-
-  const NtQueryInformationThreadFunction nt_query_information_thread =
-      reinterpret_cast<NtQueryInformationThreadFunction>(
-          ::GetProcAddress(::GetModuleHandle(L"ntdll.dll"),
-                           "NtQueryInformationThread"));
-  if (!nt_query_information_thread)
-    return nullptr;
-
-  THREAD_BASIC_INFORMATION basic_info = {0};
-  NTSTATUS status =
-      nt_query_information_thread(thread_handle, ThreadBasicInformation,
-                                  &basic_info, sizeof(THREAD_BASIC_INFORMATION),
-                                  nullptr);
-  if (status != 0)
-    return nullptr;
-
-  return basic_info.Teb;
-}
-
-#if defined(_WIN64)
-// If the value at |pointer| points to the original stack, rewrite it to point
-// to the corresponding location in the copied stack.
-void RewritePointerIfInOriginalStack(uintptr_t top, uintptr_t bottom,
-                                     void* stack_copy, const void** pointer) {
-  const uintptr_t value = reinterpret_cast<uintptr_t>(*pointer);
-  if (value >= bottom && value < top) {
-    *pointer = reinterpret_cast<const void*>(
-        static_cast<unsigned char*>(stack_copy) + (value - bottom));
-  }
-}
-#endif
-
-void CopyMemoryFromStack(void* to, const void* from, size_t length)
-    NO_SANITIZE("address") {
-#if defined(ADDRESS_SANITIZER)
-  // The following loop is an inlined version of memcpy. The code must be
-  // inlined to avoid instrumentation when using ASAN (memory sanitizer). The
-  // stack profiler is generating false positive when walking the stack.
-  for (size_t pos = 0; pos < length; ++pos)
-    reinterpret_cast<char*>(to)[pos] = reinterpret_cast<const char*>(from)[pos];
-#else
-  std::memcpy(to, from, length);
-#endif
-}
-
-// Rewrites possible pointers to locations within the stack to point to the
-// corresponding locations in the copy, and rewrites the non-volatile registers
-// in |context| likewise. This is necessary to handle stack frames with dynamic
-// stack allocation, where a pointer to the beginning of the dynamic allocation
-// area is stored on the stack and/or in a non-volatile register.
-//
-// Eager rewriting of anything that looks like a pointer to the stack, as done
-// in this function, does not adversely affect the stack unwinding. The only
-// other values on the stack the unwinding depends on are return addresses,
-// which should not point within the stack memory. The rewriting is guaranteed
-// to catch all pointers because the stacks are guaranteed by the ABI to be
-// sizeof(void*) aligned.
-//
-// Note: this function must not access memory in the original stack as it may
-// have been changed or deallocated by this point. This is why |top| and
-// |bottom| are passed as uintptr_t.
-void RewritePointersToStackMemory(uintptr_t top, uintptr_t bottom,
-                                  CONTEXT* context, void* stack_copy) {
-#if defined(_WIN64)
-  DWORD64 CONTEXT::* const nonvolatile_registers[] = {
-    &CONTEXT::R12,
-    &CONTEXT::R13,
-    &CONTEXT::R14,
-    &CONTEXT::R15,
-    &CONTEXT::Rdi,
-    &CONTEXT::Rsi,
-    &CONTEXT::Rbx,
-    &CONTEXT::Rbp,
-    &CONTEXT::Rsp
-  };
-
-  // Rewrite pointers in the context.
-  for (size_t i = 0; i < arraysize(nonvolatile_registers); ++i) {
-    DWORD64* const reg = &(context->*nonvolatile_registers[i]);
-    RewritePointerIfInOriginalStack(top, bottom, stack_copy,
-                                    reinterpret_cast<const void**>(reg));
-  }
-
-  // Rewrite pointers on the stack.
-  const void** start = reinterpret_cast<const void**>(stack_copy);
-  const void** end = reinterpret_cast<const void**>(
-      reinterpret_cast<char*>(stack_copy) + (top - bottom));
-  for (const void** loc = start; loc < end; ++loc)
-    RewritePointerIfInOriginalStack(top, bottom, stack_copy, loc);
-#endif
-}
-
-// Movable type representing a recorded stack frame.
-struct RecordedFrame {
-  RecordedFrame() {}
-
-  RecordedFrame(RecordedFrame&& other)
-      : instruction_pointer(other.instruction_pointer),
-        module(std::move(other.module)) {
-  }
-
-  RecordedFrame& operator=(RecordedFrame&& other) {
-    instruction_pointer = other.instruction_pointer;
-    module = std::move(other.module);
-    return *this;
-  }
-
-  const void* instruction_pointer;
-  ScopedModuleHandle module;
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(RecordedFrame);
-};
-
-// Walks the stack represented by |context| from the current frame downwards,
-// recording the instruction pointer and associated module for each frame in
-// |stack|.
-void RecordStack(CONTEXT* context, std::vector<RecordedFrame>* stack) {
-#ifdef _WIN64
-  DCHECK(stack->empty());
-
-  // Reserve enough memory for most stacks, to avoid repeated
-  // allocations. Approximately 99.9% of recorded stacks are 128 frames or
-  // fewer.
-  stack->reserve(128);
-
-  Win32StackFrameUnwinder frame_unwinder;
-  while (context->Rip) {
-    const void* instruction_pointer =
-        reinterpret_cast<const void*>(context->Rip);
-    ScopedModuleHandle module;
-    if (!frame_unwinder.TryUnwind(context, &module))
-      return;
-    RecordedFrame frame;
-    frame.instruction_pointer = instruction_pointer;
-    frame.module = std::move(module);
-    stack->push_back(std::move(frame));
-  }
-#endif
-}
-
-// Gets the unique build ID for a module. Windows build IDs are created by a
-// concatenation of a GUID and AGE fields found in the headers of a module. The
-// GUID is stored in the first 16 bytes and the AGE is stored in the last 4
-// bytes. Returns the empty string if the function fails to get the build ID.
-//
-// Example:
-// dumpbin chrome.exe /headers | find "Format:"
-//   ... Format: RSDS, {16B2A428-1DED-442E-9A36-FCE8CBD29726}, 10, ...
-//
-// The resulting buildID string of this instance of chrome.exe is
-// "16B2A4281DED442E9A36FCE8CBD2972610".
-//
-// Note that the AGE field is encoded in decimal, not hex.
-std::string GetBuildIDForModule(HMODULE module_handle) {
-  GUID guid;
-  DWORD age;
-  win::PEImage(module_handle).GetDebugId(&guid, &age, /* pdb_file= */ nullptr);
-  const int kGUIDSize = 39;
-  std::wstring build_id;
-  int result =
-      ::StringFromGUID2(guid, WriteInto(&build_id, kGUIDSize), kGUIDSize);
-  if (result != kGUIDSize)
-    return std::string();
-  RemoveChars(build_id, L"{}-", &build_id);
-  build_id += StringPrintf(L"%d", age);
-  return WideToUTF8(build_id);
-}
-
-// ScopedDisablePriorityBoost -------------------------------------------------
-
-// Disables priority boost on a thread for the lifetime of the object.
-class ScopedDisablePriorityBoost {
- public:
-  ScopedDisablePriorityBoost(HANDLE thread_handle);
-  ~ScopedDisablePriorityBoost();
-
- private:
-  HANDLE thread_handle_;
-  BOOL got_previous_boost_state_;
-  BOOL boost_state_was_disabled_;
-
-  DISALLOW_COPY_AND_ASSIGN(ScopedDisablePriorityBoost);
-};
-
-ScopedDisablePriorityBoost::ScopedDisablePriorityBoost(HANDLE thread_handle)
-    : thread_handle_(thread_handle),
-      got_previous_boost_state_(false),
-      boost_state_was_disabled_(false) {
-  got_previous_boost_state_ =
-      ::GetThreadPriorityBoost(thread_handle_, &boost_state_was_disabled_);
-  if (got_previous_boost_state_) {
-    // Confusingly, TRUE disables priority boost.
-    ::SetThreadPriorityBoost(thread_handle_, TRUE);
-  }
-}
-
-ScopedDisablePriorityBoost::~ScopedDisablePriorityBoost() {
-  if (got_previous_boost_state_)
-    ::SetThreadPriorityBoost(thread_handle_, boost_state_was_disabled_);
-}
-
-// ScopedSuspendThread --------------------------------------------------------
-
-// Suspends a thread for the lifetime of the object.
-class ScopedSuspendThread {
- public:
-  ScopedSuspendThread(HANDLE thread_handle);
-  ~ScopedSuspendThread();
-
-  bool was_successful() const { return was_successful_; }
-
- private:
-  HANDLE thread_handle_;
-  bool was_successful_;
-
-  DISALLOW_COPY_AND_ASSIGN(ScopedSuspendThread);
-};
-
-ScopedSuspendThread::ScopedSuspendThread(HANDLE thread_handle)
-    : thread_handle_(thread_handle),
-      was_successful_(::SuspendThread(thread_handle) !=
-                      static_cast<DWORD>(-1)) {}
-
-ScopedSuspendThread::~ScopedSuspendThread() {
-  if (!was_successful_)
-    return;
-
-  // Disable the priority boost that the thread would otherwise receive on
-  // resume. We do this to avoid artificially altering the dynamics of the
-  // executing application any more than we already are by suspending and
-  // resuming the thread.
-  //
-  // Note that this can racily disable a priority boost that otherwise would
-  // have been given to the thread, if the thread is waiting on other wait
-  // conditions at the time of SuspendThread and those conditions are satisfied
-  // before priority boost is reenabled. The measured length of this window is
-  // ~100us, so this should occur fairly rarely.
-  ScopedDisablePriorityBoost disable_priority_boost(thread_handle_);
-  bool resume_thread_succeeded =
-      ::ResumeThread(thread_handle_) != static_cast<DWORD>(-1);
-  CHECK(resume_thread_succeeded) << "ResumeThread failed: " << GetLastError();
-}
-
-// Tests whether |stack_pointer| points to a location in the guard page.
-//
-// IMPORTANT NOTE: This function is invoked while the target thread is
-// suspended so it must not do any allocation from the default heap, including
-// indirectly via use of DCHECK/CHECK or other logging statements. Otherwise
-// this code can deadlock on heap locks in the default heap acquired by the
-// target thread before it was suspended.
-bool PointsToGuardPage(uintptr_t stack_pointer) {
-  MEMORY_BASIC_INFORMATION memory_info;
-  SIZE_T result = ::VirtualQuery(reinterpret_cast<LPCVOID>(stack_pointer),
-                                 &memory_info,
-                                 sizeof(memory_info));
-  return result != 0 && (memory_info.Protect & PAGE_GUARD);
-}
-
-// Suspends the thread with |thread_handle|, copies its stack and resumes the
-// thread, then records the stack frames and associated modules into |stack|.
-//
-// IMPORTANT NOTE: No allocations from the default heap may occur in the
-// ScopedSuspendThread scope, including indirectly via use of DCHECK/CHECK or
-// other logging statements. Otherwise this code can deadlock on heap locks in
-// the default heap acquired by the target thread before it was suspended.
-void SuspendThreadAndRecordStack(
-    HANDLE thread_handle,
-    const void* base_address,
-    void* stack_copy_buffer,
-    size_t stack_copy_buffer_size,
-    std::vector<RecordedFrame>* stack,
-    NativeStackSampler::AnnotateCallback annotator,
-    StackSamplingProfiler::Sample* sample,
-    NativeStackSamplerTestDelegate* test_delegate) {
-  DCHECK(stack->empty());
-
-  CONTEXT thread_context = {0};
-  thread_context.ContextFlags = CONTEXT_FULL;
-  // The stack bounds are saved to uintptr_ts for use outside
-  // ScopedSuspendThread, as the thread's memory is not safe to dereference
-  // beyond that point.
-  const uintptr_t top = reinterpret_cast<uintptr_t>(base_address);
-  uintptr_t bottom = 0u;
-
-  {
-    ScopedSuspendThread suspend_thread(thread_handle);
-
-    if (!suspend_thread.was_successful())
-      return;
-
-    if (!::GetThreadContext(thread_handle, &thread_context))
-      return;
-#if defined(_WIN64)
-    bottom = thread_context.Rsp;
-#else
-    bottom = thread_context.Esp;
-#endif
-
-    if ((top - bottom) > stack_copy_buffer_size)
-      return;
-
-    // Dereferencing a pointer in the guard page in a thread that doesn't own
-    // the stack results in a STATUS_GUARD_PAGE_VIOLATION exception and a crash.
-    // This occurs very rarely, but reliably over the population.
-    if (PointsToGuardPage(bottom))
-      return;
-
-    (*annotator)(sample);
-
-    CopyMemoryFromStack(stack_copy_buffer,
-                        reinterpret_cast<const void*>(bottom), top - bottom);
-  }
-
-  if (test_delegate)
-    test_delegate->OnPreStackWalk();
-
-  RewritePointersToStackMemory(top, bottom, &thread_context, stack_copy_buffer);
-
-  RecordStack(&thread_context, stack);
-}
-
-// NativeStackSamplerWin ------------------------------------------------------
-
-class NativeStackSamplerWin : public NativeStackSampler {
- public:
-  NativeStackSamplerWin(win::ScopedHandle thread_handle,
-                        AnnotateCallback annotator,
-                        NativeStackSamplerTestDelegate* test_delegate);
-  ~NativeStackSamplerWin() override;
-
-  // StackSamplingProfiler::NativeStackSampler:
-  void ProfileRecordingStarting(
-      std::vector<StackSamplingProfiler::Module>* modules) override;
-  void RecordStackSample(StackBuffer* stack_buffer,
-                         StackSamplingProfiler::Sample* sample) override;
-  void ProfileRecordingStopped(StackBuffer* stack_buffer) override;
-
- private:
-  // Attempts to query the module filename, base address, and id for
-  // |module_handle|, and store them in |module|. Returns true if it succeeded.
-  static bool GetModuleForHandle(HMODULE module_handle,
-                                 StackSamplingProfiler::Module* module);
-
-  // Gets the index for the Module corresponding to |module_handle| in
-  // |modules|, adding it if it's not already present. Returns
-  // StackSamplingProfiler::Frame::kUnknownModuleIndex if no Module can be
-  // determined for |module|.
-  size_t GetModuleIndex(HMODULE module_handle,
-                        std::vector<StackSamplingProfiler::Module>* modules);
-
-  // Copies the information represented by |stack| into |sample| and |modules|.
-  void CopyToSample(const std::vector<RecordedFrame>& stack,
-                    StackSamplingProfiler::Sample* sample,
-                    std::vector<StackSamplingProfiler::Module>* modules);
-
-  win::ScopedHandle thread_handle_;
-
-  const AnnotateCallback annotator_;
-
-  NativeStackSamplerTestDelegate* const test_delegate_;
-
-  // The stack base address corresponding to |thread_handle_|.
-  const void* const thread_stack_base_address_;
-
-  // Weak. Points to the modules associated with the profile being recorded
-  // between ProfileRecordingStarting() and ProfileRecordingStopped().
-  std::vector<StackSamplingProfiler::Module>* current_modules_;
-
-  // Maps a module handle to the corresponding Module's index within
-  // current_modules_.
-  std::map<HMODULE, size_t> profile_module_index_;
-
-  DISALLOW_COPY_AND_ASSIGN(NativeStackSamplerWin);
-};
-
-NativeStackSamplerWin::NativeStackSamplerWin(
-    win::ScopedHandle thread_handle,
-    AnnotateCallback annotator,
-    NativeStackSamplerTestDelegate* test_delegate)
-    : thread_handle_(thread_handle.Take()),
-      annotator_(annotator),
-      test_delegate_(test_delegate),
-      thread_stack_base_address_(
-          GetThreadEnvironmentBlock(thread_handle_.Get())->Tib.StackBase) {
-  DCHECK(annotator_);
-}
-
-NativeStackSamplerWin::~NativeStackSamplerWin() {
-}
-
-void NativeStackSamplerWin::ProfileRecordingStarting(
-    std::vector<StackSamplingProfiler::Module>* modules) {
-  current_modules_ = modules;
-  profile_module_index_.clear();
-}
-
-void NativeStackSamplerWin::RecordStackSample(
-    StackBuffer* stack_buffer,
-    StackSamplingProfiler::Sample* sample) {
-  DCHECK(stack_buffer);
-  DCHECK(current_modules_);
-
-  std::vector<RecordedFrame> stack;
-  SuspendThreadAndRecordStack(thread_handle_.Get(), thread_stack_base_address_,
-                              stack_buffer->buffer(), stack_buffer->size(),
-                              &stack, annotator_, sample, test_delegate_);
-  CopyToSample(stack, sample, current_modules_);
-}
-
-void NativeStackSamplerWin::ProfileRecordingStopped(StackBuffer* stack_buffer) {
-  current_modules_ = nullptr;
-}
-
-// static
-bool NativeStackSamplerWin::GetModuleForHandle(
-    HMODULE module_handle,
-    StackSamplingProfiler::Module* module) {
-  wchar_t module_name[MAX_PATH];
-  DWORD result_length =
-      GetModuleFileName(module_handle, module_name, arraysize(module_name));
-  if (result_length == 0)
-    return false;
-
-  module->filename = base::FilePath(module_name);
-
-  module->base_address = reinterpret_cast<uintptr_t>(module_handle);
-
-  module->id = GetBuildIDForModule(module_handle);
-  if (module->id.empty())
-    return false;
-
-  return true;
-}
-
-size_t NativeStackSamplerWin::GetModuleIndex(
-    HMODULE module_handle,
-    std::vector<StackSamplingProfiler::Module>* modules) {
-  if (!module_handle)
-    return StackSamplingProfiler::Frame::kUnknownModuleIndex;
-
-  auto loc = profile_module_index_.find(module_handle);
-  if (loc == profile_module_index_.end()) {
-    StackSamplingProfiler::Module module;
-    if (!GetModuleForHandle(module_handle, &module))
-      return StackSamplingProfiler::Frame::kUnknownModuleIndex;
-    modules->push_back(module);
-    loc = profile_module_index_.insert(std::make_pair(
-        module_handle, modules->size() - 1)).first;
-  }
-
-  return loc->second;
-}
-
-void NativeStackSamplerWin::CopyToSample(
-    const std::vector<RecordedFrame>& stack,
-    StackSamplingProfiler::Sample* sample,
-    std::vector<StackSamplingProfiler::Module>* modules) {
-  sample->frames.clear();
-  sample->frames.reserve(stack.size());
-
-  for (const RecordedFrame& frame : stack) {
-    sample->frames.push_back(StackSamplingProfiler::Frame(
-        reinterpret_cast<uintptr_t>(frame.instruction_pointer),
-        GetModuleIndex(frame.module.Get(), modules)));
-  }
-}
-
-}  // namespace
-
-std::unique_ptr<NativeStackSampler> NativeStackSampler::Create(
-    PlatformThreadId thread_id,
-    AnnotateCallback annotator,
-    NativeStackSamplerTestDelegate* test_delegate) {
-#if _WIN64
-  // Get the thread's handle.
-  HANDLE thread_handle = ::OpenThread(
-      THREAD_GET_CONTEXT | THREAD_SUSPEND_RESUME | THREAD_QUERY_INFORMATION,
-      FALSE,
-      thread_id);
-
-  if (thread_handle) {
-    return std::unique_ptr<NativeStackSampler>(new NativeStackSamplerWin(
-        win::ScopedHandle(thread_handle), annotator, test_delegate));
-  }
-#endif
-  return std::unique_ptr<NativeStackSampler>();
-}
-
-size_t NativeStackSampler::GetStackBufferSize() {
-  // The default Win32 reserved stack size is 1 MB and Chrome Windows threads
-  // currently always use the default, but this allows for expansion if it
-  // occurs. The size beyond the actual stack size consists of unallocated
-  // virtual memory pages so carries little cost (just a bit of wasted address
-  // space).
-  return 2 << 20;  // 2 MiB
-}
-
-}  // namespace base
diff --git a/base/profiler/stack_sampling_profiler.cc b/base/profiler/stack_sampling_profiler.cc
deleted file mode 100644
index a8cddf0..0000000
--- a/base/profiler/stack_sampling_profiler.cc
+++ /dev/null
@@ -1,890 +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/profiler/stack_sampling_profiler.h"
-
-#include <algorithm>
-#include <map>
-#include <utility>
-
-#include "base/atomic_sequence_num.h"
-#include "base/atomicops.h"
-#include "base/bind.h"
-#include "base/bind_helpers.h"
-#include "base/callback.h"
-#include "base/lazy_instance.h"
-#include "base/location.h"
-#include "base/macros.h"
-#include "base/memory/ptr_util.h"
-#include "base/memory/singleton.h"
-#include "base/profiler/native_stack_sampler.h"
-#include "base/synchronization/lock.h"
-#include "base/threading/thread.h"
-#include "base/threading/thread_restrictions.h"
-#include "base/threading/thread_task_runner_handle.h"
-#include "base/timer/elapsed_timer.h"
-
-namespace base {
-
-namespace {
-
-// This value is used to initialize the WaitableEvent object. This MUST BE set
-// to MANUAL for correct operation of the IsSignaled() call in Start(). See the
-// comment there for why.
-constexpr WaitableEvent::ResetPolicy kResetPolicy =
-    WaitableEvent::ResetPolicy::MANUAL;
-
-// This value is used when there is no collection in progress and thus no ID
-// for referencing the active collection to the SamplingThread.
-const int NULL_PROFILER_ID = -1;
-
-void ChangeAtomicFlags(subtle::Atomic32* flags,
-                       subtle::Atomic32 set,
-                       subtle::Atomic32 clear) {
-  DCHECK(set != 0 || clear != 0);
-  DCHECK_EQ(0, set & clear);
-
-  subtle::Atomic32 bits = subtle::NoBarrier_Load(flags);
-  while (true) {
-    subtle::Atomic32 existing =
-        subtle::NoBarrier_CompareAndSwap(flags, bits, (bits | set) & ~clear);
-    if (existing == bits)
-      break;
-    bits = existing;
-  }
-}
-
-}  // namespace
-
-// StackSamplingProfiler::Module ----------------------------------------------
-
-StackSamplingProfiler::Module::Module() : base_address(0u) {}
-StackSamplingProfiler::Module::Module(uintptr_t base_address,
-                                      const std::string& id,
-                                      const FilePath& filename)
-    : base_address(base_address), id(id), filename(filename) {}
-
-StackSamplingProfiler::Module::~Module() = default;
-
-// StackSamplingProfiler::Frame -----------------------------------------------
-
-StackSamplingProfiler::Frame::Frame(uintptr_t instruction_pointer,
-                                    size_t module_index)
-    : instruction_pointer(instruction_pointer), module_index(module_index) {}
-
-StackSamplingProfiler::Frame::~Frame() = default;
-
-StackSamplingProfiler::Frame::Frame()
-    : instruction_pointer(0), module_index(kUnknownModuleIndex) {
-}
-
-// StackSamplingProfiler::Sample ----------------------------------------------
-
-StackSamplingProfiler::Sample::Sample() = default;
-
-StackSamplingProfiler::Sample::Sample(const Sample& sample) = default;
-
-StackSamplingProfiler::Sample::~Sample() = default;
-
-StackSamplingProfiler::Sample::Sample(const Frame& frame) {
-  frames.push_back(std::move(frame));
-}
-
-StackSamplingProfiler::Sample::Sample(const std::vector<Frame>& frames)
-    : frames(frames) {}
-
-// StackSamplingProfiler::CallStackProfile ------------------------------------
-
-StackSamplingProfiler::CallStackProfile::CallStackProfile() = default;
-
-StackSamplingProfiler::CallStackProfile::CallStackProfile(
-    CallStackProfile&& other) = default;
-
-StackSamplingProfiler::CallStackProfile::~CallStackProfile() = default;
-
-StackSamplingProfiler::CallStackProfile&
-StackSamplingProfiler::CallStackProfile::operator=(CallStackProfile&& other) =
-    default;
-
-StackSamplingProfiler::CallStackProfile
-StackSamplingProfiler::CallStackProfile::CopyForTesting() const {
-  return CallStackProfile(*this);
-}
-
-StackSamplingProfiler::CallStackProfile::CallStackProfile(
-    const CallStackProfile& other) = default;
-
-// StackSamplingProfiler::SamplingThread --------------------------------------
-
-class StackSamplingProfiler::SamplingThread : public Thread {
- public:
-  class TestAPI {
-   public:
-    // Reset the existing sampler. This will unfortunately create the object
-    // unnecessarily if it doesn't already exist but there's no way around that.
-    static void Reset();
-
-    // Disables inherent idle-shutdown behavior.
-    static void DisableIdleShutdown();
-
-    // Begins an idle shutdown as if the idle-timer had expired and wait for
-    // it to execute. Since the timer would have only been started at a time
-    // when the sampling thread actually was idle, this must be called only
-    // when it is known that there are no active sampling threads. If
-    // |simulate_intervening_add| is true then, when executed, the shutdown
-    // task will believe that a new collection has been added since it was
-    // posted.
-    static void ShutdownAssumingIdle(bool simulate_intervening_add);
-
-   private:
-    // Calls the sampling threads ShutdownTask and then signals an event.
-    static void ShutdownTaskAndSignalEvent(SamplingThread* sampler,
-                                           int add_events,
-                                           WaitableEvent* event);
-  };
-
-  struct CollectionContext {
-    CollectionContext(int profiler_id,
-                      PlatformThreadId target,
-                      const SamplingParams& params,
-                      const CompletedCallback& callback,
-                      WaitableEvent* finished,
-                      std::unique_ptr<NativeStackSampler> sampler)
-        : profiler_id(profiler_id),
-          target(target),
-          params(params),
-          callback(callback),
-          finished(finished),
-          native_sampler(std::move(sampler)) {}
-    ~CollectionContext() = default;
-
-    // An identifier for the profiler associated with this collection, used to
-    // uniquely identify the collection to outside interests.
-    const int profiler_id;
-
-    const PlatformThreadId target;     // ID of The thread being sampled.
-    const SamplingParams params;       // Information about how to sample.
-    const CompletedCallback callback;  // Callback made when sampling complete.
-    WaitableEvent* const finished;     // Signaled when all sampling complete.
-
-    // Platform-specific module that does the actual sampling.
-    std::unique_ptr<NativeStackSampler> native_sampler;
-
-    // The absolute time for the next sample.
-    Time next_sample_time;
-
-    // The time that a profile was started, for calculating the total duration.
-    Time profile_start_time;
-
-    // Counters that indicate the current position along the acquisition.
-    int burst = 0;
-    int sample = 0;
-
-    // The collected stack samples. The active profile is always at the back().
-    CallStackProfiles profiles;
-
-    // Sequence number for generating new profiler ids.
-    static AtomicSequenceNumber next_profiler_id;
-  };
-
-  // Gets the single instance of this class.
-  static SamplingThread* GetInstance();
-
-  // Adds a new CollectionContext to the thread. This can be called externally
-  // from any thread. This returns an ID that can later be used to stop
-  // the sampling.
-  int Add(std::unique_ptr<CollectionContext> collection);
-
-  // Removes an active collection based on its ID, forcing it to run its
-  // callback if any data has been collected. This can be called externally
-  // from any thread.
-  void Remove(int id);
-
- private:
-  friend class TestAPI;
-  friend struct DefaultSingletonTraits<SamplingThread>;
-
-  // The different states in which the sampling-thread can be.
-  enum ThreadExecutionState {
-    // The thread is not running because it has never been started. It will be
-    // started when a sampling request is received.
-    NOT_STARTED,
-
-    // The thread is running and processing tasks. This is the state when any
-    // sampling requests are active and during the "idle" period afterward
-    // before the thread is stopped.
-    RUNNING,
-
-    // Once all sampling requests have finished and the "idle" period has
-    // expired, the thread will be set to this state and its shutdown
-    // initiated. A call to Stop() must be made to ensure the previous thread
-    // has completely exited before calling Start() and moving back to the
-    // RUNNING state.
-    EXITING,
-  };
-
-  SamplingThread();
-  ~SamplingThread() override;
-
-  // Get task runner that is usable from the outside.
-  scoped_refptr<SingleThreadTaskRunner> GetOrCreateTaskRunnerForAdd();
-  scoped_refptr<SingleThreadTaskRunner> GetTaskRunner(
-      ThreadExecutionState* out_state);
-
-  // Get task runner that is usable from the sampling thread itself.
-  scoped_refptr<SingleThreadTaskRunner> GetTaskRunnerOnSamplingThread();
-
-  // Finishes a collection and reports collected data via callback. The
-  // collection's |finished| waitable event will be signalled. The |collection|
-  // should already have been removed from |active_collections_| by the caller,
-  // as this is needed to avoid flakyness in unit tests.
-  void FinishCollection(CollectionContext* collection);
-
-  // Records a single sample of a collection.
-  void RecordSample(CollectionContext* collection);
-
-  // Check if the sampling thread is idle and begin a shutdown if it is.
-  void ScheduleShutdownIfIdle();
-
-  // These methods are tasks that get posted to the internal message queue.
-  void AddCollectionTask(std::unique_ptr<CollectionContext> collection);
-  void RemoveCollectionTask(int id);
-  void PerformCollectionTask(int id);
-  void ShutdownTask(int add_events);
-
-  // Updates the |next_sample_time| time based on configured parameters.
-  // Returns true if there is a next sample or false if sampling is complete.
-  bool UpdateNextSampleTime(CollectionContext* collection);
-
-  // Thread:
-  void CleanUp() override;
-
-  // A stack-buffer used by the native sampler for its work. This buffer can
-  // be re-used for multiple native sampler objects so long as the API calls
-  // that take it are not called concurrently.
-  std::unique_ptr<NativeStackSampler::StackBuffer> stack_buffer_;
-
-  // A map of IDs to collection contexts. Because this class is a singleton
-  // that is never destroyed, context objects will never be destructed except
-  // by explicit action. Thus, it's acceptable to pass unretained pointers
-  // to these objects when posting tasks.
-  std::map<int, std::unique_ptr<CollectionContext>> active_collections_;
-
-  // State maintained about the current execution (or non-execution) of
-  // the thread. This state must always be accessed while holding the
-  // lock. A copy of the task-runner is maintained here for use by any
-  // calling thread; this is necessary because Thread's accessor for it is
-  // not itself thread-safe. The lock is also used to order calls to the
-  // Thread API (Start, Stop, StopSoon, & DetachFromSequence) so that
-  // multiple threads may make those calls.
-  Lock thread_execution_state_lock_;  // Protects all thread_execution_state_*
-  ThreadExecutionState thread_execution_state_ = NOT_STARTED;
-  scoped_refptr<SingleThreadTaskRunner> thread_execution_state_task_runner_;
-  bool thread_execution_state_disable_idle_shutdown_for_testing_ = false;
-
-  // A counter that notes adds of new collection requests. It is incremented
-  // when changes occur so that delayed shutdown tasks are able to detect if
-  // samething new has happened while it was waiting. Like all "execution_state"
-  // vars, this must be accessed while holding |thread_execution_state_lock_|.
-  int thread_execution_state_add_events_ = 0;
-
-  DISALLOW_COPY_AND_ASSIGN(SamplingThread);
-};
-
-// static
-void StackSamplingProfiler::SamplingThread::TestAPI::Reset() {
-  SamplingThread* sampler = SamplingThread::GetInstance();
-
-  ThreadExecutionState state;
-  {
-    AutoLock lock(sampler->thread_execution_state_lock_);
-    state = sampler->thread_execution_state_;
-    DCHECK(sampler->active_collections_.empty());
-  }
-
-  // Stop the thread and wait for it to exit. This has to be done through by
-  // the thread itself because it has taken ownership of its own lifetime.
-  if (state == RUNNING) {
-    ShutdownAssumingIdle(false);
-    state = EXITING;
-  }
-  // Make sure thread is cleaned up since state will be reset to NOT_STARTED.
-  if (state == EXITING)
-    sampler->Stop();
-
-  // Reset internal variables to the just-initialized state.
-  {
-    AutoLock lock(sampler->thread_execution_state_lock_);
-    sampler->thread_execution_state_ = NOT_STARTED;
-    sampler->thread_execution_state_task_runner_ = nullptr;
-    sampler->thread_execution_state_disable_idle_shutdown_for_testing_ = false;
-    sampler->thread_execution_state_add_events_ = 0;
-  }
-}
-
-// static
-void StackSamplingProfiler::SamplingThread::TestAPI::DisableIdleShutdown() {
-  SamplingThread* sampler = SamplingThread::GetInstance();
-
-  {
-    AutoLock lock(sampler->thread_execution_state_lock_);
-    sampler->thread_execution_state_disable_idle_shutdown_for_testing_ = true;
-  }
-}
-
-// static
-void StackSamplingProfiler::SamplingThread::TestAPI::ShutdownAssumingIdle(
-    bool simulate_intervening_add) {
-  SamplingThread* sampler = SamplingThread::GetInstance();
-
-  ThreadExecutionState state;
-  scoped_refptr<SingleThreadTaskRunner> task_runner =
-      sampler->GetTaskRunner(&state);
-  DCHECK_EQ(RUNNING, state);
-  DCHECK(task_runner);
-
-  int add_events;
-  {
-    AutoLock lock(sampler->thread_execution_state_lock_);
-    add_events = sampler->thread_execution_state_add_events_;
-    if (simulate_intervening_add)
-      ++sampler->thread_execution_state_add_events_;
-  }
-
-  WaitableEvent executed(WaitableEvent::ResetPolicy::MANUAL,
-                         WaitableEvent::InitialState::NOT_SIGNALED);
-  // PostTaskAndReply won't work because thread and associated message-loop may
-  // be shut down.
-  task_runner->PostTask(
-      FROM_HERE, BindOnce(&ShutdownTaskAndSignalEvent, Unretained(sampler),
-                          add_events, Unretained(&executed)));
-  executed.Wait();
-}
-
-// static
-void StackSamplingProfiler::SamplingThread::TestAPI::ShutdownTaskAndSignalEvent(
-    SamplingThread* sampler,
-    int add_events,
-    WaitableEvent* event) {
-  sampler->ShutdownTask(add_events);
-  event->Signal();
-}
-
-AtomicSequenceNumber
-    StackSamplingProfiler::SamplingThread::CollectionContext::next_profiler_id;
-
-StackSamplingProfiler::SamplingThread::SamplingThread()
-    : Thread("StackSamplingProfiler") {}
-
-StackSamplingProfiler::SamplingThread::~SamplingThread() = default;
-
-StackSamplingProfiler::SamplingThread*
-StackSamplingProfiler::SamplingThread::GetInstance() {
-  return Singleton<SamplingThread, LeakySingletonTraits<SamplingThread>>::get();
-}
-
-int StackSamplingProfiler::SamplingThread::Add(
-    std::unique_ptr<CollectionContext> collection) {
-  // This is not to be run on the sampling thread.
-
-  int id = collection->profiler_id;
-  scoped_refptr<SingleThreadTaskRunner> task_runner =
-      GetOrCreateTaskRunnerForAdd();
-
-  task_runner->PostTask(
-      FROM_HERE, BindOnce(&SamplingThread::AddCollectionTask, Unretained(this),
-                          std::move(collection)));
-
-  return id;
-}
-
-void StackSamplingProfiler::SamplingThread::Remove(int id) {
-  // This is not to be run on the sampling thread.
-
-  ThreadExecutionState state;
-  scoped_refptr<SingleThreadTaskRunner> task_runner = GetTaskRunner(&state);
-  if (state != RUNNING)
-    return;
-  DCHECK(task_runner);
-
-  // This can fail if the thread were to exit between acquisition of the task
-  // runner above and the call below. In that case, however, everything has
-  // stopped so there's no need to try to stop it.
-  task_runner->PostTask(
-      FROM_HERE,
-      BindOnce(&SamplingThread::RemoveCollectionTask, Unretained(this), id));
-}
-
-scoped_refptr<SingleThreadTaskRunner>
-StackSamplingProfiler::SamplingThread::GetOrCreateTaskRunnerForAdd() {
-  AutoLock lock(thread_execution_state_lock_);
-
-  // The increment of the "add events" count is why this method is to be only
-  // called from "add".
-  ++thread_execution_state_add_events_;
-
-  if (thread_execution_state_ == RUNNING) {
-    DCHECK(thread_execution_state_task_runner_);
-    // This shouldn't be called from the sampling thread as it's inefficient.
-    // Use GetTaskRunnerOnSamplingThread() instead.
-    DCHECK_NE(GetThreadId(), PlatformThread::CurrentId());
-    return thread_execution_state_task_runner_;
-  }
-
-  if (thread_execution_state_ == EXITING) {
-    // StopSoon() was previously called to shut down the thread
-    // asynchonously. Stop() must now be called before calling Start() again to
-    // reset the thread state.
-    //
-    // We must allow blocking here to satisfy the Thread implementation, but in
-    // practice the Stop() call is unlikely to actually block. For this to
-    // happen a new profiling request would have to be made within the narrow
-    // window between StopSoon() and thread exit following the end of the 60
-    // second idle period.
-    ScopedAllowBlocking allow_blocking;
-    Stop();
-  }
-
-  DCHECK(!stack_buffer_);
-  stack_buffer_ = NativeStackSampler::CreateStackBuffer();
-
-  // The thread is not running. Start it and get associated runner. The task-
-  // runner has to be saved for future use because though it can be used from
-  // any thread, it can be acquired via task_runner() only on the created
-  // thread and the thread that creates it (i.e. this thread) for thread-safety
-  // reasons which are alleviated in SamplingThread by gating access to it with
-  // the |thread_execution_state_lock_|.
-  Start();
-  thread_execution_state_ = RUNNING;
-  thread_execution_state_task_runner_ = Thread::task_runner();
-
-  // Detach the sampling thread from the "sequence" (i.e. thread) that
-  // started it so that it can be self-managed or stopped by another thread.
-  DetachFromSequence();
-
-  return thread_execution_state_task_runner_;
-}
-
-scoped_refptr<SingleThreadTaskRunner>
-StackSamplingProfiler::SamplingThread::GetTaskRunner(
-    ThreadExecutionState* out_state) {
-  AutoLock lock(thread_execution_state_lock_);
-  if (out_state)
-    *out_state = thread_execution_state_;
-  if (thread_execution_state_ == RUNNING) {
-    // This shouldn't be called from the sampling thread as it's inefficient.
-    // Use GetTaskRunnerOnSamplingThread() instead.
-    DCHECK_NE(GetThreadId(), PlatformThread::CurrentId());
-    DCHECK(thread_execution_state_task_runner_);
-  } else {
-    DCHECK(!thread_execution_state_task_runner_);
-  }
-
-  return thread_execution_state_task_runner_;
-}
-
-scoped_refptr<SingleThreadTaskRunner>
-StackSamplingProfiler::SamplingThread::GetTaskRunnerOnSamplingThread() {
-  // This should be called only from the sampling thread as it has limited
-  // accessibility.
-  DCHECK_EQ(GetThreadId(), PlatformThread::CurrentId());
-
-  return Thread::task_runner();
-}
-
-void StackSamplingProfiler::SamplingThread::FinishCollection(
-    CollectionContext* collection) {
-  DCHECK_EQ(GetThreadId(), PlatformThread::CurrentId());
-  DCHECK_EQ(0u, active_collections_.count(collection->profiler_id));
-
-  // If there is no duration for the final profile (because it was stopped),
-  // calculate it now.
-  if (!collection->profiles.empty() &&
-      collection->profiles.back().profile_duration == TimeDelta()) {
-    collection->profiles.back().profile_duration =
-        Time::Now() - collection->profile_start_time +
-        collection->params.sampling_interval;
-  }
-
-  // Extract some information so callback and event-signalling can still be
-  // done after the collection has been removed from the list of "active" ones.
-  // This allows the the controlling object (and tests using it) to be confident
-  // that collection is fully finished when those things occur.
-  const CompletedCallback callback = collection->callback;
-  CallStackProfiles profiles = std::move(collection->profiles);
-  WaitableEvent* finished = collection->finished;
-
-  // Run the associated callback, passing the collected profiles.
-  callback.Run(std::move(profiles));
-
-  // Signal that this collection is finished.
-  finished->Signal();
-}
-
-void StackSamplingProfiler::SamplingThread::RecordSample(
-    CollectionContext* collection) {
-  DCHECK_EQ(GetThreadId(), PlatformThread::CurrentId());
-  DCHECK(collection->native_sampler);
-
-  // If this is the first sample of a burst, a new Profile needs to be created
-  // and filled.
-  if (collection->sample == 0) {
-    collection->profiles.push_back(CallStackProfile());
-    CallStackProfile& profile = collection->profiles.back();
-    profile.sampling_period = collection->params.sampling_interval;
-    collection->profile_start_time = Time::Now();
-    collection->native_sampler->ProfileRecordingStarting(&profile.modules);
-  }
-
-  // The currently active profile being captured.
-  CallStackProfile& profile = collection->profiles.back();
-
-  // Record a single sample.
-  profile.samples.push_back(Sample());
-  collection->native_sampler->RecordStackSample(stack_buffer_.get(),
-                                                &profile.samples.back());
-
-  // If this is the last sample of a burst, record the total time.
-  if (collection->sample == collection->params.samples_per_burst - 1) {
-    profile.profile_duration = Time::Now() - collection->profile_start_time +
-                               collection->params.sampling_interval;
-    collection->native_sampler->ProfileRecordingStopped(stack_buffer_.get());
-  }
-}
-
-void StackSamplingProfiler::SamplingThread::ScheduleShutdownIfIdle() {
-  DCHECK_EQ(GetThreadId(), PlatformThread::CurrentId());
-
-  if (!active_collections_.empty())
-    return;
-
-  int add_events;
-  {
-    AutoLock lock(thread_execution_state_lock_);
-    if (thread_execution_state_disable_idle_shutdown_for_testing_)
-      return;
-    add_events = thread_execution_state_add_events_;
-  }
-
-  GetTaskRunnerOnSamplingThread()->PostDelayedTask(
-      FROM_HERE,
-      BindOnce(&SamplingThread::ShutdownTask, Unretained(this), add_events),
-      TimeDelta::FromSeconds(60));
-}
-
-void StackSamplingProfiler::SamplingThread::AddCollectionTask(
-    std::unique_ptr<CollectionContext> collection) {
-  DCHECK_EQ(GetThreadId(), PlatformThread::CurrentId());
-
-  const int profiler_id = collection->profiler_id;
-  const TimeDelta initial_delay = collection->params.initial_delay;
-
-  active_collections_.insert(
-      std::make_pair(profiler_id, std::move(collection)));
-
-  GetTaskRunnerOnSamplingThread()->PostDelayedTask(
-      FROM_HERE,
-      BindOnce(&SamplingThread::PerformCollectionTask, Unretained(this),
-               profiler_id),
-      initial_delay);
-
-  // Another increment of "add events" serves to invalidate any pending
-  // shutdown tasks that may have been initiated between the Add() and this
-  // task running.
-  {
-    AutoLock lock(thread_execution_state_lock_);
-    ++thread_execution_state_add_events_;
-  }
-}
-
-void StackSamplingProfiler::SamplingThread::RemoveCollectionTask(int id) {
-  DCHECK_EQ(GetThreadId(), PlatformThread::CurrentId());
-
-  auto found = active_collections_.find(id);
-  if (found == active_collections_.end())
-    return;
-
-  // Remove |collection| from |active_collections_|.
-  std::unique_ptr<CollectionContext> collection = std::move(found->second);
-  size_t count = active_collections_.erase(id);
-  DCHECK_EQ(1U, count);
-
-  FinishCollection(collection.get());
-  ScheduleShutdownIfIdle();
-}
-
-void StackSamplingProfiler::SamplingThread::PerformCollectionTask(int id) {
-  DCHECK_EQ(GetThreadId(), PlatformThread::CurrentId());
-
-  auto found = active_collections_.find(id);
-
-  // The task won't be found if it has been stopped.
-  if (found == active_collections_.end())
-    return;
-
-  CollectionContext* collection = found->second.get();
-
-  // Handle first-run with no "next time".
-  if (collection->next_sample_time == Time())
-    collection->next_sample_time = Time::Now();
-
-  // Do the collection of a single sample.
-  RecordSample(collection);
-
-  // Update the time of the next sample recording.
-  const bool collection_finished = !UpdateNextSampleTime(collection);
-  if (!collection_finished) {
-    bool success = GetTaskRunnerOnSamplingThread()->PostDelayedTask(
-        FROM_HERE,
-        BindOnce(&SamplingThread::PerformCollectionTask, Unretained(this), id),
-        std::max(collection->next_sample_time - Time::Now(), TimeDelta()));
-    DCHECK(success);
-    return;
-  }
-
-  // Take ownership of |collection| and remove it from the map. If collection is
-  // to be restarted, a new collection task will be added below.
-  std::unique_ptr<CollectionContext> owned_collection =
-      std::move(found->second);
-  size_t count = active_collections_.erase(id);
-  DCHECK_EQ(1U, count);
-
-  // All capturing has completed so finish the collection.
-  FinishCollection(collection);
-  ScheduleShutdownIfIdle();
-}
-
-void StackSamplingProfiler::SamplingThread::ShutdownTask(int add_events) {
-  DCHECK_EQ(GetThreadId(), PlatformThread::CurrentId());
-
-  // Holding this lock ensures that any attempt to start another job will
-  // get postponed until |thread_execution_state_| is updated, thus eliminating
-  // the race in starting a new thread while the previous one is exiting.
-  AutoLock lock(thread_execution_state_lock_);
-
-  // If the current count of creation requests doesn't match the passed count
-  // then other tasks have been created since this was posted. Abort shutdown.
-  if (thread_execution_state_add_events_ != add_events)
-    return;
-
-  // There can be no new AddCollectionTasks at this point because creating
-  // those always increments "add events". There may be other requests, like
-  // Remove, but it's okay to schedule the thread to stop once they've been
-  // executed (i.e. "soon").
-  DCHECK(active_collections_.empty());
-  StopSoon();
-
-  // StopSoon will have set the owning sequence (again) so it must be detached
-  // (again) in order for Stop/Start to be called (again) should more work
-  // come in. Holding the |thread_execution_state_lock_| ensures the necessary
-  // happens-after with regard to this detach and future Thread API calls.
-  DetachFromSequence();
-
-  // Set the thread_state variable so the thread will be restarted when new
-  // work comes in. Remove the |thread_execution_state_task_runner_| to avoid
-  // confusion.
-  thread_execution_state_ = EXITING;
-  thread_execution_state_task_runner_ = nullptr;
-  stack_buffer_.reset();
-}
-
-bool StackSamplingProfiler::SamplingThread::UpdateNextSampleTime(
-    CollectionContext* collection) {
-  // This will keep a consistent average interval between samples but will
-  // result in constant series of acquisitions, thus nearly locking out the
-  // target thread, if the interval is smaller than the time it takes to
-  // actually acquire the sample. Anything sampling that quickly is going
-  // to be a problem anyway so don't worry about it.
-  if (++collection->sample < collection->params.samples_per_burst) {
-    collection->next_sample_time += collection->params.sampling_interval;
-    return true;
-  }
-
-  if (++collection->burst < collection->params.bursts) {
-    collection->sample = 0;
-    collection->next_sample_time += collection->params.burst_interval;
-    return true;
-  }
-
-  return false;
-}
-
-void StackSamplingProfiler::SamplingThread::CleanUp() {
-  DCHECK_EQ(GetThreadId(), PlatformThread::CurrentId());
-
-  // There should be no collections remaining when the thread stops.
-  DCHECK(active_collections_.empty());
-
-  // Let the parent clean up.
-  Thread::CleanUp();
-}
-
-// StackSamplingProfiler ------------------------------------------------------
-
-// static
-void StackSamplingProfiler::TestAPI::Reset() {
-  SamplingThread::TestAPI::Reset();
-  ResetAnnotations();
-}
-
-// static
-void StackSamplingProfiler::TestAPI::ResetAnnotations() {
-  subtle::NoBarrier_Store(&process_milestones_, 0u);
-}
-
-// static
-bool StackSamplingProfiler::TestAPI::IsSamplingThreadRunning() {
-  return SamplingThread::GetInstance()->IsRunning();
-}
-
-// static
-void StackSamplingProfiler::TestAPI::DisableIdleShutdown() {
-  SamplingThread::TestAPI::DisableIdleShutdown();
-}
-
-// static
-void StackSamplingProfiler::TestAPI::PerformSamplingThreadIdleShutdown(
-    bool simulate_intervening_start) {
-  SamplingThread::TestAPI::ShutdownAssumingIdle(simulate_intervening_start);
-}
-
-subtle::Atomic32 StackSamplingProfiler::process_milestones_ = 0;
-
-StackSamplingProfiler::StackSamplingProfiler(
-    const SamplingParams& params,
-    const CompletedCallback& callback,
-    NativeStackSamplerTestDelegate* test_delegate)
-    : StackSamplingProfiler(base::PlatformThread::CurrentId(),
-                            params,
-                            callback,
-                            test_delegate) {}
-
-StackSamplingProfiler::StackSamplingProfiler(
-    PlatformThreadId thread_id,
-    const SamplingParams& params,
-    const CompletedCallback& callback,
-    NativeStackSamplerTestDelegate* test_delegate)
-    : thread_id_(thread_id),
-      params_(params),
-      completed_callback_(callback),
-      // The event starts "signaled" so code knows it's safe to start thread
-      // and "manual" so that it can be waited in multiple places.
-      profiling_inactive_(kResetPolicy, WaitableEvent::InitialState::SIGNALED),
-      profiler_id_(NULL_PROFILER_ID),
-      test_delegate_(test_delegate) {}
-
-StackSamplingProfiler::~StackSamplingProfiler() {
-  // Stop returns immediately but the shutdown runs asynchronously. There is a
-  // non-zero probability that one more sample will be taken after this call
-  // returns.
-  Stop();
-
-  // The behavior of sampling a thread that has exited is undefined and could
-  // cause Bad Things(tm) to occur. The safety model provided by this class is
-  // that an instance of this object is expected to live at least as long as
-  // the thread it is sampling. However, because the sampling is performed
-  // asynchronously by the SamplingThread, there is no way to guarantee this
-  // is true without waiting for it to signal that it has finished.
-  //
-  // The wait time should, at most, be only as long as it takes to collect one
-  // sample (~200us) or none at all if sampling has already completed.
-  ThreadRestrictions::ScopedAllowWait allow_wait;
-  profiling_inactive_.Wait();
-}
-
-void StackSamplingProfiler::Start() {
-  if (completed_callback_.is_null())
-    return;
-
-  std::unique_ptr<NativeStackSampler> native_sampler =
-      NativeStackSampler::Create(thread_id_, &RecordAnnotations,
-                                 test_delegate_);
-
-  if (!native_sampler)
-    return;
-
-  // The IsSignaled() check below requires that the WaitableEvent be manually
-  // reset, to avoid signaling the event in IsSignaled() itself.
-  static_assert(kResetPolicy == WaitableEvent::ResetPolicy::MANUAL,
-                "The reset policy must be set to MANUAL");
-
-  // If a previous profiling phase is still winding down, wait for it to
-  // complete. We can't use task posting for this coordination because the
-  // thread owning the profiler may not have a message loop.
-  if (!profiling_inactive_.IsSignaled())
-    profiling_inactive_.Wait();
-  profiling_inactive_.Reset();
-
-  DCHECK_EQ(NULL_PROFILER_ID, profiler_id_);
-  profiler_id_ = SamplingThread::GetInstance()->Add(
-      std::make_unique<SamplingThread::CollectionContext>(
-          SamplingThread::CollectionContext::next_profiler_id.GetNext(),
-          thread_id_, params_, completed_callback_, &profiling_inactive_,
-          std::move(native_sampler)));
-  DCHECK_NE(NULL_PROFILER_ID, profiler_id_);
-}
-
-void StackSamplingProfiler::Stop() {
-  SamplingThread::GetInstance()->Remove(profiler_id_);
-  profiler_id_ = NULL_PROFILER_ID;
-}
-
-// static
-void StackSamplingProfiler::SetProcessMilestone(int milestone) {
-  DCHECK_LE(0, milestone);
-  DCHECK_GT(static_cast<int>(sizeof(process_milestones_) * 8), milestone);
-  DCHECK_EQ(0, subtle::NoBarrier_Load(&process_milestones_) & (1 << milestone));
-  ChangeAtomicFlags(&process_milestones_, 1 << milestone, 0);
-}
-
-// static
-void StackSamplingProfiler::RecordAnnotations(Sample* sample) {
-  // The code inside this method must not do anything that could acquire a
-  // mutex, including allocating memory (which includes LOG messages) because
-  // that mutex could be held by a stopped thread, thus resulting in deadlock.
-  sample->process_milestones = subtle::NoBarrier_Load(&process_milestones_);
-}
-
-// StackSamplingProfiler::Frame global functions ------------------------------
-
-bool operator==(const StackSamplingProfiler::Module& a,
-                const StackSamplingProfiler::Module& b) {
-  return a.base_address == b.base_address && a.id == b.id &&
-      a.filename == b.filename;
-}
-
-bool operator==(const StackSamplingProfiler::Sample& a,
-                const StackSamplingProfiler::Sample& b) {
-  return a.process_milestones == b.process_milestones && a.frames == b.frames;
-}
-
-bool operator!=(const StackSamplingProfiler::Sample& a,
-                const StackSamplingProfiler::Sample& b) {
-  return !(a == b);
-}
-
-bool operator<(const StackSamplingProfiler::Sample& a,
-               const StackSamplingProfiler::Sample& b) {
-  if (a.process_milestones < b.process_milestones)
-    return true;
-  if (a.process_milestones > b.process_milestones)
-    return false;
-
-  return a.frames < b.frames;
-}
-
-bool operator==(const StackSamplingProfiler::Frame &a,
-                const StackSamplingProfiler::Frame &b) {
-  return a.instruction_pointer == b.instruction_pointer &&
-      a.module_index == b.module_index;
-}
-
-bool operator<(const StackSamplingProfiler::Frame &a,
-               const StackSamplingProfiler::Frame &b) {
-  return (a.module_index < b.module_index) ||
-      (a.module_index == b.module_index &&
-       a.instruction_pointer < b.instruction_pointer);
-}
-
-}  // namespace base
diff --git a/base/profiler/stack_sampling_profiler.h b/base/profiler/stack_sampling_profiler.h
deleted file mode 100644
index 2f9ade5..0000000
--- a/base/profiler/stack_sampling_profiler.h
+++ /dev/null
@@ -1,331 +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_PROFILER_STACK_SAMPLING_PROFILER_H_
-#define BASE_PROFILER_STACK_SAMPLING_PROFILER_H_
-
-#include <stddef.h>
-
-#include <memory>
-#include <string>
-#include <vector>
-
-#include "base/atomicops.h"
-#include "base/base_export.h"
-#include "base/callback.h"
-#include "base/files/file_path.h"
-#include "base/macros.h"
-#include "base/strings/string16.h"
-#include "base/synchronization/waitable_event.h"
-#include "base/threading/platform_thread.h"
-#include "base/time/time.h"
-
-namespace base {
-
-class NativeStackSampler;
-class NativeStackSamplerTestDelegate;
-
-// StackSamplingProfiler periodically stops a thread to sample its stack, for
-// the purpose of collecting information about which code paths are
-// executing. This information is used in aggregate by UMA to identify hot
-// and/or janky code paths.
-//
-// Sample StackSamplingProfiler usage:
-//
-//   // Create and customize params as desired.
-//   base::StackStackSamplingProfiler::SamplingParams params;
-//   // Any thread's ID may be passed as the target.
-//   base::StackSamplingProfiler profiler(base::PlatformThread::CurrentId()),
-//       params);
-//
-//   // Or, to process the profiles within Chrome rather than via UMA, use a
-//   // custom completed callback:
-//   base::StackStackSamplingProfiler::CompletedCallback
-//       thread_safe_callback = ...;
-//   base::StackSamplingProfiler profiler(base::PlatformThread::CurrentId()),
-//       params, thread_safe_callback);
-//
-//   profiler.Start();
-//   // ... work being done on the target thread here ...
-//   profiler.Stop();  // optional, stops collection before complete per params
-//
-// The default SamplingParams causes stacks to be recorded in a single burst at
-// a 10Hz interval for a total of 30 seconds. All of these parameters may be
-// altered as desired.
-//
-// When all call stack profiles are complete, or the profiler is stopped, the
-// completed callback is called from a thread created by the profiler with the
-// collected profiles.
-//
-// The results of the profiling are passed to the completed callback and consist
-// of a vector of CallStackProfiles. Each CallStackProfile corresponds to a
-// burst as specified in SamplingParams and contains a set of Samples and
-// Modules. One Sample corresponds to a single recorded stack, and the Modules
-// record those modules associated with the recorded stack frames.
-class BASE_EXPORT StackSamplingProfiler {
- public:
-  // Module represents the module (DLL or exe) corresponding to a stack frame.
-  struct BASE_EXPORT Module {
-    Module();
-    Module(uintptr_t base_address,
-           const std::string& id,
-           const FilePath& filename);
-    ~Module();
-
-    // Points to the base address of the module.
-    uintptr_t base_address;
-
-    // An opaque binary string that uniquely identifies a particular program
-    // version with high probability. This is parsed from headers of the loaded
-    // module.
-    // For binaries generated by GNU tools:
-    //   Contents of the .note.gnu.build-id field.
-    // On Windows:
-    //   GUID + AGE in the debug image headers of a module.
-    std::string id;
-
-    // The filename of the module.
-    FilePath filename;
-  };
-
-  // Frame represents an individual sampled stack frame with module information.
-  struct BASE_EXPORT Frame {
-    // Identifies an unknown module.
-    static const size_t kUnknownModuleIndex = static_cast<size_t>(-1);
-
-    Frame(uintptr_t instruction_pointer, size_t module_index);
-    ~Frame();
-
-    // Default constructor to satisfy IPC macros. Do not use explicitly.
-    Frame();
-
-    // The sampled instruction pointer within the function.
-    uintptr_t instruction_pointer;
-
-    // Index of the module in CallStackProfile::modules. We don't represent
-    // module state directly here to save space.
-    size_t module_index;
-  };
-
-  // Sample represents a set of stack frames with some extra information.
-  struct BASE_EXPORT Sample {
-    Sample();
-    Sample(const Sample& sample);
-    ~Sample();
-
-    // These constructors are used only during testing.
-    Sample(const Frame& frame);
-    Sample(const std::vector<Frame>& frames);
-
-    // The entire stack frame when the sample is taken.
-    std::vector<Frame> frames;
-
-    // A bit-field indicating which process milestones have passed. This can be
-    // used to tell where in the process lifetime the samples are taken. Just
-    // as a "lifetime" can only move forward, these bits mark the milestones of
-    // the processes life as they occur. Bits can be set but never reset. The
-    // actual definition of the individual bits is left to the user of this
-    // module.
-    uint32_t process_milestones = 0;
-  };
-
-  // CallStackProfile represents a set of samples.
-  struct BASE_EXPORT CallStackProfile {
-    CallStackProfile();
-    CallStackProfile(CallStackProfile&& other);
-    ~CallStackProfile();
-
-    CallStackProfile& operator=(CallStackProfile&& other);
-
-    CallStackProfile CopyForTesting() const;
-
-    std::vector<Module> modules;
-    std::vector<Sample> samples;
-
-    // Duration of this profile.
-    TimeDelta profile_duration;
-
-    // Time between samples.
-    TimeDelta sampling_period;
-
-   private:
-    // Copying is possible but expensive so disallow it except for internal use
-    // (i.e. CopyForTesting); use std::move instead.
-    CallStackProfile(const CallStackProfile& other);
-
-    DISALLOW_ASSIGN(CallStackProfile);
-  };
-
-  using CallStackProfiles = std::vector<CallStackProfile>;
-
-  // Represents parameters that configure the sampling.
-  struct BASE_EXPORT SamplingParams {
-    // Time to delay before first samples are taken.
-    TimeDelta initial_delay = TimeDelta::FromMilliseconds(0);
-
-    // Number of sampling bursts to perform.
-    int bursts = 1;
-
-    // Interval between sampling bursts. This is the desired duration from the
-    // start of one burst to the start of the next burst.
-    TimeDelta burst_interval = TimeDelta::FromSeconds(10);
-
-    // Number of samples to record per burst.
-    int samples_per_burst = 300;
-
-    // Interval between samples during a sampling burst. This is the desired
-    // duration from the start of one sample to the start of the next sample.
-    TimeDelta sampling_interval = TimeDelta::FromMilliseconds(100);
-  };
-
-  // Testing support. These methods are static beause they interact with the
-  // sampling thread, a singleton used by all StackSamplingProfiler objects.
-  // These methods can only be called by the same thread that started the
-  // sampling.
-  class BASE_EXPORT TestAPI {
-   public:
-    // Resets the internal state to that of a fresh start. This is necessary
-    // so that tests don't inherit state from previous tests.
-    static void Reset();
-
-    // Resets internal annotations (like process phase) to initial values.
-    static void ResetAnnotations();
-
-    // Returns whether the sampling thread is currently running or not.
-    static bool IsSamplingThreadRunning();
-
-    // Disables inherent idle-shutdown behavior.
-    static void DisableIdleShutdown();
-
-    // Initiates an idle shutdown task, as though the idle timer had expired,
-    // causing the thread to exit. There is no "idle" check so this must be
-    // called only when all sampling tasks have completed. This blocks until
-    // the task has been executed, though the actual stopping of the thread
-    // still happens asynchronously. Watch IsSamplingThreadRunning() to know
-    // when the thread has exited. If |simulate_intervening_start| is true then
-    // this method will make it appear to the shutdown task that a new profiler
-    // was started between when the idle-shutdown was initiated and when it
-    // runs.
-    static void PerformSamplingThreadIdleShutdown(
-        bool simulate_intervening_start);
-  };
-
-  // The callback type used to collect completed profiles. The passed |profiles|
-  // are move-only. Other threads, including the UI thread, may block on
-  // callback completion so this should run as quickly as possible.
-  //
-  // IMPORTANT NOTE: The callback is invoked on a thread the profiler
-  // constructs, rather than on the thread used to construct the profiler and
-  // set the callback, and thus the callback must be callable on any thread. For
-  // threads with message loops that create StackSamplingProfilers, posting a
-  // task to the message loop with the moved (i.e. std::move) profiles is the
-  // thread-safe callback implementation.
-  using CompletedCallback = Callback<void(CallStackProfiles)>;
-
-  // Creates a profiler for the CURRENT thread that sends completed profiles
-  // to |callback|. An optional |test_delegate| can be supplied by tests.
-  // The caller must ensure that this object gets destroyed before the current
-  // thread exits.
-  StackSamplingProfiler(
-      const SamplingParams& params,
-      const CompletedCallback& callback,
-      NativeStackSamplerTestDelegate* test_delegate = nullptr);
-
-  // Creates a profiler for ANOTHER thread that sends completed profiles to
-  // |callback|. An optional |test_delegate| can be supplied by tests.
-  //
-  // IMPORTANT: The caller must ensure that the thread being sampled does not
-  // exit before this object gets destructed or Bad Things(tm) may occur.
-  StackSamplingProfiler(
-      PlatformThreadId thread_id,
-      const SamplingParams& params,
-      const CompletedCallback& callback,
-      NativeStackSamplerTestDelegate* test_delegate = nullptr);
-
-  // Stops any profiling currently taking place before destroying the profiler.
-  // This will block until the callback has been run if profiling has started
-  // but not already finished.
-  ~StackSamplingProfiler();
-
-  // Initializes the profiler and starts sampling. Might block on a
-  // WaitableEvent if this StackSamplingProfiler was previously started and
-  // recently stopped, while the previous profiling phase winds down.
-  void Start();
-
-  // Stops the profiler and any ongoing sampling. This method will return
-  // immediately with the callback being run asynchronously. At most one
-  // more stack sample will be taken after this method returns. Calling this
-  // function is optional; if not invoked profiling terminates when all the
-  // profiling bursts specified in the SamplingParams are completed or the
-  // profiler object is destroyed, whichever occurs first.
-  void Stop();
-
-  // Set the current system state that is recorded with each captured stack
-  // frame. This is thread-safe so can be called from anywhere. The parameter
-  // value should be from an enumeration of the appropriate type with values
-  // ranging from 0 to 31, inclusive. This sets bits within Sample field of
-  // |process_milestones|. The actual meanings of these bits are defined
-  // (globally) by the caller(s).
-  static void SetProcessMilestone(int milestone);
-
- private:
-  friend class TestAPI;
-
-  // SamplingThread is a separate thread used to suspend and sample stacks from
-  // the target thread.
-  class SamplingThread;
-
-  // Adds annotations to a Sample.
-  static void RecordAnnotations(Sample* sample);
-
-  // This global variables holds the current system state and is recorded with
-  // every captured sample, done on a separate thread which is why updates to
-  // this must be atomic. A PostTask to move the the updates to that thread
-  // would skew the timing and a lock could result in deadlock if the thread
-  // making a change was also being profiled and got stopped.
-  static subtle::Atomic32 process_milestones_;
-
-  // The thread whose stack will be sampled.
-  PlatformThreadId thread_id_;
-
-  const SamplingParams params_;
-
-  const CompletedCallback completed_callback_;
-
-  // This starts "signaled", is reset when sampling begins, and is signaled
-  // when that sampling is complete and the callback done.
-  WaitableEvent profiling_inactive_;
-
-  // Object that does the native sampling. This is created during construction
-  // and later passed to the sampling thread when profiling is started.
-  std::unique_ptr<NativeStackSampler> native_sampler_;
-
-  // An ID uniquely identifying this profiler to the sampling thread. This
-  // will be an internal "null" value when no collection has been started.
-  int profiler_id_;
-
-  // Stored until it can be passed to the NativeStackSampler created in Start().
-  NativeStackSamplerTestDelegate* const test_delegate_;
-
-  DISALLOW_COPY_AND_ASSIGN(StackSamplingProfiler);
-};
-
-// These operators permit types to be compared and used in a map of Samples, as
-// done in tests and by the metrics provider code.
-BASE_EXPORT bool operator==(const StackSamplingProfiler::Module& a,
-                            const StackSamplingProfiler::Module& b);
-BASE_EXPORT bool operator==(const StackSamplingProfiler::Sample& a,
-                            const StackSamplingProfiler::Sample& b);
-BASE_EXPORT bool operator!=(const StackSamplingProfiler::Sample& a,
-                            const StackSamplingProfiler::Sample& b);
-BASE_EXPORT bool operator<(const StackSamplingProfiler::Sample& a,
-                           const StackSamplingProfiler::Sample& b);
-BASE_EXPORT bool operator==(const StackSamplingProfiler::Frame& a,
-                            const StackSamplingProfiler::Frame& b);
-BASE_EXPORT bool operator<(const StackSamplingProfiler::Frame& a,
-                           const StackSamplingProfiler::Frame& b);
-
-}  // namespace base
-
-#endif  // BASE_PROFILER_STACK_SAMPLING_PROFILER_H_
diff --git a/base/profiler/test_support_library.cc b/base/profiler/test_support_library.cc
deleted file mode 100644
index 035f8f7..0000000
--- a/base/profiler/test_support_library.cc
+++ /dev/null
@@ -1,30 +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.
-
-// Note: there is intentionally no header file associated with this library so
-// we don't risk implicitly demand loading it by accessing a symbol.
-
-#if defined(WIN32)
-#define BASE_PROFILER_TEST_SUPPORT_LIBRARY_EXPORT __declspec(dllexport)
-#else  // defined(WIN32)
-#define BASE_PROFILER_TEST_SUPPORT_LIBRARY_EXPORT __attribute__((visibility("default")))
-#endif
-
-namespace base {
-
-// Must be defined in an extern "C" block so we can look up the unmangled name.
-extern "C" {
-
-BASE_PROFILER_TEST_SUPPORT_LIBRARY_EXPORT void InvokeCallbackFunction(
-    void (*function)(void*),
-    void* arg) {
-  function(arg);
-  // Prevent tail call.
-  volatile int i = 0;
-  i = 1;
-}
-
-}  // extern "C"
-
-}  // namespace base
diff --git a/base/profiler/win32_stack_frame_unwinder.cc b/base/profiler/win32_stack_frame_unwinder.cc
deleted file mode 100644
index 9e6ab39..0000000
--- a/base/profiler/win32_stack_frame_unwinder.cc
+++ /dev/null
@@ -1,186 +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/profiler/win32_stack_frame_unwinder.h"
-
-#include <windows.h>
-
-#include <utility>
-
-#include "base/macros.h"
-#include "base/memory/ptr_util.h"
-
-namespace base {
-
-// Win32UnwindFunctions -------------------------------------------------------
-
-const HMODULE ModuleHandleTraits::kNonNullModuleForTesting =
-    reinterpret_cast<HMODULE>(static_cast<uintptr_t>(-1));
-
-// static
-bool ModuleHandleTraits::CloseHandle(HMODULE handle) {
-  if (handle == kNonNullModuleForTesting)
-    return true;
-
-  return ::FreeLibrary(handle) != 0;
-}
-
-// static
-bool ModuleHandleTraits::IsHandleValid(HMODULE handle) {
-  return handle != nullptr;
-}
-
-// static
-HMODULE ModuleHandleTraits::NullHandle() {
-  return nullptr;
-}
-
-namespace {
-
-// Implements the UnwindFunctions interface for the corresponding Win32
-// functions.
-class Win32UnwindFunctions : public Win32StackFrameUnwinder::UnwindFunctions {
-public:
-  Win32UnwindFunctions();
-  ~Win32UnwindFunctions() override;
-
-  PRUNTIME_FUNCTION LookupFunctionEntry(DWORD64 program_counter,
-                                        PDWORD64 image_base) override;
-
-  void VirtualUnwind(DWORD64 image_base,
-                     DWORD64 program_counter,
-                     PRUNTIME_FUNCTION runtime_function,
-                     CONTEXT* context) override;
-
-  ScopedModuleHandle GetModuleForProgramCounter(
-      DWORD64 program_counter) override;
-
-private:
-  DISALLOW_COPY_AND_ASSIGN(Win32UnwindFunctions);
-};
-
-Win32UnwindFunctions::Win32UnwindFunctions() {}
-Win32UnwindFunctions::~Win32UnwindFunctions() {}
-
-PRUNTIME_FUNCTION Win32UnwindFunctions::LookupFunctionEntry(
-    DWORD64 program_counter,
-    PDWORD64 image_base) {
-#ifdef _WIN64
-  return RtlLookupFunctionEntry(program_counter, image_base, nullptr);
-#else
-  NOTREACHED();
-  return nullptr;
-#endif
-}
-
-void Win32UnwindFunctions::VirtualUnwind(DWORD64 image_base,
-                                         DWORD64 program_counter,
-                                         PRUNTIME_FUNCTION runtime_function,
-                                         CONTEXT* context) {
-#ifdef _WIN64
-  void* handler_data;
-  ULONG64 establisher_frame;
-  KNONVOLATILE_CONTEXT_POINTERS nvcontext = {};
-  RtlVirtualUnwind(UNW_FLAG_NHANDLER, image_base, program_counter,
-                   runtime_function, context, &handler_data,
-                   &establisher_frame, &nvcontext);
-#else
-  NOTREACHED();
-#endif
-}
-
-ScopedModuleHandle Win32UnwindFunctions::GetModuleForProgramCounter(
-    DWORD64 program_counter) {
-  HMODULE module_handle = nullptr;
-  // GetModuleHandleEx() increments the module reference count, which is then
-  // managed and ultimately decremented by ScopedModuleHandle.
-  if (!::GetModuleHandleEx(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS,
-                           reinterpret_cast<LPCTSTR>(program_counter),
-                           &module_handle)) {
-    const DWORD error = ::GetLastError();
-    DCHECK_EQ(ERROR_MOD_NOT_FOUND, static_cast<int>(error));
-  }
-  return ScopedModuleHandle(module_handle);
-}
-
-}  // namespace
-
-// Win32StackFrameUnwinder ----------------------------------------------------
-
-Win32StackFrameUnwinder::UnwindFunctions::~UnwindFunctions() {}
-Win32StackFrameUnwinder::UnwindFunctions::UnwindFunctions() {}
-
-Win32StackFrameUnwinder::Win32StackFrameUnwinder()
-    : Win32StackFrameUnwinder(WrapUnique(new Win32UnwindFunctions)) {}
-
-Win32StackFrameUnwinder::~Win32StackFrameUnwinder() {}
-
-bool Win32StackFrameUnwinder::TryUnwind(CONTEXT* context,
-                                        ScopedModuleHandle* module) {
-#ifdef _WIN64
-  ScopedModuleHandle frame_module =
-      unwind_functions_->GetModuleForProgramCounter(context->Rip);
-  if (!frame_module.IsValid()) {
-    // There's no loaded module containing the instruction pointer. This can be
-    // due to executing code that is not in a module. In particular,
-    // runtime-generated code associated with third-party injected DLLs
-    // typically is not in a module. It can also be due to the the module having
-    // been unloaded since we recorded the stack.  In the latter case the
-    // function unwind information was part of the unloaded module, so it's not
-    // possible to unwind further.
-    //
-    // If a module was found, it's still theoretically possible for the detected
-    // module module to be different than the one that was loaded when the stack
-    // was copied (i.e. if the module was unloaded and a different module loaded
-    // in overlapping memory). This likely would cause a crash, but has not been
-    // observed in practice.
-    return false;
-  }
-
-  ULONG64 image_base;
-  // Try to look up unwind metadata for the current function.
-  PRUNTIME_FUNCTION runtime_function =
-      unwind_functions_->LookupFunctionEntry(context->Rip, &image_base);
-
-  if (runtime_function) {
-    unwind_functions_->VirtualUnwind(image_base, context->Rip, runtime_function,
-                                     context);
-    at_top_frame_ = false;
-  } else {
-    if (at_top_frame_) {
-      at_top_frame_ = false;
-
-      // This is a leaf function (i.e. a function that neither calls a function,
-      // nor allocates any stack space itself) so the return address is at RSP.
-      context->Rip = *reinterpret_cast<DWORD64*>(context->Rsp);
-      context->Rsp += 8;
-    } else {
-      // In theory we shouldn't get here, as it means we've encountered a
-      // function without unwind information below the top of the stack, which
-      // is forbidden by the Microsoft x64 calling convention.
-      //
-      // The one known case in Chrome code that executes this path occurs
-      // because of BoringSSL unwind information inconsistent with the actual
-      // function code. See https://crbug.com/542919.
-      //
-      // Note that dodgy third-party generated code that otherwise would enter
-      // this path should be caught by the module check above, since the code
-      // typically is located outside of a module.
-      return false;
-    }
-  }
-
-  module->Set(frame_module.Take());
-  return true;
-#else
-  NOTREACHED();
-  return false;
-#endif
-}
-
-Win32StackFrameUnwinder::Win32StackFrameUnwinder(
-    std::unique_ptr<UnwindFunctions> unwind_functions)
-    : at_top_frame_(true), unwind_functions_(std::move(unwind_functions)) {}
-
-}  // namespace base
diff --git a/base/profiler/win32_stack_frame_unwinder.h b/base/profiler/win32_stack_frame_unwinder.h
deleted file mode 100644
index c92d50c..0000000
--- a/base/profiler/win32_stack_frame_unwinder.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_PROFILER_WIN32_STACK_FRAME_UNWINDER_H_
-#define BASE_PROFILER_WIN32_STACK_FRAME_UNWINDER_H_
-
-#include <windows.h>
-
-#include <memory>
-
-#include "base/base_export.h"
-#include "base/macros.h"
-#include "base/win/scoped_handle.h"
-
-namespace base {
-
-#if !defined(_WIN64)
-// Allows code to compile for x86. Actual support for x86 will require either
-// refactoring these interfaces or separate architecture-specific interfaces.
-struct RUNTIME_FUNCTION {
-  DWORD BeginAddress;
-  DWORD EndAddress;
-};
-using PRUNTIME_FUNCTION = RUNTIME_FUNCTION*;
-#endif  // !defined(_WIN64)
-
-// Traits class to adapt GenericScopedHandle for HMODULES.
-class ModuleHandleTraits : public win::HandleTraits {
- public:
-  using Handle = HMODULE;
-
-  static bool BASE_EXPORT CloseHandle(HMODULE handle);
-  static bool BASE_EXPORT IsHandleValid(HMODULE handle);
-  static HMODULE BASE_EXPORT NullHandle();
-
-  BASE_EXPORT static const HMODULE kNonNullModuleForTesting;
-
- private:
-  DISALLOW_IMPLICIT_CONSTRUCTORS(ModuleHandleTraits);
-};
-
-// HMODULE is not really a handle, and has reference count semantics, so the
-// standard VerifierTraits does not apply.
-using ScopedModuleHandle =
-    win::GenericScopedHandle<ModuleHandleTraits, win::DummyVerifierTraits>;
-
-// Instances of this class are expected to be created and destroyed for each
-// stack unwinding. This class is not used while the target thread is suspended,
-// so may allocate from the default heap.
-class BASE_EXPORT Win32StackFrameUnwinder {
- public:
-  // Interface for Win32 unwind-related functionality this class depends
-  // on. Provides a seam for testing.
-  class BASE_EXPORT UnwindFunctions {
-   public:
-    virtual ~UnwindFunctions();
-
-    virtual PRUNTIME_FUNCTION LookupFunctionEntry(DWORD64 program_counter,
-                                                  PDWORD64 image_base) = 0;
-    virtual void VirtualUnwind(DWORD64 image_base,
-                               DWORD64 program_counter,
-                               PRUNTIME_FUNCTION runtime_function,
-                               CONTEXT* context) = 0;
-
-    // Returns the module containing |program_counter|. Can return null if the
-    // module has been unloaded.
-    virtual ScopedModuleHandle GetModuleForProgramCounter(
-        DWORD64 program_counter) = 0;
-
-   protected:
-    UnwindFunctions();
-
-   private:
-    DISALLOW_COPY_AND_ASSIGN(UnwindFunctions);
-  };
-
-  Win32StackFrameUnwinder();
-  ~Win32StackFrameUnwinder();
-
-  // Attempts to unwind the frame represented by the stack and instruction
-  // pointers in |context|. If successful, updates |context| and provides the
-  // module associated with the frame in |module|.
-  bool TryUnwind(CONTEXT* context, ScopedModuleHandle* module);
-
- private:
-  // This function is for internal and test purposes only.
-  Win32StackFrameUnwinder(std::unique_ptr<UnwindFunctions> unwind_functions);
-  friend class Win32StackFrameUnwinderTest;
-
-  // State associated with each stack unwinding.
-  bool at_top_frame_;
-  bool unwind_info_present_for_all_frames_;
-
-  std::unique_ptr<UnwindFunctions> unwind_functions_;
-
-  DISALLOW_COPY_AND_ASSIGN(Win32StackFrameUnwinder);
-};
-
-}  // namespace base
-
-#endif  // BASE_PROFILER_WIN32_STACK_FRAME_UNWINDER_H_
diff --git a/base/synchronization/lock_impl_win.cc b/base/synchronization/lock_impl_win.cc
index e0c4e9d..fe9c664 100644
--- a/base/synchronization/lock_impl_win.cc
+++ b/base/synchronization/lock_impl_win.cc
@@ -4,8 +4,6 @@
 
 #include "base/synchronization/lock_impl.h"
 
-#include "base/debug/activity_tracker.h"
-
 #include <windows.h>
 
 namespace base {
diff --git a/base/synchronization/waitable_event_win.cc b/base/synchronization/waitable_event_win.cc
index d04a5a6..60126f2 100644
--- a/base/synchronization/waitable_event_win.cc
+++ b/base/synchronization/waitable_event_win.cc
@@ -10,7 +10,6 @@
 #include <algorithm>
 #include <utility>
 
-#include "base/debug/activity_tracker.h"
 #include "base/logging.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/threading/scoped_blocking_call.h"
diff --git a/base/task_scheduler/scheduler_worker.cc b/base/task_scheduler/scheduler_worker.cc
index 33b400a..32042e4 100644
--- a/base/task_scheduler/scheduler_worker.cc
+++ b/base/task_scheduler/scheduler_worker.cc
@@ -9,7 +9,6 @@
 #include <utility>
 
 #include "base/compiler_specific.h"
-#include "base/debug/alias.h"
 #include "base/logging.h"
 #include "base/task_scheduler/scheduler_worker_observer.h"
 #include "base/task_scheduler/task_tracker.h"
@@ -212,62 +211,52 @@
 NOINLINE void SchedulerWorker::RunPooledWorker() {
   const int line_number = __LINE__;
   RunWorker();
-  base::debug::Alias(&line_number);
 }
 
 NOINLINE void SchedulerWorker::RunBackgroundPooledWorker() {
   const int line_number = __LINE__;
   RunWorker();
-  base::debug::Alias(&line_number);
 }
 
 NOINLINE void SchedulerWorker::RunSharedWorker() {
   const int line_number = __LINE__;
   RunWorker();
-  base::debug::Alias(&line_number);
 }
 
 NOINLINE void SchedulerWorker::RunBackgroundSharedWorker() {
   const int line_number = __LINE__;
   RunWorker();
-  base::debug::Alias(&line_number);
 }
 
 NOINLINE void SchedulerWorker::RunDedicatedWorker() {
   const int line_number = __LINE__;
   RunWorker();
-  base::debug::Alias(&line_number);
 }
 
 NOINLINE void SchedulerWorker::RunBackgroundDedicatedWorker() {
   const int line_number = __LINE__;
   RunWorker();
-  base::debug::Alias(&line_number);
 }
 
 #if defined(OS_WIN)
 NOINLINE void SchedulerWorker::RunSharedCOMWorker() {
   const int line_number = __LINE__;
   RunWorker();
-  base::debug::Alias(&line_number);
 }
 
 NOINLINE void SchedulerWorker::RunBackgroundSharedCOMWorker() {
   const int line_number = __LINE__;
   RunWorker();
-  base::debug::Alias(&line_number);
 }
 
 NOINLINE void SchedulerWorker::RunDedicatedCOMWorker() {
   const int line_number = __LINE__;
   RunWorker();
-  base::debug::Alias(&line_number);
 }
 
 NOINLINE void SchedulerWorker::RunBackgroundDedicatedCOMWorker() {
   const int line_number = __LINE__;
   RunWorker();
-  base::debug::Alias(&line_number);
 }
 #endif  // defined(OS_WIN)
 
diff --git a/base/task_scheduler/service_thread.cc b/base/task_scheduler/service_thread.cc
index ce8bf4d..9ee0986 100644
--- a/base/task_scheduler/service_thread.cc
+++ b/base/task_scheduler/service_thread.cc
@@ -4,7 +4,6 @@
 
 #include "base/task_scheduler/service_thread.h"
 
-#include "base/debug/alias.h"
 #include "base/task_scheduler/post_task.h"
 #include "base/task_scheduler/task_tracker.h"
 #include "base/task_scheduler/task_traits.h"
@@ -20,7 +19,6 @@
 NOINLINE void ServiceThread::Run(RunLoop* run_loop) {
   const int line_number = __LINE__;
   Thread::Run(run_loop);
-  base::debug::Alias(&line_number);
 }
 
 }  // namespace internal
diff --git a/base/task_scheduler/task_tracker.cc b/base/task_scheduler/task_tracker.cc
index 33424bb..704aadd 100644
--- a/base/task_scheduler/task_tracker.cc
+++ b/base/task_scheduler/task_tracker.cc
@@ -245,8 +245,6 @@
   if (task.delayed_run_time.is_null())
     subtle::NoBarrier_AtomicIncrement(&num_incomplete_undelayed_tasks_, 1);
 
-  task_annotator_.DidQueueTask(nullptr, task);
-
   return true;
 }
 
@@ -374,7 +372,7 @@
     }
 
     if (can_run_task) {
-      task_annotator_.RunTask(nullptr, &task);
+      std::move(task.task).Run();
     }
 
     // Make sure the arguments bound to the callback are deleted within the
diff --git a/base/task_scheduler/task_tracker.h b/base/task_scheduler/task_tracker.h
index ae484ce..3240e3a 100644
--- a/base/task_scheduler/task_tracker.h
+++ b/base/task_scheduler/task_tracker.h
@@ -12,7 +12,6 @@
 #include "base/atomicops.h"
 #include "base/base_export.h"
 #include "base/callback_forward.h"
-#include "base/debug/task_annotator.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/strings/string_piece.h"
@@ -258,8 +257,6 @@
   // manner.
   void CallFlushCallbackForTesting();
 
-  debug::TaskAnnotator task_annotator_;
-
   // Number of tasks blocking shutdown and boolean indicating whether shutdown
   // has started.
   const std::unique_ptr<State> state_;
diff --git a/base/third_party/symbolize/DEPS b/base/third_party/symbolize/DEPS
deleted file mode 100644
index 73eab50..0000000
--- a/base/third_party/symbolize/DEPS
+++ /dev/null
@@ -1,3 +0,0 @@
-include_rules = [
-  "+glog",
-]
diff --git a/base/third_party/symbolize/LICENSE b/base/third_party/symbolize/LICENSE
deleted file mode 100644
index 433a3d1..0000000
--- a/base/third_party/symbolize/LICENSE
+++ /dev/null
@@ -1,28 +0,0 @@
-// Copyright (c) 2006, Google Inc.
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/base/third_party/symbolize/README.chromium b/base/third_party/symbolize/README.chromium
deleted file mode 100644
index ff78e0e..0000000
--- a/base/third_party/symbolize/README.chromium
+++ /dev/null
@@ -1,24 +0,0 @@
-Name: google-glog's symbolization library
-URL: https://github.com/google/glog
-License: BSD
-
-The following files are copied AS-IS from:
-http://code.google.com/p/google-glog/source/browse/#svn/trunk/src (r141)
-https://github.com/google/glog/tree/a5ffa884137f7687d0393ccba22557d583654a25
-
-- demangle.cc
-- demangle.h
-- symbolize.cc
-- symbolize.h
-
-Cherry picked upstream changes:
-https://github.com/google/glog/pull/115
-https://github.com/google/glog/pull/261
-to fix symbolization issues when using lld.
-
-The following files are minimal stubs created for use in Chromium:
-
-- config.h
-- glog/logging.h
-- glog/raw_logging.h
-- utilities.h
diff --git a/base/third_party/symbolize/config.h b/base/third_party/symbolize/config.h
deleted file mode 100644
index 945f5a6..0000000
--- a/base/third_party/symbolize/config.h
+++ /dev/null
@@ -1,7 +0,0 @@
-// Copyright (c) 2010 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.
-
-#define GOOGLE_NAMESPACE google
-#define _END_GOOGLE_NAMESPACE_ }
-#define _START_GOOGLE_NAMESPACE_ namespace google {
diff --git a/base/third_party/symbolize/demangle.cc b/base/third_party/symbolize/demangle.cc
deleted file mode 100644
index e858181..0000000
--- a/base/third_party/symbolize/demangle.cc
+++ /dev/null
@@ -1,1304 +0,0 @@
-// Copyright (c) 2006, Google Inc.
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Author: Satoru Takabayashi
-//
-// For reference check out:
-// http://www.codesourcery.com/public/cxx-abi/abi.html#mangling
-//
-// Note that we only have partial C++0x support yet.
-
-#include <stdio.h>  // for NULL
-#include "demangle.h"
-
-_START_GOOGLE_NAMESPACE_
-
-typedef struct {
-  const char *abbrev;
-  const char *real_name;
-} AbbrevPair;
-
-// List of operators from Itanium C++ ABI.
-static const AbbrevPair kOperatorList[] = {
-  { "nw", "new" },
-  { "na", "new[]" },
-  { "dl", "delete" },
-  { "da", "delete[]" },
-  { "ps", "+" },
-  { "ng", "-" },
-  { "ad", "&" },
-  { "de", "*" },
-  { "co", "~" },
-  { "pl", "+" },
-  { "mi", "-" },
-  { "ml", "*" },
-  { "dv", "/" },
-  { "rm", "%" },
-  { "an", "&" },
-  { "or", "|" },
-  { "eo", "^" },
-  { "aS", "=" },
-  { "pL", "+=" },
-  { "mI", "-=" },
-  { "mL", "*=" },
-  { "dV", "/=" },
-  { "rM", "%=" },
-  { "aN", "&=" },
-  { "oR", "|=" },
-  { "eO", "^=" },
-  { "ls", "<<" },
-  { "rs", ">>" },
-  { "lS", "<<=" },
-  { "rS", ">>=" },
-  { "eq", "==" },
-  { "ne", "!=" },
-  { "lt", "<" },
-  { "gt", ">" },
-  { "le", "<=" },
-  { "ge", ">=" },
-  { "nt", "!" },
-  { "aa", "&&" },
-  { "oo", "||" },
-  { "pp", "++" },
-  { "mm", "--" },
-  { "cm", "," },
-  { "pm", "->*" },
-  { "pt", "->" },
-  { "cl", "()" },
-  { "ix", "[]" },
-  { "qu", "?" },
-  { "st", "sizeof" },
-  { "sz", "sizeof" },
-  { NULL, NULL },
-};
-
-// List of builtin types from Itanium C++ ABI.
-static const AbbrevPair kBuiltinTypeList[] = {
-  { "v", "void" },
-  { "w", "wchar_t" },
-  { "b", "bool" },
-  { "c", "char" },
-  { "a", "signed char" },
-  { "h", "unsigned char" },
-  { "s", "short" },
-  { "t", "unsigned short" },
-  { "i", "int" },
-  { "j", "unsigned int" },
-  { "l", "long" },
-  { "m", "unsigned long" },
-  { "x", "long long" },
-  { "y", "unsigned long long" },
-  { "n", "__int128" },
-  { "o", "unsigned __int128" },
-  { "f", "float" },
-  { "d", "double" },
-  { "e", "long double" },
-  { "g", "__float128" },
-  { "z", "ellipsis" },
-  { NULL, NULL }
-};
-
-// List of substitutions Itanium C++ ABI.
-static const AbbrevPair kSubstitutionList[] = {
-  { "St", "" },
-  { "Sa", "allocator" },
-  { "Sb", "basic_string" },
-  // std::basic_string<char, std::char_traits<char>,std::allocator<char> >
-  { "Ss", "string"},
-  // std::basic_istream<char, std::char_traits<char> >
-  { "Si", "istream" },
-  // std::basic_ostream<char, std::char_traits<char> >
-  { "So", "ostream" },
-  // std::basic_iostream<char, std::char_traits<char> >
-  { "Sd", "iostream" },
-  { NULL, NULL }
-};
-
-// State needed for demangling.
-typedef struct {
-  const char *mangled_cur;  // Cursor of mangled name.
-  char *out_cur;            // Cursor of output string.
-  const char *out_begin;    // Beginning of output string.
-  const char *out_end;      // End of output string.
-  const char *prev_name;    // For constructors/destructors.
-  int prev_name_length;     // For constructors/destructors.
-  short nest_level;         // For nested names.
-  bool append;              // Append flag.
-  bool overflowed;          // True if output gets overflowed.
-} State;
-
-// We don't use strlen() in libc since it's not guaranteed to be async
-// signal safe.
-static size_t StrLen(const char *str) {
-  size_t len = 0;
-  while (*str != '\0') {
-    ++str;
-    ++len;
-  }
-  return len;
-}
-
-// Returns true if "str" has at least "n" characters remaining.
-static bool AtLeastNumCharsRemaining(const char *str, int n) {
-  for (int i = 0; i < n; ++i) {
-    if (str[i] == '\0') {
-      return false;
-    }
-  }
-  return true;
-}
-
-// Returns true if "str" has "prefix" as a prefix.
-static bool StrPrefix(const char *str, const char *prefix) {
-  size_t i = 0;
-  while (str[i] != '\0' && prefix[i] != '\0' &&
-         str[i] == prefix[i]) {
-    ++i;
-  }
-  return prefix[i] == '\0';  // Consumed everything in "prefix".
-}
-
-static void InitState(State *state, const char *mangled,
-                      char *out, int out_size) {
-  state->mangled_cur = mangled;
-  state->out_cur = out;
-  state->out_begin = out;
-  state->out_end = out + out_size;
-  state->prev_name  = NULL;
-  state->prev_name_length = -1;
-  state->nest_level = -1;
-  state->append = true;
-  state->overflowed = false;
-}
-
-// Returns true and advances "mangled_cur" if we find "one_char_token"
-// at "mangled_cur" position.  It is assumed that "one_char_token" does
-// not contain '\0'.
-static bool ParseOneCharToken(State *state, const char one_char_token) {
-  if (state->mangled_cur[0] == one_char_token) {
-    ++state->mangled_cur;
-    return true;
-  }
-  return false;
-}
-
-// Returns true and advances "mangled_cur" if we find "two_char_token"
-// at "mangled_cur" position.  It is assumed that "two_char_token" does
-// not contain '\0'.
-static bool ParseTwoCharToken(State *state, const char *two_char_token) {
-  if (state->mangled_cur[0] == two_char_token[0] &&
-      state->mangled_cur[1] == two_char_token[1]) {
-    state->mangled_cur += 2;
-    return true;
-  }
-  return false;
-}
-
-// Returns true and advances "mangled_cur" if we find any character in
-// "char_class" at "mangled_cur" position.
-static bool ParseCharClass(State *state, const char *char_class) {
-  const char *p = char_class;
-  for (; *p != '\0'; ++p) {
-    if (state->mangled_cur[0] == *p) {
-      ++state->mangled_cur;
-      return true;
-    }
-  }
-  return false;
-}
-
-// This function is used for handling an optional non-terminal.
-static bool Optional(bool) {
-  return true;
-}
-
-// This function is used for handling <non-terminal>+ syntax.
-typedef bool (*ParseFunc)(State *);
-static bool OneOrMore(ParseFunc parse_func, State *state) {
-  if (parse_func(state)) {
-    while (parse_func(state)) {
-    }
-    return true;
-  }
-  return false;
-}
-
-// This function is used for handling <non-terminal>* syntax. The function
-// always returns true and must be followed by a termination token or a
-// terminating sequence not handled by parse_func (e.g.
-// ParseOneCharToken(state, 'E')).
-static bool ZeroOrMore(ParseFunc parse_func, State *state) {
-  while (parse_func(state)) {
-  }
-  return true;
-}
-
-// Append "str" at "out_cur".  If there is an overflow, "overflowed"
-// is set to true for later use.  The output string is ensured to
-// always terminate with '\0' as long as there is no overflow.
-static void Append(State *state, const char * const str, const int length) {
-  int i;
-  for (i = 0; i < length; ++i) {
-    if (state->out_cur + 1 < state->out_end) {  // +1 for '\0'
-      *state->out_cur = str[i];
-      ++state->out_cur;
-    } else {
-      state->overflowed = true;
-      break;
-    }
-  }
-  if (!state->overflowed) {
-    *state->out_cur = '\0';  // Terminate it with '\0'
-  }
-}
-
-// We don't use equivalents in libc to avoid locale issues.
-static bool IsLower(char c) {
-  return c >= 'a' && c <= 'z';
-}
-
-static bool IsAlpha(char c) {
-  return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z');
-}
-
-static bool IsDigit(char c) {
-  return c >= '0' && c <= '9';
-}
-
-// Returns true if "str" is a function clone suffix.  These suffixes are used
-// by GCC 4.5.x and later versions to indicate functions which have been
-// cloned during optimization.  We treat any sequence (.<alpha>+.<digit>+)+ as
-// a function clone suffix.
-static bool IsFunctionCloneSuffix(const char *str) {
-  size_t i = 0;
-  while (str[i] != '\0') {
-    // Consume a single .<alpha>+.<digit>+ sequence.
-    if (str[i] != '.' || !IsAlpha(str[i + 1])) {
-      return false;
-    }
-    i += 2;
-    while (IsAlpha(str[i])) {
-      ++i;
-    }
-    if (str[i] != '.' || !IsDigit(str[i + 1])) {
-      return false;
-    }
-    i += 2;
-    while (IsDigit(str[i])) {
-      ++i;
-    }
-  }
-  return true;  // Consumed everything in "str".
-}
-
-// Append "str" with some tweaks, iff "append" state is true.
-// Returns true so that it can be placed in "if" conditions.
-static void MaybeAppendWithLength(State *state, const char * const str,
-                                  const int length) {
-  if (state->append && length > 0) {
-    // Append a space if the output buffer ends with '<' and "str"
-    // starts with '<' to avoid <<<.
-    if (str[0] == '<' && state->out_begin < state->out_cur  &&
-        state->out_cur[-1] == '<') {
-      Append(state, " ", 1);
-    }
-    // Remember the last identifier name for ctors/dtors.
-    if (IsAlpha(str[0]) || str[0] == '_') {
-      state->prev_name = state->out_cur;
-      state->prev_name_length = length;
-    }
-    Append(state, str, length);
-  }
-}
-
-// A convenient wrapper arount MaybeAppendWithLength().
-static bool MaybeAppend(State *state, const char * const str) {
-  if (state->append) {
-    int length = StrLen(str);
-    MaybeAppendWithLength(state, str, length);
-  }
-  return true;
-}
-
-// This function is used for handling nested names.
-static bool EnterNestedName(State *state) {
-  state->nest_level = 0;
-  return true;
-}
-
-// This function is used for handling nested names.
-static bool LeaveNestedName(State *state, short prev_value) {
-  state->nest_level = prev_value;
-  return true;
-}
-
-// Disable the append mode not to print function parameters, etc.
-static bool DisableAppend(State *state) {
-  state->append = false;
-  return true;
-}
-
-// Restore the append mode to the previous state.
-static bool RestoreAppend(State *state, bool prev_value) {
-  state->append = prev_value;
-  return true;
-}
-
-// Increase the nest level for nested names.
-static void MaybeIncreaseNestLevel(State *state) {
-  if (state->nest_level > -1) {
-    ++state->nest_level;
-  }
-}
-
-// Appends :: for nested names if necessary.
-static void MaybeAppendSeparator(State *state) {
-  if (state->nest_level >= 1) {
-    MaybeAppend(state, "::");
-  }
-}
-
-// Cancel the last separator if necessary.
-static void MaybeCancelLastSeparator(State *state) {
-  if (state->nest_level >= 1 && state->append &&
-      state->out_begin <= state->out_cur - 2) {
-    state->out_cur -= 2;
-    *state->out_cur = '\0';
-  }
-}
-
-// Returns true if the identifier of the given length pointed to by
-// "mangled_cur" is anonymous namespace.
-static bool IdentifierIsAnonymousNamespace(State *state, int length) {
-  static const char anon_prefix[] = "_GLOBAL__N_";
-  return (length > (int)sizeof(anon_prefix) - 1 &&  // Should be longer.
-          StrPrefix(state->mangled_cur, anon_prefix));
-}
-
-// Forward declarations of our parsing functions.
-static bool ParseMangledName(State *state);
-static bool ParseEncoding(State *state);
-static bool ParseName(State *state);
-static bool ParseUnscopedName(State *state);
-static bool ParseUnscopedTemplateName(State *state);
-static bool ParseNestedName(State *state);
-static bool ParsePrefix(State *state);
-static bool ParseUnqualifiedName(State *state);
-static bool ParseSourceName(State *state);
-static bool ParseLocalSourceName(State *state);
-static bool ParseNumber(State *state, int *number_out);
-static bool ParseFloatNumber(State *state);
-static bool ParseSeqId(State *state);
-static bool ParseIdentifier(State *state, int length);
-static bool ParseOperatorName(State *state);
-static bool ParseSpecialName(State *state);
-static bool ParseCallOffset(State *state);
-static bool ParseNVOffset(State *state);
-static bool ParseVOffset(State *state);
-static bool ParseCtorDtorName(State *state);
-static bool ParseType(State *state);
-static bool ParseCVQualifiers(State *state);
-static bool ParseBuiltinType(State *state);
-static bool ParseFunctionType(State *state);
-static bool ParseBareFunctionType(State *state);
-static bool ParseClassEnumType(State *state);
-static bool ParseArrayType(State *state);
-static bool ParsePointerToMemberType(State *state);
-static bool ParseTemplateParam(State *state);
-static bool ParseTemplateTemplateParam(State *state);
-static bool ParseTemplateArgs(State *state);
-static bool ParseTemplateArg(State *state);
-static bool ParseExpression(State *state);
-static bool ParseExprPrimary(State *state);
-static bool ParseLocalName(State *state);
-static bool ParseDiscriminator(State *state);
-static bool ParseSubstitution(State *state);
-
-// Implementation note: the following code is a straightforward
-// translation of the Itanium C++ ABI defined in BNF with a couple of
-// exceptions.
-//
-// - Support GNU extensions not defined in the Itanium C++ ABI
-// - <prefix> and <template-prefix> are combined to avoid infinite loop
-// - Reorder patterns to shorten the code
-// - Reorder patterns to give greedier functions precedence
-//   We'll mark "Less greedy than" for these cases in the code
-//
-// Each parsing function changes the state and returns true on
-// success.  Otherwise, don't change the state and returns false.  To
-// ensure that the state isn't changed in the latter case, we save the
-// original state before we call more than one parsing functions
-// consecutively with &&, and restore the state if unsuccessful.  See
-// ParseEncoding() as an example of this convention.  We follow the
-// convention throughout the code.
-//
-// Originally we tried to do demangling without following the full ABI
-// syntax but it turned out we needed to follow the full syntax to
-// parse complicated cases like nested template arguments.  Note that
-// implementing a full-fledged demangler isn't trivial (libiberty's
-// cp-demangle.c has +4300 lines).
-//
-// Note that (foo) in <(foo) ...> is a modifier to be ignored.
-//
-// Reference:
-// - Itanium C++ ABI
-//   <http://www.codesourcery.com/cxx-abi/abi.html#mangling>
-
-// <mangled-name> ::= _Z <encoding>
-static bool ParseMangledName(State *state) {
-  return ParseTwoCharToken(state, "_Z") && ParseEncoding(state);
-}
-
-// <encoding> ::= <(function) name> <bare-function-type>
-//            ::= <(data) name>
-//            ::= <special-name>
-static bool ParseEncoding(State *state) {
-  State copy = *state;
-  if (ParseName(state) && ParseBareFunctionType(state)) {
-    return true;
-  }
-  *state = copy;
-
-  if (ParseName(state) || ParseSpecialName(state)) {
-    return true;
-  }
-  return false;
-}
-
-// <name> ::= <nested-name>
-//        ::= <unscoped-template-name> <template-args>
-//        ::= <unscoped-name>
-//        ::= <local-name>
-static bool ParseName(State *state) {
-  if (ParseNestedName(state) || ParseLocalName(state)) {
-    return true;
-  }
-
-  State copy = *state;
-  if (ParseUnscopedTemplateName(state) &&
-      ParseTemplateArgs(state)) {
-    return true;
-  }
-  *state = copy;
-
-  // Less greedy than <unscoped-template-name> <template-args>.
-  if (ParseUnscopedName(state)) {
-    return true;
-  }
-  return false;
-}
-
-// <unscoped-name> ::= <unqualified-name>
-//                 ::= St <unqualified-name>
-static bool ParseUnscopedName(State *state) {
-  if (ParseUnqualifiedName(state)) {
-    return true;
-  }
-
-  State copy = *state;
-  if (ParseTwoCharToken(state, "St") &&
-      MaybeAppend(state, "std::") &&
-      ParseUnqualifiedName(state)) {
-    return true;
-  }
-  *state = copy;
-  return false;
-}
-
-// <unscoped-template-name> ::= <unscoped-name>
-//                          ::= <substitution>
-static bool ParseUnscopedTemplateName(State *state) {
-  return ParseUnscopedName(state) || ParseSubstitution(state);
-}
-
-// <nested-name> ::= N [<CV-qualifiers>] <prefix> <unqualified-name> E
-//               ::= N [<CV-qualifiers>] <template-prefix> <template-args> E
-static bool ParseNestedName(State *state) {
-  State copy = *state;
-  if (ParseOneCharToken(state, 'N') &&
-      EnterNestedName(state) &&
-      Optional(ParseCVQualifiers(state)) &&
-      ParsePrefix(state) &&
-      LeaveNestedName(state, copy.nest_level) &&
-      ParseOneCharToken(state, 'E')) {
-    return true;
-  }
-  *state = copy;
-  return false;
-}
-
-// This part is tricky.  If we literally translate them to code, we'll
-// end up infinite loop.  Hence we merge them to avoid the case.
-//
-// <prefix> ::= <prefix> <unqualified-name>
-//          ::= <template-prefix> <template-args>
-//          ::= <template-param>
-//          ::= <substitution>
-//          ::= # empty
-// <template-prefix> ::= <prefix> <(template) unqualified-name>
-//                   ::= <template-param>
-//                   ::= <substitution>
-static bool ParsePrefix(State *state) {
-  bool has_something = false;
-  while (true) {
-    MaybeAppendSeparator(state);
-    if (ParseTemplateParam(state) ||
-        ParseSubstitution(state) ||
-        ParseUnscopedName(state)) {
-      has_something = true;
-      MaybeIncreaseNestLevel(state);
-      continue;
-    }
-    MaybeCancelLastSeparator(state);
-    if (has_something && ParseTemplateArgs(state)) {
-      return ParsePrefix(state);
-    } else {
-      break;
-    }
-  }
-  return true;
-}
-
-// <unqualified-name> ::= <operator-name>
-//                    ::= <ctor-dtor-name>
-//                    ::= <source-name>
-//                    ::= <local-source-name>
-static bool ParseUnqualifiedName(State *state) {
-  return (ParseOperatorName(state) ||
-          ParseCtorDtorName(state) ||
-          ParseSourceName(state) ||
-          ParseLocalSourceName(state));
-}
-
-// <source-name> ::= <positive length number> <identifier>
-static bool ParseSourceName(State *state) {
-  State copy = *state;
-  int length = -1;
-  if (ParseNumber(state, &length) && ParseIdentifier(state, length)) {
-    return true;
-  }
-  *state = copy;
-  return false;
-}
-
-// <local-source-name> ::= L <source-name> [<discriminator>]
-//
-// References:
-//   http://gcc.gnu.org/bugzilla/show_bug.cgi?id=31775
-//   http://gcc.gnu.org/viewcvs?view=rev&revision=124467
-static bool ParseLocalSourceName(State *state) {
-  State copy = *state;
-  if (ParseOneCharToken(state, 'L') && ParseSourceName(state) &&
-      Optional(ParseDiscriminator(state))) {
-    return true;
-  }
-  *state = copy;
-  return false;
-}
-
-// <number> ::= [n] <non-negative decimal integer>
-// If "number_out" is non-null, then *number_out is set to the value of the
-// parsed number on success.
-static bool ParseNumber(State *state, int *number_out) {
-  int sign = 1;
-  if (ParseOneCharToken(state, 'n')) {
-    sign = -1;
-  }
-  const char *p = state->mangled_cur;
-  int number = 0;
-  for (;*p != '\0'; ++p) {
-    if (IsDigit(*p)) {
-      number = number * 10 + (*p - '0');
-    } else {
-      break;
-    }
-  }
-  if (p != state->mangled_cur) {  // Conversion succeeded.
-    state->mangled_cur = p;
-    if (number_out != NULL) {
-      *number_out = number * sign;
-    }
-    return true;
-  }
-  return false;
-}
-
-// Floating-point literals are encoded using a fixed-length lowercase
-// hexadecimal string.
-static bool ParseFloatNumber(State *state) {
-  const char *p = state->mangled_cur;
-  for (;*p != '\0'; ++p) {
-    if (!IsDigit(*p) && !(*p >= 'a' && *p <= 'f')) {
-      break;
-    }
-  }
-  if (p != state->mangled_cur) {  // Conversion succeeded.
-    state->mangled_cur = p;
-    return true;
-  }
-  return false;
-}
-
-// The <seq-id> is a sequence number in base 36,
-// using digits and upper case letters
-static bool ParseSeqId(State *state) {
-  const char *p = state->mangled_cur;
-  for (;*p != '\0'; ++p) {
-    if (!IsDigit(*p) && !(*p >= 'A' && *p <= 'Z')) {
-      break;
-    }
-  }
-  if (p != state->mangled_cur) {  // Conversion succeeded.
-    state->mangled_cur = p;
-    return true;
-  }
-  return false;
-}
-
-// <identifier> ::= <unqualified source code identifier> (of given length)
-static bool ParseIdentifier(State *state, int length) {
-  if (length == -1 ||
-      !AtLeastNumCharsRemaining(state->mangled_cur, length)) {
-    return false;
-  }
-  if (IdentifierIsAnonymousNamespace(state, length)) {
-    MaybeAppend(state, "(anonymous namespace)");
-  } else {
-    MaybeAppendWithLength(state, state->mangled_cur, length);
-  }
-  state->mangled_cur += length;
-  return true;
-}
-
-// <operator-name> ::= nw, and other two letters cases
-//                 ::= cv <type>  # (cast)
-//                 ::= v  <digit> <source-name> # vendor extended operator
-static bool ParseOperatorName(State *state) {
-  if (!AtLeastNumCharsRemaining(state->mangled_cur, 2)) {
-    return false;
-  }
-  // First check with "cv" (cast) case.
-  State copy = *state;
-  if (ParseTwoCharToken(state, "cv") &&
-      MaybeAppend(state, "operator ") &&
-      EnterNestedName(state) &&
-      ParseType(state) &&
-      LeaveNestedName(state, copy.nest_level)) {
-    return true;
-  }
-  *state = copy;
-
-  // Then vendor extended operators.
-  if (ParseOneCharToken(state, 'v') && ParseCharClass(state, "0123456789") &&
-      ParseSourceName(state)) {
-    return true;
-  }
-  *state = copy;
-
-  // Other operator names should start with a lower alphabet followed
-  // by a lower/upper alphabet.
-  if (!(IsLower(state->mangled_cur[0]) &&
-        IsAlpha(state->mangled_cur[1]))) {
-    return false;
-  }
-  // We may want to perform a binary search if we really need speed.
-  const AbbrevPair *p;
-  for (p = kOperatorList; p->abbrev != NULL; ++p) {
-    if (state->mangled_cur[0] == p->abbrev[0] &&
-        state->mangled_cur[1] == p->abbrev[1]) {
-      MaybeAppend(state, "operator");
-      if (IsLower(*p->real_name)) {  // new, delete, etc.
-        MaybeAppend(state, " ");
-      }
-      MaybeAppend(state, p->real_name);
-      state->mangled_cur += 2;
-      return true;
-    }
-  }
-  return false;
-}
-
-// <special-name> ::= TV <type>
-//                ::= TT <type>
-//                ::= TI <type>
-//                ::= TS <type>
-//                ::= Tc <call-offset> <call-offset> <(base) encoding>
-//                ::= GV <(object) name>
-//                ::= T <call-offset> <(base) encoding>
-// G++ extensions:
-//                ::= TC <type> <(offset) number> _ <(base) type>
-//                ::= TF <type>
-//                ::= TJ <type>
-//                ::= GR <name>
-//                ::= GA <encoding>
-//                ::= Th <call-offset> <(base) encoding>
-//                ::= Tv <call-offset> <(base) encoding>
-//
-// Note: we don't care much about them since they don't appear in
-// stack traces.  The are special data.
-static bool ParseSpecialName(State *state) {
-  State copy = *state;
-  if (ParseOneCharToken(state, 'T') &&
-      ParseCharClass(state, "VTIS") &&
-      ParseType(state)) {
-    return true;
-  }
-  *state = copy;
-
-  if (ParseTwoCharToken(state, "Tc") && ParseCallOffset(state) &&
-      ParseCallOffset(state) && ParseEncoding(state)) {
-    return true;
-  }
-  *state = copy;
-
-  if (ParseTwoCharToken(state, "GV") &&
-      ParseName(state)) {
-    return true;
-  }
-  *state = copy;
-
-  if (ParseOneCharToken(state, 'T') && ParseCallOffset(state) &&
-      ParseEncoding(state)) {
-    return true;
-  }
-  *state = copy;
-
-  // G++ extensions
-  if (ParseTwoCharToken(state, "TC") && ParseType(state) &&
-      ParseNumber(state, NULL) && ParseOneCharToken(state, '_') &&
-      DisableAppend(state) &&
-      ParseType(state)) {
-    RestoreAppend(state, copy.append);
-    return true;
-  }
-  *state = copy;
-
-  if (ParseOneCharToken(state, 'T') && ParseCharClass(state, "FJ") &&
-      ParseType(state)) {
-    return true;
-  }
-  *state = copy;
-
-  if (ParseTwoCharToken(state, "GR") && ParseName(state)) {
-    return true;
-  }
-  *state = copy;
-
-  if (ParseTwoCharToken(state, "GA") && ParseEncoding(state)) {
-    return true;
-  }
-  *state = copy;
-
-  if (ParseOneCharToken(state, 'T') && ParseCharClass(state, "hv") &&
-      ParseCallOffset(state) && ParseEncoding(state)) {
-    return true;
-  }
-  *state = copy;
-  return false;
-}
-
-// <call-offset> ::= h <nv-offset> _
-//               ::= v <v-offset> _
-static bool ParseCallOffset(State *state) {
-  State copy = *state;
-  if (ParseOneCharToken(state, 'h') &&
-      ParseNVOffset(state) && ParseOneCharToken(state, '_')) {
-    return true;
-  }
-  *state = copy;
-
-  if (ParseOneCharToken(state, 'v') &&
-      ParseVOffset(state) && ParseOneCharToken(state, '_')) {
-    return true;
-  }
-  *state = copy;
-
-  return false;
-}
-
-// <nv-offset> ::= <(offset) number>
-static bool ParseNVOffset(State *state) {
-  return ParseNumber(state, NULL);
-}
-
-// <v-offset>  ::= <(offset) number> _ <(virtual offset) number>
-static bool ParseVOffset(State *state) {
-  State copy = *state;
-  if (ParseNumber(state, NULL) && ParseOneCharToken(state, '_') &&
-      ParseNumber(state, NULL)) {
-    return true;
-  }
-  *state = copy;
-  return false;
-}
-
-// <ctor-dtor-name> ::= C1 | C2 | C3
-//                  ::= D0 | D1 | D2
-static bool ParseCtorDtorName(State *state) {
-  State copy = *state;
-  if (ParseOneCharToken(state, 'C') &&
-      ParseCharClass(state, "123")) {
-    const char * const prev_name = state->prev_name;
-    const int prev_name_length = state->prev_name_length;
-    MaybeAppendWithLength(state, prev_name, prev_name_length);
-    return true;
-  }
-  *state = copy;
-
-  if (ParseOneCharToken(state, 'D') &&
-      ParseCharClass(state, "012")) {
-    const char * const prev_name = state->prev_name;
-    const int prev_name_length = state->prev_name_length;
-    MaybeAppend(state, "~");
-    MaybeAppendWithLength(state, prev_name, prev_name_length);
-    return true;
-  }
-  *state = copy;
-  return false;
-}
-
-// <type> ::= <CV-qualifiers> <type>
-//        ::= P <type>   # pointer-to
-//        ::= R <type>   # reference-to
-//        ::= O <type>   # rvalue reference-to (C++0x)
-//        ::= C <type>   # complex pair (C 2000)
-//        ::= G <type>   # imaginary (C 2000)
-//        ::= U <source-name> <type>  # vendor extended type qualifier
-//        ::= <builtin-type>
-//        ::= <function-type>
-//        ::= <class-enum-type>
-//        ::= <array-type>
-//        ::= <pointer-to-member-type>
-//        ::= <template-template-param> <template-args>
-//        ::= <template-param>
-//        ::= <substitution>
-//        ::= Dp <type>          # pack expansion of (C++0x)
-//        ::= Dt <expression> E  # decltype of an id-expression or class
-//                               # member access (C++0x)
-//        ::= DT <expression> E  # decltype of an expression (C++0x)
-//
-static bool ParseType(State *state) {
-  // We should check CV-qualifers, and PRGC things first.
-  State copy = *state;
-  if (ParseCVQualifiers(state) && ParseType(state)) {
-    return true;
-  }
-  *state = copy;
-
-  if (ParseCharClass(state, "OPRCG") && ParseType(state)) {
-    return true;
-  }
-  *state = copy;
-
-  if (ParseTwoCharToken(state, "Dp") && ParseType(state)) {
-    return true;
-  }
-  *state = copy;
-
-  if (ParseOneCharToken(state, 'D') && ParseCharClass(state, "tT") &&
-      ParseExpression(state) && ParseOneCharToken(state, 'E')) {
-    return true;
-  }
-  *state = copy;
-
-  if (ParseOneCharToken(state, 'U') && ParseSourceName(state) &&
-      ParseType(state)) {
-    return true;
-  }
-  *state = copy;
-
-  if (ParseBuiltinType(state) ||
-      ParseFunctionType(state) ||
-      ParseClassEnumType(state) ||
-      ParseArrayType(state) ||
-      ParsePointerToMemberType(state) ||
-      ParseSubstitution(state)) {
-    return true;
-  }
-
-  if (ParseTemplateTemplateParam(state) &&
-      ParseTemplateArgs(state)) {
-    return true;
-  }
-  *state = copy;
-
-  // Less greedy than <template-template-param> <template-args>.
-  if (ParseTemplateParam(state)) {
-    return true;
-  }
-
-  return false;
-}
-
-// <CV-qualifiers> ::= [r] [V] [K]
-// We don't allow empty <CV-qualifiers> to avoid infinite loop in
-// ParseType().
-static bool ParseCVQualifiers(State *state) {
-  int num_cv_qualifiers = 0;
-  num_cv_qualifiers += ParseOneCharToken(state, 'r');
-  num_cv_qualifiers += ParseOneCharToken(state, 'V');
-  num_cv_qualifiers += ParseOneCharToken(state, 'K');
-  return num_cv_qualifiers > 0;
-}
-
-// <builtin-type> ::= v, etc.
-//                ::= u <source-name>
-static bool ParseBuiltinType(State *state) {
-  const AbbrevPair *p;
-  for (p = kBuiltinTypeList; p->abbrev != NULL; ++p) {
-    if (state->mangled_cur[0] == p->abbrev[0]) {
-      MaybeAppend(state, p->real_name);
-      ++state->mangled_cur;
-      return true;
-    }
-  }
-
-  State copy = *state;
-  if (ParseOneCharToken(state, 'u') && ParseSourceName(state)) {
-    return true;
-  }
-  *state = copy;
-  return false;
-}
-
-// <function-type> ::= F [Y] <bare-function-type> E
-static bool ParseFunctionType(State *state) {
-  State copy = *state;
-  if (ParseOneCharToken(state, 'F') &&
-      Optional(ParseOneCharToken(state, 'Y')) &&
-      ParseBareFunctionType(state) && ParseOneCharToken(state, 'E')) {
-    return true;
-  }
-  *state = copy;
-  return false;
-}
-
-// <bare-function-type> ::= <(signature) type>+
-static bool ParseBareFunctionType(State *state) {
-  State copy = *state;
-  DisableAppend(state);
-  if (OneOrMore(ParseType, state)) {
-    RestoreAppend(state, copy.append);
-    MaybeAppend(state, "()");
-    return true;
-  }
-  *state = copy;
-  return false;
-}
-
-// <class-enum-type> ::= <name>
-static bool ParseClassEnumType(State *state) {
-  return ParseName(state);
-}
-
-// <array-type> ::= A <(positive dimension) number> _ <(element) type>
-//              ::= A [<(dimension) expression>] _ <(element) type>
-static bool ParseArrayType(State *state) {
-  State copy = *state;
-  if (ParseOneCharToken(state, 'A') && ParseNumber(state, NULL) &&
-      ParseOneCharToken(state, '_') && ParseType(state)) {
-    return true;
-  }
-  *state = copy;
-
-  if (ParseOneCharToken(state, 'A') && Optional(ParseExpression(state)) &&
-      ParseOneCharToken(state, '_') && ParseType(state)) {
-    return true;
-  }
-  *state = copy;
-  return false;
-}
-
-// <pointer-to-member-type> ::= M <(class) type> <(member) type>
-static bool ParsePointerToMemberType(State *state) {
-  State copy = *state;
-  if (ParseOneCharToken(state, 'M') && ParseType(state) &&
-      ParseType(state)) {
-    return true;
-  }
-  *state = copy;
-  return false;
-}
-
-// <template-param> ::= T_
-//                  ::= T <parameter-2 non-negative number> _
-static bool ParseTemplateParam(State *state) {
-  if (ParseTwoCharToken(state, "T_")) {
-    MaybeAppend(state, "?");  // We don't support template substitutions.
-    return true;
-  }
-
-  State copy = *state;
-  if (ParseOneCharToken(state, 'T') && ParseNumber(state, NULL) &&
-      ParseOneCharToken(state, '_')) {
-    MaybeAppend(state, "?");  // We don't support template substitutions.
-    return true;
-  }
-  *state = copy;
-  return false;
-}
-
-
-// <template-template-param> ::= <template-param>
-//                           ::= <substitution>
-static bool ParseTemplateTemplateParam(State *state) {
-  return (ParseTemplateParam(state) ||
-          ParseSubstitution(state));
-}
-
-// <template-args> ::= I <template-arg>+ E
-static bool ParseTemplateArgs(State *state) {
-  State copy = *state;
-  DisableAppend(state);
-  if (ParseOneCharToken(state, 'I') &&
-      OneOrMore(ParseTemplateArg, state) &&
-      ParseOneCharToken(state, 'E')) {
-    RestoreAppend(state, copy.append);
-    MaybeAppend(state, "<>");
-    return true;
-  }
-  *state = copy;
-  return false;
-}
-
-// <template-arg>  ::= <type>
-//                 ::= <expr-primary>
-//                 ::= I <template-arg>* E        # argument pack
-//                 ::= X <expression> E
-static bool ParseTemplateArg(State *state) {
-  State copy = *state;
-  if (ParseOneCharToken(state, 'I') &&
-      ZeroOrMore(ParseTemplateArg, state) &&
-      ParseOneCharToken(state, 'E')) {
-    return true;
-  }
-  *state = copy;
-
-  if (ParseType(state) ||
-      ParseExprPrimary(state)) {
-    return true;
-  }
-  *state = copy;
-
-  if (ParseOneCharToken(state, 'X') && ParseExpression(state) &&
-      ParseOneCharToken(state, 'E')) {
-    return true;
-  }
-  *state = copy;
-  return false;
-}
-
-// <expression> ::= <template-param>
-//              ::= <expr-primary>
-//              ::= <unary operator-name> <expression>
-//              ::= <binary operator-name> <expression> <expression>
-//              ::= <trinary operator-name> <expression> <expression>
-//                  <expression>
-//              ::= st <type>
-//              ::= sr <type> <unqualified-name> <template-args>
-//              ::= sr <type> <unqualified-name>
-static bool ParseExpression(State *state) {
-  if (ParseTemplateParam(state) || ParseExprPrimary(state)) {
-    return true;
-  }
-
-  State copy = *state;
-  if (ParseOperatorName(state) &&
-      ParseExpression(state) &&
-      ParseExpression(state) &&
-      ParseExpression(state)) {
-    return true;
-  }
-  *state = copy;
-
-  if (ParseOperatorName(state) &&
-      ParseExpression(state) &&
-      ParseExpression(state)) {
-    return true;
-  }
-  *state = copy;
-
-  if (ParseOperatorName(state) &&
-      ParseExpression(state)) {
-    return true;
-  }
-  *state = copy;
-
-  if (ParseTwoCharToken(state, "st") && ParseType(state)) {
-    return true;
-  }
-  *state = copy;
-
-  if (ParseTwoCharToken(state, "sr") && ParseType(state) &&
-      ParseUnqualifiedName(state) &&
-      ParseTemplateArgs(state)) {
-    return true;
-  }
-  *state = copy;
-
-  if (ParseTwoCharToken(state, "sr") && ParseType(state) &&
-      ParseUnqualifiedName(state)) {
-    return true;
-  }
-  *state = copy;
-  return false;
-}
-
-// <expr-primary> ::= L <type> <(value) number> E
-//                ::= L <type> <(value) float> E
-//                ::= L <mangled-name> E
-//                // A bug in g++'s C++ ABI version 2 (-fabi-version=2).
-//                ::= LZ <encoding> E
-static bool ParseExprPrimary(State *state) {
-  State copy = *state;
-  if (ParseOneCharToken(state, 'L') && ParseType(state) &&
-      ParseNumber(state, NULL) &&
-      ParseOneCharToken(state, 'E')) {
-    return true;
-  }
-  *state = copy;
-
-  if (ParseOneCharToken(state, 'L') && ParseType(state) &&
-      ParseFloatNumber(state) &&
-      ParseOneCharToken(state, 'E')) {
-    return true;
-  }
-  *state = copy;
-
-  if (ParseOneCharToken(state, 'L') && ParseMangledName(state) &&
-      ParseOneCharToken(state, 'E')) {
-    return true;
-  }
-  *state = copy;
-
-  if (ParseTwoCharToken(state, "LZ") && ParseEncoding(state) &&
-      ParseOneCharToken(state, 'E')) {
-    return true;
-  }
-  *state = copy;
-
-  return false;
-}
-
-// <local-name> := Z <(function) encoding> E <(entity) name>
-//                 [<discriminator>]
-//              := Z <(function) encoding> E s [<discriminator>]
-static bool ParseLocalName(State *state) {
-  State copy = *state;
-  if (ParseOneCharToken(state, 'Z') && ParseEncoding(state) &&
-      ParseOneCharToken(state, 'E') && MaybeAppend(state, "::") &&
-      ParseName(state) && Optional(ParseDiscriminator(state))) {
-    return true;
-  }
-  *state = copy;
-
-  if (ParseOneCharToken(state, 'Z') && ParseEncoding(state) &&
-      ParseTwoCharToken(state, "Es") && Optional(ParseDiscriminator(state))) {
-    return true;
-  }
-  *state = copy;
-  return false;
-}
-
-// <discriminator> := _ <(non-negative) number>
-static bool ParseDiscriminator(State *state) {
-  State copy = *state;
-  if (ParseOneCharToken(state, '_') && ParseNumber(state, NULL)) {
-    return true;
-  }
-  *state = copy;
-  return false;
-}
-
-// <substitution> ::= S_
-//                ::= S <seq-id> _
-//                ::= St, etc.
-static bool ParseSubstitution(State *state) {
-  if (ParseTwoCharToken(state, "S_")) {
-    MaybeAppend(state, "?");  // We don't support substitutions.
-    return true;
-  }
-
-  State copy = *state;
-  if (ParseOneCharToken(state, 'S') && ParseSeqId(state) &&
-      ParseOneCharToken(state, '_')) {
-    MaybeAppend(state, "?");  // We don't support substitutions.
-    return true;
-  }
-  *state = copy;
-
-  // Expand abbreviations like "St" => "std".
-  if (ParseOneCharToken(state, 'S')) {
-    const AbbrevPair *p;
-    for (p = kSubstitutionList; p->abbrev != NULL; ++p) {
-      if (state->mangled_cur[0] == p->abbrev[1]) {
-        MaybeAppend(state, "std");
-        if (p->real_name[0] != '\0') {
-          MaybeAppend(state, "::");
-          MaybeAppend(state, p->real_name);
-        }
-        ++state->mangled_cur;
-        return true;
-      }
-    }
-  }
-  *state = copy;
-  return false;
-}
-
-// Parse <mangled-name>, optionally followed by either a function-clone suffix
-// or version suffix.  Returns true only if all of "mangled_cur" was consumed.
-static bool ParseTopLevelMangledName(State *state) {
-  if (ParseMangledName(state)) {
-    if (state->mangled_cur[0] != '\0') {
-      // Drop trailing function clone suffix, if any.
-      if (IsFunctionCloneSuffix(state->mangled_cur)) {
-        return true;
-      }
-      // Append trailing version suffix if any.
-      // ex. _Z3foo@@GLIBCXX_3.4
-      if (state->mangled_cur[0] == '@') {
-        MaybeAppend(state, state->mangled_cur);
-        return true;
-      }
-      return false;  // Unconsumed suffix.
-    }
-    return true;
-  }
-  return false;
-}
-
-// The demangler entry point.
-bool Demangle(const char *mangled, char *out, int out_size) {
-  State state;
-  InitState(&state, mangled, out, out_size);
-  return ParseTopLevelMangledName(&state) && !state.overflowed;
-}
-
-_END_GOOGLE_NAMESPACE_
diff --git a/base/third_party/symbolize/demangle.h b/base/third_party/symbolize/demangle.h
deleted file mode 100644
index 9c75915..0000000
--- a/base/third_party/symbolize/demangle.h
+++ /dev/null
@@ -1,84 +0,0 @@
-// Copyright (c) 2006, Google Inc.
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Author: Satoru Takabayashi
-//
-// An async-signal-safe and thread-safe demangler for Itanium C++ ABI
-// (aka G++ V3 ABI).
-
-// The demangler is implemented to be used in async signal handlers to
-// symbolize stack traces.  We cannot use libstdc++'s
-// abi::__cxa_demangle() in such signal handlers since it's not async
-// signal safe (it uses malloc() internally).
-//
-// Note that this demangler doesn't support full demangling.  More
-// specifically, it doesn't print types of function parameters and
-// types of template arguments.  It just skips them.  However, it's
-// still very useful to extract basic information such as class,
-// function, constructor, destructor, and operator names.
-//
-// See the implementation note in demangle.cc if you are interested.
-//
-// Example:
-//
-// | Mangled Name  | The Demangler | abi::__cxa_demangle()
-// |---------------|---------------|-----------------------
-// | _Z1fv         | f()           | f()
-// | _Z1fi         | f()           | f(int)
-// | _Z3foo3bar    | foo()         | foo(bar)
-// | _Z1fIiEvi     | f<>()         | void f<int>(int)
-// | _ZN1N1fE      | N::f          | N::f
-// | _ZN3Foo3BarEv | Foo::Bar()    | Foo::Bar()
-// | _Zrm1XS_"     | operator%()   | operator%(X, X)
-// | _ZN3FooC1Ev   | Foo::Foo()    | Foo::Foo()
-// | _Z1fSs        | f()           | f(std::basic_string<char,
-// |               |               |   std::char_traits<char>,
-// |               |               |   std::allocator<char> >)
-//
-// See the unit test for more examples.
-//
-// Note: we might want to write demanglers for ABIs other than Itanium
-// C++ ABI in the future.
-//
-
-#ifndef BASE_DEMANGLE_H_
-#define BASE_DEMANGLE_H_
-
-#include "config.h"
-
-_START_GOOGLE_NAMESPACE_
-
-// Demangle "mangled".  On success, return true and write the
-// demangled symbol name to "out".  Otherwise, return false.
-// "out" is modified even if demangling is unsuccessful.
-bool Demangle(const char *mangled, char *out, int out_size);
-
-_END_GOOGLE_NAMESPACE_
-
-#endif  // BASE_DEMANGLE_H_
diff --git a/base/third_party/symbolize/glog/logging.h b/base/third_party/symbolize/glog/logging.h
deleted file mode 100644
index a42c306..0000000
--- a/base/third_party/symbolize/glog/logging.h
+++ /dev/null
@@ -1,5 +0,0 @@
-// Copyright (c) 2010 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.
-
-// Empty.
diff --git a/base/third_party/symbolize/glog/raw_logging.h b/base/third_party/symbolize/glog/raw_logging.h
deleted file mode 100644
index f5515c4..0000000
--- a/base/third_party/symbolize/glog/raw_logging.h
+++ /dev/null
@@ -1,6 +0,0 @@
-// Copyright (c) 2010 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.
-
-#define WARNING 1;
-#define RAW_LOG(severity, ...);  // Do nothing.
diff --git a/base/third_party/symbolize/symbolize.cc b/base/third_party/symbolize/symbolize.cc
deleted file mode 100644
index e6fbb84..0000000
--- a/base/third_party/symbolize/symbolize.cc
+++ /dev/null
@@ -1,883 +0,0 @@
-// Copyright (c) 2006, Google Inc.
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Author: Satoru Takabayashi
-// Stack-footprint reduction work done by Raksit Ashok
-//
-// Implementation note:
-//
-// We don't use heaps but only use stacks.  We want to reduce the
-// stack consumption so that the symbolizer can run on small stacks.
-//
-// Here are some numbers collected with GCC 4.1.0 on x86:
-// - sizeof(Elf32_Sym)  = 16
-// - sizeof(Elf32_Shdr) = 40
-// - sizeof(Elf64_Sym)  = 24
-// - sizeof(Elf64_Shdr) = 64
-//
-// This implementation is intended to be async-signal-safe but uses
-// some functions which are not guaranteed to be so, such as memchr()
-// and memmove().  We assume they are async-signal-safe.
-//
-// Additional header can be specified by the GLOG_BUILD_CONFIG_INCLUDE
-// macro to add platform specific defines (e.g. OS_OPENBSD).
-
-#ifdef GLOG_BUILD_CONFIG_INCLUDE
-#include GLOG_BUILD_CONFIG_INCLUDE
-#endif  // GLOG_BUILD_CONFIG_INCLUDE
-
-#include "utilities.h"
-
-#if defined(HAVE_SYMBOLIZE)
-
-#include <string.h>
-
-#include <algorithm>
-#include <limits>
-
-#include "symbolize.h"
-#include "demangle.h"
-
-_START_GOOGLE_NAMESPACE_
-
-// We don't use assert() since it's not guaranteed to be
-// async-signal-safe.  Instead we define a minimal assertion
-// macro. So far, we don't need pretty printing for __FILE__, etc.
-
-// A wrapper for abort() to make it callable in ? :.
-static int AssertFail() {
-  abort();
-  return 0;  // Should not reach.
-}
-
-#define SAFE_ASSERT(expr) ((expr) ? 0 : AssertFail())
-
-static SymbolizeCallback g_symbolize_callback = NULL;
-void InstallSymbolizeCallback(SymbolizeCallback callback) {
-  g_symbolize_callback = callback;
-}
-
-static SymbolizeOpenObjectFileCallback g_symbolize_open_object_file_callback =
-    NULL;
-void InstallSymbolizeOpenObjectFileCallback(
-    SymbolizeOpenObjectFileCallback callback) {
-  g_symbolize_open_object_file_callback = callback;
-}
-
-// This function wraps the Demangle function to provide an interface
-// where the input symbol is demangled in-place.
-// To keep stack consumption low, we would like this function to not
-// get inlined.
-static ATTRIBUTE_NOINLINE void DemangleInplace(char *out, int out_size) {
-  char demangled[256];  // Big enough for sane demangled symbols.
-  if (Demangle(out, demangled, sizeof(demangled))) {
-    // Demangling succeeded. Copy to out if the space allows.
-    size_t len = strlen(demangled);
-    if (len + 1 <= (size_t)out_size) {  // +1 for '\0'.
-      SAFE_ASSERT(len < sizeof(demangled));
-      memmove(out, demangled, len + 1);
-    }
-  }
-}
-
-_END_GOOGLE_NAMESPACE_
-
-#if defined(__ELF__)
-
-#include <dlfcn.h>
-#if defined(OS_OPENBSD)
-#include <sys/exec_elf.h>
-#else
-#include <elf.h>
-#endif
-#include <errno.h>
-#include <fcntl.h>
-#include <limits.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <stddef.h>
-#include <string.h>
-#include <sys/stat.h>
-#include <sys/types.h>
-#include <unistd.h>
-
-#include "symbolize.h"
-#include "config.h"
-#include "glog/raw_logging.h"
-
-// Re-runs fn until it doesn't cause EINTR.
-#define NO_INTR(fn)   do {} while ((fn) < 0 && errno == EINTR)
-
-_START_GOOGLE_NAMESPACE_
-
-// Read up to "count" bytes from file descriptor "fd" into the buffer
-// starting at "buf" while handling short reads and EINTR.  On
-// success, return the number of bytes read.  Otherwise, return -1.
-static ssize_t ReadPersistent(const int fd, void *buf, const size_t count) {
-  SAFE_ASSERT(fd >= 0);
-  SAFE_ASSERT(count <= std::numeric_limits<ssize_t>::max());
-  char *buf0 = reinterpret_cast<char *>(buf);
-  ssize_t num_bytes = 0;
-  while (num_bytes < count) {
-    ssize_t len;
-    NO_INTR(len = read(fd, buf0 + num_bytes, count - num_bytes));
-    if (len < 0) {  // There was an error other than EINTR.
-      return -1;
-    }
-    if (len == 0) {  // Reached EOF.
-      break;
-    }
-    num_bytes += len;
-  }
-  SAFE_ASSERT(num_bytes <= count);
-  return num_bytes;
-}
-
-// Read up to "count" bytes from "offset" in the file pointed by file
-// descriptor "fd" into the buffer starting at "buf".  On success,
-// return the number of bytes read.  Otherwise, return -1.
-static ssize_t ReadFromOffset(const int fd, void *buf,
-                              const size_t count, const off_t offset) {
-  off_t off = lseek(fd, offset, SEEK_SET);
-  if (off == (off_t)-1) {
-    return -1;
-  }
-  return ReadPersistent(fd, buf, count);
-}
-
-// Try reading exactly "count" bytes from "offset" bytes in a file
-// pointed by "fd" into the buffer starting at "buf" while handling
-// short reads and EINTR.  On success, return true. Otherwise, return
-// false.
-static bool ReadFromOffsetExact(const int fd, void *buf,
-                                const size_t count, const off_t offset) {
-  ssize_t len = ReadFromOffset(fd, buf, count, offset);
-  return len == count;
-}
-
-// Returns elf_header.e_type if the file pointed by fd is an ELF binary.
-static int FileGetElfType(const int fd) {
-  ElfW(Ehdr) elf_header;
-  if (!ReadFromOffsetExact(fd, &elf_header, sizeof(elf_header), 0)) {
-    return -1;
-  }
-  if (memcmp(elf_header.e_ident, ELFMAG, SELFMAG) != 0) {
-    return -1;
-  }
-  return elf_header.e_type;
-}
-
-// Read the section headers in the given ELF binary, and if a section
-// of the specified type is found, set the output to this section header
-// and return true.  Otherwise, return false.
-// To keep stack consumption low, we would like this function to not get
-// inlined.
-static ATTRIBUTE_NOINLINE bool
-GetSectionHeaderByType(const int fd, ElfW(Half) sh_num, const off_t sh_offset,
-                       ElfW(Word) type, ElfW(Shdr) *out) {
-  // Read at most 16 section headers at a time to save read calls.
-  ElfW(Shdr) buf[16];
-  for (int i = 0; i < sh_num;) {
-    const ssize_t num_bytes_left = (sh_num - i) * sizeof(buf[0]);
-    const ssize_t num_bytes_to_read =
-        (sizeof(buf) > num_bytes_left) ? num_bytes_left : sizeof(buf);
-    const ssize_t len = ReadFromOffset(fd, buf, num_bytes_to_read,
-                                       sh_offset + i * sizeof(buf[0]));
-    SAFE_ASSERT(len % sizeof(buf[0]) == 0);
-    const ssize_t num_headers_in_buf = len / sizeof(buf[0]);
-    SAFE_ASSERT(num_headers_in_buf <= sizeof(buf) / sizeof(buf[0]));
-    for (int j = 0; j < num_headers_in_buf; ++j) {
-      if (buf[j].sh_type == type) {
-        *out = buf[j];
-        return true;
-      }
-    }
-    i += num_headers_in_buf;
-  }
-  return false;
-}
-
-// There is no particular reason to limit section name to 63 characters,
-// but there has (as yet) been no need for anything longer either.
-const int kMaxSectionNameLen = 64;
-
-// name_len should include terminating '\0'.
-bool GetSectionHeaderByName(int fd, const char *name, size_t name_len,
-                            ElfW(Shdr) *out) {
-  ElfW(Ehdr) elf_header;
-  if (!ReadFromOffsetExact(fd, &elf_header, sizeof(elf_header), 0)) {
-    return false;
-  }
-
-  ElfW(Shdr) shstrtab;
-  off_t shstrtab_offset = (elf_header.e_shoff +
-                           elf_header.e_shentsize * elf_header.e_shstrndx);
-  if (!ReadFromOffsetExact(fd, &shstrtab, sizeof(shstrtab), shstrtab_offset)) {
-    return false;
-  }
-
-  for (int i = 0; i < elf_header.e_shnum; ++i) {
-    off_t section_header_offset = (elf_header.e_shoff +
-                                   elf_header.e_shentsize * i);
-    if (!ReadFromOffsetExact(fd, out, sizeof(*out), section_header_offset)) {
-      return false;
-    }
-    char header_name[kMaxSectionNameLen];
-    if (sizeof(header_name) < name_len) {
-      RAW_LOG(WARNING, "Section name '%s' is too long (%" PRIuS "); "
-              "section will not be found (even if present).", name, name_len);
-      // No point in even trying.
-      return false;
-    }
-    off_t name_offset = shstrtab.sh_offset + out->sh_name;
-    ssize_t n_read = ReadFromOffset(fd, &header_name, name_len, name_offset);
-    if (n_read == -1) {
-      return false;
-    } else if (n_read != name_len) {
-      // Short read -- name could be at end of file.
-      continue;
-    }
-    if (memcmp(header_name, name, name_len) == 0) {
-      return true;
-    }
-  }
-  return false;
-}
-
-// Read a symbol table and look for the symbol containing the
-// pc. Iterate over symbols in a symbol table and look for the symbol
-// containing "pc".  On success, return true and write the symbol name
-// to out.  Otherwise, return false.
-// To keep stack consumption low, we would like this function to not get
-// inlined.
-static ATTRIBUTE_NOINLINE bool
-FindSymbol(uint64_t pc, const int fd, char *out, int out_size,
-           uint64_t symbol_offset, const ElfW(Shdr) *strtab,
-           const ElfW(Shdr) *symtab) {
-  if (symtab == NULL) {
-    return false;
-  }
-  const int num_symbols = symtab->sh_size / symtab->sh_entsize;
-  for (int i = 0; i < num_symbols;) {
-    off_t offset = symtab->sh_offset + i * symtab->sh_entsize;
-
-    // If we are reading Elf64_Sym's, we want to limit this array to
-    // 32 elements (to keep stack consumption low), otherwise we can
-    // have a 64 element Elf32_Sym array.
-#if __WORDSIZE == 64
-#define NUM_SYMBOLS 32
-#else
-#define NUM_SYMBOLS 64
-#endif
-
-    // Read at most NUM_SYMBOLS symbols at once to save read() calls.
-    ElfW(Sym) buf[NUM_SYMBOLS];
-    int num_symbols_to_read = std::min(NUM_SYMBOLS, num_symbols - i);
-    const ssize_t len =
-        ReadFromOffset(fd, &buf, sizeof(buf[0]) * num_symbols_to_read, offset);
-    SAFE_ASSERT(len % sizeof(buf[0]) == 0);
-    const ssize_t num_symbols_in_buf = len / sizeof(buf[0]);
-    SAFE_ASSERT(num_symbols_in_buf <= num_symbols_to_read);
-    for (int j = 0; j < num_symbols_in_buf; ++j) {
-      const ElfW(Sym)& symbol = buf[j];
-      uint64_t start_address = symbol.st_value;
-      start_address += symbol_offset;
-      uint64_t end_address = start_address + symbol.st_size;
-      if (symbol.st_value != 0 &&  // Skip null value symbols.
-          symbol.st_shndx != 0 &&  // Skip undefined symbols.
-          start_address <= pc && pc < end_address) {
-        ssize_t len1 = ReadFromOffset(fd, out, out_size,
-                                      strtab->sh_offset + symbol.st_name);
-        if (len1 <= 0 || memchr(out, '\0', out_size) == NULL) {
-          return false;
-        }
-        return true;  // Obtained the symbol name.
-      }
-    }
-    i += num_symbols_in_buf;
-  }
-  return false;
-}
-
-// Get the symbol name of "pc" from the file pointed by "fd".  Process
-// both regular and dynamic symbol tables if necessary.  On success,
-// write the symbol name to "out" and return true.  Otherwise, return
-// false.
-static bool GetSymbolFromObjectFile(const int fd,
-                                    uint64_t pc,
-                                    char* out,
-                                    int out_size,
-                                    uint64_t base_address) {
-  // Read the ELF header.
-  ElfW(Ehdr) elf_header;
-  if (!ReadFromOffsetExact(fd, &elf_header, sizeof(elf_header), 0)) {
-    return false;
-  }
-
-  ElfW(Shdr) symtab, strtab;
-
-  // Consult a regular symbol table first.
-  if (GetSectionHeaderByType(fd, elf_header.e_shnum, elf_header.e_shoff,
-                             SHT_SYMTAB, &symtab)) {
-    if (!ReadFromOffsetExact(fd, &strtab, sizeof(strtab), elf_header.e_shoff +
-                             symtab.sh_link * sizeof(symtab))) {
-      return false;
-    }
-    if (FindSymbol(pc, fd, out, out_size, base_address, &strtab, &symtab)) {
-      return true;  // Found the symbol in a regular symbol table.
-    }
-  }
-
-  // If the symbol is not found, then consult a dynamic symbol table.
-  if (GetSectionHeaderByType(fd, elf_header.e_shnum, elf_header.e_shoff,
-                             SHT_DYNSYM, &symtab)) {
-    if (!ReadFromOffsetExact(fd, &strtab, sizeof(strtab), elf_header.e_shoff +
-                             symtab.sh_link * sizeof(symtab))) {
-      return false;
-    }
-    if (FindSymbol(pc, fd, out, out_size, base_address, &strtab, &symtab)) {
-      return true;  // Found the symbol in a dynamic symbol table.
-    }
-  }
-
-  return false;
-}
-
-namespace {
-// Thin wrapper around a file descriptor so that the file descriptor
-// gets closed for sure.
-struct FileDescriptor {
-  const int fd_;
-  explicit FileDescriptor(int fd) : fd_(fd) {}
-  ~FileDescriptor() {
-    if (fd_ >= 0) {
-      NO_INTR(close(fd_));
-    }
-  }
-  int get() { return fd_; }
-
- private:
-  explicit FileDescriptor(const FileDescriptor&);
-  void operator=(const FileDescriptor&);
-};
-
-// Helper class for reading lines from file.
-//
-// Note: we don't use ProcMapsIterator since the object is big (it has
-// a 5k array member) and uses async-unsafe functions such as sscanf()
-// and snprintf().
-class LineReader {
- public:
-  explicit LineReader(int fd, char *buf, int buf_len) : fd_(fd),
-    buf_(buf), buf_len_(buf_len), bol_(buf), eol_(buf), eod_(buf) {
-  }
-
-  // Read '\n'-terminated line from file.  On success, modify "bol"
-  // and "eol", then return true.  Otherwise, return false.
-  //
-  // Note: if the last line doesn't end with '\n', the line will be
-  // dropped.  It's an intentional behavior to make the code simple.
-  bool ReadLine(const char **bol, const char **eol) {
-    if (BufferIsEmpty()) {  // First time.
-      const ssize_t num_bytes = ReadPersistent(fd_, buf_, buf_len_);
-      if (num_bytes <= 0) {  // EOF or error.
-        return false;
-      }
-      eod_ = buf_ + num_bytes;
-      bol_ = buf_;
-    } else {
-      bol_ = eol_ + 1;  // Advance to the next line in the buffer.
-      SAFE_ASSERT(bol_ <= eod_);  // "bol_" can point to "eod_".
-      if (!HasCompleteLine()) {
-        const int incomplete_line_length = eod_ - bol_;
-        // Move the trailing incomplete line to the beginning.
-        memmove(buf_, bol_, incomplete_line_length);
-        // Read text from file and append it.
-        char * const append_pos = buf_ + incomplete_line_length;
-        const int capacity_left = buf_len_ - incomplete_line_length;
-        const ssize_t num_bytes = ReadPersistent(fd_, append_pos,
-                                                 capacity_left);
-        if (num_bytes <= 0) {  // EOF or error.
-          return false;
-        }
-        eod_ = append_pos + num_bytes;
-        bol_ = buf_;
-      }
-    }
-    eol_ = FindLineFeed();
-    if (eol_ == NULL) {  // '\n' not found.  Malformed line.
-      return false;
-    }
-    *eol_ = '\0';  // Replace '\n' with '\0'.
-
-    *bol = bol_;
-    *eol = eol_;
-    return true;
-  }
-
-  // Beginning of line.
-  const char *bol() {
-    return bol_;
-  }
-
-  // End of line.
-  const char *eol() {
-    return eol_;
-  }
-
- private:
-  explicit LineReader(const LineReader&);
-  void operator=(const LineReader&);
-
-  char *FindLineFeed() {
-    return reinterpret_cast<char *>(memchr(bol_, '\n', eod_ - bol_));
-  }
-
-  bool BufferIsEmpty() {
-    return buf_ == eod_;
-  }
-
-  bool HasCompleteLine() {
-    return !BufferIsEmpty() && FindLineFeed() != NULL;
-  }
-
-  const int fd_;
-  char * const buf_;
-  const int buf_len_;
-  char *bol_;
-  char *eol_;
-  const char *eod_;  // End of data in "buf_".
-};
-}  // namespace
-
-// Place the hex number read from "start" into "*hex".  The pointer to
-// the first non-hex character or "end" is returned.
-static char *GetHex(const char *start, const char *end, uint64_t *hex) {
-  *hex = 0;
-  const char *p;
-  for (p = start; p < end; ++p) {
-    int ch = *p;
-    if ((ch >= '0' && ch <= '9') ||
-        (ch >= 'A' && ch <= 'F') || (ch >= 'a' && ch <= 'f')) {
-      *hex = (*hex << 4) | (ch < 'A' ? ch - '0' : (ch & 0xF) + 9);
-    } else {  // Encountered the first non-hex character.
-      break;
-    }
-  }
-  SAFE_ASSERT(p <= end);
-  return const_cast<char *>(p);
-}
-
-// Searches for the object file (from /proc/self/maps) that contains
-// the specified pc.  If found, sets |start_address| to the start address
-// of where this object file is mapped in memory, sets the module base
-// address into |base_address|, copies the object file name into
-// |out_file_name|, and attempts to open the object file.  If the object
-// file is opened successfully, returns the file descriptor.  Otherwise,
-// returns -1.  |out_file_name_size| is the size of the file name buffer
-// (including the null-terminator).
-static ATTRIBUTE_NOINLINE int
-OpenObjectFileContainingPcAndGetStartAddress(uint64_t pc,
-                                             uint64_t &start_address,
-                                             uint64_t &base_address,
-                                             char *out_file_name,
-                                             int out_file_name_size) {
-  int object_fd;
-
-  int maps_fd;
-  NO_INTR(maps_fd = open("/proc/self/maps", O_RDONLY));
-  FileDescriptor wrapped_maps_fd(maps_fd);
-  if (wrapped_maps_fd.get() < 0) {
-    return -1;
-  }
-
-  int mem_fd;
-  NO_INTR(mem_fd = open("/proc/self/mem", O_RDONLY));
-  FileDescriptor wrapped_mem_fd(mem_fd);
-  if (wrapped_mem_fd.get() < 0) {
-    return -1;
-  }
-
-  // Iterate over maps and look for the map containing the pc.  Then
-  // look into the symbol tables inside.
-  char buf[1024];  // Big enough for line of sane /proc/self/maps
-  int num_maps = 0;
-  LineReader reader(wrapped_maps_fd.get(), buf, sizeof(buf));
-  while (true) {
-    num_maps++;
-    const char *cursor;
-    const char *eol;
-    if (!reader.ReadLine(&cursor, &eol)) {  // EOF or malformed line.
-      return -1;
-    }
-
-    // Start parsing line in /proc/self/maps.  Here is an example:
-    //
-    // 08048000-0804c000 r-xp 00000000 08:01 2142121    /bin/cat
-    //
-    // We want start address (08048000), end address (0804c000), flags
-    // (r-xp) and file name (/bin/cat).
-
-    // Read start address.
-    cursor = GetHex(cursor, eol, &start_address);
-    if (cursor == eol || *cursor != '-') {
-      return -1;  // Malformed line.
-    }
-    ++cursor;  // Skip '-'.
-
-    // Read end address.
-    uint64_t end_address;
-    cursor = GetHex(cursor, eol, &end_address);
-    if (cursor == eol || *cursor != ' ') {
-      return -1;  // Malformed line.
-    }
-    ++cursor;  // Skip ' '.
-
-    // Read flags.  Skip flags until we encounter a space or eol.
-    const char * const flags_start = cursor;
-    while (cursor < eol && *cursor != ' ') {
-      ++cursor;
-    }
-    // We expect at least four letters for flags (ex. "r-xp").
-    if (cursor == eol || cursor < flags_start + 4) {
-      return -1;  // Malformed line.
-    }
-
-    // Determine the base address by reading ELF headers in process memory.
-    ElfW(Ehdr) ehdr;
-    if (flags_start[0] == 'r' &&
-        ReadFromOffsetExact(mem_fd, &ehdr, sizeof(ElfW(Ehdr)), start_address) &&
-        memcmp(ehdr.e_ident, ELFMAG, SELFMAG) == 0) {
-      switch (ehdr.e_type) {
-        case ET_EXEC:
-          base_address = 0;
-          break;
-        case ET_DYN:
-          // Find the segment containing file offset 0. This will correspond
-          // to the ELF header that we just read. Normally this will have
-          // virtual address 0, but this is not guaranteed. We must subtract
-          // the virtual address from the address where the ELF header was
-          // mapped to get the base address.
-          //
-          // If we fail to find a segment for file offset 0, use the address
-          // of the ELF header as the base address.
-          base_address = start_address;
-          for (unsigned i = 0; i != ehdr.e_phnum; ++i) {
-            ElfW(Phdr) phdr;
-            if (ReadFromOffsetExact(
-                    mem_fd, &phdr, sizeof(phdr),
-                    start_address + ehdr.e_phoff + i * sizeof(phdr)) &&
-                phdr.p_type == PT_LOAD && phdr.p_offset == 0) {
-              base_address = start_address - phdr.p_vaddr;
-              break;
-            }
-          }
-          break;
-        default:
-          // ET_REL or ET_CORE. These aren't directly executable, so they don't
-          // affect the base address.
-          break;
-      }
-    }
-
-    // Check start and end addresses.
-    if (!(start_address <= pc && pc < end_address)) {
-      continue;  // We skip this map.  PC isn't in this map.
-    }
-
-    // Check flags.  We are only interested in "r-x" maps.
-    if (memcmp(flags_start, "r-x", 3) != 0) {  // Not a "r-x" map.
-      continue;  // We skip this map.
-    }
-    ++cursor;  // Skip ' '.
-
-    // Read file offset.
-    uint64_t file_offset;
-    cursor = GetHex(cursor, eol, &file_offset);
-    if (cursor == eol || *cursor != ' ') {
-      return -1;  // Malformed line.
-    }
-    ++cursor;  // Skip ' '.
-
-    // Skip to file name.  "cursor" now points to dev.  We need to
-    // skip at least two spaces for dev and inode.
-    int num_spaces = 0;
-    while (cursor < eol) {
-      if (*cursor == ' ') {
-        ++num_spaces;
-      } else if (num_spaces >= 2) {
-        // The first non-space character after skipping two spaces
-        // is the beginning of the file name.
-        break;
-      }
-      ++cursor;
-    }
-    if (cursor == eol) {
-      return -1;  // Malformed line.
-    }
-
-    // Finally, "cursor" now points to file name of our interest.
-    NO_INTR(object_fd = open(cursor, O_RDONLY));
-    if (object_fd < 0) {
-      // Failed to open object file.  Copy the object file name to
-      // |out_file_name|.
-      strncpy(out_file_name, cursor, out_file_name_size);
-      // Making sure |out_file_name| is always null-terminated.
-      out_file_name[out_file_name_size - 1] = '\0';
-      return -1;
-    }
-    return object_fd;
-  }
-}
-
-// POSIX doesn't define any async-signal safe function for converting
-// an integer to ASCII. We'll have to define our own version.
-// itoa_r() converts a (signed) integer to ASCII. It returns "buf", if the
-// conversion was successful or NULL otherwise. It never writes more than "sz"
-// bytes. Output will be truncated as needed, and a NUL character is always
-// appended.
-// NOTE: code from sandbox/linux/seccomp-bpf/demo.cc.
-char *itoa_r(intptr_t i, char *buf, size_t sz, int base, size_t padding) {
-  // Make sure we can write at least one NUL byte.
-  size_t n = 1;
-  if (n > sz)
-    return NULL;
-
-  if (base < 2 || base > 16) {
-    buf[0] = '\000';
-    return NULL;
-  }
-
-  char *start = buf;
-
-  uintptr_t j = i;
-
-  // Handle negative numbers (only for base 10).
-  if (i < 0 && base == 10) {
-    // This does "j = -i" while avoiding integer overflow.
-    j = static_cast<uintptr_t>(-(i + 1)) + 1;
-
-    // Make sure we can write the '-' character.
-    if (++n > sz) {
-      buf[0] = '\000';
-      return NULL;
-    }
-    *start++ = '-';
-  }
-
-  // Loop until we have converted the entire number. Output at least one
-  // character (i.e. '0').
-  char *ptr = start;
-  do {
-    // Make sure there is still enough space left in our output buffer.
-    if (++n > sz) {
-      buf[0] = '\000';
-      return NULL;
-    }
-
-    // Output the next digit.
-    *ptr++ = "0123456789abcdef"[j % base];
-    j /= base;
-
-    if (padding > 0)
-      padding--;
-  } while (j > 0 || padding > 0);
-
-  // Terminate the output with a NUL character.
-  *ptr = '\000';
-
-  // Conversion to ASCII actually resulted in the digits being in reverse
-  // order. We can't easily generate them in forward order, as we can't tell
-  // the number of characters needed until we are done converting.
-  // So, now, we reverse the string (except for the possible "-" sign).
-  while (--ptr > start) {
-    char ch = *ptr;
-    *ptr = *start;
-    *start++ = ch;
-  }
-  return buf;
-}
-
-// Safely appends string |source| to string |dest|.  Never writes past the
-// buffer size |dest_size| and guarantees that |dest| is null-terminated.
-void SafeAppendString(const char* source, char* dest, int dest_size) {
-  int dest_string_length = strlen(dest);
-  SAFE_ASSERT(dest_string_length < dest_size);
-  dest += dest_string_length;
-  dest_size -= dest_string_length;
-  strncpy(dest, source, dest_size);
-  // Making sure |dest| is always null-terminated.
-  dest[dest_size - 1] = '\0';
-}
-
-// Converts a 64-bit value into a hex string, and safely appends it to |dest|.
-// Never writes past the buffer size |dest_size| and guarantees that |dest| is
-// null-terminated.
-void SafeAppendHexNumber(uint64_t value, char* dest, int dest_size) {
-  // 64-bit numbers in hex can have up to 16 digits.
-  char buf[17] = {'\0'};
-  SafeAppendString(itoa_r(value, buf, sizeof(buf), 16, 0), dest, dest_size);
-}
-
-// The implementation of our symbolization routine.  If it
-// successfully finds the symbol containing "pc" and obtains the
-// symbol name, returns true and write the symbol name to "out".
-// Otherwise, returns false. If Callback function is installed via
-// InstallSymbolizeCallback(), the function is also called in this function,
-// and "out" is used as its output.
-// To keep stack consumption low, we would like this function to not
-// get inlined.
-static ATTRIBUTE_NOINLINE bool SymbolizeAndDemangle(void *pc, char *out,
-                                                    int out_size) {
-  uint64_t pc0 = reinterpret_cast<uintptr_t>(pc);
-  uint64_t start_address = 0;
-  uint64_t base_address = 0;
-  int object_fd = -1;
-
-  if (out_size < 1) {
-    return false;
-  }
-  out[0] = '\0';
-  SafeAppendString("(", out, out_size);
-
-  if (g_symbolize_open_object_file_callback) {
-    object_fd = g_symbolize_open_object_file_callback(pc0, start_address,
-                                                      base_address, out + 1,
-                                                      out_size - 1);
-  } else {
-    object_fd = OpenObjectFileContainingPcAndGetStartAddress(pc0, start_address,
-                                                             base_address,
-                                                             out + 1,
-                                                             out_size - 1);
-  }
-
-  // Check whether a file name was returned.
-#if !defined(PRINT_UNSYMBOLIZED_STACK_TRACES)
-  if (object_fd < 0) {
-#endif
-    if (out[1]) {
-      // The object file containing PC was determined successfully however the
-      // object file was not opened successfully.  This is still considered
-      // success because the object file name and offset are known and tools
-      // like asan_symbolize.py can be used for the symbolization.
-      out[out_size - 1] = '\0';  // Making sure |out| is always null-terminated.
-      SafeAppendString("+0x", out, out_size);
-      SafeAppendHexNumber(pc0 - base_address, out, out_size);
-      SafeAppendString(")", out, out_size);
-      return true;
-    }
-    // Failed to determine the object file containing PC.  Bail out.
-    return false;
-#if !defined(PRINT_UNSYMBOLIZED_STACK_TRACES)
-  }
-#endif
-  FileDescriptor wrapped_object_fd(object_fd);
-  int elf_type = FileGetElfType(wrapped_object_fd.get());
-  if (elf_type == -1) {
-    return false;
-  }
-  if (g_symbolize_callback) {
-    // Run the call back if it's installed.
-    // Note: relocation (and much of the rest of this code) will be
-    // wrong for prelinked shared libraries and PIE executables.
-    uint64_t relocation = (elf_type == ET_DYN) ? start_address : 0;
-    int num_bytes_written = g_symbolize_callback(wrapped_object_fd.get(),
-                                                 pc, out, out_size,
-                                                 relocation);
-    if (num_bytes_written > 0) {
-      out += num_bytes_written;
-      out_size -= num_bytes_written;
-    }
-  }
-  if (!GetSymbolFromObjectFile(wrapped_object_fd.get(), pc0,
-                               out, out_size, base_address)) {
-    return false;
-  }
-
-  // Symbolization succeeded.  Now we try to demangle the symbol.
-  DemangleInplace(out, out_size);
-  return true;
-}
-
-_END_GOOGLE_NAMESPACE_
-
-#elif defined(OS_MACOSX) && defined(HAVE_DLADDR)
-
-#include <dlfcn.h>
-#include <string.h>
-
-_START_GOOGLE_NAMESPACE_
-
-static ATTRIBUTE_NOINLINE bool SymbolizeAndDemangle(void *pc, char *out,
-                                                    int out_size) {
-  Dl_info info;
-  if (dladdr(pc, &info)) {
-    if ((int)strlen(info.dli_sname) < out_size) {
-      strcpy(out, info.dli_sname);
-      // Symbolization succeeded.  Now we try to demangle the symbol.
-      DemangleInplace(out, out_size);
-      return true;
-    }
-  }
-  return false;
-}
-
-_END_GOOGLE_NAMESPACE_
-
-#else
-# error BUG: HAVE_SYMBOLIZE was wrongly set
-#endif
-
-_START_GOOGLE_NAMESPACE_
-
-bool Symbolize(void *pc, char *out, int out_size) {
-  SAFE_ASSERT(out_size >= 0);
-  return SymbolizeAndDemangle(pc, out, out_size);
-}
-
-_END_GOOGLE_NAMESPACE_
-
-#else  /* HAVE_SYMBOLIZE */
-
-#include <assert.h>
-
-#include "config.h"
-
-_START_GOOGLE_NAMESPACE_
-
-// TODO: Support other environments.
-bool Symbolize(void *pc, char *out, int out_size) {
-  assert(0);
-  return false;
-}
-
-_END_GOOGLE_NAMESPACE_
-
-#endif
diff --git a/base/third_party/symbolize/symbolize.h b/base/third_party/symbolize/symbolize.h
deleted file mode 100644
index aeb2fe3..0000000
--- a/base/third_party/symbolize/symbolize.h
+++ /dev/null
@@ -1,155 +0,0 @@
-// Copyright (c) 2006, Google Inc.
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Author: Satoru Takabayashi
-//
-// This library provides Symbolize() function that symbolizes program
-// counters to their corresponding symbol names on linux platforms.
-// This library has a minimal implementation of an ELF symbol table
-// reader (i.e. it doesn't depend on libelf, etc.).
-//
-// The algorithm used in Symbolize() is as follows.
-//
-//   1. Go through a list of maps in /proc/self/maps and find the map
-//   containing the program counter.
-//
-//   2. Open the mapped file and find a regular symbol table inside.
-//   Iterate over symbols in the symbol table and look for the symbol
-//   containing the program counter.  If such a symbol is found,
-//   obtain the symbol name, and demangle the symbol if possible.
-//   If the symbol isn't found in the regular symbol table (binary is
-//   stripped), try the same thing with a dynamic symbol table.
-//
-// Note that Symbolize() is originally implemented to be used in
-// FailureSignalHandler() in base/google.cc.  Hence it doesn't use
-// malloc() and other unsafe operations.  It should be both
-// thread-safe and async-signal-safe.
-
-#ifndef BASE_SYMBOLIZE_H_
-#define BASE_SYMBOLIZE_H_
-
-#include "utilities.h"
-#include "config.h"
-#include "glog/logging.h"
-
-#ifdef HAVE_SYMBOLIZE
-
-#if defined(__ELF__)  // defined by gcc
-#if defined(__OpenBSD__)
-#include <sys/exec_elf.h>
-#else
-#include <elf.h>
-#endif
-
-#if !defined(ANDROID)
-#include <link.h>  // For ElfW() macro.
-#endif
-
-// For systems where SIZEOF_VOID_P is not defined, determine it
-// based on __LP64__ (defined by gcc on 64-bit systems)
-#if !defined(SIZEOF_VOID_P)
-# if defined(__LP64__)
-#  define SIZEOF_VOID_P 8
-# else
-#  define SIZEOF_VOID_P 4
-# endif
-#endif
-
-// If there is no ElfW macro, let's define it by ourself.
-#ifndef ElfW
-# if SIZEOF_VOID_P == 4
-#  define ElfW(type) Elf32_##type
-# elif SIZEOF_VOID_P == 8
-#  define ElfW(type) Elf64_##type
-# else
-#  error "Unknown sizeof(void *)"
-# endif
-#endif
-
-_START_GOOGLE_NAMESPACE_
-
-// Gets the section header for the given name, if it exists. Returns true on
-// success. Otherwise, returns false.
-bool GetSectionHeaderByName(int fd, const char *name, size_t name_len,
-                            ElfW(Shdr) *out);
-
-_END_GOOGLE_NAMESPACE_
-
-#endif  /* __ELF__ */
-
-_START_GOOGLE_NAMESPACE_
-
-// Restrictions on the callbacks that follow:
-//  - The callbacks must not use heaps but only use stacks.
-//  - The callbacks must be async-signal-safe.
-
-// Installs a callback function, which will be called right before a symbol name
-// is printed. The callback is intended to be used for showing a file name and a
-// line number preceding a symbol name.
-// "fd" is a file descriptor of the object file containing the program
-// counter "pc". The callback function should write output to "out"
-// and return the size of the output written. On error, the callback
-// function should return -1.
-typedef int (*SymbolizeCallback)(int fd, void *pc, char *out, size_t out_size,
-                                 uint64_t relocation);
-void InstallSymbolizeCallback(SymbolizeCallback callback);
-
-// Installs a callback function, which will be called instead of
-// OpenObjectFileContainingPcAndGetStartAddress.  The callback is expected
-// to searches for the object file (from /proc/self/maps) that contains
-// the specified pc.  If found, sets |start_address| to the start address
-// of where this object file is mapped in memory, sets the module base
-// address into |base_address|, copies the object file name into
-// |out_file_name|, and attempts to open the object file.  If the object
-// file is opened successfully, returns the file descriptor.  Otherwise,
-// returns -1.  |out_file_name_size| is the size of the file name buffer
-// (including the null-terminator).
-typedef int (*SymbolizeOpenObjectFileCallback)(uint64_t pc,
-                                               uint64_t &start_address,
-                                               uint64_t &base_address,
-                                               char *out_file_name,
-                                               int out_file_name_size);
-void InstallSymbolizeOpenObjectFileCallback(
-    SymbolizeOpenObjectFileCallback callback);
-
-_END_GOOGLE_NAMESPACE_
-
-#endif
-
-_START_GOOGLE_NAMESPACE_
-
-// Symbolizes a program counter.  On success, returns true and write the
-// symbol name to "out".  The symbol name is demangled if possible
-// (supports symbols generated by GCC 3.x or newer).  Otherwise,
-// returns false.
-bool Symbolize(void *pc, char *out, int out_size);
-
-_END_GOOGLE_NAMESPACE_
-
-#endif  // BASE_SYMBOLIZE_H_
diff --git a/base/third_party/symbolize/utilities.h b/base/third_party/symbolize/utilities.h
deleted file mode 100644
index 65c5ba0..0000000
--- a/base/third_party/symbolize/utilities.h
+++ /dev/null
@@ -1,11 +0,0 @@
-// Copyright (c) 2010 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 <inttypes.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#define HAVE_SYMBOLIZE 1
-#define ATTRIBUTE_NOINLINE __attribute__ ((noinline))
diff --git a/base/threading/platform_thread_win.cc b/base/threading/platform_thread_win.cc
index daccc0e..d45211f 100644
--- a/base/threading/platform_thread_win.cc
+++ b/base/threading/platform_thread_win.cc
@@ -6,9 +6,6 @@
 
 #include <stddef.h>
 
-#include "base/debug/activity_tracker.h"
-#include "base/debug/alias.h"
-#include "base/debug/profiler.h"
 #include "base/logging.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/utf_string_conversions.h"
@@ -237,10 +234,6 @@
   if (!thread_id)
     last_error = ::GetLastError();
 
-  // Record information about the exiting thread in case joining hangs.
-  base::debug::Alias(&thread_id);
-  base::debug::Alias(&last_error);
-
   // Record the event that this thread is blocking upon (for hang diagnosis).
   base::debug::ScopedThreadJoinActivity thread_activity(&thread_handle);
 
diff --git a/base/threading/post_task_and_reply_impl.cc b/base/threading/post_task_and_reply_impl.cc
index 5aacdad..83c9dcb 100644
--- a/base/threading/post_task_and_reply_impl.cc
+++ b/base/threading/post_task_and_reply_impl.cc
@@ -7,7 +7,6 @@
 #include <utility>
 
 #include "base/bind.h"
-#include "base/debug/leak_annotations.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/sequenced_task_runner.h"
@@ -54,7 +53,6 @@
         // https://crbug.com/829122).
         auto relay_to_delete =
             std::make_unique<PostTaskAndReplyRelay>(std::move(*this));
-        ANNOTATE_LEAKING_OBJECT_PTR(relay_to_delete.get());
         reply_task_runner_->DeleteSoon(from_here_, std::move(relay_to_delete));
       }
 
diff --git a/base/win/scoped_handle_verifier.cc b/base/win/scoped_handle_verifier.cc
index 930d147..080bdbc 100644
--- a/base/win/scoped_handle_verifier.cc
+++ b/base/win/scoped_handle_verifier.cc
@@ -9,8 +9,6 @@
 
 #include <unordered_map>
 
-#include "base/debug/alias.h"
-#include "base/debug/stack_trace.h"
 #include "base/synchronization/lock_impl.h"
 #include "base/win/current_module.h"
 
@@ -156,9 +154,7 @@
   std::pair<HandleMap::iterator, bool> result = map_.insert(item);
   if (!result.second) {
     ScopedHandleVerifierInfo other = result.first->second;
-    base::debug::Alias(&other);
     auto creation_stack = creation_stack_;
-    base::debug::Alias(&creation_stack);
     CHECK(false);  // Attempt to start tracking already tracked handle.
   }
 }
@@ -174,15 +170,12 @@
   HandleMap::iterator i = map_.find(handle);
   if (i == map_.end()) {
     auto creation_stack = creation_stack_;
-    base::debug::Alias(&creation_stack);
     CHECK(false);  // Attempting to close an untracked handle.
   }
 
   ScopedHandleVerifierInfo other = i->second;
   if (other.owner != owner) {
-    base::debug::Alias(&other);
     auto creation_stack = creation_stack_;
-    base::debug::Alias(&creation_stack);
     CHECK(false);  // Attempting to close a handle not owned by opener.
   }
 
@@ -206,9 +199,7 @@
     return;
 
   ScopedHandleVerifierInfo other = i->second;
-  base::debug::Alias(&other);
   auto creation_stack = creation_stack_;
-  base::debug::Alias(&creation_stack);
   CHECK(false);  // CloseHandle called on tracked handle.
 }
 
diff --git a/base/win/scoped_handle_verifier.h b/base/win/scoped_handle_verifier.h
index 008e790..a7c131e 100644
--- a/base/win/scoped_handle_verifier.h
+++ b/base/win/scoped_handle_verifier.h
@@ -10,7 +10,6 @@
 #include <unordered_map>
 
 #include "base/base_export.h"
-#include "base/debug/stack_trace.h"
 #include "base/hash.h"
 #include "base/synchronization/lock_impl.h"
 #include "base/threading/thread_local.h"
diff --git a/base/win/scoped_hdc.h b/base/win/scoped_hdc.h
index 890e34a..ef50e05 100644
--- a/base/win/scoped_hdc.h
+++ b/base/win/scoped_hdc.h
@@ -7,7 +7,6 @@
 
 #include <windows.h>
 
-#include "base/debug/gdi_debug_util_win.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/win/scoped_handle.h"
diff --git a/build/gen.py b/build/gen.py
index 39257c9..2755480 100755
--- a/build/gen.py
+++ b/build/gen.py
@@ -231,11 +231,6 @@
         'base/callback_helpers.cc',
         'base/callback_internal.cc',
         'base/command_line.cc',
-        'base/debug/alias.cc',
-        'base/debug/crash_logging.cc',
-        'base/debug/dump_without_crashing.cc',
-        'base/debug/stack_trace.cc',
-        'base/debug/task_annotator.cc',
         'base/environment.cc',
         'base/files/file.cc',
         'base/files/file_enumerator.cc',
@@ -543,8 +538,6 @@
   if is_posix:
     static_libraries['base']['sources'].extend([
         'base/base_paths_posix.cc',
-        'base/debug/debugger_posix.cc',
-        'base/debug/stack_trace_posix.cc',
         'base/files/file_enumerator_posix.cc',
         'base/files/file_descriptor_watcher_posix.cc',
         'base/files/file_posix.cc',
@@ -664,11 +657,6 @@
     static_libraries['base']['sources'].extend([
         'base/base_paths_win.cc',
         'base/cpu.cc',
-        'base/debug/close_handle_hook_win.cc',
-        'base/debug/debugger.cc',
-        'base/debug/debugger_win.cc',
-        'base/debug/profiler.cc',
-        'base/debug/stack_trace_win.cc',
         'base/files/file_enumerator_win.cc',
         'base/files/file_path_watcher_win.cc',
         'base/files/file_util_win.cc',
@@ -686,8 +674,6 @@
         'base/process/process_iterator_win.cc',
         'base/process/process_metrics_win.cc',
         'base/process/process_win.cc',
-        'base/profiler/native_stack_sampler_win.cc',
-        'base/profiler/win32_stack_frame_unwinder.cc',
         'base/rand_util_win.cc',
         'base/strings/sys_string_conversions_win.cc',
         'base/synchronization/condition_variable_win.cc',