diff --git a/base/debug/activity_tracker.cc b/base/debug/activity_tracker.cc
deleted file mode 100644
index bb1349c..0000000
--- a/base/debug/activity_tracker.cc
+++ /dev/null
@@ -1,1828 +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_tracker.h"
-
-#include <algorithm>
-#include <limits>
-#include <utility>
-
-#include "base/atomic_sequence_num.h"
-#include "base/debug/stack_trace.h"
-#include "base/files/file.h"
-#include "base/files/file_path.h"
-#include "base/files/memory_mapped_file.h"
-#include "base/logging.h"
-#include "base/memory/ptr_util.h"
-#include "base/metrics/field_trial.h"
-#include "base/metrics/histogram_macros.h"
-#include "base/pending_task.h"
-#include "base/pickle.h"
-#include "base/process/process.h"
-#include "base/process/process_handle.h"
-#include "base/stl_util.h"
-#include "base/strings/string_util.h"
-#include "base/strings/utf_string_conversions.h"
-#include "base/threading/platform_thread.h"
-#include "build_config.h"
-
-namespace base {
-namespace debug {
-
-namespace {
-
-// The minimum depth a stack should support.
-const int kMinStackDepth = 2;
-
-// The amount of memory set aside for holding arbitrary user data (key/value
-// pairs) globally or associated with ActivityData entries.
-const size_t kUserDataSize = 1 << 10;     // 1 KiB
-const size_t kProcessDataSize = 4 << 10;  // 4 KiB
-const size_t kMaxUserDataNameLength =
-    static_cast<size_t>(std::numeric_limits<uint8_t>::max());
-
-// A constant used to indicate that module information is changing.
-const uint32_t kModuleInformationChanging = 0x80000000;
-
-// The key used to record process information.
-const char kProcessPhaseDataKey[] = "process-phase";
-
-// An atomically incrementing number, used to check for recreations of objects
-// in the same memory space.
-AtomicSequenceNumber g_next_id;
-
-union ThreadRef {
-  int64_t as_id;
-#if defined(OS_WIN)
-  // On Windows, the handle itself is often a pseudo-handle with a common
-  // value meaning "this thread" and so the thread-id is used. The former
-  // can be converted to a thread-id with a system call.
-  PlatformThreadId as_tid;
-#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
-  // On Posix and Fuchsia, the handle is always a unique identifier so no
-  // conversion needs to be done. However, its value is officially opaque so
-  // there is no one correct way to convert it to a numerical identifier.
-  PlatformThreadHandle::Handle as_handle;
-#endif
-};
-
-// Gets the next non-zero identifier. It is only unique within a process.
-uint32_t GetNextDataId() {
-  uint32_t id;
-  while ((id = g_next_id.GetNext()) == 0)
-    ;
-  return id;
-}
-
-// Gets the current process-id, either from the GlobalActivityTracker if it
-// exists (where the PID can be defined for testing) or from the system if
-// there isn't such.
-int64_t GetProcessId() {
-  GlobalActivityTracker* global = GlobalActivityTracker::Get();
-  if (global)
-    return global->process_id();
-  return GetCurrentProcId();
-}
-
-// Finds and reuses a specific allocation or creates a new one.
-PersistentMemoryAllocator::Reference AllocateFrom(
-    PersistentMemoryAllocator* allocator,
-    uint32_t from_type,
-    size_t size,
-    uint32_t to_type) {
-  PersistentMemoryAllocator::Iterator iter(allocator);
-  PersistentMemoryAllocator::Reference ref;
-  while ((ref = iter.GetNextOfType(from_type)) != 0) {
-    DCHECK_LE(size, allocator->GetAllocSize(ref));
-    // This can fail if a another thread has just taken it. It is assumed that
-    // the memory is cleared during the "free" operation.
-    if (allocator->ChangeType(ref, to_type, from_type, /*clear=*/false))
-      return ref;
-  }
-
-  return allocator->Allocate(size, to_type);
-}
-
-// Determines the previous aligned index.
-size_t RoundDownToAlignment(size_t index, size_t alignment) {
-  return index & (0 - alignment);
-}
-
-// Determines the next aligned index.
-size_t RoundUpToAlignment(size_t index, size_t alignment) {
-  return (index + (alignment - 1)) & (0 - alignment);
-}
-
-// Converts "tick" timing into wall time.
-Time WallTimeFromTickTime(int64_t ticks_start, int64_t ticks, Time time_start) {
-  return time_start + TimeDelta::FromInternalValue(ticks - ticks_start);
-}
-
-}  // namespace
-
-OwningProcess::OwningProcess() = default;
-OwningProcess::~OwningProcess() = default;
-
-void OwningProcess::Release_Initialize(int64_t pid) {
-  uint32_t old_id = data_id.load(std::memory_order_acquire);
-  DCHECK_EQ(0U, old_id);
-  process_id = pid != 0 ? pid : GetProcessId();
-  create_stamp = Time::Now().ToInternalValue();
-  data_id.store(GetNextDataId(), std::memory_order_release);
-}
-
-void OwningProcess::SetOwningProcessIdForTesting(int64_t pid, int64_t stamp) {
-  DCHECK_NE(0U, data_id);
-  process_id = pid;
-  create_stamp = stamp;
-}
-
-// static
-bool OwningProcess::GetOwningProcessId(const void* memory,
-                                       int64_t* out_id,
-                                       int64_t* out_stamp) {
-  const OwningProcess* info = reinterpret_cast<const OwningProcess*>(memory);
-  uint32_t id = info->data_id.load(std::memory_order_acquire);
-  if (id == 0)
-    return false;
-
-  *out_id = info->process_id;
-  *out_stamp = info->create_stamp;
-  return id == info->data_id.load(std::memory_order_seq_cst);
-}
-
-// It doesn't matter what is contained in this (though it will be all zeros)
-// as only the address of it is important.
-const ActivityData kNullActivityData = {};
-
-ActivityData ActivityData::ForThread(const PlatformThreadHandle& handle) {
-  ThreadRef thread_ref;
-  thread_ref.as_id = 0;  // Zero the union in case other is smaller.
-#if defined(OS_WIN)
-  thread_ref.as_tid = ::GetThreadId(handle.platform_handle());
-#elif defined(OS_POSIX)
-  thread_ref.as_handle = handle.platform_handle();
-#endif
-  return ForThread(thread_ref.as_id);
-}
-
-ActivityTrackerMemoryAllocator::ActivityTrackerMemoryAllocator(
-    PersistentMemoryAllocator* allocator,
-    uint32_t object_type,
-    uint32_t object_free_type,
-    size_t object_size,
-    size_t cache_size,
-    bool make_iterable)
-    : allocator_(allocator),
-      object_type_(object_type),
-      object_free_type_(object_free_type),
-      object_size_(object_size),
-      cache_size_(cache_size),
-      make_iterable_(make_iterable),
-      iterator_(allocator),
-      cache_values_(new Reference[cache_size]),
-      cache_used_(0) {
-  DCHECK(allocator);
-}
-
-ActivityTrackerMemoryAllocator::~ActivityTrackerMemoryAllocator() = default;
-
-ActivityTrackerMemoryAllocator::Reference
-ActivityTrackerMemoryAllocator::GetObjectReference() {
-  // First see if there is a cached value that can be returned. This is much
-  // faster than searching the memory system for free blocks.
-  while (cache_used_ > 0) {
-    Reference cached = cache_values_[--cache_used_];
-    // Change the type of the cached object to the proper type and return it.
-    // If the type-change fails that means another thread has taken this from
-    // under us (via the search below) so ignore it and keep trying. Don't
-    // clear the memory because that was done when the type was made "free".
-    if (allocator_->ChangeType(cached, object_type_, object_free_type_, false))
-      return cached;
-  }
-
-  // Fetch the next "free" object from persistent memory. Rather than restart
-  // the iterator at the head each time and likely waste time going again
-  // through objects that aren't relevant, the iterator continues from where
-  // it last left off and is only reset when the end is reached. If the
-  // returned reference matches |last|, then it has wrapped without finding
-  // anything.
-  const Reference last = iterator_.GetLast();
-  while (true) {
-    uint32_t type;
-    Reference found = iterator_.GetNext(&type);
-    if (found && type == object_free_type_) {
-      // Found a free object. Change it to the proper type and return it. If
-      // the type-change fails that means another thread has taken this from
-      // under us so ignore it and keep trying.
-      if (allocator_->ChangeType(found, object_type_, object_free_type_, false))
-        return found;
-    }
-    if (found == last) {
-      // Wrapped. No desired object was found.
-      break;
-    }
-    if (!found) {
-      // Reached end; start over at the beginning.
-      iterator_.Reset();
-    }
-  }
-
-  // No free block was found so instead allocate a new one.
-  Reference allocated = allocator_->Allocate(object_size_, object_type_);
-  if (allocated && make_iterable_)
-    allocator_->MakeIterable(allocated);
-  return allocated;
-}
-
-void ActivityTrackerMemoryAllocator::ReleaseObjectReference(Reference ref) {
-  // Mark object as free.
-  bool success = allocator_->ChangeType(ref, object_free_type_, object_type_,
-                                        /*clear=*/true);
-  DCHECK(success);
-
-  // Add this reference to our "free" cache if there is space. If not, the type
-  // has still been changed to indicate that it is free so this (or another)
-  // thread can find it, albeit more slowly, using the iteration method above.
-  if (cache_used_ < cache_size_)
-    cache_values_[cache_used_++] = ref;
-}
-
-// static
-void Activity::FillFrom(Activity* activity,
-                        const void* program_counter,
-                        const void* origin,
-                        Type type,
-                        const ActivityData& data) {
-  activity->time_internal = base::TimeTicks::Now().ToInternalValue();
-  activity->calling_address = reinterpret_cast<uintptr_t>(program_counter);
-  activity->origin_address = reinterpret_cast<uintptr_t>(origin);
-  activity->activity_type = type;
-  activity->data = data;
-
-#if (!defined(OS_NACL) && DCHECK_IS_ON()) || defined(ADDRESS_SANITIZER)
-  // Create a stacktrace from the current location and get the addresses for
-  // improved debuggability.
-  StackTrace stack_trace;
-  size_t stack_depth;
-  const void* const* stack_addrs = stack_trace.Addresses(&stack_depth);
-  // Copy the stack addresses, ignoring the first one (here).
-  size_t i;
-  for (i = 1; i < stack_depth && i < kActivityCallStackSize; ++i) {
-    activity->call_stack[i - 1] = reinterpret_cast<uintptr_t>(stack_addrs[i]);
-  }
-  activity->call_stack[i - 1] = 0;
-#else
-  activity->call_stack[0] = 0;
-#endif
-}
-
-ActivityUserData::TypedValue::TypedValue() = default;
-ActivityUserData::TypedValue::TypedValue(const TypedValue& other) = default;
-ActivityUserData::TypedValue::~TypedValue() = default;
-
-StringPiece ActivityUserData::TypedValue::Get() const {
-  DCHECK_EQ(RAW_VALUE, type_);
-  return long_value_;
-}
-
-StringPiece ActivityUserData::TypedValue::GetString() const {
-  DCHECK_EQ(STRING_VALUE, type_);
-  return long_value_;
-}
-
-bool ActivityUserData::TypedValue::GetBool() const {
-  DCHECK_EQ(BOOL_VALUE, type_);
-  return short_value_ != 0;
-}
-
-char ActivityUserData::TypedValue::GetChar() const {
-  DCHECK_EQ(CHAR_VALUE, type_);
-  return static_cast<char>(short_value_);
-}
-
-int64_t ActivityUserData::TypedValue::GetInt() const {
-  DCHECK_EQ(SIGNED_VALUE, type_);
-  return static_cast<int64_t>(short_value_);
-}
-
-uint64_t ActivityUserData::TypedValue::GetUint() const {
-  DCHECK_EQ(UNSIGNED_VALUE, type_);
-  return static_cast<uint64_t>(short_value_);
-}
-
-StringPiece ActivityUserData::TypedValue::GetReference() const {
-  DCHECK_EQ(RAW_VALUE_REFERENCE, type_);
-  return ref_value_;
-}
-
-StringPiece ActivityUserData::TypedValue::GetStringReference() const {
-  DCHECK_EQ(STRING_VALUE_REFERENCE, type_);
-  return ref_value_;
-}
-
-// These are required because std::atomic is (currently) not a POD type and
-// thus clang requires explicit out-of-line constructors and destructors even
-// when they do nothing.
-ActivityUserData::ValueInfo::ValueInfo() = default;
-ActivityUserData::ValueInfo::ValueInfo(ValueInfo&&) = default;
-ActivityUserData::ValueInfo::~ValueInfo() = default;
-ActivityUserData::MemoryHeader::MemoryHeader() = default;
-ActivityUserData::MemoryHeader::~MemoryHeader() = default;
-ActivityUserData::FieldHeader::FieldHeader() = default;
-ActivityUserData::FieldHeader::~FieldHeader() = default;
-
-ActivityUserData::ActivityUserData() : ActivityUserData(nullptr, 0, -1) {}
-
-ActivityUserData::ActivityUserData(void* memory, size_t size, int64_t pid)
-    : memory_(reinterpret_cast<char*>(memory)),
-      available_(RoundDownToAlignment(size, kMemoryAlignment)),
-      header_(reinterpret_cast<MemoryHeader*>(memory)),
-      orig_data_id(0),
-      orig_process_id(0),
-      orig_create_stamp(0) {
-  // It's possible that no user data is being stored.
-  if (!memory_)
-    return;
-
-  static_assert(0 == sizeof(MemoryHeader) % kMemoryAlignment, "invalid header");
-  DCHECK_LT(sizeof(MemoryHeader), available_);
-  if (header_->owner.data_id.load(std::memory_order_acquire) == 0)
-    header_->owner.Release_Initialize(pid);
-  memory_ += sizeof(MemoryHeader);
-  available_ -= sizeof(MemoryHeader);
-
-  // Make a copy of identifying information for later comparison.
-  *const_cast<uint32_t*>(&orig_data_id) =
-      header_->owner.data_id.load(std::memory_order_acquire);
-  *const_cast<int64_t*>(&orig_process_id) = header_->owner.process_id;
-  *const_cast<int64_t*>(&orig_create_stamp) = header_->owner.create_stamp;
-
-  // If there is already data present, load that. This allows the same class
-  // to be used for analysis through snapshots.
-  ImportExistingData();
-}
-
-ActivityUserData::~ActivityUserData() = default;
-
-bool ActivityUserData::CreateSnapshot(Snapshot* output_snapshot) const {
-  DCHECK(output_snapshot);
-  DCHECK(output_snapshot->empty());
-
-  // Find any new data that may have been added by an active instance of this
-  // class that is adding records.
-  ImportExistingData();
-
-  // Add all the values to the snapshot.
-  for (const auto& entry : values_) {
-    TypedValue value;
-    const size_t size = entry.second.size_ptr->load(std::memory_order_acquire);
-    value.type_ = entry.second.type;
-    DCHECK_GE(entry.second.extent, size);
-
-    switch (entry.second.type) {
-      case RAW_VALUE:
-      case STRING_VALUE:
-        value.long_value_ =
-            std::string(reinterpret_cast<char*>(entry.second.memory), size);
-        break;
-      case RAW_VALUE_REFERENCE:
-      case STRING_VALUE_REFERENCE: {
-        ReferenceRecord* ref =
-            reinterpret_cast<ReferenceRecord*>(entry.second.memory);
-        value.ref_value_ = StringPiece(
-            reinterpret_cast<char*>(static_cast<uintptr_t>(ref->address)),
-            static_cast<size_t>(ref->size));
-      } break;
-      case BOOL_VALUE:
-      case CHAR_VALUE:
-        value.short_value_ = *reinterpret_cast<char*>(entry.second.memory);
-        break;
-      case SIGNED_VALUE:
-      case UNSIGNED_VALUE:
-        value.short_value_ = *reinterpret_cast<uint64_t*>(entry.second.memory);
-        break;
-      case END_OF_VALUES:  // Included for completeness purposes.
-        NOTREACHED();
-    }
-    auto inserted = output_snapshot->insert(
-        std::make_pair(entry.second.name.as_string(), std::move(value)));
-    DCHECK(inserted.second);  // True if inserted, false if existed.
-  }
-
-  // Another import attempt will validate that the underlying memory has not
-  // been reused for another purpose. Entries added since the first import
-  // will be ignored here but will be returned if another snapshot is created.
-  ImportExistingData();
-  if (!memory_) {
-    output_snapshot->clear();
-    return false;
-  }
-
-  // Successful snapshot.
-  return true;
-}
-
-const void* ActivityUserData::GetBaseAddress() const {
-  // The |memory_| pointer advances as elements are written but the |header_|
-  // value is always at the start of the block so just return that.
-  return header_;
-}
-
-void ActivityUserData::SetOwningProcessIdForTesting(int64_t pid,
-                                                    int64_t stamp) {
-  if (!header_)
-    return;
-  header_->owner.SetOwningProcessIdForTesting(pid, stamp);
-}
-
-// static
-bool ActivityUserData::GetOwningProcessId(const void* memory,
-                                          int64_t* out_id,
-                                          int64_t* out_stamp) {
-  const MemoryHeader* header = reinterpret_cast<const MemoryHeader*>(memory);
-  return OwningProcess::GetOwningProcessId(&header->owner, out_id, out_stamp);
-}
-
-void ActivityUserData::Set(StringPiece name,
-                           ValueType type,
-                           const void* memory,
-                           size_t size) {
-  DCHECK_GE(std::numeric_limits<uint8_t>::max(), name.length());
-  size = std::min(std::numeric_limits<uint16_t>::max() - (kMemoryAlignment - 1),
-                  size);
-
-  // It's possible that no user data is being stored.
-  if (!memory_)
-    return;
-
-  // The storage of a name is limited so use that limit during lookup.
-  if (name.length() > kMaxUserDataNameLength)
-    name.set(name.data(), kMaxUserDataNameLength);
-
-  ValueInfo* info;
-  auto existing = values_.find(name);
-  if (existing != values_.end()) {
-    info = &existing->second;
-  } else {
-    // The name size is limited to what can be held in a single byte but
-    // because there are not alignment constraints on strings, it's set tight
-    // against the header. Its extent (the reserved space, even if it's not
-    // all used) is calculated so that, when pressed against the header, the
-    // following field will be aligned properly.
-    size_t name_size = name.length();
-    size_t name_extent =
-        RoundUpToAlignment(sizeof(FieldHeader) + name_size, kMemoryAlignment) -
-        sizeof(FieldHeader);
-    size_t value_extent = RoundUpToAlignment(size, kMemoryAlignment);
-
-    // The "base size" is the size of the header and (padded) string key. Stop
-    // now if there's not room enough for even this.
-    size_t base_size = sizeof(FieldHeader) + name_extent;
-    if (base_size > available_)
-      return;
-
-    // The "full size" is the size for storing the entire value.
-    size_t full_size = std::min(base_size + value_extent, available_);
-
-    // If the value is actually a single byte, see if it can be stuffed at the
-    // end of the name extent rather than wasting kMemoryAlignment bytes.
-    if (size == 1 && name_extent > name_size) {
-      full_size = base_size;
-      --name_extent;
-      --base_size;
-    }
-
-    // Truncate the stored size to the amount of available memory. Stop now if
-    // there's not any room for even part of the value.
-    if (size != 0) {
-      size = std::min(full_size - base_size, size);
-      if (size == 0)
-        return;
-    }
-
-    // Allocate a chunk of memory.
-    FieldHeader* header = reinterpret_cast<FieldHeader*>(memory_);
-    memory_ += full_size;
-    available_ -= full_size;
-
-    // Datafill the header and name records. Memory must be zeroed. The |type|
-    // is written last, atomically, to release all the other values.
-    DCHECK_EQ(END_OF_VALUES, header->type.load(std::memory_order_relaxed));
-    DCHECK_EQ(0, header->value_size.load(std::memory_order_relaxed));
-    header->name_size = static_cast<uint8_t>(name_size);
-    header->record_size = full_size;
-    char* name_memory = reinterpret_cast<char*>(header) + sizeof(FieldHeader);
-    void* value_memory =
-        reinterpret_cast<char*>(header) + sizeof(FieldHeader) + name_extent;
-    memcpy(name_memory, name.data(), name_size);
-    header->type.store(type, std::memory_order_release);
-
-    // Create an entry in |values_| so that this field can be found and changed
-    // later on without having to allocate new entries.
-    StringPiece persistent_name(name_memory, name_size);
-    auto inserted =
-        values_.insert(std::make_pair(persistent_name, ValueInfo()));
-    DCHECK(inserted.second);  // True if inserted, false if existed.
-    info = &inserted.first->second;
-    info->name = persistent_name;
-    info->memory = value_memory;
-    info->size_ptr = &header->value_size;
-    info->extent = full_size - sizeof(FieldHeader) - name_extent;
-    info->type = type;
-  }
-
-  // Copy the value data to storage. The |size| is written last, atomically, to
-  // release the copied data. Until then, a parallel reader will just ignore
-  // records with a zero size.
-  DCHECK_EQ(type, info->type);
-  size = std::min(size, info->extent);
-  info->size_ptr->store(0, std::memory_order_seq_cst);
-  memcpy(info->memory, memory, size);
-  info->size_ptr->store(size, std::memory_order_release);
-}
-
-void ActivityUserData::SetReference(StringPiece name,
-                                    ValueType type,
-                                    const void* memory,
-                                    size_t size) {
-  ReferenceRecord rec;
-  rec.address = reinterpret_cast<uintptr_t>(memory);
-  rec.size = size;
-  Set(name, type, &rec, sizeof(rec));
-}
-
-void ActivityUserData::ImportExistingData() const {
-  // It's possible that no user data is being stored.
-  if (!memory_)
-    return;
-
-  while (available_ > sizeof(FieldHeader)) {
-    FieldHeader* header = reinterpret_cast<FieldHeader*>(memory_);
-    ValueType type =
-        static_cast<ValueType>(header->type.load(std::memory_order_acquire));
-    if (type == END_OF_VALUES)
-      return;
-    if (header->record_size > available_)
-      return;
-
-    size_t value_offset = RoundUpToAlignment(
-        sizeof(FieldHeader) + header->name_size, kMemoryAlignment);
-    if (header->record_size == value_offset &&
-        header->value_size.load(std::memory_order_relaxed) == 1) {
-      value_offset -= 1;
-    }
-    if (value_offset + header->value_size > header->record_size)
-      return;
-
-    ValueInfo info;
-    info.name = StringPiece(memory_ + sizeof(FieldHeader), header->name_size);
-    info.type = type;
-    info.memory = memory_ + value_offset;
-    info.size_ptr = &header->value_size;
-    info.extent = header->record_size - value_offset;
-
-    StringPiece key(info.name);
-    values_.insert(std::make_pair(key, std::move(info)));
-
-    memory_ += header->record_size;
-    available_ -= header->record_size;
-  }
-
-  // Check if memory has been completely reused.
-  if (header_->owner.data_id.load(std::memory_order_acquire) != orig_data_id ||
-      header_->owner.process_id != orig_process_id ||
-      header_->owner.create_stamp != orig_create_stamp) {
-    memory_ = nullptr;
-    values_.clear();
-  }
-}
-
-// This information is kept for every thread that is tracked. It is filled
-// the very first time the thread is seen. All fields must be of exact sizes
-// so there is no issue moving between 32 and 64-bit builds.
-struct ThreadActivityTracker::Header {
-  // Defined in .h for analyzer access. Increment this if structure changes!
-  static constexpr uint32_t kPersistentTypeId =
-      GlobalActivityTracker::kTypeIdActivityTracker;
-
-  // Expected size for 32/64-bit check.
-  static constexpr size_t kExpectedInstanceSize =
-      OwningProcess::kExpectedInstanceSize + Activity::kExpectedInstanceSize +
-      72;
-
-  // This information uniquely identifies a process.
-  OwningProcess owner;
-
-  // The thread-id (thread_ref.as_id) to which this data belongs. This number
-  // is not guaranteed to mean anything but combined with the process-id from
-  // OwningProcess is unique among all active trackers.
-  ThreadRef thread_ref;
-
-  // The start-time and start-ticks when the data was created. Each activity
-  // record has a |time_internal| value that can be converted to a "wall time"
-  // with these two values.
-  int64_t start_time;
-  int64_t start_ticks;
-
-  // The number of Activity slots (spaces that can hold an Activity) that
-  // immediately follow this structure in memory.
-  uint32_t stack_slots;
-
-  // Some padding to keep everything 64-bit aligned.
-  uint32_t padding;
-
-  // The current depth of the stack. This may be greater than the number of
-  // slots. If the depth exceeds the number of slots, the newest entries
-  // won't be recorded.
-  std::atomic<uint32_t> current_depth;
-
-  // A memory location used to indicate if changes have been made to the data
-  // that would invalidate an in-progress read of its contents. The active
-  // tracker will increment the value whenever something gets popped from the
-  // stack. A monitoring tracker can check the value before and after access
-  // to know, if it's still the same, that the contents didn't change while
-  // being copied.
-  std::atomic<uint32_t> data_version;
-
-  // The last "exception" activity. This can't be stored on the stack because
-  // that could get popped as things unwind.
-  Activity last_exception;
-
-  // The name of the thread (up to a maximum length). Dynamic-length names
-  // are not practical since the memory has to come from the same persistent
-  // allocator that holds this structure and to which this object has no
-  // reference.
-  char thread_name[32];
-};
-
-ThreadActivityTracker::Snapshot::Snapshot() = default;
-ThreadActivityTracker::Snapshot::~Snapshot() = default;
-
-ThreadActivityTracker::ScopedActivity::ScopedActivity(
-    ThreadActivityTracker* tracker,
-    const void* program_counter,
-    const void* origin,
-    Activity::Type type,
-    const ActivityData& data)
-    : tracker_(tracker) {
-  if (tracker_)
-    activity_id_ = tracker_->PushActivity(program_counter, origin, type, data);
-}
-
-ThreadActivityTracker::ScopedActivity::~ScopedActivity() {
-  if (tracker_)
-    tracker_->PopActivity(activity_id_);
-}
-
-void ThreadActivityTracker::ScopedActivity::ChangeTypeAndData(
-    Activity::Type type,
-    const ActivityData& data) {
-  if (tracker_)
-    tracker_->ChangeActivity(activity_id_, type, data);
-}
-
-ThreadActivityTracker::ThreadActivityTracker(void* base, size_t size)
-    : header_(static_cast<Header*>(base)),
-      stack_(reinterpret_cast<Activity*>(reinterpret_cast<char*>(base) +
-                                         sizeof(Header))),
-#if DCHECK_IS_ON()
-      thread_id_(PlatformThreadRef()),
-#endif
-      stack_slots_(
-          static_cast<uint32_t>((size - sizeof(Header)) / sizeof(Activity))) {
-
-  // Verify the parameters but fail gracefully if they're not valid so that
-  // production code based on external inputs will not crash.  IsValid() will
-  // return false in this case.
-  if (!base ||
-      // Ensure there is enough space for the header and at least a few records.
-      size < sizeof(Header) + kMinStackDepth * sizeof(Activity) ||
-      // Ensure that the |stack_slots_| calculation didn't overflow.
-      (size - sizeof(Header)) / sizeof(Activity) >
-          std::numeric_limits<uint32_t>::max()) {
-    NOTREACHED();
-    return;
-  }
-
-  // Ensure that the thread reference doesn't exceed the size of the ID number.
-  // This won't compile at the global scope because Header is a private struct.
-  static_assert(
-      sizeof(header_->thread_ref) == sizeof(header_->thread_ref.as_id),
-      "PlatformThreadHandle::Handle is too big to hold in 64-bit ID");
-
-  // Ensure that the alignment of Activity.data is properly aligned to a
-  // 64-bit boundary so there are no interoperability-issues across cpu
-  // architectures.
-  static_assert(offsetof(Activity, data) % sizeof(uint64_t) == 0,
-                "ActivityData.data is not 64-bit aligned");
-
-  // Provided memory should either be completely initialized or all zeros.
-  if (header_->owner.data_id.load(std::memory_order_relaxed) == 0) {
-    // This is a new file. Double-check other fields and then initialize.
-    DCHECK_EQ(0, header_->owner.process_id);
-    DCHECK_EQ(0, header_->owner.create_stamp);
-    DCHECK_EQ(0, header_->thread_ref.as_id);
-    DCHECK_EQ(0, header_->start_time);
-    DCHECK_EQ(0, header_->start_ticks);
-    DCHECK_EQ(0U, header_->stack_slots);
-    DCHECK_EQ(0U, header_->current_depth.load(std::memory_order_relaxed));
-    DCHECK_EQ(0U, header_->data_version.load(std::memory_order_relaxed));
-    DCHECK_EQ(0, stack_[0].time_internal);
-    DCHECK_EQ(0U, stack_[0].origin_address);
-    DCHECK_EQ(0U, stack_[0].call_stack[0]);
-    DCHECK_EQ(0U, stack_[0].data.task.sequence_id);
-
-#if defined(OS_WIN)
-    header_->thread_ref.as_tid = PlatformThread::CurrentId();
-#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
-    header_->thread_ref.as_handle =
-        PlatformThread::CurrentHandle().platform_handle();
-#endif
-
-    header_->start_time = base::Time::Now().ToInternalValue();
-    header_->start_ticks = base::TimeTicks::Now().ToInternalValue();
-    header_->stack_slots = stack_slots_;
-    strlcpy(header_->thread_name, PlatformThread::GetName(),
-            sizeof(header_->thread_name));
-
-    // This is done last so as to guarantee that everything above is "released"
-    // by the time this value gets written.
-    header_->owner.Release_Initialize();
-
-    valid_ = true;
-    DCHECK(IsValid());
-  } else {
-    // This is a file with existing data. Perform basic consistency checks.
-    valid_ = true;
-    valid_ = IsValid();
-  }
-}
-
-ThreadActivityTracker::~ThreadActivityTracker() = default;
-
-ThreadActivityTracker::ActivityId ThreadActivityTracker::PushActivity(
-    const void* program_counter,
-    const void* origin,
-    Activity::Type type,
-    const ActivityData& data) {
-  // A thread-checker creates a lock to check the thread-id which means
-  // re-entry into this code if lock acquisitions are being tracked.
-  DCHECK(type == Activity::ACT_LOCK_ACQUIRE || CalledOnValidThread());
-
-  // Get the current depth of the stack. No access to other memory guarded
-  // by this variable is done here so a "relaxed" load is acceptable.
-  uint32_t depth = header_->current_depth.load(std::memory_order_relaxed);
-
-  // Handle the case where the stack depth has exceeded the storage capacity.
-  // Extra entries will be lost leaving only the base of the stack.
-  if (depth >= stack_slots_) {
-    // Since no other threads modify the data, no compare/exchange is needed.
-    // Since no other memory is being modified, a "relaxed" store is acceptable.
-    header_->current_depth.store(depth + 1, std::memory_order_relaxed);
-    return depth;
-  }
-
-  // Get a pointer to the next activity and load it. No atomicity is required
-  // here because the memory is known only to this thread. It will be made
-  // known to other threads once the depth is incremented.
-  Activity::FillFrom(&stack_[depth], program_counter, origin, type, data);
-
-  // Save the incremented depth. Because this guards |activity| memory filled
-  // above that may be read by another thread once the recorded depth changes,
-  // a "release" store is required.
-  header_->current_depth.store(depth + 1, std::memory_order_release);
-
-  // The current depth is used as the activity ID because it simply identifies
-  // an entry. Once an entry is pop'd, it's okay to reuse the ID.
-  return depth;
-}
-
-void ThreadActivityTracker::ChangeActivity(ActivityId id,
-                                           Activity::Type type,
-                                           const ActivityData& data) {
-  DCHECK(CalledOnValidThread());
-  DCHECK(type != Activity::ACT_NULL || &data != &kNullActivityData);
-  DCHECK_LT(id, header_->current_depth.load(std::memory_order_acquire));
-
-  // Update the information if it is being recorded (i.e. within slot limit).
-  if (id < stack_slots_) {
-    Activity* activity = &stack_[id];
-
-    if (type != Activity::ACT_NULL) {
-      DCHECK_EQ(activity->activity_type & Activity::ACT_CATEGORY_MASK,
-                type & Activity::ACT_CATEGORY_MASK);
-      activity->activity_type = type;
-    }
-
-    if (&data != &kNullActivityData)
-      activity->data = data;
-  }
-}
-
-void ThreadActivityTracker::PopActivity(ActivityId id) {
-  // Do an atomic decrement of the depth. No changes to stack entries guarded
-  // by this variable are done here so a "relaxed" operation is acceptable.
-  // |depth| will receive the value BEFORE it was modified which means the
-  // return value must also be decremented. The slot will be "free" after
-  // this call but since only a single thread can access this object, the
-  // data will remain valid until this method returns or calls outside.
-  uint32_t depth =
-      header_->current_depth.fetch_sub(1, std::memory_order_relaxed) - 1;
-
-  // Validate that everything is running correctly.
-  DCHECK_EQ(id, depth);
-
-  // A thread-checker creates a lock to check the thread-id which means
-  // re-entry into this code if lock acquisitions are being tracked.
-  DCHECK(stack_[depth].activity_type == Activity::ACT_LOCK_ACQUIRE ||
-         CalledOnValidThread());
-
-  // The stack has shrunk meaning that some other thread trying to copy the
-  // contents for reporting purposes could get bad data. Increment the data
-  // version so that it con tell that things have changed. This needs to
-  // happen after the atomic |depth| operation above so a "release" store
-  // is required.
-  header_->data_version.fetch_add(1, std::memory_order_release);
-}
-
-std::unique_ptr<ActivityUserData> ThreadActivityTracker::GetUserData(
-    ActivityId id,
-    ActivityTrackerMemoryAllocator* allocator) {
-  // Don't allow user data for lock acquisition as recursion may occur.
-  if (stack_[id].activity_type == Activity::ACT_LOCK_ACQUIRE) {
-    NOTREACHED();
-    return std::make_unique<ActivityUserData>();
-  }
-
-  // User-data is only stored for activities actually held in the stack.
-  if (id >= stack_slots_)
-    return std::make_unique<ActivityUserData>();
-
-  // Create and return a real UserData object.
-  return CreateUserDataForActivity(&stack_[id], allocator);
-}
-
-bool ThreadActivityTracker::HasUserData(ActivityId id) {
-  // User-data is only stored for activities actually held in the stack.
-  return (id < stack_slots_ && stack_[id].user_data_ref);
-}
-
-void ThreadActivityTracker::ReleaseUserData(
-    ActivityId id,
-    ActivityTrackerMemoryAllocator* allocator) {
-  // User-data is only stored for activities actually held in the stack.
-  if (id < stack_slots_ && stack_[id].user_data_ref) {
-    allocator->ReleaseObjectReference(stack_[id].user_data_ref);
-    stack_[id].user_data_ref = 0;
-  }
-}
-
-void ThreadActivityTracker::RecordExceptionActivity(const void* program_counter,
-                                                    const void* origin,
-                                                    Activity::Type type,
-                                                    const ActivityData& data) {
-  // A thread-checker creates a lock to check the thread-id which means
-  // re-entry into this code if lock acquisitions are being tracked.
-  DCHECK(CalledOnValidThread());
-
-  // Fill the reusable exception activity.
-  Activity::FillFrom(&header_->last_exception, program_counter, origin, type,
-                     data);
-
-  // The data has changed meaning that some other thread trying to copy the
-  // contents for reporting purposes could get bad data.
-  header_->data_version.fetch_add(1, std::memory_order_relaxed);
-}
-
-bool ThreadActivityTracker::IsValid() const {
-  if (header_->owner.data_id.load(std::memory_order_acquire) == 0 ||
-      header_->owner.process_id == 0 || header_->thread_ref.as_id == 0 ||
-      header_->start_time == 0 || header_->start_ticks == 0 ||
-      header_->stack_slots != stack_slots_ ||
-      header_->thread_name[sizeof(header_->thread_name) - 1] != '\0') {
-    return false;
-  }
-
-  return valid_;
-}
-
-bool ThreadActivityTracker::CreateSnapshot(Snapshot* output_snapshot) const {
-  DCHECK(output_snapshot);
-
-  // There is no "called on valid thread" check for this method as it can be
-  // called from other threads or even other processes. It is also the reason
-  // why atomic operations must be used in certain places above.
-
-  // It's possible for the data to change while reading it in such a way that it
-  // invalidates the read. Make several attempts but don't try forever.
-  const int kMaxAttempts = 10;
-  uint32_t depth;
-
-  // Stop here if the data isn't valid.
-  if (!IsValid())
-    return false;
-
-  // Allocate the maximum size for the stack so it doesn't have to be done
-  // during the time-sensitive snapshot operation. It is shrunk once the
-  // actual size is known.
-  output_snapshot->activity_stack.reserve(stack_slots_);
-
-  for (int attempt = 0; attempt < kMaxAttempts; ++attempt) {
-    // Remember the data IDs to ensure nothing is replaced during the snapshot
-    // operation. Use "acquire" so that all the non-atomic fields of the
-    // structure are valid (at least at the current moment in time).
-    const uint32_t starting_id =
-        header_->owner.data_id.load(std::memory_order_acquire);
-    const int64_t starting_create_stamp = header_->owner.create_stamp;
-    const int64_t starting_process_id = header_->owner.process_id;
-    const int64_t starting_thread_id = header_->thread_ref.as_id;
-
-    // Note the current |data_version| so it's possible to detect at the end
-    // that nothing has changed since copying the data began. A "cst" operation
-    // is required to ensure it occurs before everything else. Using "cst"
-    // memory ordering is relatively expensive but this is only done during
-    // analysis so doesn't directly affect the worker threads.
-    const uint32_t pre_version =
-        header_->data_version.load(std::memory_order_seq_cst);
-
-    // Fetching the current depth also "acquires" the contents of the stack.
-    depth = header_->current_depth.load(std::memory_order_acquire);
-    uint32_t count = std::min(depth, stack_slots_);
-    output_snapshot->activity_stack.resize(count);
-    if (count > 0) {
-      // Copy the existing contents. Memcpy is used for speed.
-      memcpy(&output_snapshot->activity_stack[0], stack_,
-             count * sizeof(Activity));
-    }
-
-    // Capture the last exception.
-    memcpy(&output_snapshot->last_exception, &header_->last_exception,
-           sizeof(Activity));
-
-    // TODO(bcwhite): Snapshot other things here.
-
-    // Retry if something changed during the copy. A "cst" operation ensures
-    // it must happen after all the above operations.
-    if (header_->data_version.load(std::memory_order_seq_cst) != pre_version)
-      continue;
-
-    // Stack copied. Record it's full depth.
-    output_snapshot->activity_stack_depth = depth;
-
-    // Get the general thread information.
-    output_snapshot->thread_name =
-        std::string(header_->thread_name, sizeof(header_->thread_name) - 1);
-    output_snapshot->create_stamp = header_->owner.create_stamp;
-    output_snapshot->thread_id = header_->thread_ref.as_id;
-    output_snapshot->process_id = header_->owner.process_id;
-
-    // All characters of the thread-name buffer were copied so as to not break
-    // if the trailing NUL were missing. Now limit the length if the actual
-    // name is shorter.
-    output_snapshot->thread_name.resize(
-        strlen(output_snapshot->thread_name.c_str()));
-
-    // If the data ID has changed then the tracker has exited and the memory
-    // reused by a new one. Try again.
-    if (header_->owner.data_id.load(std::memory_order_seq_cst) != starting_id ||
-        output_snapshot->create_stamp != starting_create_stamp ||
-        output_snapshot->process_id != starting_process_id ||
-        output_snapshot->thread_id != starting_thread_id) {
-      continue;
-    }
-
-    // Only successful if the data is still valid once everything is done since
-    // it's possible for the thread to end somewhere in the middle and all its
-    // values become garbage.
-    if (!IsValid())
-      return false;
-
-    // Change all the timestamps in the activities from "ticks" to "wall" time.
-    const Time start_time = Time::FromInternalValue(header_->start_time);
-    const int64_t start_ticks = header_->start_ticks;
-    for (Activity& activity : output_snapshot->activity_stack) {
-      activity.time_internal =
-          WallTimeFromTickTime(start_ticks, activity.time_internal, start_time)
-              .ToInternalValue();
-    }
-    output_snapshot->last_exception.time_internal =
-        WallTimeFromTickTime(start_ticks,
-                             output_snapshot->last_exception.time_internal,
-                             start_time)
-            .ToInternalValue();
-
-    // Success!
-    return true;
-  }
-
-  // Too many attempts.
-  return false;
-}
-
-const void* ThreadActivityTracker::GetBaseAddress() {
-  return header_;
-}
-
-uint32_t ThreadActivityTracker::GetDataVersionForTesting() {
-  return header_->data_version.load(std::memory_order_relaxed);
-}
-
-void ThreadActivityTracker::SetOwningProcessIdForTesting(int64_t pid,
-                                                         int64_t stamp) {
-  header_->owner.SetOwningProcessIdForTesting(pid, stamp);
-}
-
-// static
-bool ThreadActivityTracker::GetOwningProcessId(const void* memory,
-                                               int64_t* out_id,
-                                               int64_t* out_stamp) {
-  const Header* header = reinterpret_cast<const Header*>(memory);
-  return OwningProcess::GetOwningProcessId(&header->owner, out_id, out_stamp);
-}
-
-// static
-size_t ThreadActivityTracker::SizeForStackDepth(int stack_depth) {
-  return static_cast<size_t>(stack_depth) * sizeof(Activity) + sizeof(Header);
-}
-
-bool ThreadActivityTracker::CalledOnValidThread() {
-#if DCHECK_IS_ON()
-  return thread_id_ == PlatformThreadRef();
-#else
-  return true;
-#endif
-}
-
-std::unique_ptr<ActivityUserData>
-ThreadActivityTracker::CreateUserDataForActivity(
-    Activity* activity,
-    ActivityTrackerMemoryAllocator* allocator) {
-  DCHECK_EQ(0U, activity->user_data_ref);
-
-  PersistentMemoryAllocator::Reference ref = allocator->GetObjectReference();
-  void* memory = allocator->GetAsArray<char>(ref, kUserDataSize);
-  if (memory) {
-    std::unique_ptr<ActivityUserData> user_data =
-        std::make_unique<ActivityUserData>(memory, kUserDataSize);
-    activity->user_data_ref = ref;
-    activity->user_data_id = user_data->id();
-    return user_data;
-  }
-
-  // Return a dummy object that will still accept (but ignore) Set() calls.
-  return std::make_unique<ActivityUserData>();
-}
-
-// The instantiation of the GlobalActivityTracker object.
-// The object held here will obviously not be destructed at process exit
-// but that's best since PersistentMemoryAllocator objects (that underlie
-// GlobalActivityTracker objects) are explicitly forbidden from doing anything
-// essential at exit anyway due to the fact that they depend on data managed
-// elsewhere and which could be destructed first. An AtomicWord is used instead
-// of std::atomic because the latter can create global ctors and dtors.
-subtle::AtomicWord GlobalActivityTracker::g_tracker_ = 0;
-
-GlobalActivityTracker::ModuleInfo::ModuleInfo() = default;
-GlobalActivityTracker::ModuleInfo::ModuleInfo(ModuleInfo&& rhs) = default;
-GlobalActivityTracker::ModuleInfo::ModuleInfo(const ModuleInfo& rhs) = default;
-GlobalActivityTracker::ModuleInfo::~ModuleInfo() = default;
-
-GlobalActivityTracker::ModuleInfo& GlobalActivityTracker::ModuleInfo::operator=(
-    ModuleInfo&& rhs) = default;
-GlobalActivityTracker::ModuleInfo& GlobalActivityTracker::ModuleInfo::operator=(
-    const ModuleInfo& rhs) = default;
-
-GlobalActivityTracker::ModuleInfoRecord::ModuleInfoRecord() = default;
-GlobalActivityTracker::ModuleInfoRecord::~ModuleInfoRecord() = default;
-
-bool GlobalActivityTracker::ModuleInfoRecord::DecodeTo(
-    GlobalActivityTracker::ModuleInfo* info,
-    size_t record_size) const {
-  // Get the current "changes" indicator, acquiring all the other values.
-  uint32_t current_changes = changes.load(std::memory_order_acquire);
-
-  // Copy out the dynamic information.
-  info->is_loaded = loaded != 0;
-  info->address = static_cast<uintptr_t>(address);
-  info->load_time = load_time;
-
-  // Check to make sure no information changed while being read. A "seq-cst"
-  // operation is expensive but is only done during analysis and it's the only
-  // way to ensure this occurs after all the accesses above. If changes did
-  // occur then return a "not loaded" result so that |size| and |address|
-  // aren't expected to be accurate.
-  if ((current_changes & kModuleInformationChanging) != 0 ||
-      changes.load(std::memory_order_seq_cst) != current_changes) {
-    info->is_loaded = false;
-  }
-
-  // Copy out the static information. These never change so don't have to be
-  // protected by the atomic |current_changes| operations.
-  info->size = static_cast<size_t>(size);
-  info->timestamp = timestamp;
-  info->age = age;
-  memcpy(info->identifier, identifier, sizeof(info->identifier));
-
-  if (offsetof(ModuleInfoRecord, pickle) + pickle_size > record_size)
-    return false;
-  Pickle pickler(pickle, pickle_size);
-  PickleIterator iter(pickler);
-  return iter.ReadString(&info->file) && iter.ReadString(&info->debug_file);
-}
-
-GlobalActivityTracker::ModuleInfoRecord*
-GlobalActivityTracker::ModuleInfoRecord::CreateFrom(
-    const GlobalActivityTracker::ModuleInfo& info,
-    PersistentMemoryAllocator* allocator) {
-  Pickle pickler;
-  pickler.WriteString(info.file);
-  pickler.WriteString(info.debug_file);
-  size_t required_size = offsetof(ModuleInfoRecord, pickle) + pickler.size();
-  ModuleInfoRecord* record = allocator->New<ModuleInfoRecord>(required_size);
-  if (!record)
-    return nullptr;
-
-  // These fields never changes and are done before the record is made
-  // iterable so no thread protection is necessary.
-  record->size = info.size;
-  record->timestamp = info.timestamp;
-  record->age = info.age;
-  memcpy(record->identifier, info.identifier, sizeof(identifier));
-  memcpy(record->pickle, pickler.data(), pickler.size());
-  record->pickle_size = pickler.size();
-  record->changes.store(0, std::memory_order_relaxed);
-
-  // Initialize the owner info.
-  record->owner.Release_Initialize();
-
-  // Now set those fields that can change.
-  bool success = record->UpdateFrom(info);
-  DCHECK(success);
-  return record;
-}
-
-bool GlobalActivityTracker::ModuleInfoRecord::UpdateFrom(
-    const GlobalActivityTracker::ModuleInfo& info) {
-  // Updates can occur after the record is made visible so make changes atomic.
-  // A "strong" exchange ensures no false failures.
-  uint32_t old_changes = changes.load(std::memory_order_relaxed);
-  uint32_t new_changes = old_changes | kModuleInformationChanging;
-  if ((old_changes & kModuleInformationChanging) != 0 ||
-      !changes.compare_exchange_strong(old_changes, new_changes,
-                                       std::memory_order_acquire,
-                                       std::memory_order_acquire)) {
-    NOTREACHED() << "Multiple sources are updating module information.";
-    return false;
-  }
-
-  loaded = info.is_loaded ? 1 : 0;
-  address = info.address;
-  load_time = Time::Now().ToInternalValue();
-
-  bool success = changes.compare_exchange_strong(new_changes, old_changes + 1,
-                                                 std::memory_order_release,
-                                                 std::memory_order_relaxed);
-  DCHECK(success);
-  return true;
-}
-
-GlobalActivityTracker::ScopedThreadActivity::ScopedThreadActivity(
-    const void* program_counter,
-    const void* origin,
-    Activity::Type type,
-    const ActivityData& data,
-    bool lock_allowed)
-    : ThreadActivityTracker::ScopedActivity(GetOrCreateTracker(lock_allowed),
-                                            program_counter,
-                                            origin,
-                                            type,
-                                            data) {}
-
-GlobalActivityTracker::ScopedThreadActivity::~ScopedThreadActivity() {
-  if (tracker_ && tracker_->HasUserData(activity_id_)) {
-    GlobalActivityTracker* global = GlobalActivityTracker::Get();
-    AutoLock lock(global->user_data_allocator_lock_);
-    tracker_->ReleaseUserData(activity_id_, &global->user_data_allocator_);
-  }
-}
-
-ActivityUserData& GlobalActivityTracker::ScopedThreadActivity::user_data() {
-  if (!user_data_) {
-    if (tracker_) {
-      GlobalActivityTracker* global = GlobalActivityTracker::Get();
-      AutoLock lock(global->user_data_allocator_lock_);
-      user_data_ =
-          tracker_->GetUserData(activity_id_, &global->user_data_allocator_);
-    } else {
-      user_data_ = std::make_unique<ActivityUserData>();
-    }
-  }
-  return *user_data_;
-}
-
-GlobalActivityTracker::ThreadSafeUserData::ThreadSafeUserData(void* memory,
-                                                              size_t size,
-                                                              int64_t pid)
-    : ActivityUserData(memory, size, pid) {}
-
-GlobalActivityTracker::ThreadSafeUserData::~ThreadSafeUserData() = default;
-
-void GlobalActivityTracker::ThreadSafeUserData::Set(StringPiece name,
-                                                    ValueType type,
-                                                    const void* memory,
-                                                    size_t size) {
-  AutoLock lock(data_lock_);
-  ActivityUserData::Set(name, type, memory, size);
-}
-
-GlobalActivityTracker::ManagedActivityTracker::ManagedActivityTracker(
-    PersistentMemoryAllocator::Reference mem_reference,
-    void* base,
-    size_t size)
-    : ThreadActivityTracker(base, size),
-      mem_reference_(mem_reference),
-      mem_base_(base) {}
-
-GlobalActivityTracker::ManagedActivityTracker::~ManagedActivityTracker() {
-  // The global |g_tracker_| must point to the owner of this class since all
-  // objects of this type must be destructed before |g_tracker_| can be changed
-  // (something that only occurs in tests).
-  DCHECK(g_tracker_);
-  GlobalActivityTracker::Get()->ReturnTrackerMemory(this);
-}
-
-void GlobalActivityTracker::CreateWithAllocator(
-    std::unique_ptr<PersistentMemoryAllocator> allocator,
-    int stack_depth,
-    int64_t process_id) {
-  // There's no need to do anything with the result. It is self-managing.
-  GlobalActivityTracker* global_tracker =
-      new GlobalActivityTracker(std::move(allocator), stack_depth, process_id);
-  // Create a tracker for this thread since it is known.
-  global_tracker->CreateTrackerForCurrentThread();
-}
-
-#if !defined(OS_NACL)
-// static
-bool GlobalActivityTracker::CreateWithFile(const FilePath& file_path,
-                                           size_t size,
-                                           uint64_t id,
-                                           StringPiece name,
-                                           int stack_depth) {
-  DCHECK(!file_path.empty());
-  DCHECK_GE(static_cast<uint64_t>(std::numeric_limits<int64_t>::max()), size);
-
-  // Create and map the file into memory and make it globally available.
-  std::unique_ptr<MemoryMappedFile> mapped_file(new MemoryMappedFile());
-  bool success = mapped_file->Initialize(
-      File(file_path, File::FLAG_CREATE_ALWAYS | File::FLAG_READ |
-                          File::FLAG_WRITE | File::FLAG_SHARE_DELETE),
-      {0, size}, MemoryMappedFile::READ_WRITE_EXTEND);
-  if (!success)
-    return false;
-  if (!FilePersistentMemoryAllocator::IsFileAcceptable(*mapped_file, false))
-    return false;
-  CreateWithAllocator(std::make_unique<FilePersistentMemoryAllocator>(
-                          std::move(mapped_file), size, id, name, false),
-                      stack_depth, 0);
-  return true;
-}
-#endif  // !defined(OS_NACL)
-
-// static
-bool GlobalActivityTracker::CreateWithLocalMemory(size_t size,
-                                                  uint64_t id,
-                                                  StringPiece name,
-                                                  int stack_depth,
-                                                  int64_t process_id) {
-  CreateWithAllocator(
-      std::make_unique<LocalPersistentMemoryAllocator>(size, id, name),
-      stack_depth, process_id);
-  return true;
-}
-
-// static
-bool GlobalActivityTracker::CreateWithSharedMemory(
-    std::unique_ptr<SharedMemory> shm,
-    uint64_t id,
-    StringPiece name,
-    int stack_depth) {
-  if (shm->mapped_size() == 0 ||
-      !SharedPersistentMemoryAllocator::IsSharedMemoryAcceptable(*shm)) {
-    return false;
-  }
-  CreateWithAllocator(std::make_unique<SharedPersistentMemoryAllocator>(
-                          std::move(shm), id, name, false),
-                      stack_depth, 0);
-  return true;
-}
-
-// static
-bool GlobalActivityTracker::CreateWithSharedMemoryHandle(
-    const SharedMemoryHandle& handle,
-    size_t size,
-    uint64_t id,
-    StringPiece name,
-    int stack_depth) {
-  std::unique_ptr<SharedMemory> shm(
-      new SharedMemory(handle, /*readonly=*/false));
-  if (!shm->Map(size))
-    return false;
-  return CreateWithSharedMemory(std::move(shm), id, name, stack_depth);
-}
-
-// static
-void GlobalActivityTracker::SetForTesting(
-    std::unique_ptr<GlobalActivityTracker> tracker) {
-  CHECK(!subtle::NoBarrier_Load(&g_tracker_));
-  subtle::Release_Store(&g_tracker_,
-                        reinterpret_cast<uintptr_t>(tracker.release()));
-}
-
-// static
-std::unique_ptr<GlobalActivityTracker>
-GlobalActivityTracker::ReleaseForTesting() {
-  GlobalActivityTracker* tracker = Get();
-  if (!tracker)
-    return nullptr;
-
-  // Thread trackers assume that the global tracker is present for some
-  // operations so ensure that there aren't any.
-  tracker->ReleaseTrackerForCurrentThreadForTesting();
-  DCHECK_EQ(0, tracker->thread_tracker_count_.load(std::memory_order_relaxed));
-
-  subtle::Release_Store(&g_tracker_, 0);
-  return WrapUnique(tracker);
-}
-
-ThreadActivityTracker* GlobalActivityTracker::CreateTrackerForCurrentThread() {
-  DCHECK(!this_thread_tracker_.Get());
-
-  PersistentMemoryAllocator::Reference mem_reference;
-
-  {
-    base::AutoLock autolock(thread_tracker_allocator_lock_);
-    mem_reference = thread_tracker_allocator_.GetObjectReference();
-  }
-
-  if (!mem_reference) {
-    // Failure. This shouldn't happen. But be graceful if it does, probably
-    // because the underlying allocator wasn't given enough memory to satisfy
-    // to all possible requests.
-    NOTREACHED();
-    // Report the thread-count at which the allocator was full so that the
-    // failure can be seen and underlying memory resized appropriately.
-    UMA_HISTOGRAM_COUNTS_1000(
-        "ActivityTracker.ThreadTrackers.MemLimitTrackerCount",
-        thread_tracker_count_.load(std::memory_order_relaxed));
-    // Return null, just as if tracking wasn't enabled.
-    return nullptr;
-  }
-
-  // Convert the memory block found above into an actual memory address.
-  // Doing the conversion as a Header object enacts the 32/64-bit size
-  // consistency checks which would not otherwise be done. Unfortunately,
-  // some older compilers and MSVC don't have standard-conforming definitions
-  // of std::atomic which cause it not to be plain-old-data. Don't check on
-  // those platforms assuming that the checks on other platforms will be
-  // sufficient.
-  // TODO(bcwhite): Review this after major compiler releases.
-  DCHECK(mem_reference);
-  void* mem_base;
-  mem_base =
-      allocator_->GetAsObject<ThreadActivityTracker::Header>(mem_reference);
-
-  DCHECK(mem_base);
-  DCHECK_LE(stack_memory_size_, allocator_->GetAllocSize(mem_reference));
-
-  // Create a tracker with the acquired memory and set it as the tracker
-  // for this particular thread in thread-local-storage.
-  ManagedActivityTracker* tracker =
-      new ManagedActivityTracker(mem_reference, mem_base, stack_memory_size_);
-  DCHECK(tracker->IsValid());
-  this_thread_tracker_.Set(tracker);
-  int old_count = thread_tracker_count_.fetch_add(1, std::memory_order_relaxed);
-
-  UMA_HISTOGRAM_EXACT_LINEAR("ActivityTracker.ThreadTrackers.Count",
-                             old_count + 1, static_cast<int>(kMaxThreadCount));
-  return tracker;
-}
-
-void GlobalActivityTracker::ReleaseTrackerForCurrentThreadForTesting() {
-  ThreadActivityTracker* tracker =
-      reinterpret_cast<ThreadActivityTracker*>(this_thread_tracker_.Get());
-  if (tracker) {
-    this_thread_tracker_.Set(nullptr);
-    delete tracker;
-  }
-}
-
-void GlobalActivityTracker::SetBackgroundTaskRunner(
-    const scoped_refptr<TaskRunner>& runner) {
-  AutoLock lock(global_tracker_lock_);
-  background_task_runner_ = runner;
-}
-
-void GlobalActivityTracker::SetProcessExitCallback(
-    ProcessExitCallback callback) {
-  AutoLock lock(global_tracker_lock_);
-  process_exit_callback_ = callback;
-}
-
-void GlobalActivityTracker::RecordProcessLaunch(
-    ProcessId process_id,
-    const FilePath::StringType& cmd) {
-  const int64_t pid = process_id;
-  DCHECK_NE(GetProcessId(), pid);
-  DCHECK_NE(0, pid);
-
-  base::AutoLock lock(global_tracker_lock_);
-  if (base::ContainsKey(known_processes_, pid)) {
-    // TODO(bcwhite): Measure this in UMA.
-    NOTREACHED() << "Process #" << process_id
-                 << " was previously recorded as \"launched\""
-                 << " with no corresponding exit.\n"
-                 << known_processes_[pid];
-    known_processes_.erase(pid);
-  }
-
-#if defined(OS_WIN)
-  known_processes_.insert(std::make_pair(pid, UTF16ToUTF8(cmd)));
-#else
-  known_processes_.insert(std::make_pair(pid, cmd));
-#endif
-}
-
-void GlobalActivityTracker::RecordProcessLaunch(
-    ProcessId process_id,
-    const FilePath::StringType& exe,
-    const FilePath::StringType& args) {
-  if (exe.find(FILE_PATH_LITERAL(" "))) {
-    RecordProcessLaunch(process_id,
-                        FilePath::StringType(FILE_PATH_LITERAL("\"")) + exe +
-                            FILE_PATH_LITERAL("\" ") + args);
-  } else {
-    RecordProcessLaunch(process_id, exe + FILE_PATH_LITERAL(' ') + args);
-  }
-}
-
-void GlobalActivityTracker::RecordProcessExit(ProcessId process_id,
-                                              int exit_code) {
-  const int64_t pid = process_id;
-  DCHECK_NE(GetProcessId(), pid);
-  DCHECK_NE(0, pid);
-
-  scoped_refptr<TaskRunner> task_runner;
-  std::string command_line;
-  {
-    base::AutoLock lock(global_tracker_lock_);
-    task_runner = background_task_runner_;
-    auto found = known_processes_.find(pid);
-    if (found != known_processes_.end()) {
-      command_line = std::move(found->second);
-      known_processes_.erase(found);
-    } else {
-      DLOG(ERROR) << "Recording exit of unknown process #" << process_id;
-    }
-  }
-
-  // Use the current time to differentiate the process that just exited
-  // from any that might be created in the future with the same ID.
-  int64_t now_stamp = Time::Now().ToInternalValue();
-
-  // The persistent allocator is thread-safe so run the iteration and
-  // adjustments on a worker thread if one was provided.
-  if (task_runner && !task_runner->RunsTasksInCurrentSequence()) {
-    task_runner->PostTask(
-        FROM_HERE,
-        BindOnce(&GlobalActivityTracker::CleanupAfterProcess, Unretained(this),
-                 pid, now_stamp, exit_code, std::move(command_line)));
-    return;
-  }
-
-  CleanupAfterProcess(pid, now_stamp, exit_code, std::move(command_line));
-}
-
-void GlobalActivityTracker::SetProcessPhase(ProcessPhase phase) {
-  process_data().SetInt(kProcessPhaseDataKey, phase);
-}
-
-void GlobalActivityTracker::CleanupAfterProcess(int64_t process_id,
-                                                int64_t exit_stamp,
-                                                int exit_code,
-                                                std::string&& command_line) {
-  // The process may not have exited cleanly so its necessary to go through
-  // all the data structures it may have allocated in the persistent memory
-  // segment and mark them as "released". This will allow them to be reused
-  // later on.
-
-  PersistentMemoryAllocator::Iterator iter(allocator_.get());
-  PersistentMemoryAllocator::Reference ref;
-
-  ProcessExitCallback process_exit_callback;
-  {
-    AutoLock lock(global_tracker_lock_);
-    process_exit_callback = process_exit_callback_;
-  }
-  if (process_exit_callback) {
-    // Find the processes user-data record so the process phase can be passed
-    // to the callback.
-    ActivityUserData::Snapshot process_data_snapshot;
-    while ((ref = iter.GetNextOfType(kTypeIdProcessDataRecord)) != 0) {
-      const void* memory = allocator_->GetAsArray<char>(
-          ref, kTypeIdProcessDataRecord, PersistentMemoryAllocator::kSizeAny);
-      if (!memory)
-        continue;
-      int64_t found_id;
-      int64_t create_stamp;
-      if (ActivityUserData::GetOwningProcessId(memory, &found_id,
-                                               &create_stamp)) {
-        if (found_id == process_id && create_stamp < exit_stamp) {
-          const ActivityUserData process_data(const_cast<void*>(memory),
-                                              allocator_->GetAllocSize(ref));
-          process_data.CreateSnapshot(&process_data_snapshot);
-          break;  // No need to look for any others.
-        }
-      }
-    }
-    iter.Reset();  // So it starts anew when used below.
-
-    // Record the process's phase at exit so callback doesn't need to go
-    // searching based on a private key value.
-    ProcessPhase exit_phase = PROCESS_PHASE_UNKNOWN;
-    auto phase = process_data_snapshot.find(kProcessPhaseDataKey);
-    if (phase != process_data_snapshot.end())
-      exit_phase = static_cast<ProcessPhase>(phase->second.GetInt());
-
-    // Perform the callback.
-    process_exit_callback.Run(process_id, exit_stamp, exit_code, exit_phase,
-                              std::move(command_line),
-                              std::move(process_data_snapshot));
-  }
-
-  // Find all allocations associated with the exited process and free them.
-  uint32_t type;
-  while ((ref = iter.GetNext(&type)) != 0) {
-    switch (type) {
-      case kTypeIdActivityTracker:
-      case kTypeIdUserDataRecord:
-      case kTypeIdProcessDataRecord:
-      case ModuleInfoRecord::kPersistentTypeId: {
-        const void* memory = allocator_->GetAsArray<char>(
-            ref, type, PersistentMemoryAllocator::kSizeAny);
-        if (!memory)
-          continue;
-        int64_t found_id;
-        int64_t create_stamp;
-
-        // By convention, the OwningProcess structure is always the first
-        // field of the structure so there's no need to handle all the
-        // cases separately.
-        if (OwningProcess::GetOwningProcessId(memory, &found_id,
-                                              &create_stamp)) {
-          // Only change the type to be "free" if the process ID matches and
-          // the creation time is before the exit time (so PID re-use doesn't
-          // cause the erasure of something that is in-use). Memory is cleared
-          // here, rather than when it's needed, so as to limit the impact at
-          // that critical time.
-          if (found_id == process_id && create_stamp < exit_stamp)
-            allocator_->ChangeType(ref, ~type, type, /*clear=*/true);
-        }
-      } break;
-    }
-  }
-}
-
-void GlobalActivityTracker::RecordLogMessage(StringPiece message) {
-  // Allocate at least one extra byte so the string is NUL terminated. All
-  // memory returned by the allocator is guaranteed to be zeroed.
-  PersistentMemoryAllocator::Reference ref =
-      allocator_->Allocate(message.size() + 1, kTypeIdGlobalLogMessage);
-  char* memory = allocator_->GetAsArray<char>(ref, kTypeIdGlobalLogMessage,
-                                              message.size() + 1);
-  if (memory) {
-    memcpy(memory, message.data(), message.size());
-    allocator_->MakeIterable(ref);
-  }
-}
-
-void GlobalActivityTracker::RecordModuleInfo(const ModuleInfo& info) {
-  AutoLock lock(modules_lock_);
-  auto found = modules_.find(info.file);
-  if (found != modules_.end()) {
-    ModuleInfoRecord* record = found->second;
-    DCHECK(record);
-
-    // Update the basic state of module information that has been already
-    // recorded. It is assumed that the string information (identifier,
-    // version, etc.) remain unchanged which means that there's no need
-    // to create a new record to accommodate a possibly longer length.
-    record->UpdateFrom(info);
-    return;
-  }
-
-  ModuleInfoRecord* record =
-      ModuleInfoRecord::CreateFrom(info, allocator_.get());
-  if (!record)
-    return;
-  allocator_->MakeIterable(record);
-  modules_.emplace(info.file, record);
-}
-
-void GlobalActivityTracker::RecordFieldTrial(const std::string& trial_name,
-                                             StringPiece group_name) {
-  const std::string key = std::string("FieldTrial.") + trial_name;
-  process_data_.SetString(key, group_name);
-}
-
-void GlobalActivityTracker::RecordException(const void* pc,
-                                            const void* origin,
-                                            uint32_t code) {
-  RecordExceptionImpl(pc, origin, code);
-}
-
-void GlobalActivityTracker::MarkDeleted() {
-  allocator_->SetMemoryState(PersistentMemoryAllocator::MEMORY_DELETED);
-}
-
-GlobalActivityTracker::GlobalActivityTracker(
-    std::unique_ptr<PersistentMemoryAllocator> allocator,
-    int stack_depth,
-    int64_t process_id)
-    : allocator_(std::move(allocator)),
-      stack_memory_size_(ThreadActivityTracker::SizeForStackDepth(stack_depth)),
-      process_id_(process_id == 0 ? GetCurrentProcId() : process_id),
-      this_thread_tracker_(&OnTLSDestroy),
-      thread_tracker_count_(0),
-      thread_tracker_allocator_(allocator_.get(),
-                                kTypeIdActivityTracker,
-                                kTypeIdActivityTrackerFree,
-                                stack_memory_size_,
-                                kCachedThreadMemories,
-                                /*make_iterable=*/true),
-      user_data_allocator_(allocator_.get(),
-                           kTypeIdUserDataRecord,
-                           kTypeIdUserDataRecordFree,
-                           kUserDataSize,
-                           kCachedUserDataMemories,
-                           /*make_iterable=*/true),
-      process_data_(allocator_->GetAsArray<char>(
-                        AllocateFrom(allocator_.get(),
-                                     kTypeIdProcessDataRecordFree,
-                                     kProcessDataSize,
-                                     kTypeIdProcessDataRecord),
-                        kTypeIdProcessDataRecord,
-                        kProcessDataSize),
-                    kProcessDataSize,
-                    process_id_) {
-  DCHECK_NE(0, process_id_);
-
-  // Ensure that there is no other global object and then make this one such.
-  DCHECK(!g_tracker_);
-  subtle::Release_Store(&g_tracker_, reinterpret_cast<uintptr_t>(this));
-
-  // The data records must be iterable in order to be found by an analyzer.
-  allocator_->MakeIterable(allocator_->GetAsReference(
-      process_data_.GetBaseAddress(), kTypeIdProcessDataRecord));
-
-  // Note that this process has launched.
-  SetProcessPhase(PROCESS_LAUNCHED);
-
-  // Fetch and record all activated field trials.
-  FieldTrial::ActiveGroups active_groups;
-  FieldTrialList::GetActiveFieldTrialGroups(&active_groups);
-  for (auto& group : active_groups)
-    RecordFieldTrial(group.trial_name, group.group_name);
-}
-
-GlobalActivityTracker::~GlobalActivityTracker() {
-  DCHECK(Get() == nullptr || Get() == this);
-  DCHECK_EQ(0, thread_tracker_count_.load(std::memory_order_relaxed));
-  subtle::Release_Store(&g_tracker_, 0);
-}
-
-void GlobalActivityTracker::ReturnTrackerMemory(
-    ManagedActivityTracker* tracker) {
-  PersistentMemoryAllocator::Reference mem_reference = tracker->mem_reference_;
-  void* mem_base = tracker->mem_base_;
-  DCHECK(mem_reference);
-  DCHECK(mem_base);
-
-  // Remove the destructed tracker from the set of known ones.
-  DCHECK_LE(1, thread_tracker_count_.load(std::memory_order_relaxed));
-  thread_tracker_count_.fetch_sub(1, std::memory_order_relaxed);
-
-  // Release this memory for re-use at a later time.
-  base::AutoLock autolock(thread_tracker_allocator_lock_);
-  thread_tracker_allocator_.ReleaseObjectReference(mem_reference);
-}
-
-void GlobalActivityTracker::RecordExceptionImpl(const void* pc,
-                                                const void* origin,
-                                                uint32_t code) {
-  // Get an existing tracker for this thread. It's not possible to create
-  // one at this point because such would involve memory allocations and
-  // other potentially complex operations that can cause failures if done
-  // within an exception handler. In most cases various operations will
-  // have already created the tracker so this shouldn't generally be a
-  // problem.
-  ThreadActivityTracker* tracker = GetTrackerForCurrentThread();
-  if (!tracker)
-    return;
-
-  tracker->RecordExceptionActivity(pc, origin, Activity::ACT_EXCEPTION,
-                                   ActivityData::ForException(code));
-}
-
-// static
-void GlobalActivityTracker::OnTLSDestroy(void* value) {
-  delete reinterpret_cast<ManagedActivityTracker*>(value);
-}
-
-ScopedActivity::ScopedActivity(const void* program_counter,
-                               uint8_t action,
-                               uint32_t id,
-                               int32_t info)
-    : GlobalActivityTracker::ScopedThreadActivity(
-          program_counter,
-          nullptr,
-          static_cast<Activity::Type>(Activity::ACT_GENERIC | action),
-          ActivityData::ForGeneric(id, info),
-          /*lock_allowed=*/true),
-      id_(id) {
-  // The action must not affect the category bits of the activity type.
-  DCHECK_EQ(0, action & Activity::ACT_CATEGORY_MASK);
-}
-
-void ScopedActivity::ChangeAction(uint8_t action) {
-  DCHECK_EQ(0, action & Activity::ACT_CATEGORY_MASK);
-  ChangeTypeAndData(static_cast<Activity::Type>(Activity::ACT_GENERIC | action),
-                    kNullActivityData);
-}
-
-void ScopedActivity::ChangeInfo(int32_t info) {
-  ChangeTypeAndData(Activity::ACT_NULL, ActivityData::ForGeneric(id_, info));
-}
-
-void ScopedActivity::ChangeActionAndInfo(uint8_t action, int32_t info) {
-  DCHECK_EQ(0, action & Activity::ACT_CATEGORY_MASK);
-  ChangeTypeAndData(static_cast<Activity::Type>(Activity::ACT_GENERIC | action),
-                    ActivityData::ForGeneric(id_, info));
-}
-
-ScopedTaskRunActivity::ScopedTaskRunActivity(
-    const void* program_counter,
-    const base::PendingTask& task)
-    : GlobalActivityTracker::ScopedThreadActivity(
-          program_counter,
-          task.posted_from.program_counter(),
-          Activity::ACT_TASK_RUN,
-          ActivityData::ForTask(task.sequence_num),
-          /*lock_allowed=*/true) {}
-
-ScopedLockAcquireActivity::ScopedLockAcquireActivity(
-    const void* program_counter,
-    const base::internal::LockImpl* lock)
-    : GlobalActivityTracker::ScopedThreadActivity(
-          program_counter,
-          nullptr,
-          Activity::ACT_LOCK_ACQUIRE,
-          ActivityData::ForLock(lock),
-          /*lock_allowed=*/false) {}
-
-ScopedEventWaitActivity::ScopedEventWaitActivity(
-    const void* program_counter,
-    const base::WaitableEvent* event)
-    : GlobalActivityTracker::ScopedThreadActivity(
-          program_counter,
-          nullptr,
-          Activity::ACT_EVENT_WAIT,
-          ActivityData::ForEvent(event),
-          /*lock_allowed=*/true) {}
-
-ScopedThreadJoinActivity::ScopedThreadJoinActivity(
-    const void* program_counter,
-    const base::PlatformThreadHandle* thread)
-    : GlobalActivityTracker::ScopedThreadActivity(
-          program_counter,
-          nullptr,
-          Activity::ACT_THREAD_JOIN,
-          ActivityData::ForThread(*thread),
-          /*lock_allowed=*/true) {}
-
-#if !defined(OS_NACL) && !defined(OS_IOS)
-ScopedProcessWaitActivity::ScopedProcessWaitActivity(
-    const void* program_counter,
-    const base::Process* process)
-    : GlobalActivityTracker::ScopedThreadActivity(
-          program_counter,
-          nullptr,
-          Activity::ACT_PROCESS_WAIT,
-          ActivityData::ForProcess(process->Pid()),
-          /*lock_allowed=*/true) {}
-#endif
-
-}  // namespace debug
-}  // namespace base
diff --git a/base/debug/activity_tracker.h b/base/debug/activity_tracker.h
deleted file mode 100644
index bfd9f9d..0000000
--- a/base/debug/activity_tracker.h
+++ /dev/null
@@ -1,1360 +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.
-
-// Activity tracking provides a low-overhead method of collecting information
-// about the state of the application for analysis both while it is running
-// and after it has terminated unexpectedly. Its primary purpose is to help
-// locate reasons the browser becomes unresponsive by providing insight into
-// what all the various threads and processes are (or were) doing.
-
-#ifndef BASE_DEBUG_ACTIVITY_TRACKER_H_
-#define BASE_DEBUG_ACTIVITY_TRACKER_H_
-
-// std::atomic is undesired due to performance issues when used as global
-// variables. There are no such instances here. This module uses the
-// PersistentMemoryAllocator which also uses std::atomic and is written
-// by the same author.
-#include <atomic>
-#include <map>
-#include <memory>
-#include <string>
-#include <vector>
-
-#include "base/atomicops.h"
-#include "base/base_export.h"
-#include "base/callback.h"
-#include "base/compiler_specific.h"
-#include "base/gtest_prod_util.h"
-#include "base/location.h"
-#include "base/memory/shared_memory.h"
-#include "base/metrics/persistent_memory_allocator.h"
-#include "base/process/process_handle.h"
-#include "base/strings/string_piece.h"
-#include "base/strings/utf_string_conversions.h"
-#include "base/task_runner.h"
-#include "base/threading/platform_thread.h"
-#include "base/threading/thread_local_storage.h"
-
-namespace base {
-
-struct PendingTask;
-
-class FilePath;
-class Lock;
-class PlatformThreadHandle;
-class Process;
-class WaitableEvent;
-
-namespace debug {
-
-class ThreadActivityTracker;
-
-
-enum : int {
-  // The maximum number of call-stack addresses stored per activity. This
-  // cannot be changed without also changing the version number of the
-  // structure. See kTypeIdActivityTracker in GlobalActivityTracker.
-  kActivityCallStackSize = 10,
-};
-
-// A class for keeping all information needed to verify that a structure is
-// associated with a given process.
-struct OwningProcess {
-  OwningProcess();
-  ~OwningProcess();
-
-  // Initializes structure with the current process id and the current time.
-  // These can uniquely identify a process. A unique non-zero data_id will be
-  // set making it possible to tell using atomic reads if the data has changed.
-  void Release_Initialize(int64_t pid = 0);
-
-  // Explicitly sets the process ID.
-  void SetOwningProcessIdForTesting(int64_t pid, int64_t stamp);
-
-  // Gets the associated process ID, in native form, and the creation timestamp
-  // from memory without loading the entire structure for analysis. This will
-  // return false if no valid process ID is available.
-  static bool GetOwningProcessId(const void* memory,
-                                 int64_t* out_id,
-                                 int64_t* out_stamp);
-
-  // SHA1(base::debug::OwningProcess): Increment this if structure changes!
-  static constexpr uint32_t kPersistentTypeId = 0xB1179672 + 1;
-
-  // Expected size for 32/64-bit check by PersistentMemoryAllocator.
-  static constexpr size_t kExpectedInstanceSize = 24;
-
-  std::atomic<uint32_t> data_id;
-  uint32_t padding;
-  int64_t process_id;
-  int64_t create_stamp;
-};
-
-// The data associated with an activity is dependent upon the activity type.
-// This union defines all of the various fields. All fields must be explicitly
-// sized types to ensure no interoperability problems between 32-bit and
-// 64-bit systems.
-union ActivityData {
-  // Expected size for 32/64-bit check.
-  // TODO(bcwhite): VC2015 doesn't allow statics in unions. Fix when it does.
-  // static constexpr size_t kExpectedInstanceSize = 8;
-
-  // Generic activities don't have any defined structure.
-  struct {
-    uint32_t id;   // An arbitrary identifier used for association.
-    int32_t info;  // An arbitrary value used for information purposes.
-  } generic;
-  struct {
-    uint64_t sequence_id;  // The sequence identifier of the posted task.
-  } task;
-  struct {
-    uint64_t lock_address;  // The memory address of the lock object.
-  } lock;
-  struct {
-    uint64_t event_address;  // The memory address of the event object.
-  } event;
-  struct {
-    int64_t thread_id;  // A unique identifier for a thread within a process.
-  } thread;
-  struct {
-    int64_t process_id;  // A unique identifier for a process.
-  } process;
-  struct {
-    uint32_t code;  // An "exception code" number.
-  } exception;
-
-  // These methods create an ActivityData object from the appropriate
-  // parameters. Objects of this type should always be created this way to
-  // ensure that no fields remain unpopulated should the set of recorded
-  // fields change. They're defined inline where practical because they
-  // reduce to loading a small local structure with a few values, roughly
-  // the same as loading all those values into parameters.
-
-  static ActivityData ForGeneric(uint32_t id, int32_t info) {
-    ActivityData data;
-    data.generic.id = id;
-    data.generic.info = info;
-    return data;
-  }
-
-  static ActivityData ForTask(uint64_t sequence) {
-    ActivityData data;
-    data.task.sequence_id = sequence;
-    return data;
-  }
-
-  static ActivityData ForLock(const void* lock) {
-    ActivityData data;
-    data.lock.lock_address = reinterpret_cast<uintptr_t>(lock);
-    return data;
-  }
-
-  static ActivityData ForEvent(const void* event) {
-    ActivityData data;
-    data.event.event_address = reinterpret_cast<uintptr_t>(event);
-    return data;
-  }
-
-  static ActivityData ForThread(const PlatformThreadHandle& handle);
-  static ActivityData ForThread(const int64_t id) {
-    ActivityData data;
-    data.thread.thread_id = id;
-    return data;
-  }
-
-  static ActivityData ForProcess(const int64_t id) {
-    ActivityData data;
-    data.process.process_id = id;
-    return data;
-  }
-
-  static ActivityData ForException(const uint32_t code) {
-    ActivityData data;
-    data.exception.code = code;
-    return data;
-  }
-};
-
-// A "null" activity-data that can be passed to indicate "do not change".
-extern const ActivityData kNullActivityData;
-
-
-// A helper class that is used for managing memory allocations within a
-// persistent memory allocator. Instances of this class are NOT thread-safe.
-// Use from a single thread or protect access with a lock.
-class BASE_EXPORT ActivityTrackerMemoryAllocator {
- public:
-  using Reference = PersistentMemoryAllocator::Reference;
-
-  // Creates a instance for allocating objects of a fixed |object_type|, a
-  // corresponding |object_free| type, and the |object_size|. An internal
-  // cache of the last |cache_size| released references will be kept for
-  // quick future fetches. If |make_iterable| then allocated objects will
-  // be marked "iterable" in the allocator.
-  ActivityTrackerMemoryAllocator(PersistentMemoryAllocator* allocator,
-                                 uint32_t object_type,
-                                 uint32_t object_free_type,
-                                 size_t object_size,
-                                 size_t cache_size,
-                                 bool make_iterable);
-  ~ActivityTrackerMemoryAllocator();
-
-  // Gets a reference to an object of the configured type. This can return
-  // a null reference if it was not possible to allocate the memory.
-  Reference GetObjectReference();
-
-  // Returns an object to the "free" pool.
-  void ReleaseObjectReference(Reference ref);
-
-  // Helper function to access an object allocated using this instance.
-  template <typename T>
-  T* GetAsObject(Reference ref) {
-    return allocator_->GetAsObject<T>(ref);
-  }
-
-  // Similar to GetAsObject() but converts references to arrays of objects.
-  template <typename T>
-  T* GetAsArray(Reference ref, size_t count) {
-    return allocator_->GetAsArray<T>(ref, object_type_, count);
-  }
-
-  // The current "used size" of the internal cache, visible for testing.
-  size_t cache_used() const { return cache_used_; }
-
- private:
-  PersistentMemoryAllocator* const allocator_;
-  const uint32_t object_type_;
-  const uint32_t object_free_type_;
-  const size_t object_size_;
-  const size_t cache_size_;
-  const bool make_iterable_;
-
-  // An iterator for going through persistent memory looking for free'd objects.
-  PersistentMemoryAllocator::Iterator iterator_;
-
-  // The cache of released object memories.
-  std::unique_ptr<Reference[]> cache_values_;
-  size_t cache_used_;
-
-  DISALLOW_COPY_AND_ASSIGN(ActivityTrackerMemoryAllocator);
-};
-
-
-// This structure is the full contents recorded for every activity pushed
-// onto the stack. The |activity_type| indicates what is actually stored in
-// the |data| field. All fields must be explicitly sized types to ensure no
-// interoperability problems between 32-bit and 64-bit systems.
-struct Activity {
-  // SHA1(base::debug::Activity): Increment this if structure changes!
-  static constexpr uint32_t kPersistentTypeId = 0x99425159 + 1;
-  // Expected size for 32/64-bit check. Update this if structure changes!
-  static constexpr size_t kExpectedInstanceSize =
-      48 + 8 * kActivityCallStackSize;
-
-  // The type of an activity on the stack. Activities are broken into
-  // categories with the category ID taking the top 4 bits and the lower
-  // bits representing an action within that category. This combination
-  // makes it easy to "switch" based on the type during analysis.
-  enum Type : uint8_t {
-    // This "null" constant is used to indicate "do not change" in calls.
-    ACT_NULL = 0,
-
-    // Task activities involve callbacks posted to a thread or thread-pool
-    // using the PostTask() method or any of its friends.
-    ACT_TASK = 1 << 4,
-    ACT_TASK_RUN = ACT_TASK,
-
-    // Lock activities involve the acquisition of "mutex" locks.
-    ACT_LOCK = 2 << 4,
-    ACT_LOCK_ACQUIRE = ACT_LOCK,
-    ACT_LOCK_RELEASE,
-
-    // Event activities involve operations on a WaitableEvent.
-    ACT_EVENT = 3 << 4,
-    ACT_EVENT_WAIT = ACT_EVENT,
-    ACT_EVENT_SIGNAL,
-
-    // Thread activities involve the life management of threads.
-    ACT_THREAD = 4 << 4,
-    ACT_THREAD_START = ACT_THREAD,
-    ACT_THREAD_JOIN,
-
-    // Process activities involve the life management of processes.
-    ACT_PROCESS = 5 << 4,
-    ACT_PROCESS_START = ACT_PROCESS,
-    ACT_PROCESS_WAIT,
-
-    // Exception activities indicate the occurence of something unexpected.
-    ACT_EXCEPTION = 14 << 4,
-
-    // Generic activities are user defined and can be anything.
-    ACT_GENERIC = 15 << 4,
-
-    // These constants can be used to separate the category and action from
-    // a combined activity type.
-    ACT_CATEGORY_MASK = 0xF << 4,
-    ACT_ACTION_MASK = 0xF
-  };
-
-  // Internal representation of time. During collection, this is in "ticks"
-  // but when returned in a snapshot, it is "wall time".
-  int64_t time_internal;
-
-  // The address that pushed the activity onto the stack as a raw number.
-  uint64_t calling_address;
-
-  // The address that is the origin of the activity if it not obvious from
-  // the call stack. This is useful for things like tasks that are posted
-  // from a completely different thread though most activities will leave
-  // it null.
-  uint64_t origin_address;
-
-  // Array of program-counters that make up the top of the call stack.
-  // Despite the fixed size, this list is always null-terminated. Entries
-  // after the terminator have no meaning and may or may not also be null.
-  // The list will be completely empty if call-stack collection is not
-  // enabled.
-  uint64_t call_stack[kActivityCallStackSize];
-
-  // Reference to arbitrary user data within the persistent memory segment
-  // and a unique identifier for it.
-  uint32_t user_data_ref;
-  uint32_t user_data_id;
-
-  // The (enumerated) type of the activity. This defines what fields of the
-  // |data| record are valid.
-  uint8_t activity_type;
-
-  // Padding to ensure that the next member begins on a 64-bit boundary
-  // even on 32-bit builds which ensures inter-operability between CPU
-  // architectures. New fields can be taken from this space.
-  uint8_t padding[7];
-
-  // Information specific to the |activity_type|.
-  ActivityData data;
-
-  static void FillFrom(Activity* activity,
-                       const void* program_counter,
-                       const void* origin,
-                       Type type,
-                       const ActivityData& data);
-};
-
-// This class manages arbitrary user data that can be associated with activities
-// done by a thread by supporting key/value pairs of any type. This can provide
-// additional information during debugging. It is also used to store arbitrary
-// global data. All updates must be done from the same thread though other
-// threads can read it concurrently if they create new objects using the same
-// memory.
-class BASE_EXPORT ActivityUserData {
- public:
-  // List of known value type. REFERENCE types must immediately follow the non-
-  // external types.
-  enum ValueType : uint8_t {
-    END_OF_VALUES = 0,
-    RAW_VALUE,
-    RAW_VALUE_REFERENCE,
-    STRING_VALUE,
-    STRING_VALUE_REFERENCE,
-    CHAR_VALUE,
-    BOOL_VALUE,
-    SIGNED_VALUE,
-    UNSIGNED_VALUE,
-  };
-
-  class BASE_EXPORT TypedValue {
-   public:
-    TypedValue();
-    TypedValue(const TypedValue& other);
-    ~TypedValue();
-
-    ValueType type() const { return type_; }
-
-    // These methods return the extracted value in the correct format.
-    StringPiece Get() const;
-    StringPiece GetString() const;
-    bool GetBool() const;
-    char GetChar() const;
-    int64_t GetInt() const;
-    uint64_t GetUint() const;
-
-    // These methods return references to process memory as originally provided
-    // to corresponding Set calls. USE WITH CAUTION! There is no guarantee that
-    // the referenced memory is assessible or useful.  It's possible that:
-    //  - the memory was free'd and reallocated for a different purpose
-    //  - the memory has been released back to the OS
-    //  - the memory belongs to a different process's address space
-    // Dereferencing the returned StringPiece when the memory is not accessible
-    // will cause the program to SEGV!
-    StringPiece GetReference() const;
-    StringPiece GetStringReference() const;
-
-   private:
-    friend class ActivityUserData;
-
-    ValueType type_ = END_OF_VALUES;
-    uint64_t short_value_;    // Used to hold copy of numbers, etc.
-    std::string long_value_;  // Used to hold copy of raw/string data.
-    StringPiece ref_value_;   // Used to hold reference to external data.
-  };
-
-  using Snapshot = std::map<std::string, TypedValue>;
-
-  // Initialize the object either as a "sink" that just accepts and discards
-  // data or an active one that writes to a given (zeroed) memory block.
-  ActivityUserData();
-  ActivityUserData(void* memory, size_t size, int64_t pid = 0);
-  virtual ~ActivityUserData();
-
-  // Gets the unique ID number for this user data. If this changes then the
-  // contents have been overwritten by another thread. The return value is
-  // always non-zero unless it's actually just a data "sink".
-  uint32_t id() const {
-    return header_ ? header_->owner.data_id.load(std::memory_order_relaxed) : 0;
-  }
-
-  // Writes a |value| (as part of a key/value pair) that will be included with
-  // the activity in any reports. The same |name| can be written multiple times
-  // with each successive call overwriting the previously stored |value|. For
-  // raw and string values, the maximum size of successive writes is limited by
-  // the first call. The length of "name" is limited to 255 characters.
-  //
-  // This information is stored on a "best effort" basis. It may be dropped if
-  // the memory buffer is full or the associated activity is beyond the maximum
-  // recording depth.
-  void Set(StringPiece name, const void* memory, size_t size) {
-    Set(name, RAW_VALUE, memory, size);
-  }
-  void SetString(StringPiece name, StringPiece value) {
-    Set(name, STRING_VALUE, value.data(), value.length());
-  }
-  void SetString(StringPiece name, StringPiece16 value) {
-    SetString(name, UTF16ToUTF8(value));
-  }
-  void SetBool(StringPiece name, bool value) {
-    char cvalue = value ? 1 : 0;
-    Set(name, BOOL_VALUE, &cvalue, sizeof(cvalue));
-  }
-  void SetChar(StringPiece name, char value) {
-    Set(name, CHAR_VALUE, &value, sizeof(value));
-  }
-  void SetInt(StringPiece name, int64_t value) {
-    Set(name, SIGNED_VALUE, &value, sizeof(value));
-  }
-  void SetUint(StringPiece name, uint64_t value) {
-    Set(name, UNSIGNED_VALUE, &value, sizeof(value));
-  }
-
-  // These function as above but don't actually copy the data into the
-  // persistent memory. They store unaltered pointers along with a size. These
-  // can be used in conjuction with a memory dump to find certain large pieces
-  // of information.
-  void SetReference(StringPiece name, const void* memory, size_t size) {
-    SetReference(name, RAW_VALUE_REFERENCE, memory, size);
-  }
-  void SetStringReference(StringPiece name, StringPiece value) {
-    SetReference(name, STRING_VALUE_REFERENCE, value.data(), value.length());
-  }
-
-  // Creates a snapshot of the key/value pairs contained within. The returned
-  // data will be fixed, independent of whatever changes afterward. There is
-  // some protection against concurrent modification. This will return false
-  // if the data is invalid or if a complete overwrite of the contents is
-  // detected.
-  bool CreateSnapshot(Snapshot* output_snapshot) const;
-
-  // Gets the base memory address used for storing data.
-  const void* GetBaseAddress() const;
-
-  // Explicitly sets the process ID.
-  void SetOwningProcessIdForTesting(int64_t pid, int64_t stamp);
-
-  // Gets the associated process ID, in native form, and the creation timestamp
-  // from tracker memory without loading the entire structure for analysis. This
-  // will return false if no valid process ID is available.
-  static bool GetOwningProcessId(const void* memory,
-                                 int64_t* out_id,
-                                 int64_t* out_stamp);
-
- protected:
-  virtual void Set(StringPiece name,
-                   ValueType type,
-                   const void* memory,
-                   size_t size);
-
- private:
-  FRIEND_TEST_ALL_PREFIXES(ActivityTrackerTest, UserDataTest);
-
-  enum : size_t { kMemoryAlignment = sizeof(uint64_t) };
-
-  // A structure that defines the structure header in memory.
-  struct MemoryHeader {
-    MemoryHeader();
-    ~MemoryHeader();
-
-    OwningProcess owner;  // Information about the creating process.
-  };
-
-  // Header to a key/value record held in persistent memory.
-  struct FieldHeader {
-    FieldHeader();
-    ~FieldHeader();
-
-    std::atomic<uint8_t> type;         // Encoded ValueType
-    uint8_t name_size;                 // Length of "name" key.
-    std::atomic<uint16_t> value_size;  // Actual size of of the stored value.
-    uint16_t record_size;              // Total storage of name, value, header.
-  };
-
-  // A structure used to reference data held outside of persistent memory.
-  struct ReferenceRecord {
-    uint64_t address;
-    uint64_t size;
-  };
-
-  // This record is used to hold known value is a map so that they can be
-  // found and overwritten later.
-  struct ValueInfo {
-    ValueInfo();
-    ValueInfo(ValueInfo&&);
-    ~ValueInfo();
-
-    StringPiece name;                 // The "key" of the record.
-    ValueType type;                   // The type of the value.
-    void* memory;                     // Where the "value" is held.
-    std::atomic<uint16_t>* size_ptr;  // Address of the actual size of value.
-    size_t extent;                    // The total storage of the value,
-  };                                  // typically rounded up for alignment.
-
-  void SetReference(StringPiece name,
-                    ValueType type,
-                    const void* memory,
-                    size_t size);
-
-  // Loads any data already in the memory segment. This allows for accessing
-  // records created previously. If this detects that the underlying data has
-  // gone away (cleared by another thread/process), it will invalidate all the
-  // data in this object and turn it into simple "sink" with no values to
-  // return.
-  void ImportExistingData() const;
-
-  // A map of all the values within the memory block, keyed by name for quick
-  // updates of the values. This is "mutable" because it changes on "const"
-  // objects even when the actual data values can't change.
-  mutable std::map<StringPiece, ValueInfo> values_;
-
-  // Information about the memory block in which new data can be stored. These
-  // are "mutable" because they change even on "const" objects that are just
-  // skipping already set values.
-  mutable char* memory_;
-  mutable size_t available_;
-
-  // A pointer to the memory header for this instance.
-  MemoryHeader* const header_;
-
-  // These hold values used when initially creating the object. They are
-  // compared against current header values to check for outside changes.
-  const uint32_t orig_data_id;
-  const int64_t orig_process_id;
-  const int64_t orig_create_stamp;
-
-  DISALLOW_COPY_AND_ASSIGN(ActivityUserData);
-};
-
-// This class manages tracking a stack of activities for a single thread in
-// a persistent manner, implementing a bounded-size stack in a fixed-size
-// memory allocation. In order to support an operational mode where another
-// thread is analyzing this data in real-time, atomic operations are used
-// where necessary to guarantee a consistent view from the outside.
-//
-// This class is not generally used directly but instead managed by the
-// GlobalActivityTracker instance and updated using Scoped*Activity local
-// objects.
-class BASE_EXPORT ThreadActivityTracker {
- public:
-  using ActivityId = uint32_t;
-
-  // This structure contains all the common information about the thread so
-  // it doesn't have to be repeated in every entry on the stack. It is defined
-  // and used completely within the .cc file.
-  struct Header;
-
-  // This structure holds a copy of all the internal data at the moment the
-  // "snapshot" operation is done. It is disconnected from the live tracker
-  // so that continued operation of the thread will not cause changes here.
-  struct BASE_EXPORT Snapshot {
-    // Explicit constructor/destructor are needed because of complex types
-    // with non-trivial default constructors and destructors.
-    Snapshot();
-    ~Snapshot();
-
-    // The name of the thread as set when it was created. The name may be
-    // truncated due to internal length limitations.
-    std::string thread_name;
-
-    // The timestamp at which this process was created.
-    int64_t create_stamp;
-
-    // The process and thread IDs. These values have no meaning other than
-    // they uniquely identify a running process and a running thread within
-    // that process.  Thread-IDs can be re-used across different processes
-    // and both can be re-used after the process/thread exits.
-    int64_t process_id = 0;
-    int64_t thread_id = 0;
-
-    // The current stack of activities that are underway for this thread. It
-    // is limited in its maximum size with later entries being left off.
-    std::vector<Activity> activity_stack;
-
-    // The current total depth of the activity stack, including those later
-    // entries not recorded in the |activity_stack| vector.
-    uint32_t activity_stack_depth = 0;
-
-    // The last recorded "exception" activity.
-    Activity last_exception;
-  };
-
-  // This is the base class for having the compiler manage an activity on the
-  // tracker's stack. It does nothing but call methods on the passed |tracker|
-  // if it is not null, making it safe (and cheap) to create these objects
-  // even if activity tracking is not enabled.
-  class BASE_EXPORT ScopedActivity {
-   public:
-    ScopedActivity(ThreadActivityTracker* tracker,
-                   const void* program_counter,
-                   const void* origin,
-                   Activity::Type type,
-                   const ActivityData& data);
-    ~ScopedActivity();
-
-    // Changes some basic metadata about the activity.
-    void ChangeTypeAndData(Activity::Type type, const ActivityData& data);
-
-   protected:
-    // The thread tracker to which this object reports. It can be null if
-    // activity tracking is not (yet) enabled.
-    ThreadActivityTracker* const tracker_;
-
-    // An identifier that indicates a specific activity on the stack.
-    ActivityId activity_id_;
-
-   private:
-    DISALLOW_COPY_AND_ASSIGN(ScopedActivity);
-  };
-
-  // A ThreadActivityTracker runs on top of memory that is managed externally.
-  // It must be large enough for the internal header and a few Activity
-  // blocks. See SizeForStackDepth().
-  ThreadActivityTracker(void* base, size_t size);
-  virtual ~ThreadActivityTracker();
-
-  // Indicates that an activity has started from a given |origin| address in
-  // the code, though it can be null if the creator's address is not known.
-  // The |type| and |data| describe the activity. |program_counter| should be
-  // the result of GetProgramCounter() where push is called. Returned is an
-  // ID that can be used to adjust the pushed activity.
-  ActivityId PushActivity(const void* program_counter,
-                          const void* origin,
-                          Activity::Type type,
-                          const ActivityData& data);
-
-  // An inlined version of the above that gets the program counter where it
-  // is called.
-  ALWAYS_INLINE
-  ActivityId PushActivity(const void* origin,
-                          Activity::Type type,
-                          const ActivityData& data) {
-    return PushActivity(GetProgramCounter(), origin, type, data);
-  }
-
-  // Changes the activity |type| and |data| of the top-most entry on the stack.
-  // This is useful if the information has changed and it is desireable to
-  // track that change without creating a new stack entry. If the type is
-  // ACT_NULL or the data is kNullActivityData then that value will remain
-  // unchanged. The type, if changed, must remain in the same category.
-  // Changing both is not atomic so a snapshot operation could occur between
-  // the update of |type| and |data| or between update of |data| fields.
-  void ChangeActivity(ActivityId id,
-                      Activity::Type type,
-                      const ActivityData& data);
-
-  // Indicates that an activity has completed.
-  void PopActivity(ActivityId id);
-
-  // Sets the user-data information for an activity.
-  std::unique_ptr<ActivityUserData> GetUserData(
-      ActivityId id,
-      ActivityTrackerMemoryAllocator* allocator);
-
-  // Returns if there is true use-data associated with a given ActivityId since
-  // it's possible than any returned object is just a sink.
-  bool HasUserData(ActivityId id);
-
-  // Release the user-data information for an activity.
-  void ReleaseUserData(ActivityId id,
-                       ActivityTrackerMemoryAllocator* allocator);
-
-  // Save an exception. |origin| is the location of the exception.
-  void RecordExceptionActivity(const void* program_counter,
-                               const void* origin,
-                               Activity::Type type,
-                               const ActivityData& data);
-
-  // Returns whether the current data is valid or not. It is not valid if
-  // corruption has been detected in the header or other data structures.
-  bool IsValid() const;
-
-  // Gets a copy of the tracker contents for analysis. Returns false if a
-  // snapshot was not possible, perhaps because the data is not valid; the
-  // contents of |output_snapshot| are undefined in that case. The current
-  // implementation does not support concurrent snapshot operations.
-  bool CreateSnapshot(Snapshot* output_snapshot) const;
-
-  // Gets the base memory address used for storing data.
-  const void* GetBaseAddress();
-
-  // Access the "data version" value so tests can determine if an activity
-  // was pushed and popped in a single call.
-  uint32_t GetDataVersionForTesting();
-
-  // Explicitly sets the process ID.
-  void SetOwningProcessIdForTesting(int64_t pid, int64_t stamp);
-
-  // Gets the associated process ID, in native form, and the creation timestamp
-  // from tracker memory without loading the entire structure for analysis. This
-  // will return false if no valid process ID is available.
-  static bool GetOwningProcessId(const void* memory,
-                                 int64_t* out_id,
-                                 int64_t* out_stamp);
-
-  // Calculates the memory size required for a given stack depth, including
-  // the internal header structure for the stack.
-  static size_t SizeForStackDepth(int stack_depth);
-
- private:
-  friend class ActivityTrackerTest;
-
-  bool CalledOnValidThread();
-
-  std::unique_ptr<ActivityUserData> CreateUserDataForActivity(
-      Activity* activity,
-      ActivityTrackerMemoryAllocator* allocator);
-
-  Header* const header_;        // Pointer to the Header structure.
-  Activity* const stack_;       // The stack of activities.
-
-#if DCHECK_IS_ON()
-  // The ActivityTracker is thread bound, and will be invoked across all the
-  // sequences that run on the thread. A ThreadChecker does not work here, as it
-  // asserts on running in the same sequence each time.
-  const PlatformThreadRef thread_id_;  // The thread this instance is bound to.
-#endif
-  const uint32_t stack_slots_;  // The total number of stack slots.
-
-  bool valid_ = false;          // Tracks whether the data is valid or not.
-
-  DISALLOW_COPY_AND_ASSIGN(ThreadActivityTracker);
-};
-
-
-// The global tracker manages all the individual thread trackers. Memory for
-// the thread trackers is taken from a PersistentMemoryAllocator which allows
-// for the data to be analyzed by a parallel process or even post-mortem.
-class BASE_EXPORT GlobalActivityTracker {
- public:
-  // Type identifiers used when storing in persistent memory so they can be
-  // identified during extraction; the first 4 bytes of the SHA1 of the name
-  // is used as a unique integer. A "version number" is added to the base
-  // so that, if the structure of that object changes, stored older versions
-  // will be safely ignored. These are public so that an external process
-  // can recognize records of this type within an allocator.
-  enum : uint32_t {
-    kTypeIdActivityTracker = 0x5D7381AF + 4,   // SHA1(ActivityTracker) v4
-    kTypeIdUserDataRecord = 0x615EDDD7 + 3,    // SHA1(UserDataRecord) v3
-    kTypeIdGlobalLogMessage = 0x4CF434F9 + 1,  // SHA1(GlobalLogMessage) v1
-    kTypeIdProcessDataRecord = kTypeIdUserDataRecord + 0x100,
-
-    kTypeIdActivityTrackerFree = ~kTypeIdActivityTracker,
-    kTypeIdUserDataRecordFree = ~kTypeIdUserDataRecord,
-    kTypeIdProcessDataRecordFree = ~kTypeIdProcessDataRecord,
-  };
-
-  // An enumeration of common process life stages. All entries are given an
-  // explicit number so they are known and remain constant; this allows for
-  // cross-version analysis either locally or on a server.
-  enum ProcessPhase : int {
-    // The phases are generic and may have meaning to the tracker.
-    PROCESS_PHASE_UNKNOWN = 0,
-    PROCESS_LAUNCHED = 1,
-    PROCESS_LAUNCH_FAILED = 2,
-    PROCESS_EXITED_CLEANLY = 10,
-    PROCESS_EXITED_WITH_CODE = 11,
-
-    // Add here whatever is useful for analysis.
-    PROCESS_SHUTDOWN_STARTED = 100,
-    PROCESS_MAIN_LOOP_STARTED = 101,
-  };
-
-  // A callback made when a process exits to allow immediate analysis of its
-  // data. Note that the system may reuse the |process_id| so when fetching
-  // records it's important to ensure that what is returned was created before
-  // the |exit_stamp|. Movement of |process_data| information is allowed.
-  using ProcessExitCallback =
-      Callback<void(int64_t process_id,
-                    int64_t exit_stamp,
-                    int exit_code,
-                    ProcessPhase exit_phase,
-                    std::string&& command_line,
-                    ActivityUserData::Snapshot&& process_data)>;
-
-  // This structure contains information about a loaded module, as shown to
-  // users of the tracker.
-  struct BASE_EXPORT ModuleInfo {
-    ModuleInfo();
-    ModuleInfo(ModuleInfo&& rhs);
-    ModuleInfo(const ModuleInfo& rhs);
-    ~ModuleInfo();
-
-    ModuleInfo& operator=(ModuleInfo&& rhs);
-    ModuleInfo& operator=(const ModuleInfo& rhs);
-
-    // Information about where and when the module was loaded/unloaded.
-    bool is_loaded = false;  // Was the last operation a load or unload?
-    uintptr_t address = 0;   // Address of the last load operation.
-    int64_t load_time = 0;   // Time of last change; set automatically.
-
-    // Information about the module itself. These never change no matter how
-    // many times a module may be loaded and unloaded.
-    size_t size = 0;         // The size of the loaded module.
-    uint32_t timestamp = 0;  // Opaque "timestamp" for the module.
-    uint32_t age = 0;        // Opaque "age" for the module.
-    uint8_t identifier[16];  // Opaque identifier (GUID, etc.) for the module.
-    std::string file;        // The full path to the file. (UTF-8)
-    std::string debug_file;  // The full path to the debug file.
-  };
-
-  // This is a thin wrapper around the thread-tracker's ScopedActivity that
-  // allows thread-safe access to data values. It is safe to use even if
-  // activity tracking is not enabled.
-  class BASE_EXPORT ScopedThreadActivity
-      : public ThreadActivityTracker::ScopedActivity {
-   public:
-    ScopedThreadActivity(const void* program_counter,
-                         const void* origin,
-                         Activity::Type type,
-                         const ActivityData& data,
-                         bool lock_allowed);
-    ~ScopedThreadActivity();
-
-    // Returns an object for manipulating user data.
-    ActivityUserData& user_data();
-
-   private:
-    // Gets (or creates) a tracker for the current thread. If locking is not
-    // allowed (because a lock is being tracked which would cause recursion)
-    // then the attempt to create one if none found will be skipped. Once
-    // the tracker for this thread has been created for other reasons, locks
-    // will be tracked. The thread-tracker uses locks.
-    static ThreadActivityTracker* GetOrCreateTracker(bool lock_allowed) {
-      GlobalActivityTracker* global_tracker = Get();
-      if (!global_tracker)
-        return nullptr;
-      if (lock_allowed)
-        return global_tracker->GetOrCreateTrackerForCurrentThread();
-      else
-        return global_tracker->GetTrackerForCurrentThread();
-    }
-
-    // An object that manages additional user data, created only upon request.
-    std::unique_ptr<ActivityUserData> user_data_;
-
-    DISALLOW_COPY_AND_ASSIGN(ScopedThreadActivity);
-  };
-
-  ~GlobalActivityTracker();
-
-  // Creates a global tracker using a given persistent-memory |allocator| and
-  // providing the given |stack_depth| to each thread tracker it manages. The
-  // created object is activated so tracking will begin immediately upon return.
-  // The |process_id| can be zero to get it from the OS but is taken for testing
-  // purposes.
-  static void CreateWithAllocator(
-      std::unique_ptr<PersistentMemoryAllocator> allocator,
-      int stack_depth,
-      int64_t process_id);
-
-#if !defined(OS_NACL)
-  // Like above but internally creates an allocator around a disk file with
-  // the specified |size| at the given |file_path|. Any existing file will be
-  // overwritten. The |id| and |name| are arbitrary and stored in the allocator
-  // for reference by whatever process reads it. Returns true if successful.
-  static bool CreateWithFile(const FilePath& file_path,
-                             size_t size,
-                             uint64_t id,
-                             StringPiece name,
-                             int stack_depth);
-#endif  // !defined(OS_NACL)
-
-  // Like above but internally creates an allocator using local heap memory of
-  // the specified size. This is used primarily for unit tests. The |process_id|
-  // can be zero to get it from the OS but is taken for testing purposes.
-  static bool CreateWithLocalMemory(size_t size,
-                                    uint64_t id,
-                                    StringPiece name,
-                                    int stack_depth,
-                                    int64_t process_id);
-
-  // Like above but internally creates an allocator using a shared-memory
-  // segment. The segment must already be mapped into the local memory space.
-  static bool CreateWithSharedMemory(std::unique_ptr<SharedMemory> shm,
-                                     uint64_t id,
-                                     StringPiece name,
-                                     int stack_depth);
-
-  // Like above but takes a handle to an existing shared memory segment and
-  // maps it before creating the tracker.
-  static bool CreateWithSharedMemoryHandle(const SharedMemoryHandle& handle,
-                                           size_t size,
-                                           uint64_t id,
-                                           StringPiece name,
-                                           int stack_depth);
-
-  // Gets the global activity-tracker or null if none exists.
-  static GlobalActivityTracker* Get() {
-    return reinterpret_cast<GlobalActivityTracker*>(
-        subtle::Acquire_Load(&g_tracker_));
-  }
-
-  // Sets the global activity-tracker for testing purposes.
-  static void SetForTesting(std::unique_ptr<GlobalActivityTracker> tracker);
-
-  // This access to the persistent allocator is only for testing; it extracts
-  // the global tracker completely. All tracked threads must exit before
-  // calling this. Tracking for the current thread will be automatically
-  // stopped.
-  static std::unique_ptr<GlobalActivityTracker> ReleaseForTesting();
-
-  // Convenience method for determining if a global tracker is active.
-  static bool IsEnabled() { return Get() != nullptr; }
-
-  // Gets the persistent-memory-allocator in which data is stored. Callers
-  // can store additional records here to pass more information to the
-  // analysis process.
-  PersistentMemoryAllocator* allocator() { return allocator_.get(); }
-
-  // Gets the thread's activity-tracker if it exists. This is inline for
-  // performance reasons and it uses thread-local-storage (TLS) so that there
-  // is no significant lookup time required to find the one for the calling
-  // thread. Ownership remains with the global tracker.
-  ThreadActivityTracker* GetTrackerForCurrentThread() {
-    return reinterpret_cast<ThreadActivityTracker*>(this_thread_tracker_.Get());
-  }
-
-  // Gets the thread's activity-tracker or creates one if none exists. This
-  // is inline for performance reasons. Ownership remains with the global
-  // tracker.
-  ThreadActivityTracker* GetOrCreateTrackerForCurrentThread() {
-    ThreadActivityTracker* tracker = GetTrackerForCurrentThread();
-    if (tracker)
-      return tracker;
-    return CreateTrackerForCurrentThread();
-  }
-
-  // Creates an activity-tracker for the current thread.
-  ThreadActivityTracker* CreateTrackerForCurrentThread();
-
-  // Releases the activity-tracker for the current thread (for testing only).
-  void ReleaseTrackerForCurrentThreadForTesting();
-
-  // Sets a task-runner that can be used for background work.
-  void SetBackgroundTaskRunner(const scoped_refptr<TaskRunner>& runner);
-
-  // Sets an optional callback to be called when a process exits.
-  void SetProcessExitCallback(ProcessExitCallback callback);
-
-  // Manages process lifetimes. These are called by the process that launched
-  // and reaped the subprocess, not the subprocess itself. If it is expensive
-  // to generate the parameters, Get() the global tracker and call these
-  // conditionally rather than using the static versions.
-  void RecordProcessLaunch(ProcessId process_id,
-                           const FilePath::StringType& cmd);
-  void RecordProcessLaunch(ProcessId process_id,
-                           const FilePath::StringType& exe,
-                           const FilePath::StringType& args);
-  void RecordProcessExit(ProcessId process_id, int exit_code);
-  static void RecordProcessLaunchIfEnabled(ProcessId process_id,
-                                           const FilePath::StringType& cmd) {
-    GlobalActivityTracker* tracker = Get();
-    if (tracker)
-      tracker->RecordProcessLaunch(process_id, cmd);
-  }
-  static void RecordProcessLaunchIfEnabled(ProcessId process_id,
-                                           const FilePath::StringType& exe,
-                                           const FilePath::StringType& args) {
-    GlobalActivityTracker* tracker = Get();
-    if (tracker)
-      tracker->RecordProcessLaunch(process_id, exe, args);
-  }
-  static void RecordProcessExitIfEnabled(ProcessId process_id, int exit_code) {
-    GlobalActivityTracker* tracker = Get();
-    if (tracker)
-      tracker->RecordProcessExit(process_id, exit_code);
-  }
-
-  // Sets the "phase" of the current process, useful for knowing what it was
-  // doing when it last reported.
-  void SetProcessPhase(ProcessPhase phase);
-  static void SetProcessPhaseIfEnabled(ProcessPhase phase) {
-    GlobalActivityTracker* tracker = Get();
-    if (tracker)
-      tracker->SetProcessPhase(phase);
-  }
-
-  // Records a log message. The current implementation does NOT recycle these
-  // only store critical messages such as FATAL ones.
-  void RecordLogMessage(StringPiece message);
-  static void RecordLogMessageIfEnabled(StringPiece message) {
-    GlobalActivityTracker* tracker = Get();
-    if (tracker)
-      tracker->RecordLogMessage(message);
-  }
-
-  // Records a module load/unload event. This is safe to call multiple times
-  // even with the same information.
-  void RecordModuleInfo(const ModuleInfo& info);
-  static void RecordModuleInfoIfEnabled(const ModuleInfo& info) {
-    GlobalActivityTracker* tracker = Get();
-    if (tracker)
-      tracker->RecordModuleInfo(info);
-  }
-
-  // Record field trial information. This call is thread-safe. In addition to
-  // this, construction of a GlobalActivityTracker will cause all existing
-  // active field trials to be fetched and recorded.
-  void RecordFieldTrial(const std::string& trial_name, StringPiece group_name);
-  static void RecordFieldTrialIfEnabled(const std::string& trial_name,
-                                        StringPiece group_name) {
-    GlobalActivityTracker* tracker = Get();
-    if (tracker)
-      tracker->RecordFieldTrial(trial_name, group_name);
-  }
-
-  // Record exception information for the current thread.
-  ALWAYS_INLINE
-  void RecordException(const void* origin, uint32_t code) {
-    return RecordExceptionImpl(GetProgramCounter(), origin, code);
-  }
-  void RecordException(const void* pc, const void* origin, uint32_t code);
-
-  // Marks the tracked data as deleted.
-  void MarkDeleted();
-
-  // Gets the process ID used for tracking. This is typically the same as what
-  // the OS thinks is the current process but can be overridden for testing.
-  int64_t process_id() { return process_id_; }
-
-  // Accesses the process data record for storing arbitrary key/value pairs.
-  // Updates to this are thread-safe.
-  ActivityUserData& process_data() { return process_data_; }
-
- private:
-  friend class GlobalActivityAnalyzer;
-  friend class ScopedThreadActivity;
-  friend class ActivityTrackerTest;
-
-  enum : int {
-    // The maximum number of threads that can be tracked within a process. If
-    // more than this number run concurrently, tracking of new ones may cease.
-    kMaxThreadCount = 100,
-    kCachedThreadMemories = 10,
-    kCachedUserDataMemories = 10,
-  };
-
-  // A wrapper around ActivityUserData that is thread-safe and thus can be used
-  // in the global scope without the requirement of being called from only one
-  // thread.
-  class ThreadSafeUserData : public ActivityUserData {
-   public:
-    ThreadSafeUserData(void* memory, size_t size, int64_t pid = 0);
-    ~ThreadSafeUserData() override;
-
-   private:
-    void Set(StringPiece name,
-             ValueType type,
-             const void* memory,
-             size_t size) override;
-
-    Lock data_lock_;
-
-    DISALLOW_COPY_AND_ASSIGN(ThreadSafeUserData);
-  };
-
-  // State of a module as stored in persistent memory. This supports a single
-  // loading of a module only. If modules are loaded multiple times at
-  // different addresses, only the last will be recorded and an unload will
-  // not revert to the information of any other addresses.
-  struct BASE_EXPORT ModuleInfoRecord {
-    // SHA1(ModuleInfoRecord): Increment this if structure changes!
-    static constexpr uint32_t kPersistentTypeId = 0x05DB5F41 + 1;
-
-    // Expected size for 32/64-bit check by PersistentMemoryAllocator.
-    static constexpr size_t kExpectedInstanceSize =
-        OwningProcess::kExpectedInstanceSize + 56;
-
-    // The atomic unfortunately makes this a "complex" class on some compilers
-    // and thus requires an out-of-line constructor & destructor even though
-    // they do nothing.
-    ModuleInfoRecord();
-    ~ModuleInfoRecord();
-
-    OwningProcess owner;            // The process that created this record.
-    uint64_t address;               // The base address of the module.
-    uint64_t load_time;             // Time of last load/unload.
-    uint64_t size;                  // The size of the module in bytes.
-    uint32_t timestamp;             // Opaque timestamp of the module.
-    uint32_t age;                   // Opaque "age" associated with the module.
-    uint8_t identifier[16];         // Opaque identifier for the module.
-    std::atomic<uint32_t> changes;  // Number load/unload actions.
-    uint16_t pickle_size;           // The size of the following pickle.
-    uint8_t loaded;                 // Flag if module is loaded or not.
-    char pickle[1];                 // Other strings; may allocate larger.
-
-    // Decodes/encodes storage structure from more generic info structure.
-    bool DecodeTo(GlobalActivityTracker::ModuleInfo* info,
-                  size_t record_size) const;
-    static ModuleInfoRecord* CreateFrom(
-        const GlobalActivityTracker::ModuleInfo& info,
-        PersistentMemoryAllocator* allocator);
-
-    // Updates the core information without changing the encoded strings. This
-    // is useful when a known module changes state (i.e. new load or unload).
-    bool UpdateFrom(const GlobalActivityTracker::ModuleInfo& info);
-
-   private:
-    DISALLOW_COPY_AND_ASSIGN(ModuleInfoRecord);
-  };
-
-  // A thin wrapper around the main thread-tracker that keeps additional
-  // information that the global tracker needs to handle joined threads.
-  class ManagedActivityTracker : public ThreadActivityTracker {
-   public:
-    ManagedActivityTracker(PersistentMemoryAllocator::Reference mem_reference,
-                           void* base,
-                           size_t size);
-    ~ManagedActivityTracker() override;
-
-    // The reference into persistent memory from which the thread-tracker's
-    // memory was created.
-    const PersistentMemoryAllocator::Reference mem_reference_;
-
-    // The physical address used for the thread-tracker's memory.
-    void* const mem_base_;
-
-   private:
-    DISALLOW_COPY_AND_ASSIGN(ManagedActivityTracker);
-  };
-
-  // Creates a global tracker using a given persistent-memory |allocator| and
-  // providing the given |stack_depth| to each thread tracker it manages. The
-  // created object is activated so tracking has already started upon return.
-  // The |process_id| can be zero to get it from the OS but is taken for testing
-  // purposes.
-  GlobalActivityTracker(std::unique_ptr<PersistentMemoryAllocator> allocator,
-                        int stack_depth,
-                        int64_t process_id);
-
-  // Returns the memory used by an activity-tracker managed by this class.
-  // It is called during the destruction of a ManagedActivityTracker object.
-  void ReturnTrackerMemory(ManagedActivityTracker* tracker);
-
-  // Records exception information.
-  void RecordExceptionImpl(const void* pc, const void* origin, uint32_t code);
-
-  // Releases the activity-tracker associcated with thread. It is called
-  // automatically when a thread is joined and thus there is nothing more to
-  // be tracked. |value| is a pointer to a ManagedActivityTracker.
-  static void OnTLSDestroy(void* value);
-
-  // Does process-exit work. This can be run on any thread.
-  void CleanupAfterProcess(int64_t process_id,
-                           int64_t exit_stamp,
-                           int exit_code,
-                           std::string&& command_line);
-
-  // The persistent-memory allocator from which the memory for all trackers
-  // is taken.
-  std::unique_ptr<PersistentMemoryAllocator> allocator_;
-
-  // The size (in bytes) of memory required by a ThreadActivityTracker to
-  // provide the stack-depth requested during construction.
-  const size_t stack_memory_size_;
-
-  // The process-id of the current process. This is kept as a member variable,
-  // defined during initialization, for testing purposes.
-  const int64_t process_id_;
-
-  // The activity tracker for the currently executing thread.
-  ThreadLocalStorage::Slot this_thread_tracker_;
-
-  // The number of thread trackers currently active.
-  std::atomic<int> thread_tracker_count_;
-
-  // A caching memory allocator for thread-tracker objects.
-  ActivityTrackerMemoryAllocator thread_tracker_allocator_;
-  Lock thread_tracker_allocator_lock_;
-
-  // A caching memory allocator for user data attached to activity data.
-  ActivityTrackerMemoryAllocator user_data_allocator_;
-  Lock user_data_allocator_lock_;
-
-  // An object for holding arbitrary key value pairs with thread-safe access.
-  ThreadSafeUserData process_data_;
-
-  // A map of global module information, keyed by module path.
-  std::map<const std::string, ModuleInfoRecord*> modules_;
-  Lock modules_lock_;
-
-  // The active global activity tracker.
-  static subtle::AtomicWord g_tracker_;
-
-  // A lock that is used to protect access to the following fields.
-  Lock global_tracker_lock_;
-
-  // The collection of processes being tracked and their command-lines.
-  std::map<int64_t, std::string> known_processes_;
-
-  // A task-runner that can be used for doing background processing.
-  scoped_refptr<TaskRunner> background_task_runner_;
-
-  // A callback performed when a subprocess exits, including its exit-code
-  // and the phase it was in when that occurred. This will be called via
-  // the |background_task_runner_| if one is set or whatever thread reaped
-  // the process otherwise.
-  ProcessExitCallback process_exit_callback_;
-
-  DISALLOW_COPY_AND_ASSIGN(GlobalActivityTracker);
-};
-
-
-// Record entry in to and out of an arbitrary block of code.
-class BASE_EXPORT ScopedActivity
-    : public GlobalActivityTracker::ScopedThreadActivity {
- public:
-  // Track activity at the specified FROM_HERE location for an arbitrary
-  // 4-bit |action|, an arbitrary 32-bit |id|, and 32-bits of arbitrary
-  // |info|. None of these values affect operation; they're all purely
-  // for association and analysis. To have unique identifiers across a
-  // diverse code-base, create the number by taking the first 8 characters
-  // of the hash of the activity being tracked.
-  //
-  // For example:
-  //   Tracking method: void MayNeverExit(uint32_t foo) {...}
-  //   echo -n "MayNeverExit" | sha1sum   =>   e44873ccab21e2b71270da24aa1...
-  //
-  //   void MayNeverExit(int32_t foo) {
-  //     base::debug::ScopedActivity track_me(0, 0xE44873CC, foo);
-  //     ...
-  //   }
-  ALWAYS_INLINE
-  ScopedActivity(uint8_t action, uint32_t id, int32_t info)
-      : ScopedActivity(GetProgramCounter(), action, id, info) {}
-  ScopedActivity() : ScopedActivity(0, 0, 0) {}
-
-  // Changes the |action| and/or |info| of this activity on the stack. This
-  // is useful for tracking progress through a function, updating the action
-  // to indicate "milestones" in the block (max 16 milestones: 0-15) or the
-  // info to reflect other changes. Changing both is not atomic so a snapshot
-  // operation could occur between the update of |action| and |info|.
-  void ChangeAction(uint8_t action);
-  void ChangeInfo(int32_t info);
-  void ChangeActionAndInfo(uint8_t action, int32_t info);
-
- private:
-  // Constructs the object using a passed-in program-counter.
-  ScopedActivity(const void* program_counter,
-                 uint8_t action,
-                 uint32_t id,
-                 int32_t info);
-
-  // A copy of the ID code so it doesn't have to be passed by the caller when
-  // changing the |info| field.
-  uint32_t id_;
-
-  DISALLOW_COPY_AND_ASSIGN(ScopedActivity);
-};
-
-
-// These "scoped" classes provide easy tracking of various blocking actions.
-
-class BASE_EXPORT ScopedTaskRunActivity
-    : public GlobalActivityTracker::ScopedThreadActivity {
- public:
-  ALWAYS_INLINE
-  explicit ScopedTaskRunActivity(const PendingTask& task)
-      : ScopedTaskRunActivity(GetProgramCounter(), task) {}
-
- private:
-  ScopedTaskRunActivity(const void* program_counter, const PendingTask& task);
-  DISALLOW_COPY_AND_ASSIGN(ScopedTaskRunActivity);
-};
-
-class BASE_EXPORT ScopedLockAcquireActivity
-    : public GlobalActivityTracker::ScopedThreadActivity {
- public:
-  ALWAYS_INLINE
-  explicit ScopedLockAcquireActivity(const base::internal::LockImpl* lock)
-      : ScopedLockAcquireActivity(GetProgramCounter(), lock) {}
-
- private:
-  ScopedLockAcquireActivity(const void* program_counter,
-                            const base::internal::LockImpl* lock);
-  DISALLOW_COPY_AND_ASSIGN(ScopedLockAcquireActivity);
-};
-
-class BASE_EXPORT ScopedEventWaitActivity
-    : public GlobalActivityTracker::ScopedThreadActivity {
- public:
-  ALWAYS_INLINE
-  explicit ScopedEventWaitActivity(const WaitableEvent* event)
-      : ScopedEventWaitActivity(GetProgramCounter(), event) {}
-
- private:
-  ScopedEventWaitActivity(const void* program_counter,
-                          const WaitableEvent* event);
-  DISALLOW_COPY_AND_ASSIGN(ScopedEventWaitActivity);
-};
-
-class BASE_EXPORT ScopedThreadJoinActivity
-    : public GlobalActivityTracker::ScopedThreadActivity {
- public:
-  ALWAYS_INLINE
-  explicit ScopedThreadJoinActivity(const PlatformThreadHandle* thread)
-      : ScopedThreadJoinActivity(GetProgramCounter(), thread) {}
-
- private:
-  ScopedThreadJoinActivity(const void* program_counter,
-                           const PlatformThreadHandle* thread);
-  DISALLOW_COPY_AND_ASSIGN(ScopedThreadJoinActivity);
-};
-
-// Some systems don't have base::Process
-#if !defined(OS_NACL) && !defined(OS_IOS)
-class BASE_EXPORT ScopedProcessWaitActivity
-    : public GlobalActivityTracker::ScopedThreadActivity {
- public:
-  ALWAYS_INLINE
-  explicit ScopedProcessWaitActivity(const Process* process)
-      : ScopedProcessWaitActivity(GetProgramCounter(), process) {}
-
- private:
-  ScopedProcessWaitActivity(const void* program_counter,
-                            const Process* process);
-  DISALLOW_COPY_AND_ASSIGN(ScopedProcessWaitActivity);
-};
-#endif
-
-}  // namespace debug
-}  // namespace base
-
-#endif  // BASE_DEBUG_ACTIVITY_TRACKER_H_
diff --git a/base/debug/task_annotator.cc b/base/debug/task_annotator.cc
index def2d7a..69b9c04 100644
--- a/base/debug/task_annotator.cc
+++ b/base/debug/task_annotator.cc
@@ -6,7 +6,6 @@
 
 #include <array>
 
-#include "base/debug/activity_tracker.h"
 #include "base/debug/alias.h"
 #include "base/no_destructor.h"
 #include "base/pending_task.h"
@@ -54,8 +53,6 @@
 
 void TaskAnnotator::RunTask(const char* queue_function,
                             PendingTask* pending_task) {
-  ScopedTaskRunActivity task_activity(*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
diff --git a/base/feature_list.cc b/base/feature_list.cc
deleted file mode 100644
index 1610eec..0000000
--- a/base/feature_list.cc
+++ /dev/null
@@ -1,438 +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/feature_list.h"
-
-#include <stddef.h>
-
-#include <utility>
-#include <vector>
-
-#include "base/logging.h"
-#include "base/memory/ptr_util.h"
-#include "base/metrics/field_trial.h"
-#include "base/pickle.h"
-#include "base/strings/string_split.h"
-#include "base/strings/string_util.h"
-
-namespace base {
-
-namespace {
-
-// Pointer to the FeatureList instance singleton that was set via
-// FeatureList::SetInstance(). Does not use base/memory/singleton.h in order to
-// have more control over initialization timing. Leaky.
-FeatureList* g_feature_list_instance = nullptr;
-
-// Tracks whether the FeatureList instance was initialized via an accessor.
-bool g_initialized_from_accessor = false;
-
-// An allocator entry for a feature in shared memory. The FeatureEntry is
-// followed by a base::Pickle object that contains the feature and trial name.
-struct FeatureEntry {
-  // SHA1(FeatureEntry): Increment this if structure changes!
-  static constexpr uint32_t kPersistentTypeId = 0x06567CA6 + 1;
-
-  // Expected size for 32/64-bit check.
-  static constexpr size_t kExpectedInstanceSize = 8;
-
-  // Specifies whether a feature override enables or disables the feature. Same
-  // values as the OverrideState enum in feature_list.h
-  uint32_t override_state;
-
-  // Size of the pickled structure, NOT the total size of this entry.
-  uint32_t pickle_size;
-
-  // Reads the feature and trial name from the pickle. Calling this is only
-  // valid on an initialized entry that's in shared memory.
-  bool GetFeatureAndTrialName(StringPiece* feature_name,
-                              StringPiece* trial_name) const {
-    const char* src =
-        reinterpret_cast<const char*>(this) + sizeof(FeatureEntry);
-
-    Pickle pickle(src, pickle_size);
-    PickleIterator pickle_iter(pickle);
-
-    if (!pickle_iter.ReadStringPiece(feature_name))
-      return false;
-
-    // Return true because we are not guaranteed to have a trial name anyways.
-    auto sink = pickle_iter.ReadStringPiece(trial_name);
-    ALLOW_UNUSED_LOCAL(sink);
-    return true;
-  }
-};
-
-// Some characters are not allowed to appear in feature names or the associated
-// field trial names, as they are used as special characters for command-line
-// serialization. This function checks that the strings are ASCII (since they
-// are used in command-line API functions that require ASCII) and whether there
-// are any reserved characters present, returning true if the string is valid.
-// Only called in DCHECKs.
-bool IsValidFeatureOrFieldTrialName(const std::string& name) {
-  return IsStringASCII(name) && name.find_first_of(",<*") == std::string::npos;
-}
-
-}  // namespace
-
-#if DCHECK_IS_CONFIGURABLE
-const Feature kDCheckIsFatalFeature{"DcheckIsFatal",
-                                    base::FEATURE_DISABLED_BY_DEFAULT};
-#endif  // DCHECK_IS_CONFIGURABLE
-
-FeatureList::FeatureList() = default;
-
-FeatureList::~FeatureList() = default;
-
-void FeatureList::InitializeFromCommandLine(
-    const std::string& enable_features,
-    const std::string& disable_features) {
-  DCHECK(!initialized_);
-
-  // Process disabled features first, so that disabled ones take precedence over
-  // enabled ones (since RegisterOverride() uses insert()).
-  RegisterOverridesFromCommandLine(disable_features, OVERRIDE_DISABLE_FEATURE);
-  RegisterOverridesFromCommandLine(enable_features, OVERRIDE_ENABLE_FEATURE);
-
-  initialized_from_command_line_ = true;
-}
-
-void FeatureList::InitializeFromSharedMemory(
-    PersistentMemoryAllocator* allocator) {
-  DCHECK(!initialized_);
-
-  PersistentMemoryAllocator::Iterator iter(allocator);
-  const FeatureEntry* entry;
-  while ((entry = iter.GetNextOfObject<FeatureEntry>()) != nullptr) {
-    OverrideState override_state =
-        static_cast<OverrideState>(entry->override_state);
-
-    StringPiece feature_name;
-    StringPiece trial_name;
-    if (!entry->GetFeatureAndTrialName(&feature_name, &trial_name))
-      continue;
-
-    FieldTrial* trial = FieldTrialList::Find(trial_name.as_string());
-    RegisterOverride(feature_name, override_state, trial);
-  }
-}
-
-bool FeatureList::IsFeatureOverriddenFromCommandLine(
-    const std::string& feature_name,
-    OverrideState state) const {
-  auto it = overrides_.find(feature_name);
-  return it != overrides_.end() && it->second.overridden_state == state &&
-         !it->second.overridden_by_field_trial;
-}
-
-void FeatureList::AssociateReportingFieldTrial(
-    const std::string& feature_name,
-    OverrideState for_overridden_state,
-    FieldTrial* field_trial) {
-  DCHECK(
-      IsFeatureOverriddenFromCommandLine(feature_name, for_overridden_state));
-
-  // Only one associated field trial is supported per feature. This is generally
-  // enforced server-side.
-  OverrideEntry* entry = &overrides_.find(feature_name)->second;
-  if (entry->field_trial) {
-    NOTREACHED() << "Feature " << feature_name
-                 << " already has trial: " << entry->field_trial->trial_name()
-                 << ", associating trial: " << field_trial->trial_name();
-    return;
-  }
-
-  entry->field_trial = field_trial;
-}
-
-void FeatureList::RegisterFieldTrialOverride(const std::string& feature_name,
-                                             OverrideState override_state,
-                                             FieldTrial* field_trial) {
-  DCHECK(field_trial);
-  DCHECK(!ContainsKey(overrides_, feature_name) ||
-         !overrides_.find(feature_name)->second.field_trial)
-      << "Feature " << feature_name
-      << " has conflicting field trial overrides: "
-      << overrides_.find(feature_name)->second.field_trial->trial_name()
-      << " / " << field_trial->trial_name();
-
-  RegisterOverride(feature_name, override_state, field_trial);
-}
-
-void FeatureList::AddFeaturesToAllocator(PersistentMemoryAllocator* allocator) {
-  DCHECK(initialized_);
-
-  for (const auto& override : overrides_) {
-    Pickle pickle;
-    pickle.WriteString(override.first);
-    if (override.second.field_trial)
-      pickle.WriteString(override.second.field_trial->trial_name());
-
-    size_t total_size = sizeof(FeatureEntry) + pickle.size();
-    FeatureEntry* entry = allocator->New<FeatureEntry>(total_size);
-    if (!entry)
-      return;
-
-    entry->override_state = override.second.overridden_state;
-    entry->pickle_size = pickle.size();
-
-    char* dst = reinterpret_cast<char*>(entry) + sizeof(FeatureEntry);
-    memcpy(dst, pickle.data(), pickle.size());
-
-    allocator->MakeIterable(entry);
-  }
-}
-
-void FeatureList::GetFeatureOverrides(std::string* enable_overrides,
-                                      std::string* disable_overrides) {
-  GetFeatureOverridesImpl(enable_overrides, disable_overrides, false);
-}
-
-void FeatureList::GetCommandLineFeatureOverrides(
-    std::string* enable_overrides,
-    std::string* disable_overrides) {
-  GetFeatureOverridesImpl(enable_overrides, disable_overrides, true);
-}
-
-// static
-bool FeatureList::IsEnabled(const Feature& feature) {
-  if (!g_feature_list_instance) {
-    g_initialized_from_accessor = true;
-    return feature.default_state == FEATURE_ENABLED_BY_DEFAULT;
-  }
-  return g_feature_list_instance->IsFeatureEnabled(feature);
-}
-
-// static
-FieldTrial* FeatureList::GetFieldTrial(const Feature& feature) {
-  if (!g_feature_list_instance) {
-    g_initialized_from_accessor = true;
-    return nullptr;
-  }
-  return g_feature_list_instance->GetAssociatedFieldTrial(feature);
-}
-
-// static
-std::vector<base::StringPiece> FeatureList::SplitFeatureListString(
-    base::StringPiece input) {
-  return SplitStringPiece(input, ",", TRIM_WHITESPACE, SPLIT_WANT_NONEMPTY);
-}
-
-// static
-bool FeatureList::InitializeInstance(const std::string& enable_features,
-                                     const std::string& disable_features) {
-  // We want to initialize a new instance here to support command-line features
-  // in testing better. For example, we initialize a dummy instance in
-  // base/test/test_suite.cc, and override it in content/browser/
-  // browser_main_loop.cc.
-  // On the other hand, we want to avoid re-initialization from command line.
-  // For example, we initialize an instance in chrome/browser/
-  // chrome_browser_main.cc and do not override it in content/browser/
-  // browser_main_loop.cc.
-  // If the singleton was previously initialized from within an accessor, we
-  // want to prevent callers from reinitializing the singleton and masking the
-  // accessor call(s) which likely returned incorrect information.
-  CHECK(!g_initialized_from_accessor);
-  bool instance_existed_before = false;
-  if (g_feature_list_instance) {
-    if (g_feature_list_instance->initialized_from_command_line_)
-      return false;
-
-    delete g_feature_list_instance;
-    g_feature_list_instance = nullptr;
-    instance_existed_before = true;
-  }
-
-  std::unique_ptr<base::FeatureList> feature_list(new base::FeatureList);
-  feature_list->InitializeFromCommandLine(enable_features, disable_features);
-  base::FeatureList::SetInstance(std::move(feature_list));
-  return !instance_existed_before;
-}
-
-// static
-FeatureList* FeatureList::GetInstance() {
-  return g_feature_list_instance;
-}
-
-// static
-void FeatureList::SetInstance(std::unique_ptr<FeatureList> instance) {
-  DCHECK(!g_feature_list_instance);
-  instance->FinalizeInitialization();
-
-  // Note: Intentional leak of global singleton.
-  g_feature_list_instance = instance.release();
-
-#if DCHECK_IS_CONFIGURABLE
-  // Update the behaviour of LOG_DCHECK to match the Feature configuration.
-  // DCHECK is also forced to be FATAL if we are running a death-test.
-  // TODO(asvitkine): If we find other use-cases that need integrating here
-  // then define a proper API/hook for the purpose.
-  if (base::FeatureList::IsEnabled(kDCheckIsFatalFeature) ||
-      base::CommandLine::ForCurrentProcess()->HasSwitch(
-          "gtest_internal_run_death_test")) {
-    logging::LOG_DCHECK = logging::LOG_FATAL;
-  } else {
-    logging::LOG_DCHECK = logging::LOG_INFO;
-  }
-#endif  // DCHECK_IS_CONFIGURABLE
-}
-
-// static
-std::unique_ptr<FeatureList> FeatureList::ClearInstanceForTesting() {
-  FeatureList* old_instance = g_feature_list_instance;
-  g_feature_list_instance = nullptr;
-  g_initialized_from_accessor = false;
-  return base::WrapUnique(old_instance);
-}
-
-// static
-void FeatureList::RestoreInstanceForTesting(
-    std::unique_ptr<FeatureList> instance) {
-  DCHECK(!g_feature_list_instance);
-  // Note: Intentional leak of global singleton.
-  g_feature_list_instance = instance.release();
-}
-
-void FeatureList::FinalizeInitialization() {
-  DCHECK(!initialized_);
-  initialized_ = true;
-}
-
-bool FeatureList::IsFeatureEnabled(const Feature& feature) {
-  DCHECK(initialized_);
-  DCHECK(IsValidFeatureOrFieldTrialName(feature.name)) << feature.name;
-  DCHECK(CheckFeatureIdentity(feature)) << feature.name;
-
-  auto it = overrides_.find(feature.name);
-  if (it != overrides_.end()) {
-    const OverrideEntry& entry = it->second;
-
-    // Activate the corresponding field trial, if necessary.
-    if (entry.field_trial)
-      entry.field_trial->group();
-
-    // TODO(asvitkine) Expand this section as more support is added.
-
-    // If marked as OVERRIDE_USE_DEFAULT, simply return the default state below.
-    if (entry.overridden_state != OVERRIDE_USE_DEFAULT)
-      return entry.overridden_state == OVERRIDE_ENABLE_FEATURE;
-  }
-  // Otherwise, return the default state.
-  return feature.default_state == FEATURE_ENABLED_BY_DEFAULT;
-}
-
-FieldTrial* FeatureList::GetAssociatedFieldTrial(const Feature& feature) {
-  DCHECK(initialized_);
-  DCHECK(IsValidFeatureOrFieldTrialName(feature.name)) << feature.name;
-  DCHECK(CheckFeatureIdentity(feature)) << feature.name;
-
-  auto it = overrides_.find(feature.name);
-  if (it != overrides_.end()) {
-    const OverrideEntry& entry = it->second;
-    return entry.field_trial;
-  }
-
-  return nullptr;
-}
-
-void FeatureList::RegisterOverridesFromCommandLine(
-    const std::string& feature_list,
-    OverrideState overridden_state) {
-  for (const auto& value : SplitFeatureListString(feature_list)) {
-    StringPiece feature_name = value;
-    base::FieldTrial* trial = nullptr;
-
-    // The entry may be of the form FeatureName<FieldTrialName - in which case,
-    // this splits off the field trial name and associates it with the override.
-    std::string::size_type pos = feature_name.find('<');
-    if (pos != std::string::npos) {
-      feature_name.set(value.data(), pos);
-      trial = base::FieldTrialList::Find(value.substr(pos + 1).as_string());
-    }
-
-    RegisterOverride(feature_name, overridden_state, trial);
-  }
-}
-
-void FeatureList::RegisterOverride(StringPiece feature_name,
-                                   OverrideState overridden_state,
-                                   FieldTrial* field_trial) {
-  DCHECK(!initialized_);
-  if (field_trial) {
-    DCHECK(IsValidFeatureOrFieldTrialName(field_trial->trial_name()))
-        << field_trial->trial_name();
-  }
-  if (feature_name.starts_with("*")) {
-    feature_name = feature_name.substr(1);
-    overridden_state = OVERRIDE_USE_DEFAULT;
-  }
-
-  // Note: The semantics of insert() is that it does not overwrite the entry if
-  // one already exists for the key. Thus, only the first override for a given
-  // feature name takes effect.
-  overrides_.insert(std::make_pair(
-      feature_name.as_string(), OverrideEntry(overridden_state, field_trial)));
-}
-
-void FeatureList::GetFeatureOverridesImpl(std::string* enable_overrides,
-                                          std::string* disable_overrides,
-                                          bool command_line_only) {
-  DCHECK(initialized_);
-
-  enable_overrides->clear();
-  disable_overrides->clear();
-
-  // Note: Since |overrides_| is a std::map, iteration will be in alphabetical
-  // order. This is not guaranteed to users of this function, but is useful for
-  // tests to assume the order.
-  for (const auto& entry : overrides_) {
-    if (command_line_only &&
-        (entry.second.field_trial != nullptr ||
-         entry.second.overridden_state == OVERRIDE_USE_DEFAULT)) {
-      continue;
-    }
-
-    std::string* target_list = nullptr;
-    switch (entry.second.overridden_state) {
-      case OVERRIDE_USE_DEFAULT:
-      case OVERRIDE_ENABLE_FEATURE:
-        target_list = enable_overrides;
-        break;
-      case OVERRIDE_DISABLE_FEATURE:
-        target_list = disable_overrides;
-        break;
-    }
-
-    if (!target_list->empty())
-      target_list->push_back(',');
-    if (entry.second.overridden_state == OVERRIDE_USE_DEFAULT)
-      target_list->push_back('*');
-    target_list->append(entry.first);
-    if (entry.second.field_trial) {
-      target_list->push_back('<');
-      target_list->append(entry.second.field_trial->trial_name());
-    }
-  }
-}
-
-bool FeatureList::CheckFeatureIdentity(const Feature& feature) {
-  AutoLock auto_lock(feature_identity_tracker_lock_);
-
-  auto it = feature_identity_tracker_.find(feature.name);
-  if (it == feature_identity_tracker_.end()) {
-    // If it's not tracked yet, register it.
-    feature_identity_tracker_[feature.name] = &feature;
-    return true;
-  }
-  // Compare address of |feature| to the existing tracked entry.
-  return it->second == &feature;
-}
-
-FeatureList::OverrideEntry::OverrideEntry(OverrideState overridden_state,
-                                          FieldTrial* field_trial)
-    : overridden_state(overridden_state),
-      field_trial(field_trial),
-      overridden_by_field_trial(field_trial != nullptr) {}
-
-}  // namespace base
diff --git a/base/feature_list.h b/base/feature_list.h
deleted file mode 100644
index 2237507..0000000
--- a/base/feature_list.h
+++ /dev/null
@@ -1,310 +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_FEATURE_LIST_H_
-#define BASE_FEATURE_LIST_H_
-
-#include <map>
-#include <memory>
-#include <string>
-#include <vector>
-
-#include "base/base_export.h"
-#include "base/gtest_prod_util.h"
-#include "base/macros.h"
-#include "base/metrics/persistent_memory_allocator.h"
-#include "base/strings/string_piece.h"
-#include "base/synchronization/lock.h"
-
-namespace base {
-
-class FieldTrial;
-
-// Specifies whether a given feature is enabled or disabled by default.
-enum FeatureState {
-  FEATURE_DISABLED_BY_DEFAULT,
-  FEATURE_ENABLED_BY_DEFAULT,
-};
-
-// The Feature struct is used to define the default state for a feature. See
-// comment below for more details. There must only ever be one struct instance
-// for a given feature name - generally defined as a constant global variable or
-// file static. It should never be used as a constexpr as it breaks
-// pointer-based identity lookup.
-struct BASE_EXPORT Feature {
-  // The name of the feature. This should be unique to each feature and is used
-  // for enabling/disabling features via command line flags and experiments.
-  // It is strongly recommended to use CamelCase style for feature names, e.g.
-  // "MyGreatFeature".
-  const char* const name;
-
-  // The default state (i.e. enabled or disabled) for this feature.
-  const FeatureState default_state;
-};
-
-#if DCHECK_IS_CONFIGURABLE
-// DCHECKs have been built-in, and are configurable at run-time to be fatal, or
-// not, via a DcheckIsFatal feature. We define the Feature here since it is
-// checked in FeatureList::SetInstance(). See https://crbug.com/596231.
-extern BASE_EXPORT const Feature kDCheckIsFatalFeature;
-#endif  // DCHECK_IS_CONFIGURABLE
-
-// The FeatureList class is used to determine whether a given feature is on or
-// off. It provides an authoritative answer, taking into account command-line
-// overrides and experimental control.
-//
-// The basic use case is for any feature that can be toggled (e.g. through
-// command-line or an experiment) to have a defined Feature struct, e.g.:
-//
-//   const base::Feature kMyGreatFeature {
-//     "MyGreatFeature", base::FEATURE_ENABLED_BY_DEFAULT
-//   };
-//
-// Then, client code that wishes to query the state of the feature would check:
-//
-//   if (base::FeatureList::IsEnabled(kMyGreatFeature)) {
-//     // Feature code goes here.
-//   }
-//
-// Behind the scenes, the above call would take into account any command-line
-// flags to enable or disable the feature, any experiments that may control it
-// and finally its default state (in that order of priority), to determine
-// whether the feature is on.
-//
-// Features can be explicitly forced on or off by specifying a list of comma-
-// separated feature names via the following command-line flags:
-//
-//   --enable-features=Feature5,Feature7
-//   --disable-features=Feature1,Feature2,Feature3
-//
-// To enable/disable features in a test, do NOT append --enable-features or
-// --disable-features to the command-line directly. Instead, use
-// ScopedFeatureList. See base/test/scoped_feature_list.h for details.
-//
-// After initialization (which should be done single-threaded), the FeatureList
-// API is thread safe.
-//
-// Note: This class is a singleton, but does not use base/memory/singleton.h in
-// order to have control over its initialization sequence. Specifically, the
-// intended use is to create an instance of this class and fully initialize it,
-// before setting it as the singleton for a process, via SetInstance().
-class BASE_EXPORT FeatureList {
- public:
-  FeatureList();
-  ~FeatureList();
-
-  // Initializes feature overrides via command-line flags |enable_features| and
-  // |disable_features|, each of which is a comma-separated list of features to
-  // enable or disable, respectively. If a feature appears on both lists, then
-  // it will be disabled. If a list entry has the format "FeatureName<TrialName"
-  // then this initialization will also associate the feature state override
-  // with the named field trial, if it exists. If a feature name is prefixed
-  // with the '*' character, it will be created with OVERRIDE_USE_DEFAULT -
-  // which is useful for associating with a trial while using the default state.
-  // Must only be invoked during the initialization phase (before
-  // FinalizeInitialization() has been called).
-  void InitializeFromCommandLine(const std::string& enable_features,
-                                 const std::string& disable_features);
-
-  // Initializes feature overrides through the field trial allocator, which
-  // we're using to store the feature names, their override state, and the name
-  // of the associated field trial.
-  void InitializeFromSharedMemory(PersistentMemoryAllocator* allocator);
-
-  // Specifies whether a feature override enables or disables the feature.
-  enum OverrideState {
-    OVERRIDE_USE_DEFAULT,
-    OVERRIDE_DISABLE_FEATURE,
-    OVERRIDE_ENABLE_FEATURE,
-  };
-
-  // Returns true if the state of |feature_name| has been overridden via
-  // |InitializeFromCommandLine()|.
-  bool IsFeatureOverriddenFromCommandLine(const std::string& feature_name,
-                                          OverrideState state) const;
-
-  // Associates a field trial for reporting purposes corresponding to the
-  // command-line setting the feature state to |for_overridden_state|. The trial
-  // will be activated when the state of the feature is first queried. This
-  // should be called during registration, after InitializeFromCommandLine() has
-  // been called but before the instance is registered via SetInstance().
-  void AssociateReportingFieldTrial(const std::string& feature_name,
-                                    OverrideState for_overridden_state,
-                                    FieldTrial* field_trial);
-
-  // Registers a field trial to override the enabled state of the specified
-  // feature to |override_state|. Command-line overrides still take precedence
-  // over field trials, so this will have no effect if the feature is being
-  // overridden from the command-line. The associated field trial will be
-  // activated when the feature state for this feature is queried. This should
-  // be called during registration, after InitializeFromCommandLine() has been
-  // called but before the instance is registered via SetInstance().
-  void RegisterFieldTrialOverride(const std::string& feature_name,
-                                  OverrideState override_state,
-                                  FieldTrial* field_trial);
-
-  // Loops through feature overrides and serializes them all into |allocator|.
-  void AddFeaturesToAllocator(PersistentMemoryAllocator* allocator);
-
-  // Returns comma-separated lists of feature names (in the same format that is
-  // accepted by InitializeFromCommandLine()) corresponding to features that
-  // have been overridden - either through command-line or via FieldTrials. For
-  // those features that have an associated FieldTrial, the output entry will be
-  // of the format "FeatureName<TrialName", where "TrialName" is the name of the
-  // FieldTrial. Features that have overrides with OVERRIDE_USE_DEFAULT will be
-  // added to |enable_overrides| with a '*' character prefix. Must be called
-  // only after the instance has been initialized and registered.
-  void GetFeatureOverrides(std::string* enable_overrides,
-                           std::string* disable_overrides);
-
-  // Like GetFeatureOverrides(), but only returns overrides that were specified
-  // explicitly on the command-line, omitting the ones from field trials.
-  void GetCommandLineFeatureOverrides(std::string* enable_overrides,
-                                      std::string* disable_overrides);
-
-  // Returns whether the given |feature| is enabled. Must only be called after
-  // the singleton instance has been registered via SetInstance(). Additionally,
-  // a feature with a given name must only have a single corresponding Feature
-  // struct, which is checked in builds with DCHECKs enabled.
-  static bool IsEnabled(const Feature& feature);
-
-  // Returns the field trial associated with the given |feature|. Must only be
-  // called after the singleton instance has been registered via SetInstance().
-  static FieldTrial* GetFieldTrial(const Feature& feature);
-
-  // Splits a comma-separated string containing feature names into a vector. The
-  // resulting pieces point to parts of |input|.
-  static std::vector<base::StringPiece> SplitFeatureListString(
-      base::StringPiece input);
-
-  // Initializes and sets an instance of FeatureList with feature overrides via
-  // command-line flags |enable_features| and |disable_features| if one has not
-  // already been set from command-line flags. Returns true if an instance did
-  // not previously exist. See InitializeFromCommandLine() for more details
-  // about |enable_features| and |disable_features| parameters.
-  static bool InitializeInstance(const std::string& enable_features,
-                                 const std::string& disable_features);
-
-  // Returns the singleton instance of FeatureList. Will return null until an
-  // instance is registered via SetInstance().
-  static FeatureList* GetInstance();
-
-  // Registers the given |instance| to be the singleton feature list for this
-  // process. This should only be called once and |instance| must not be null.
-  // Note: If you are considering using this for the purposes of testing, take
-  // a look at using base/test/scoped_feature_list.h instead.
-  static void SetInstance(std::unique_ptr<FeatureList> instance);
-
-  // Clears the previously-registered singleton instance for tests and returns
-  // the old instance.
-  // Note: Most tests should never call this directly. Instead consider using
-  // base::test::ScopedFeatureList.
-  static std::unique_ptr<FeatureList> ClearInstanceForTesting();
-
-  // Sets a given (initialized) |instance| to be the singleton feature list,
-  // for testing. Existing instance must be null. This is primarily intended
-  // to support base::test::ScopedFeatureList helper class.
-  static void RestoreInstanceForTesting(std::unique_ptr<FeatureList> instance);
-
- private:
-  FRIEND_TEST_ALL_PREFIXES(FeatureListTest, CheckFeatureIdentity);
-  FRIEND_TEST_ALL_PREFIXES(FeatureListTest,
-                           StoreAndRetrieveFeaturesFromSharedMemory);
-  FRIEND_TEST_ALL_PREFIXES(FeatureListTest,
-                           StoreAndRetrieveAssociatedFeaturesFromSharedMemory);
-
-  struct OverrideEntry {
-    // The overridden enable (on/off) state of the feature.
-    const OverrideState overridden_state;
-
-    // An optional associated field trial, which will be activated when the
-    // state of the feature is queried for the first time. Weak pointer to the
-    // FieldTrial object that is owned by the FieldTrialList singleton.
-    base::FieldTrial* field_trial;
-
-    // Specifies whether the feature's state is overridden by |field_trial|.
-    // If it's not, and |field_trial| is not null, it means it is simply an
-    // associated field trial for reporting purposes (and |overridden_state|
-    // came from the command-line).
-    const bool overridden_by_field_trial;
-
-    // TODO(asvitkine): Expand this as more support is added.
-
-    // Constructs an OverrideEntry for the given |overridden_state|. If
-    // |field_trial| is not null, it implies that |overridden_state| comes from
-    // the trial, so |overridden_by_field_trial| will be set to true.
-    OverrideEntry(OverrideState overridden_state, FieldTrial* field_trial);
-  };
-
-  // Finalizes the initialization state of the FeatureList, so that no further
-  // overrides can be registered. This is called by SetInstance() on the
-  // singleton feature list that is being registered.
-  void FinalizeInitialization();
-
-  // Returns whether the given |feature| is enabled. This is invoked by the
-  // public FeatureList::IsEnabled() static function on the global singleton.
-  // Requires the FeatureList to have already been fully initialized.
-  bool IsFeatureEnabled(const Feature& feature);
-
-  // Returns the field trial associated with the given |feature|. This is
-  // invoked by the public FeatureList::GetFieldTrial() static function on the
-  // global singleton. Requires the FeatureList to have already been fully
-  // initialized.
-  base::FieldTrial* GetAssociatedFieldTrial(const Feature& feature);
-
-  // For each feature name in comma-separated list of strings |feature_list|,
-  // registers an override with the specified |overridden_state|. Also, will
-  // associate an optional named field trial if the entry is of the format
-  // "FeatureName<TrialName".
-  void RegisterOverridesFromCommandLine(const std::string& feature_list,
-                                        OverrideState overridden_state);
-
-  // Registers an override for feature |feature_name|. The override specifies
-  // whether the feature should be on or off (via |overridden_state|), which
-  // will take precedence over the feature's default state. If |field_trial| is
-  // not null, registers the specified field trial object to be associated with
-  // the feature, which will activate the field trial when the feature state is
-  // queried. If an override is already registered for the given feature, it
-  // will not be changed.
-  void RegisterOverride(StringPiece feature_name,
-                        OverrideState overridden_state,
-                        FieldTrial* field_trial);
-
-  // Implementation of GetFeatureOverrides() with a parameter that specifies
-  // whether only command-line enabled overrides should be emitted. See that
-  // function's comments for more details.
-  void GetFeatureOverridesImpl(std::string* enable_overrides,
-                               std::string* disable_overrides,
-                               bool command_line_only);
-
-  // Verifies that there's only a single definition of a Feature struct for a
-  // given feature name. Keeps track of the first seen Feature struct for each
-  // feature. Returns false when called on a Feature struct with a different
-  // address than the first one it saw for that feature name. Used only from
-  // DCHECKs and tests.
-  bool CheckFeatureIdentity(const Feature& feature);
-
-  // Map from feature name to an OverrideEntry struct for the feature, if it
-  // exists.
-  std::map<std::string, OverrideEntry> overrides_;
-
-  // Locked map that keeps track of seen features, to ensure a single feature is
-  // only defined once. This verification is only done in builds with DCHECKs
-  // enabled.
-  Lock feature_identity_tracker_lock_;
-  std::map<std::string, const Feature*> feature_identity_tracker_;
-
-  // Whether this object has been fully initialized. This gets set to true as a
-  // result of FinalizeInitialization().
-  bool initialized_ = false;
-
-  // Whether this object has been initialized from command line.
-  bool initialized_from_command_line_ = false;
-
-  DISALLOW_COPY_AND_ASSIGN(FeatureList);
-};
-
-}  // namespace base
-
-#endif  // BASE_FEATURE_LIST_H_
diff --git a/base/files/file.cc b/base/files/file.cc
index 92ff6dd..b79802b 100644
--- a/base/files/file.cc
+++ b/base/files/file.cc
@@ -5,7 +5,6 @@
 #include "base/files/file.h"
 #include "base/files/file_path.h"
 #include "base/files/file_tracing.h"
-#include "base/metrics/histogram.h"
 #include "base/timer/elapsed_timer.h"
 #include "build_config.h"
 
diff --git a/base/files/file_posix.cc b/base/files/file_posix.cc
index d6b7641..9f6ae16 100644
--- a/base/files/file_posix.cc
+++ b/base/files/file_posix.cc
@@ -11,7 +11,6 @@
 #include <unistd.h>
 
 #include "base/logging.h"
-#include "base/metrics/histogram_functions.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread_restrictions.h"
@@ -421,9 +420,6 @@
     case ENOTDIR:
       return FILE_ERROR_NOT_A_DIRECTORY;
     default:
-#if !defined(OS_NACL)  // NaCl build has no metrics code.
-      UmaHistogramSparse("PlatformFile.UnknownErrors.Posix", saved_errno);
-#endif
       // This function should only be called for errors.
       DCHECK_NE(0, saved_errno);
       return FILE_ERROR_FAILED;
diff --git a/base/files/important_file_writer.cc b/base/files/important_file_writer.cc
deleted file mode 100644
index 7fd9d79..0000000
--- a/base/files/important_file_writer.cc
+++ /dev/null
@@ -1,315 +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/files/important_file_writer.h"
-
-#include <stddef.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <string>
-#include <utility>
-
-#include "base/bind.h"
-#include "base/callback_helpers.h"
-#include "base/critical_closure.h"
-#include "base/debug/alias.h"
-#include "base/files/file.h"
-#include "base/files/file_path.h"
-#include "base/files/file_util.h"
-#include "base/logging.h"
-#include "base/macros.h"
-#include "base/metrics/histogram_functions.h"
-#include "base/metrics/histogram_macros.h"
-#include "base/numerics/safe_conversions.h"
-#include "base/strings/string_number_conversions.h"
-#include "base/strings/string_util.h"
-#include "base/task_runner.h"
-#include "base/task_runner_util.h"
-#include "base/threading/thread.h"
-#include "base/time/time.h"
-#include "build_config.h"
-
-namespace base {
-
-namespace {
-
-constexpr auto kDefaultCommitInterval = TimeDelta::FromSeconds(10);
-
-// This enum is used to define the buckets for an enumerated UMA histogram.
-// Hence,
-//   (a) existing enumerated constants should never be deleted or reordered, and
-//   (b) new constants should only be appended at the end of the enumeration.
-enum TempFileFailure {
-  FAILED_CREATING,
-  FAILED_OPENING,
-  FAILED_CLOSING,  // Unused.
-  FAILED_WRITING,
-  FAILED_RENAMING,
-  FAILED_FLUSHING,
-  TEMP_FILE_FAILURE_MAX
-};
-
-// Helper function to write samples to a histogram with a dynamically assigned
-// histogram name.  Works with different error code types convertible to int
-// which is the actual argument type of UmaHistogramExactLinear.
-template <typename SampleType>
-void UmaHistogramExactLinearWithSuffix(const char* histogram_name,
-                                       StringPiece histogram_suffix,
-                                       SampleType add_sample,
-                                       SampleType max_sample) {
-  static_assert(std::is_convertible<SampleType, int>::value,
-                "SampleType should be convertible to int");
-  DCHECK(histogram_name);
-  std::string histogram_full_name(histogram_name);
-  if (!histogram_suffix.empty()) {
-    histogram_full_name.append(".");
-    histogram_full_name.append(histogram_suffix.data(),
-                               histogram_suffix.length());
-  }
-  UmaHistogramExactLinear(histogram_full_name, static_cast<int>(add_sample),
-                          static_cast<int>(max_sample));
-}
-
-// Helper function to write samples to a histogram with a dynamically assigned
-// histogram name.  Works with short timings from 1 ms up to 10 seconds (50
-// buckets) which is the actual argument type of UmaHistogramTimes.
-void UmaHistogramTimesWithSuffix(const char* histogram_name,
-                                 StringPiece histogram_suffix,
-                                 TimeDelta sample) {
-  DCHECK(histogram_name);
-  std::string histogram_full_name(histogram_name);
-  if (!histogram_suffix.empty()) {
-    histogram_full_name.append(".");
-    histogram_full_name.append(histogram_suffix.data(),
-                               histogram_suffix.length());
-  }
-  UmaHistogramTimes(histogram_full_name, sample);
-}
-
-void LogFailure(const FilePath& path,
-                StringPiece histogram_suffix,
-                TempFileFailure failure_code,
-                StringPiece message) {
-  UmaHistogramExactLinearWithSuffix("ImportantFile.TempFileFailures",
-                                    histogram_suffix, failure_code,
-                                    TEMP_FILE_FAILURE_MAX);
-  DPLOG(WARNING) << "temp file failure: " << path.value() << " : " << message;
-}
-
-// Helper function to call WriteFileAtomically() with a
-// std::unique_ptr<std::string>.
-void WriteScopedStringToFileAtomically(
-    const FilePath& path,
-    std::unique_ptr<std::string> data,
-    Closure before_write_callback,
-    Callback<void(bool success)> after_write_callback,
-    const std::string& histogram_suffix) {
-  if (!before_write_callback.is_null())
-    before_write_callback.Run();
-
-  TimeTicks start_time = TimeTicks::Now();
-  bool result =
-      ImportantFileWriter::WriteFileAtomically(path, *data, histogram_suffix);
-  if (result) {
-    UmaHistogramTimesWithSuffix("ImportantFile.TimeToWrite", histogram_suffix,
-                                TimeTicks::Now() - start_time);
-  }
-
-  if (!after_write_callback.is_null())
-    after_write_callback.Run(result);
-}
-
-void DeleteTmpFile(const FilePath& tmp_file_path,
-                   StringPiece histogram_suffix) {
-  if (!DeleteFile(tmp_file_path, false)) {
-    UmaHistogramExactLinearWithSuffix(
-        "ImportantFile.FileDeleteError", histogram_suffix,
-        -base::File::GetLastFileError(), -base::File::FILE_ERROR_MAX);
-  }
-}
-
-}  // namespace
-
-// static
-bool ImportantFileWriter::WriteFileAtomically(const FilePath& path,
-                                              StringPiece data,
-                                              StringPiece histogram_suffix) {
-#if defined(OS_CHROMEOS)
-  // On Chrome OS, chrome gets killed when it cannot finish shutdown quickly,
-  // and this function seems to be one of the slowest shutdown steps.
-  // Include some info to the report for investigation. crbug.com/418627
-  // TODO(hashimoto): Remove this.
-  struct {
-    size_t data_size;
-    char path[128];
-  } file_info;
-  file_info.data_size = data.size();
-  strlcpy(file_info.path, path.value().c_str(), arraysize(file_info.path));
-  debug::Alias(&file_info);
-#endif
-
-  // Write the data to a temp file then rename to avoid data loss if we crash
-  // while writing the file. Ensure that the temp file is on the same volume
-  // as target file, so it can be moved in one step, and that the temp file
-  // is securely created.
-  FilePath tmp_file_path;
-  if (!CreateTemporaryFileInDir(path.DirName(), &tmp_file_path)) {
-    UmaHistogramExactLinearWithSuffix(
-        "ImportantFile.FileCreateError", histogram_suffix,
-        -base::File::GetLastFileError(), -base::File::FILE_ERROR_MAX);
-    LogFailure(path, histogram_suffix, FAILED_CREATING,
-               "could not create temporary file");
-    return false;
-  }
-
-  File tmp_file(tmp_file_path, File::FLAG_OPEN | File::FLAG_WRITE);
-  if (!tmp_file.IsValid()) {
-    UmaHistogramExactLinearWithSuffix(
-        "ImportantFile.FileOpenError", histogram_suffix,
-        -tmp_file.error_details(), -base::File::FILE_ERROR_MAX);
-    LogFailure(path, histogram_suffix, FAILED_OPENING,
-               "could not open temporary file");
-    DeleteFile(tmp_file_path, false);
-    return false;
-  }
-
-  // If this fails in the wild, something really bad is going on.
-  const int data_length = checked_cast<int32_t>(data.length());
-  int bytes_written = tmp_file.Write(0, data.data(), data_length);
-  if (bytes_written < data_length) {
-    UmaHistogramExactLinearWithSuffix(
-        "ImportantFile.FileWriteError", histogram_suffix,
-        -base::File::GetLastFileError(), -base::File::FILE_ERROR_MAX);
-  }
-  bool flush_success = tmp_file.Flush();
-  tmp_file.Close();
-
-  if (bytes_written < data_length) {
-    LogFailure(path, histogram_suffix, FAILED_WRITING,
-               "error writing, bytes_written=" + IntToString(bytes_written));
-    DeleteTmpFile(tmp_file_path, histogram_suffix);
-    return false;
-  }
-
-  if (!flush_success) {
-    LogFailure(path, histogram_suffix, FAILED_FLUSHING, "error flushing");
-    DeleteTmpFile(tmp_file_path, histogram_suffix);
-    return false;
-  }
-
-  base::File::Error replace_file_error = base::File::FILE_OK;
-  if (!ReplaceFile(tmp_file_path, path, &replace_file_error)) {
-    UmaHistogramExactLinearWithSuffix("ImportantFile.FileRenameError",
-                                      histogram_suffix, -replace_file_error,
-                                      -base::File::FILE_ERROR_MAX);
-    LogFailure(path, histogram_suffix, FAILED_RENAMING,
-               "could not rename temporary file");
-    DeleteTmpFile(tmp_file_path, histogram_suffix);
-    return false;
-  }
-
-  return true;
-}
-
-ImportantFileWriter::ImportantFileWriter(
-    const FilePath& path,
-    scoped_refptr<SequencedTaskRunner> task_runner,
-    const char* histogram_suffix)
-    : ImportantFileWriter(path,
-                          std::move(task_runner),
-                          kDefaultCommitInterval,
-                          histogram_suffix) {}
-
-ImportantFileWriter::ImportantFileWriter(
-    const FilePath& path,
-    scoped_refptr<SequencedTaskRunner> task_runner,
-    TimeDelta interval,
-    const char* histogram_suffix)
-    : path_(path),
-      task_runner_(std::move(task_runner)),
-      serializer_(nullptr),
-      commit_interval_(interval),
-      histogram_suffix_(histogram_suffix ? histogram_suffix : ""),
-      weak_factory_(this) {
-  DCHECK(task_runner_);
-}
-
-ImportantFileWriter::~ImportantFileWriter() {
-  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
-  // We're usually a member variable of some other object, which also tends
-  // to be our serializer. It may not be safe to call back to the parent object
-  // being destructed.
-  DCHECK(!HasPendingWrite());
-}
-
-bool ImportantFileWriter::HasPendingWrite() const {
-  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
-  return timer().IsRunning();
-}
-
-void ImportantFileWriter::WriteNow(std::unique_ptr<std::string> data) {
-  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
-  if (!IsValueInRangeForNumericType<int32_t>(data->length())) {
-    NOTREACHED();
-    return;
-  }
-
-  Closure task = AdaptCallbackForRepeating(
-      BindOnce(&WriteScopedStringToFileAtomically, path_, std::move(data),
-               std::move(before_next_write_callback_),
-               std::move(after_next_write_callback_), histogram_suffix_));
-
-  if (!task_runner_->PostTask(FROM_HERE, MakeCriticalClosure(task))) {
-    // Posting the task to background message loop is not expected
-    // to fail, but if it does, avoid losing data and just hit the disk
-    // on the current thread.
-    NOTREACHED();
-
-    task.Run();
-  }
-  ClearPendingWrite();
-}
-
-void ImportantFileWriter::ScheduleWrite(DataSerializer* serializer) {
-  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
-
-  DCHECK(serializer);
-  serializer_ = serializer;
-
-  if (!timer().IsRunning()) {
-    timer().Start(
-        FROM_HERE, commit_interval_,
-        Bind(&ImportantFileWriter::DoScheduledWrite, Unretained(this)));
-  }
-}
-
-void ImportantFileWriter::DoScheduledWrite() {
-  DCHECK(serializer_);
-  std::unique_ptr<std::string> data(new std::string);
-  if (serializer_->SerializeData(data.get())) {
-    WriteNow(std::move(data));
-  } else {
-    DLOG(WARNING) << "failed to serialize data to be saved in "
-                  << path_.value();
-  }
-  ClearPendingWrite();
-}
-
-void ImportantFileWriter::RegisterOnNextWriteCallbacks(
-    const Closure& before_next_write_callback,
-    const Callback<void(bool success)>& after_next_write_callback) {
-  before_next_write_callback_ = before_next_write_callback;
-  after_next_write_callback_ = after_next_write_callback;
-}
-
-void ImportantFileWriter::ClearPendingWrite() {
-  timer().Stop();
-  serializer_ = nullptr;
-}
-
-void ImportantFileWriter::SetTimerForTesting(Timer* timer_override) {
-  timer_override_ = timer_override;
-}
-
-}  // namespace base
diff --git a/base/files/important_file_writer.h b/base/files/important_file_writer.h
deleted file mode 100644
index 08a7ee3..0000000
--- a/base/files/important_file_writer.h
+++ /dev/null
@@ -1,162 +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_FILES_IMPORTANT_FILE_WRITER_H_
-#define BASE_FILES_IMPORTANT_FILE_WRITER_H_
-
-#include <string>
-
-#include "base/base_export.h"
-#include "base/callback.h"
-#include "base/files/file_path.h"
-#include "base/macros.h"
-#include "base/memory/ref_counted.h"
-#include "base/sequence_checker.h"
-#include "base/strings/string_piece.h"
-#include "base/time/time.h"
-#include "base/timer/timer.h"
-
-namespace base {
-
-class SequencedTaskRunner;
-
-// Helper for atomically writing a file to ensure that it won't be corrupted by
-// *application* crash during write (implemented as create, flush, rename).
-//
-// As an added benefit, ImportantFileWriter makes it less likely that the file
-// is corrupted by *system* crash, though even if the ImportantFileWriter call
-// has already returned at the time of the crash it is not specified which
-// version of the file (old or new) is preserved. And depending on system
-// configuration (hardware and software) a significant likelihood of file
-// corruption may remain, thus using ImportantFileWriter is not a valid
-// substitute for file integrity checks and recovery codepaths for malformed
-// files.
-//
-// Also note that ImportantFileWriter can be *really* slow (cf. File::Flush()
-// for details) and thus please don't block shutdown on ImportantFileWriter.
-class BASE_EXPORT ImportantFileWriter {
- public:
-  // Used by ScheduleSave to lazily provide the data to be saved. Allows us
-  // to also batch data serializations.
-  class BASE_EXPORT DataSerializer {
-   public:
-    // Should put serialized string in |data| and return true on successful
-    // serialization. Will be called on the same thread on which
-    // ImportantFileWriter has been created.
-    virtual bool SerializeData(std::string* data) = 0;
-
-   protected:
-    virtual ~DataSerializer() = default;
-  };
-
-  // Save |data| to |path| in an atomic manner. Blocks and writes data on the
-  // current thread. Does not guarantee file integrity across system crash (see
-  // the class comment above).
-  static bool WriteFileAtomically(const FilePath& path,
-                                  StringPiece data,
-                                  StringPiece histogram_suffix = StringPiece());
-
-  // Initialize the writer.
-  // |path| is the name of file to write.
-  // |task_runner| is the SequencedTaskRunner instance where on which we will
-  // execute file I/O operations.
-  // All non-const methods, ctor and dtor must be called on the same thread.
-  ImportantFileWriter(const FilePath& path,
-                      scoped_refptr<SequencedTaskRunner> task_runner,
-                      const char* histogram_suffix = nullptr);
-
-  // Same as above, but with a custom commit interval.
-  ImportantFileWriter(const FilePath& path,
-                      scoped_refptr<SequencedTaskRunner> task_runner,
-                      TimeDelta interval,
-                      const char* histogram_suffix = nullptr);
-
-  // You have to ensure that there are no pending writes at the moment
-  // of destruction.
-  ~ImportantFileWriter();
-
-  const FilePath& path() const { return path_; }
-
-  // Returns true if there is a scheduled write pending which has not yet
-  // been started.
-  bool HasPendingWrite() const;
-
-  // Save |data| to target filename. Does not block. If there is a pending write
-  // scheduled by ScheduleWrite(), it is cancelled.
-  void WriteNow(std::unique_ptr<std::string> data);
-
-  // Schedule a save to target filename. Data will be serialized and saved
-  // to disk after the commit interval. If another ScheduleWrite is issued
-  // before that, only one serialization and write to disk will happen, and
-  // the most recent |serializer| will be used. This operation does not block.
-  // |serializer| should remain valid through the lifetime of
-  // ImportantFileWriter.
-  void ScheduleWrite(DataSerializer* serializer);
-
-  // Serialize data pending to be saved and execute write on backend thread.
-  void DoScheduledWrite();
-
-  // Registers |before_next_write_callback| and |after_next_write_callback| to
-  // be synchronously invoked from WriteFileAtomically() before its next write
-  // and after its next write, respectively. The boolean passed to
-  // |after_next_write_callback| indicates whether the write was successful.
-  // Both callbacks must be thread safe as they will be called on |task_runner_|
-  // and may be called during Chrome shutdown.
-  // If called more than once before a write is scheduled on |task_runner|, the
-  // latest callbacks clobber the others.
-  void RegisterOnNextWriteCallbacks(
-      const Closure& before_next_write_callback,
-      const Callback<void(bool success)>& after_next_write_callback);
-
-  TimeDelta commit_interval() const {
-    return commit_interval_;
-  }
-
-  // Overrides the timer to use for scheduling writes with |timer_override|.
-  void SetTimerForTesting(Timer* timer_override);
-
- private:
-  const Timer& timer() const {
-    return timer_override_ ? const_cast<const Timer&>(*timer_override_)
-                           : timer_;
-  }
-  Timer& timer() { return timer_override_ ? *timer_override_ : timer_; }
-
-  void ClearPendingWrite();
-
-  // Invoked synchronously on the next write event.
-  Closure before_next_write_callback_;
-  Callback<void(bool success)> after_next_write_callback_;
-
-  // Path being written to.
-  const FilePath path_;
-
-  // TaskRunner for the thread on which file I/O can be done.
-  const scoped_refptr<SequencedTaskRunner> task_runner_;
-
-  // Timer used to schedule commit after ScheduleWrite.
-  OneShotTimer timer_;
-
-  // An override for |timer_| used for testing.
-  Timer* timer_override_ = nullptr;
-
-  // Serializer which will provide the data to be saved.
-  DataSerializer* serializer_;
-
-  // Time delta after which scheduled data will be written to disk.
-  const TimeDelta commit_interval_;
-
-  // Custom histogram suffix.
-  const std::string histogram_suffix_;
-
-  SEQUENCE_CHECKER(sequence_checker_);
-
-  WeakPtrFactory<ImportantFileWriter> weak_factory_;
-
-  DISALLOW_COPY_AND_ASSIGN(ImportantFileWriter);
-};
-
-}  // namespace base
-
-#endif  // BASE_FILES_IMPORTANT_FILE_WRITER_H_
diff --git a/base/logging.cc b/base/logging.cc
index cf96aeb..72ca87a 100644
--- a/base/logging.cc
+++ b/base/logging.cc
@@ -88,7 +88,6 @@
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/containers/stack.h"
-#include "base/debug/activity_tracker.h"
 #include "base/debug/alias.h"
 #include "base/debug/debugger.h"
 #include "base/debug/stack_trace.h"
@@ -816,12 +815,6 @@
   }
 
   if (severity_ == LOG_FATAL) {
-    // Write the log message to the global activity tracker, if running.
-    base::debug::GlobalActivityTracker* tracker =
-        base::debug::GlobalActivityTracker::Get();
-    if (tracker)
-      tracker->RecordLogMessage(str_newline);
-
     // 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);
diff --git a/base/memory/shared_memory_mac.cc b/base/memory/shared_memory_mac.cc
index 3990948..5e9e8fc 100644
--- a/base/memory/shared_memory_mac.cc
+++ b/base/memory/shared_memory_mac.cc
@@ -19,8 +19,6 @@
 #include "base/mac/scoped_mach_vm.h"
 #include "base/memory/shared_memory_helper.h"
 #include "base/memory/shared_memory_tracker.h"
-#include "base/metrics/field_trial.h"
-#include "base/metrics/histogram_macros.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/posix/safe_strerror.h"
 #include "base/process/process_metrics.h"
diff --git a/base/metrics/OWNERS b/base/metrics/OWNERS
deleted file mode 100644
index 4cc69ff..0000000
--- a/base/metrics/OWNERS
+++ /dev/null
@@ -1,10 +0,0 @@
-asvitkine@chromium.org
-bcwhite@chromium.org
-gayane@chromium.org
-holte@chromium.org
-isherman@chromium.org
-jwd@chromium.org
-mpearson@chromium.org
-rkaplow@chromium.org
-
-# COMPONENT: Internals>Metrics
diff --git a/base/metrics/bucket_ranges.cc b/base/metrics/bucket_ranges.cc
deleted file mode 100644
index 39b3793..0000000
--- a/base/metrics/bucket_ranges.cc
+++ /dev/null
@@ -1,124 +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/metrics/bucket_ranges.h"
-
-#include <cmath>
-
-#include "base/logging.h"
-
-namespace base {
-
-// Static table of checksums for all possible 8 bit bytes.
-const uint32_t kCrcTable[256] = {
-    0x0,         0x77073096L, 0xee0e612cL, 0x990951baL, 0x76dc419L,
-    0x706af48fL, 0xe963a535L, 0x9e6495a3L, 0xedb8832L,  0x79dcb8a4L,
-    0xe0d5e91eL, 0x97d2d988L, 0x9b64c2bL,  0x7eb17cbdL, 0xe7b82d07L,
-    0x90bf1d91L, 0x1db71064L, 0x6ab020f2L, 0xf3b97148L, 0x84be41deL,
-    0x1adad47dL, 0x6ddde4ebL, 0xf4d4b551L, 0x83d385c7L, 0x136c9856L,
-    0x646ba8c0L, 0xfd62f97aL, 0x8a65c9ecL, 0x14015c4fL, 0x63066cd9L,
-    0xfa0f3d63L, 0x8d080df5L, 0x3b6e20c8L, 0x4c69105eL, 0xd56041e4L,
-    0xa2677172L, 0x3c03e4d1L, 0x4b04d447L, 0xd20d85fdL, 0xa50ab56bL,
-    0x35b5a8faL, 0x42b2986cL, 0xdbbbc9d6L, 0xacbcf940L, 0x32d86ce3L,
-    0x45df5c75L, 0xdcd60dcfL, 0xabd13d59L, 0x26d930acL, 0x51de003aL,
-    0xc8d75180L, 0xbfd06116L, 0x21b4f4b5L, 0x56b3c423L, 0xcfba9599L,
-    0xb8bda50fL, 0x2802b89eL, 0x5f058808L, 0xc60cd9b2L, 0xb10be924L,
-    0x2f6f7c87L, 0x58684c11L, 0xc1611dabL, 0xb6662d3dL, 0x76dc4190L,
-    0x1db7106L,  0x98d220bcL, 0xefd5102aL, 0x71b18589L, 0x6b6b51fL,
-    0x9fbfe4a5L, 0xe8b8d433L, 0x7807c9a2L, 0xf00f934L,  0x9609a88eL,
-    0xe10e9818L, 0x7f6a0dbbL, 0x86d3d2dL,  0x91646c97L, 0xe6635c01L,
-    0x6b6b51f4L, 0x1c6c6162L, 0x856530d8L, 0xf262004eL, 0x6c0695edL,
-    0x1b01a57bL, 0x8208f4c1L, 0xf50fc457L, 0x65b0d9c6L, 0x12b7e950L,
-    0x8bbeb8eaL, 0xfcb9887cL, 0x62dd1ddfL, 0x15da2d49L, 0x8cd37cf3L,
-    0xfbd44c65L, 0x4db26158L, 0x3ab551ceL, 0xa3bc0074L, 0xd4bb30e2L,
-    0x4adfa541L, 0x3dd895d7L, 0xa4d1c46dL, 0xd3d6f4fbL, 0x4369e96aL,
-    0x346ed9fcL, 0xad678846L, 0xda60b8d0L, 0x44042d73L, 0x33031de5L,
-    0xaa0a4c5fL, 0xdd0d7cc9L, 0x5005713cL, 0x270241aaL, 0xbe0b1010L,
-    0xc90c2086L, 0x5768b525L, 0x206f85b3L, 0xb966d409L, 0xce61e49fL,
-    0x5edef90eL, 0x29d9c998L, 0xb0d09822L, 0xc7d7a8b4L, 0x59b33d17L,
-    0x2eb40d81L, 0xb7bd5c3bL, 0xc0ba6cadL, 0xedb88320L, 0x9abfb3b6L,
-    0x3b6e20cL,  0x74b1d29aL, 0xead54739L, 0x9dd277afL, 0x4db2615L,
-    0x73dc1683L, 0xe3630b12L, 0x94643b84L, 0xd6d6a3eL,  0x7a6a5aa8L,
-    0xe40ecf0bL, 0x9309ff9dL, 0xa00ae27L,  0x7d079eb1L, 0xf00f9344L,
-    0x8708a3d2L, 0x1e01f268L, 0x6906c2feL, 0xf762575dL, 0x806567cbL,
-    0x196c3671L, 0x6e6b06e7L, 0xfed41b76L, 0x89d32be0L, 0x10da7a5aL,
-    0x67dd4accL, 0xf9b9df6fL, 0x8ebeeff9L, 0x17b7be43L, 0x60b08ed5L,
-    0xd6d6a3e8L, 0xa1d1937eL, 0x38d8c2c4L, 0x4fdff252L, 0xd1bb67f1L,
-    0xa6bc5767L, 0x3fb506ddL, 0x48b2364bL, 0xd80d2bdaL, 0xaf0a1b4cL,
-    0x36034af6L, 0x41047a60L, 0xdf60efc3L, 0xa867df55L, 0x316e8eefL,
-    0x4669be79L, 0xcb61b38cL, 0xbc66831aL, 0x256fd2a0L, 0x5268e236L,
-    0xcc0c7795L, 0xbb0b4703L, 0x220216b9L, 0x5505262fL, 0xc5ba3bbeL,
-    0xb2bd0b28L, 0x2bb45a92L, 0x5cb36a04L, 0xc2d7ffa7L, 0xb5d0cf31L,
-    0x2cd99e8bL, 0x5bdeae1dL, 0x9b64c2b0L, 0xec63f226L, 0x756aa39cL,
-    0x26d930aL,  0x9c0906a9L, 0xeb0e363fL, 0x72076785L, 0x5005713L,
-    0x95bf4a82L, 0xe2b87a14L, 0x7bb12baeL, 0xcb61b38L,  0x92d28e9bL,
-    0xe5d5be0dL, 0x7cdcefb7L, 0xbdbdf21L,  0x86d3d2d4L, 0xf1d4e242L,
-    0x68ddb3f8L, 0x1fda836eL, 0x81be16cdL, 0xf6b9265bL, 0x6fb077e1L,
-    0x18b74777L, 0x88085ae6L, 0xff0f6a70L, 0x66063bcaL, 0x11010b5cL,
-    0x8f659effL, 0xf862ae69L, 0x616bffd3L, 0x166ccf45L, 0xa00ae278L,
-    0xd70dd2eeL, 0x4e048354L, 0x3903b3c2L, 0xa7672661L, 0xd06016f7L,
-    0x4969474dL, 0x3e6e77dbL, 0xaed16a4aL, 0xd9d65adcL, 0x40df0b66L,
-    0x37d83bf0L, 0xa9bcae53L, 0xdebb9ec5L, 0x47b2cf7fL, 0x30b5ffe9L,
-    0xbdbdf21cL, 0xcabac28aL, 0x53b39330L, 0x24b4a3a6L, 0xbad03605L,
-    0xcdd70693L, 0x54de5729L, 0x23d967bfL, 0xb3667a2eL, 0xc4614ab8L,
-    0x5d681b02L, 0x2a6f2b94L, 0xb40bbe37L, 0xc30c8ea1L, 0x5a05df1bL,
-    0x2d02ef8dL,
-};
-
-// We generate the CRC-32 using the low order bits to select whether to XOR in
-// the reversed polynomial 0xedb88320L.  This is nice and simple, and allows us
-// to keep the quotient in a uint32_t.  Since we're not concerned about the
-// nature of corruptions (i.e., we don't care about bit sequencing, since we are
-// handling memory changes, which are more grotesque) so we don't bother to get
-// the CRC correct for big-endian vs little-ending calculations.  All we need is
-// a nice hash, that tends to depend on all the bits of the sample, with very
-// little chance of changes in one place impacting changes in another place.
-static uint32_t Crc32(uint32_t sum, HistogramBase::Sample value) {
-  union {
-    HistogramBase::Sample range;
-    unsigned char bytes[sizeof(HistogramBase::Sample)];
-  } converter;
-  converter.range = value;
-  for (size_t i = 0; i < sizeof(converter); ++i) {
-    sum = kCrcTable[(sum & 0xff) ^ converter.bytes[i]] ^ (sum >> 8);
-  }
-  return sum;
-}
-
-BucketRanges::BucketRanges(size_t num_ranges)
-    : ranges_(num_ranges, 0),
-      checksum_(0) {}
-
-BucketRanges::~BucketRanges() = default;
-
-uint32_t BucketRanges::CalculateChecksum() const {
-  // Seed checksum.
-  uint32_t checksum = static_cast<uint32_t>(ranges_.size());
-
-  for (size_t index = 0; index < ranges_.size(); ++index)
-    checksum = Crc32(checksum, ranges_[index]);
-  return checksum;
-}
-
-bool BucketRanges::HasValidChecksum() const {
-  return CalculateChecksum() == checksum_;
-}
-
-void BucketRanges::ResetChecksum() {
-  checksum_ = CalculateChecksum();
-}
-
-bool BucketRanges::Equals(const BucketRanges* other) const {
-  if (checksum_ != other->checksum_)
-    return false;
-  if (ranges_.size() != other->ranges_.size())
-    return false;
-  for (size_t index = 0; index < ranges_.size(); ++index) {
-    if (ranges_[index] != other->ranges_[index])
-      return false;
-  }
-  return true;
-}
-
-}  // namespace base
diff --git a/base/metrics/bucket_ranges.h b/base/metrics/bucket_ranges.h
deleted file mode 100644
index 1b6d069..0000000
--- a/base/metrics/bucket_ranges.h
+++ /dev/null
@@ -1,105 +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.
-//
-// BucketRanges stores the vector of ranges that delimit what samples are
-// tallied in the corresponding buckets of a histogram. Histograms that have
-// same ranges for all their corresponding buckets should share the same
-// BucketRanges object.
-//
-// E.g. A 5 buckets LinearHistogram with 1 as minimal value and 4 as maximal
-// value will need a BucketRanges with 6 ranges:
-// 0, 1, 2, 3, 4, INT_MAX
-//
-// TODO(kaiwang): Currently we keep all negative values in 0~1 bucket. Consider
-// changing 0 to INT_MIN.
-
-#ifndef BASE_METRICS_BUCKET_RANGES_H_
-#define BASE_METRICS_BUCKET_RANGES_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-#include <vector>
-
-#include <limits.h>
-
-#include "base/atomicops.h"
-#include "base/base_export.h"
-#include "base/macros.h"
-#include "base/metrics/histogram_base.h"
-
-namespace base {
-
-class BASE_EXPORT BucketRanges {
- public:
-  typedef std::vector<HistogramBase::Sample> Ranges;
-
-  explicit BucketRanges(size_t num_ranges);
-  ~BucketRanges();
-
-  size_t size() const { return ranges_.size(); }
-  HistogramBase::Sample range(size_t i) const { return ranges_[i]; }
-  void set_range(size_t i, HistogramBase::Sample value) {
-    DCHECK_LT(i, ranges_.size());
-    DCHECK_GE(value, 0);
-    ranges_[i] = value;
-  }
-  uint32_t checksum() const { return checksum_; }
-  void set_checksum(uint32_t checksum) { checksum_ = checksum; }
-
-  // A bucket is defined by a consecutive pair of entries in |ranges|, so there
-  // is one fewer bucket than there are ranges.  For example, if |ranges| is
-  // [0, 1, 3, 7, INT_MAX], then the buckets in this histogram are
-  // [0, 1), [1, 3), [3, 7), and [7, INT_MAX).
-  size_t bucket_count() const { return ranges_.size() - 1; }
-
-  // Checksum methods to verify whether the ranges are corrupted (e.g. bad
-  // memory access).
-  uint32_t CalculateChecksum() const;
-  bool HasValidChecksum() const;
-  void ResetChecksum();
-
-  // Return true iff |other| object has same ranges_ as |this| object's ranges_.
-  bool Equals(const BucketRanges* other) const;
-
-  // Set and get a reference into persistent memory where this bucket data
-  // can be found (and re-used). These calls are internally atomic with no
-  // safety against overwriting an existing value since though it is wasteful
-  // to have multiple identical persistent records, it is still safe.
-  void set_persistent_reference(uint32_t ref) const {
-    subtle::Release_Store(&persistent_reference_, ref);
-  }
-  uint32_t persistent_reference() const {
-    return subtle::Acquire_Load(&persistent_reference_);
-  }
-
- private:
-  // A monotonically increasing list of values which determine which bucket to
-  // put a sample into.  For each index, show the smallest sample that can be
-  // added to the corresponding bucket.
-  Ranges ranges_;
-
-  // Checksum for the conntents of ranges_.  Used to detect random over-writes
-  // of our data, and to quickly see if some other BucketRanges instance is
-  // possibly Equal() to this instance.
-  // TODO(kaiwang): Consider change this to uint64_t. Because we see a lot of
-  // noise on UMA dashboard.
-  uint32_t checksum_;
-
-  // A reference into a global PersistentMemoryAllocator where the ranges
-  // information is stored. This allows for the record to be created once and
-  // re-used simply by having all histograms with the same ranges use the
-  // same reference.
-  mutable subtle::Atomic32 persistent_reference_ = 0;
-
-  DISALLOW_COPY_AND_ASSIGN(BucketRanges);
-};
-
-//////////////////////////////////////////////////////////////////////////////
-// Expose only for test.
-BASE_EXPORT extern const uint32_t kCrcTable[256];
-
-}  // namespace base
-
-#endif  // BASE_METRICS_BUCKET_RANGES_H_
diff --git a/base/metrics/dummy_histogram.cc b/base/metrics/dummy_histogram.cc
deleted file mode 100644
index 2707733..0000000
--- a/base/metrics/dummy_histogram.cc
+++ /dev/null
@@ -1,102 +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/metrics/dummy_histogram.h"
-
-#include <memory>
-
-#include "base/logging.h"
-#include "base/metrics/histogram_samples.h"
-#include "base/metrics/metrics_hashes.h"
-
-namespace base {
-
-namespace {
-
-// Helper classes for DummyHistogram.
-class DummySampleCountIterator : public SampleCountIterator {
- public:
-  DummySampleCountIterator() {}
-  ~DummySampleCountIterator() override {}
-
-  // SampleCountIterator:
-  bool Done() const override { return true; }
-  void Next() override { NOTREACHED(); }
-  void Get(HistogramBase::Sample* min,
-           int64_t* max,
-           HistogramBase::Count* count) const override {
-    NOTREACHED();
-  }
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(DummySampleCountIterator);
-};
-
-class DummyHistogramSamples : public HistogramSamples {
- public:
-  explicit DummyHistogramSamples() : HistogramSamples(0, new LocalMetadata()) {}
-  ~DummyHistogramSamples() override {
-    delete static_cast<LocalMetadata*>(meta());
-  }
-
-  // HistogramSamples:
-  void Accumulate(HistogramBase::Sample value,
-                  HistogramBase::Count count) override {}
-  HistogramBase::Count GetCount(HistogramBase::Sample value) const override {
-    return HistogramBase::Count();
-  }
-  HistogramBase::Count TotalCount() const override {
-    return HistogramBase::Count();
-  }
-  std::unique_ptr<SampleCountIterator> Iterator() const override {
-    return std::make_unique<DummySampleCountIterator>();
-  }
-  bool AddSubtractImpl(SampleCountIterator* iter, Operator op) override {
-    return true;
-  }
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(DummyHistogramSamples);
-};
-
-}  // namespace
-
-// static
-DummyHistogram* DummyHistogram::GetInstance() {
-  static base::NoDestructor<DummyHistogram> dummy_histogram;
-  return dummy_histogram.get();
-}
-
-uint64_t DummyHistogram::name_hash() const {
-  return HashMetricName(histogram_name());
-}
-
-HistogramType DummyHistogram::GetHistogramType() const {
-  return DUMMY_HISTOGRAM;
-}
-
-bool DummyHistogram::HasConstructionArguments(
-    Sample expected_minimum,
-    Sample expected_maximum,
-    uint32_t expected_bucket_count) const {
-  return true;
-}
-
-bool DummyHistogram::AddSamplesFromPickle(PickleIterator* iter) {
-  return true;
-}
-
-std::unique_ptr<HistogramSamples> DummyHistogram::SnapshotSamples() const {
-  return std::make_unique<DummyHistogramSamples>();
-}
-
-std::unique_ptr<HistogramSamples> DummyHistogram::SnapshotDelta() {
-  return std::make_unique<DummyHistogramSamples>();
-}
-
-std::unique_ptr<HistogramSamples> DummyHistogram::SnapshotFinalDelta() const {
-  return std::make_unique<DummyHistogramSamples>();
-}
-
-}  // namespace base
diff --git a/base/metrics/dummy_histogram.h b/base/metrics/dummy_histogram.h
deleted file mode 100644
index e2cb64e..0000000
--- a/base/metrics/dummy_histogram.h
+++ /dev/null
@@ -1,61 +0,0 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_METRICS_DUMMY_HISTOGRAM_H_
-#define BASE_METRICS_DUMMY_HISTOGRAM_H_
-
-#include <stdint.h>
-
-#include <memory>
-#include <string>
-
-#include "base/base_export.h"
-#include "base/metrics/histogram_base.h"
-#include "base/no_destructor.h"
-
-namespace base {
-
-// DummyHistogram is used for mocking histogram objects for histograms that
-// shouldn't be recorded. It doesn't do any actual processing.
-class BASE_EXPORT DummyHistogram : public HistogramBase {
- public:
-  static DummyHistogram* GetInstance();
-
-  // HistogramBase:
-  void CheckName(const StringPiece& name) const override {}
-  uint64_t name_hash() const override;
-  HistogramType GetHistogramType() const override;
-  bool HasConstructionArguments(Sample expected_minimum,
-                                Sample expected_maximum,
-                                uint32_t expected_bucket_count) const override;
-  void Add(Sample value) override {}
-  void AddCount(Sample value, int count) override {}
-  void AddSamples(const HistogramSamples& samples) override {}
-  bool AddSamplesFromPickle(PickleIterator* iter) override;
-  std::unique_ptr<HistogramSamples> SnapshotSamples() const override;
-  std::unique_ptr<HistogramSamples> SnapshotDelta() override;
-  std::unique_ptr<HistogramSamples> SnapshotFinalDelta() const override;
-  void WriteHTMLGraph(std::string* output) const override {}
-  void WriteAscii(std::string* output) const override {}
-
- protected:
-  // HistogramBase:
-  void SerializeInfoImpl(Pickle* pickle) const override {}
-  void GetParameters(DictionaryValue* params) const override {}
-  void GetCountAndBucketData(Count* count,
-                             int64_t* sum,
-                             ListValue* buckets) const override {}
-
- private:
-  friend class NoDestructor<DummyHistogram>;
-
-  DummyHistogram() : HistogramBase("dummy_histogram") {}
-  ~DummyHistogram() override {}
-
-  DISALLOW_COPY_AND_ASSIGN(DummyHistogram);
-};
-
-}  // namespace base
-
-#endif  // BASE_METRICS_DUMMY_HISTOGRAM_H_
diff --git a/base/metrics/field_trial.cc b/base/metrics/field_trial.cc
deleted file mode 100644
index 25f21ca..0000000
--- a/base/metrics/field_trial.cc
+++ /dev/null
@@ -1,1517 +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/metrics/field_trial.h"
-
-#include <algorithm>
-#include <utility>
-
-#include "base/base_switches.h"
-#include "base/command_line.h"
-#include "base/debug/activity_tracker.h"
-#include "base/logging.h"
-#include "base/metrics/field_trial_param_associator.h"
-#include "base/process/memory.h"
-#include "base/process/process_handle.h"
-#include "base/process/process_info.h"
-#include "base/rand_util.h"
-#include "base/strings/string_number_conversions.h"
-#include "base/strings/string_split.h"
-#include "base/strings/string_util.h"
-#include "base/strings/stringprintf.h"
-#include "base/strings/utf_string_conversions.h"
-#include "base/unguessable_token.h"
-
-// On POSIX, the fd is shared using the mapping in GlobalDescriptors.
-#if defined(OS_POSIX) && !defined(OS_NACL)
-#include "base/posix/global_descriptors.h"
-#endif
-
-namespace base {
-
-namespace {
-
-// Define a separator character to use when creating a persistent form of an
-// instance.  This is intended for use as a command line argument, passed to a
-// second process to mimic our state (i.e., provide the same group name).
-const char kPersistentStringSeparator = '/';  // Currently a slash.
-
-// Define a marker character to be used as a prefix to a trial name on the
-// command line which forces its activation.
-const char kActivationMarker = '*';
-
-// Use shared memory to communicate field trial (experiment) state. Set to false
-// for now while the implementation is fleshed out (e.g. data format, single
-// shared memory segment). See https://codereview.chromium.org/2365273004/ and
-// crbug.com/653874
-// The browser is the only process that has write access to the shared memory.
-// This is safe from race conditions because MakeIterable is a release operation
-// and GetNextOfType is an acquire operation, so memory writes before
-// MakeIterable happen before memory reads after GetNextOfType.
-#if defined(OS_FUCHSIA)  // TODO(752368): Not yet supported on Fuchsia.
-const bool kUseSharedMemoryForFieldTrials = false;
-#else
-const bool kUseSharedMemoryForFieldTrials = true;
-#endif
-
-// Constants for the field trial allocator.
-const char kAllocatorName[] = "FieldTrialAllocator";
-
-// We allocate 128 KiB to hold all the field trial data. This should be enough,
-// as most people use 3 - 25 KiB for field trials (as of 11/25/2016).
-// This also doesn't allocate all 128 KiB at once -- the pages only get mapped
-// to physical memory when they are touched. If the size of the allocated field
-// trials does get larger than 128 KiB, then we will drop some field trials in
-// child processes, leading to an inconsistent view between browser and child
-// processes and possibly causing crashes (see crbug.com/661617).
-const size_t kFieldTrialAllocationSize = 128 << 10;  // 128 KiB
-
-// Writes out string1 and then string2 to pickle.
-void WriteStringPair(Pickle* pickle,
-                     const StringPiece& string1,
-                     const StringPiece& string2) {
-  pickle->WriteString(string1);
-  pickle->WriteString(string2);
-}
-
-// Writes out the field trial's contents (via trial_state) to the pickle. The
-// format of the pickle looks like:
-// TrialName, GroupName, ParamKey1, ParamValue1, ParamKey2, ParamValue2, ...
-// If there are no parameters, then it just ends at GroupName.
-void PickleFieldTrial(const FieldTrial::State& trial_state, Pickle* pickle) {
-  WriteStringPair(pickle, *trial_state.trial_name, *trial_state.group_name);
-
-  // Get field trial params.
-  std::map<std::string, std::string> params;
-  FieldTrialParamAssociator::GetInstance()->GetFieldTrialParamsWithoutFallback(
-      *trial_state.trial_name, *trial_state.group_name, &params);
-
-  // Write params to pickle.
-  for (const auto& param : params)
-    WriteStringPair(pickle, param.first, param.second);
-}
-
-// Created a time value based on |year|, |month| and |day_of_month| parameters.
-Time CreateTimeFromParams(int year, int month, int day_of_month) {
-  DCHECK_GT(year, 1970);
-  DCHECK_GT(month, 0);
-  DCHECK_LT(month, 13);
-  DCHECK_GT(day_of_month, 0);
-  DCHECK_LT(day_of_month, 32);
-
-  Time::Exploded exploded;
-  exploded.year = year;
-  exploded.month = month;
-  exploded.day_of_week = 0;  // Should be unused.
-  exploded.day_of_month = day_of_month;
-  exploded.hour = 0;
-  exploded.minute = 0;
-  exploded.second = 0;
-  exploded.millisecond = 0;
-  Time out_time;
-  if (!Time::FromLocalExploded(exploded, &out_time)) {
-    // TODO(maksims): implement failure handling.
-    // We might just return |out_time|, which is Time(0).
-    NOTIMPLEMENTED();
-  }
-
-  return out_time;
-}
-
-// Returns the boundary value for comparing against the FieldTrial's added
-// groups for a given |divisor| (total probability) and |entropy_value|.
-FieldTrial::Probability GetGroupBoundaryValue(
-    FieldTrial::Probability divisor,
-    double entropy_value) {
-  // Add a tiny epsilon value to get consistent results when converting floating
-  // points to int. Without it, boundary values have inconsistent results, e.g.:
-  //
-  //   static_cast<FieldTrial::Probability>(100 * 0.56) == 56
-  //   static_cast<FieldTrial::Probability>(100 * 0.57) == 56
-  //   static_cast<FieldTrial::Probability>(100 * 0.58) == 57
-  //   static_cast<FieldTrial::Probability>(100 * 0.59) == 59
-  const double kEpsilon = 1e-8;
-  const FieldTrial::Probability result =
-      static_cast<FieldTrial::Probability>(divisor * entropy_value + kEpsilon);
-  // Ensure that adding the epsilon still results in a value < |divisor|.
-  return std::min(result, divisor - 1);
-}
-
-// Separate type from FieldTrial::State so that it can use StringPieces.
-struct FieldTrialStringEntry {
-  StringPiece trial_name;
-  StringPiece group_name;
-  bool activated = false;
-};
-
-// Parses the --force-fieldtrials string |trials_string| into |entries|.
-// Returns true if the string was parsed correctly. On failure, the |entries|
-// array may end up being partially filled.
-bool ParseFieldTrialsString(const std::string& trials_string,
-                            std::vector<FieldTrialStringEntry>* entries) {
-  const StringPiece trials_string_piece(trials_string);
-
-  size_t next_item = 0;
-  while (next_item < trials_string.length()) {
-    size_t name_end = trials_string.find(kPersistentStringSeparator, next_item);
-    if (name_end == trials_string.npos || next_item == name_end)
-      return false;
-    size_t group_name_end =
-        trials_string.find(kPersistentStringSeparator, name_end + 1);
-    if (name_end + 1 == group_name_end)
-      return false;
-    if (group_name_end == trials_string.npos)
-      group_name_end = trials_string.length();
-
-    FieldTrialStringEntry entry;
-    // Verify if the trial should be activated or not.
-    if (trials_string[next_item] == kActivationMarker) {
-      // Name cannot be only the indicator.
-      if (name_end - next_item == 1)
-        return false;
-      next_item++;
-      entry.activated = true;
-    }
-    entry.trial_name =
-        trials_string_piece.substr(next_item, name_end - next_item);
-    entry.group_name =
-        trials_string_piece.substr(name_end + 1, group_name_end - name_end - 1);
-    next_item = group_name_end + 1;
-
-    entries->push_back(std::move(entry));
-  }
-  return true;
-}
-
-void AddFeatureAndFieldTrialFlags(const char* enable_features_switch,
-                                  const char* disable_features_switch,
-                                  CommandLine* cmd_line) {
-  std::string enabled_features;
-  std::string disabled_features;
-  FeatureList::GetInstance()->GetFeatureOverrides(&enabled_features,
-                                                  &disabled_features);
-
-  if (!enabled_features.empty())
-    cmd_line->AppendSwitchASCII(enable_features_switch, enabled_features);
-  if (!disabled_features.empty())
-    cmd_line->AppendSwitchASCII(disable_features_switch, disabled_features);
-
-  std::string field_trial_states;
-  FieldTrialList::AllStatesToString(&field_trial_states, false);
-  if (!field_trial_states.empty()) {
-    cmd_line->AppendSwitchASCII(switches::kForceFieldTrials,
-                                field_trial_states);
-  }
-}
-
-void OnOutOfMemory(size_t size) {
-#if defined(OS_NACL)
-  NOTREACHED();
-#else
-  TerminateBecauseOutOfMemory(size);
-#endif
-}
-
-#if !defined(OS_NACL)
-// Returns whether the operation succeeded.
-bool DeserializeGUIDFromStringPieces(base::StringPiece first,
-                                     base::StringPiece second,
-                                     base::UnguessableToken* guid) {
-  uint64_t high = 0;
-  uint64_t low = 0;
-  if (!base::StringToUint64(first, &high) ||
-      !base::StringToUint64(second, &low)) {
-    return false;
-  }
-
-  *guid = base::UnguessableToken::Deserialize(high, low);
-  return true;
-}
-
-// Extract a read-only SharedMemoryHandle from an existing |shared_memory|
-// handle. Note that on Android, this also makes the whole region read-only.
-SharedMemoryHandle GetSharedMemoryReadOnlyHandle(SharedMemory* shared_memory) {
-  SharedMemoryHandle result = shared_memory->GetReadOnlyHandle();
-#if defined(OS_ANDROID)
-  // On Android, turn the region read-only. This prevents any future
-  // writable mapping attempts, but the original one in |shm| survives
-  // and is still usable in the current process.
-  result.SetRegionReadOnly();
-#endif  // OS_ANDROID
-  return result;
-}
-#endif  // !OS_NACL
-
-}  // namespace
-
-// statics
-const int FieldTrial::kNotFinalized = -1;
-const int FieldTrial::kDefaultGroupNumber = 0;
-bool FieldTrial::enable_benchmarking_ = false;
-
-int FieldTrialList::kNoExpirationYear = 0;
-
-//------------------------------------------------------------------------------
-// FieldTrial methods and members.
-
-FieldTrial::EntropyProvider::~EntropyProvider() = default;
-
-FieldTrial::State::State() = default;
-
-FieldTrial::State::State(const State& other) = default;
-
-FieldTrial::State::~State() = default;
-
-bool FieldTrial::FieldTrialEntry::GetTrialAndGroupName(
-    StringPiece* trial_name,
-    StringPiece* group_name) const {
-  PickleIterator iter = GetPickleIterator();
-  return ReadStringPair(&iter, trial_name, group_name);
-}
-
-bool FieldTrial::FieldTrialEntry::GetParams(
-    std::map<std::string, std::string>* params) const {
-  PickleIterator iter = GetPickleIterator();
-  StringPiece tmp;
-  // Skip reading trial and group name.
-  if (!ReadStringPair(&iter, &tmp, &tmp))
-    return false;
-
-  while (true) {
-    StringPiece key;
-    StringPiece value;
-    if (!ReadStringPair(&iter, &key, &value))
-      return key.empty();  // Non-empty is bad: got one of a pair.
-    (*params)[key.as_string()] = value.as_string();
-  }
-}
-
-PickleIterator FieldTrial::FieldTrialEntry::GetPickleIterator() const {
-  const char* src =
-      reinterpret_cast<const char*>(this) + sizeof(FieldTrialEntry);
-
-  Pickle pickle(src, pickle_size);
-  return PickleIterator(pickle);
-}
-
-bool FieldTrial::FieldTrialEntry::ReadStringPair(
-    PickleIterator* iter,
-    StringPiece* trial_name,
-    StringPiece* group_name) const {
-  if (!iter->ReadStringPiece(trial_name))
-    return false;
-  if (!iter->ReadStringPiece(group_name))
-    return false;
-  return true;
-}
-
-void FieldTrial::Disable() {
-  DCHECK(!group_reported_);
-  enable_field_trial_ = false;
-
-  // In case we are disabled after initialization, we need to switch
-  // the trial to the default group.
-  if (group_ != kNotFinalized) {
-    // Only reset when not already the default group, because in case we were
-    // forced to the default group, the group number may not be
-    // kDefaultGroupNumber, so we should keep it as is.
-    if (group_name_ != default_group_name_)
-      SetGroupChoice(default_group_name_, kDefaultGroupNumber);
-  }
-}
-
-int FieldTrial::AppendGroup(const std::string& name,
-                            Probability group_probability) {
-  // When the group choice was previously forced, we only need to return the
-  // the id of the chosen group, and anything can be returned for the others.
-  if (forced_) {
-    DCHECK(!group_name_.empty());
-    if (name == group_name_) {
-      // Note that while |group_| may be equal to |kDefaultGroupNumber| on the
-      // forced trial, it will not have the same value as the default group
-      // number returned from the non-forced |FactoryGetFieldTrial()| call,
-      // which takes care to ensure that this does not happen.
-      return group_;
-    }
-    DCHECK_NE(next_group_number_, group_);
-    // We still return different numbers each time, in case some caller need
-    // them to be different.
-    return next_group_number_++;
-  }
-
-  DCHECK_LE(group_probability, divisor_);
-  DCHECK_GE(group_probability, 0);
-
-  if (enable_benchmarking_ || !enable_field_trial_)
-    group_probability = 0;
-
-  accumulated_group_probability_ += group_probability;
-
-  DCHECK_LE(accumulated_group_probability_, divisor_);
-  if (group_ == kNotFinalized && accumulated_group_probability_ > random_) {
-    // This is the group that crossed the random line, so we do the assignment.
-    SetGroupChoice(name, next_group_number_);
-  }
-  return next_group_number_++;
-}
-
-int FieldTrial::group() {
-  FinalizeGroupChoice();
-  if (trial_registered_)
-    FieldTrialList::NotifyFieldTrialGroupSelection(this);
-  return group_;
-}
-
-const std::string& FieldTrial::group_name() {
-  // Call |group()| to ensure group gets assigned and observers are notified.
-  group();
-  DCHECK(!group_name_.empty());
-  return group_name_;
-}
-
-const std::string& FieldTrial::GetGroupNameWithoutActivation() {
-  FinalizeGroupChoice();
-  return group_name_;
-}
-
-void FieldTrial::SetForced() {
-  // We might have been forced before (e.g., by CreateFieldTrial) and it's
-  // first come first served, e.g., command line switch has precedence.
-  if (forced_)
-    return;
-
-  // And we must finalize the group choice before we mark ourselves as forced.
-  FinalizeGroupChoice();
-  forced_ = true;
-}
-
-// static
-void FieldTrial::EnableBenchmarking() {
-  DCHECK_EQ(0u, FieldTrialList::GetFieldTrialCount());
-  enable_benchmarking_ = true;
-}
-
-// static
-FieldTrial* FieldTrial::CreateSimulatedFieldTrial(
-    const std::string& trial_name,
-    Probability total_probability,
-    const std::string& default_group_name,
-    double entropy_value) {
-  return new FieldTrial(trial_name, total_probability, default_group_name,
-                        entropy_value);
-}
-
-FieldTrial::FieldTrial(const std::string& trial_name,
-                       const Probability total_probability,
-                       const std::string& default_group_name,
-                       double entropy_value)
-    : trial_name_(trial_name),
-      divisor_(total_probability),
-      default_group_name_(default_group_name),
-      random_(GetGroupBoundaryValue(total_probability, entropy_value)),
-      accumulated_group_probability_(0),
-      next_group_number_(kDefaultGroupNumber + 1),
-      group_(kNotFinalized),
-      enable_field_trial_(true),
-      forced_(false),
-      group_reported_(false),
-      trial_registered_(false),
-      ref_(FieldTrialList::FieldTrialAllocator::kReferenceNull) {
-  DCHECK_GT(total_probability, 0);
-  DCHECK(!trial_name_.empty());
-  DCHECK(!default_group_name_.empty())
-      << "Trial " << trial_name << " is missing a default group name.";
-}
-
-FieldTrial::~FieldTrial() = default;
-
-void FieldTrial::SetTrialRegistered() {
-  DCHECK_EQ(kNotFinalized, group_);
-  DCHECK(!trial_registered_);
-  trial_registered_ = true;
-}
-
-void FieldTrial::SetGroupChoice(const std::string& group_name, int number) {
-  group_ = number;
-  if (group_name.empty())
-    StringAppendF(&group_name_, "%d", group_);
-  else
-    group_name_ = group_name;
-  DVLOG(1) << "Field trial: " << trial_name_ << " Group choice:" << group_name_;
-}
-
-void FieldTrial::FinalizeGroupChoice() {
-  FinalizeGroupChoiceImpl(false);
-}
-
-void FieldTrial::FinalizeGroupChoiceImpl(bool is_locked) {
-  if (group_ != kNotFinalized)
-    return;
-  accumulated_group_probability_ = divisor_;
-  // Here it's OK to use |kDefaultGroupNumber| since we can't be forced and not
-  // finalized.
-  DCHECK(!forced_);
-  SetGroupChoice(default_group_name_, kDefaultGroupNumber);
-
-  // Add the field trial to shared memory.
-  if (kUseSharedMemoryForFieldTrials && trial_registered_)
-    FieldTrialList::OnGroupFinalized(is_locked, this);
-}
-
-bool FieldTrial::GetActiveGroup(ActiveGroup* active_group) const {
-  if (!group_reported_ || !enable_field_trial_)
-    return false;
-  DCHECK_NE(group_, kNotFinalized);
-  active_group->trial_name = trial_name_;
-  active_group->group_name = group_name_;
-  return true;
-}
-
-bool FieldTrial::GetStateWhileLocked(State* field_trial_state,
-                                     bool include_expired) {
-  if (!include_expired && !enable_field_trial_)
-    return false;
-  FinalizeGroupChoiceImpl(true);
-  field_trial_state->trial_name = &trial_name_;
-  field_trial_state->group_name = &group_name_;
-  field_trial_state->activated = group_reported_;
-  return true;
-}
-
-//------------------------------------------------------------------------------
-// FieldTrialList methods and members.
-
-// static
-FieldTrialList* FieldTrialList::global_ = nullptr;
-
-// static
-bool FieldTrialList::used_without_global_ = false;
-
-FieldTrialList::Observer::~Observer() = default;
-
-FieldTrialList::FieldTrialList(
-    std::unique_ptr<const FieldTrial::EntropyProvider> entropy_provider)
-    : entropy_provider_(std::move(entropy_provider)),
-      observer_list_(new ObserverListThreadSafe<FieldTrialList::Observer>(
-          ObserverListPolicy::EXISTING_ONLY)) {
-  DCHECK(!global_);
-  DCHECK(!used_without_global_);
-  global_ = this;
-
-  CHECK(false);  // TODO(scottmg): Remove FieldTrialList.
-}
-
-FieldTrialList::~FieldTrialList() {
-  AutoLock auto_lock(lock_);
-  while (!registered_.empty()) {
-    RegistrationMap::iterator it = registered_.begin();
-    it->second->Release();
-    registered_.erase(it->first);
-  }
-  DCHECK_EQ(this, global_);
-  global_ = nullptr;
-}
-
-// static
-FieldTrial* FieldTrialList::FactoryGetFieldTrial(
-    const std::string& trial_name,
-    FieldTrial::Probability total_probability,
-    const std::string& default_group_name,
-    const int year,
-    const int month,
-    const int day_of_month,
-    FieldTrial::RandomizationType randomization_type,
-    int* default_group_number) {
-  return FactoryGetFieldTrialWithRandomizationSeed(
-      trial_name, total_probability, default_group_name, year, month,
-      day_of_month, randomization_type, 0, default_group_number, nullptr);
-}
-
-// static
-FieldTrial* FieldTrialList::FactoryGetFieldTrialWithRandomizationSeed(
-    const std::string& trial_name,
-    FieldTrial::Probability total_probability,
-    const std::string& default_group_name,
-    const int year,
-    const int month,
-    const int day_of_month,
-    FieldTrial::RandomizationType randomization_type,
-    uint32_t randomization_seed,
-    int* default_group_number,
-    const FieldTrial::EntropyProvider* override_entropy_provider) {
-  if (default_group_number)
-    *default_group_number = FieldTrial::kDefaultGroupNumber;
-  // Check if the field trial has already been created in some other way.
-  FieldTrial* existing_trial = Find(trial_name);
-  if (existing_trial) {
-    CHECK(existing_trial->forced_);
-    // If the default group name differs between the existing forced trial
-    // and this trial, then use a different value for the default group number.
-    if (default_group_number &&
-        default_group_name != existing_trial->default_group_name()) {
-      // If the new default group number corresponds to the group that was
-      // chosen for the forced trial (which has been finalized when it was
-      // forced), then set the default group number to that.
-      if (default_group_name == existing_trial->group_name_internal()) {
-        *default_group_number = existing_trial->group_;
-      } else {
-        // Otherwise, use |kNonConflictingGroupNumber| (-2) for the default
-        // group number, so that it does not conflict with the |AppendGroup()|
-        // result for the chosen group.
-        const int kNonConflictingGroupNumber = -2;
-        static_assert(
-            kNonConflictingGroupNumber != FieldTrial::kDefaultGroupNumber,
-            "The 'non-conflicting' group number conflicts");
-        static_assert(kNonConflictingGroupNumber != FieldTrial::kNotFinalized,
-                      "The 'non-conflicting' group number conflicts");
-        *default_group_number = kNonConflictingGroupNumber;
-      }
-    }
-    return existing_trial;
-  }
-
-  double entropy_value;
-  if (randomization_type == FieldTrial::ONE_TIME_RANDOMIZED) {
-    // If an override entropy provider is given, use it.
-    const FieldTrial::EntropyProvider* entropy_provider =
-        override_entropy_provider ? override_entropy_provider
-                                  : GetEntropyProviderForOneTimeRandomization();
-    CHECK(entropy_provider);
-    entropy_value = entropy_provider->GetEntropyForTrial(trial_name,
-                                                         randomization_seed);
-  } else {
-    DCHECK_EQ(FieldTrial::SESSION_RANDOMIZED, randomization_type);
-    DCHECK_EQ(0U, randomization_seed);
-    entropy_value = RandDouble();
-  }
-
-  FieldTrial* field_trial = new FieldTrial(trial_name, total_probability,
-                                           default_group_name, entropy_value);
-  CHECK(false);  // TODO(scottmg): Remove FieldTrialList.
-  return field_trial;
-}
-
-// static
-FieldTrial* FieldTrialList::Find(const std::string& trial_name) {
-  if (!global_)
-    return nullptr;
-  AutoLock auto_lock(global_->lock_);
-  return global_->PreLockedFind(trial_name);
-}
-
-// static
-int FieldTrialList::FindValue(const std::string& trial_name) {
-  FieldTrial* field_trial = Find(trial_name);
-  if (field_trial)
-    return field_trial->group();
-  return FieldTrial::kNotFinalized;
-}
-
-// static
-std::string FieldTrialList::FindFullName(const std::string& trial_name) {
-  FieldTrial* field_trial = Find(trial_name);
-  if (field_trial)
-    return field_trial->group_name();
-  return std::string();
-}
-
-// static
-bool FieldTrialList::TrialExists(const std::string& trial_name) {
-  return Find(trial_name) != nullptr;
-}
-
-// static
-bool FieldTrialList::IsTrialActive(const std::string& trial_name) {
-  FieldTrial* field_trial = Find(trial_name);
-  FieldTrial::ActiveGroup active_group;
-  return field_trial && field_trial->GetActiveGroup(&active_group);
-}
-
-// static
-void FieldTrialList::StatesToString(std::string* output) {
-  FieldTrial::ActiveGroups active_groups;
-  GetActiveFieldTrialGroups(&active_groups);
-  for (FieldTrial::ActiveGroups::const_iterator it = active_groups.begin();
-       it != active_groups.end(); ++it) {
-    DCHECK_EQ(std::string::npos,
-              it->trial_name.find(kPersistentStringSeparator));
-    DCHECK_EQ(std::string::npos,
-              it->group_name.find(kPersistentStringSeparator));
-    output->append(it->trial_name);
-    output->append(1, kPersistentStringSeparator);
-    output->append(it->group_name);
-    output->append(1, kPersistentStringSeparator);
-  }
-}
-
-// static
-void FieldTrialList::AllStatesToString(std::string* output,
-                                       bool include_expired) {
-  if (!global_)
-    return;
-  AutoLock auto_lock(global_->lock_);
-
-  for (const auto& registered : global_->registered_) {
-    FieldTrial::State trial;
-    if (!registered.second->GetStateWhileLocked(&trial, include_expired))
-      continue;
-    DCHECK_EQ(std::string::npos,
-              trial.trial_name->find(kPersistentStringSeparator));
-    DCHECK_EQ(std::string::npos,
-              trial.group_name->find(kPersistentStringSeparator));
-    if (trial.activated)
-      output->append(1, kActivationMarker);
-    output->append(*trial.trial_name);
-    output->append(1, kPersistentStringSeparator);
-    output->append(*trial.group_name);
-    output->append(1, kPersistentStringSeparator);
-  }
-}
-
-// static
-std::string FieldTrialList::AllParamsToString(bool include_expired,
-                                              EscapeDataFunc encode_data_func) {
-  FieldTrialParamAssociator* params_associator =
-      FieldTrialParamAssociator::GetInstance();
-  std::string output;
-  for (const auto& registered : GetRegisteredTrials()) {
-    FieldTrial::State trial;
-    if (!registered.second->GetStateWhileLocked(&trial, include_expired))
-      continue;
-    DCHECK_EQ(std::string::npos,
-              trial.trial_name->find(kPersistentStringSeparator));
-    DCHECK_EQ(std::string::npos,
-              trial.group_name->find(kPersistentStringSeparator));
-    std::map<std::string, std::string> params;
-    if (params_associator->GetFieldTrialParamsWithoutFallback(
-            *trial.trial_name, *trial.group_name, &params)) {
-      if (params.size() > 0) {
-        // Add comma to seprate from previous entry if it exists.
-        if (!output.empty())
-          output.append(1, ',');
-
-        output.append(encode_data_func(*trial.trial_name));
-        output.append(1, '.');
-        output.append(encode_data_func(*trial.group_name));
-        output.append(1, ':');
-
-        std::string param_str;
-        for (const auto& param : params) {
-          // Add separator from previous param information if it exists.
-          if (!param_str.empty())
-            param_str.append(1, kPersistentStringSeparator);
-          param_str.append(encode_data_func(param.first));
-          param_str.append(1, kPersistentStringSeparator);
-          param_str.append(encode_data_func(param.second));
-        }
-
-        output.append(param_str);
-      }
-    }
-  }
-  return output;
-}
-
-// static
-void FieldTrialList::GetActiveFieldTrialGroups(
-    FieldTrial::ActiveGroups* active_groups) {
-  DCHECK(active_groups->empty());
-  if (!global_)
-    return;
-  AutoLock auto_lock(global_->lock_);
-
-  for (RegistrationMap::iterator it = global_->registered_.begin();
-       it != global_->registered_.end(); ++it) {
-    FieldTrial::ActiveGroup active_group;
-    if (it->second->GetActiveGroup(&active_group))
-      active_groups->push_back(active_group);
-  }
-}
-
-// static
-void FieldTrialList::GetActiveFieldTrialGroupsFromString(
-    const std::string& trials_string,
-    FieldTrial::ActiveGroups* active_groups) {
-  std::vector<FieldTrialStringEntry> entries;
-  if (!ParseFieldTrialsString(trials_string, &entries))
-    return;
-
-  for (const auto& entry : entries) {
-    if (entry.activated) {
-      FieldTrial::ActiveGroup group;
-      group.trial_name = entry.trial_name.as_string();
-      group.group_name = entry.group_name.as_string();
-      active_groups->push_back(group);
-    }
-  }
-}
-
-// static
-void FieldTrialList::GetInitiallyActiveFieldTrials(
-    const base::CommandLine& command_line,
-    FieldTrial::ActiveGroups* active_groups) {
-  DCHECK(global_);
-  DCHECK(global_->create_trials_from_command_line_called_);
-
-  if (!global_->field_trial_allocator_) {
-    GetActiveFieldTrialGroupsFromString(
-        command_line.GetSwitchValueASCII(switches::kForceFieldTrials),
-        active_groups);
-    return;
-  }
-
-  FieldTrialAllocator* allocator = global_->field_trial_allocator_.get();
-  FieldTrialAllocator::Iterator mem_iter(allocator);
-  const FieldTrial::FieldTrialEntry* entry;
-  while ((entry = mem_iter.GetNextOfObject<FieldTrial::FieldTrialEntry>()) !=
-         nullptr) {
-    StringPiece trial_name;
-    StringPiece group_name;
-    if (subtle::NoBarrier_Load(&entry->activated) &&
-        entry->GetTrialAndGroupName(&trial_name, &group_name)) {
-      FieldTrial::ActiveGroup group;
-      group.trial_name = trial_name.as_string();
-      group.group_name = group_name.as_string();
-      active_groups->push_back(group);
-    }
-  }
-}
-
-// static
-bool FieldTrialList::CreateTrialsFromString(
-    const std::string& trials_string,
-    const std::set<std::string>& ignored_trial_names) {
-  DCHECK(global_);
-  if (trials_string.empty() || !global_)
-    return true;
-
-  std::vector<FieldTrialStringEntry> entries;
-  if (!ParseFieldTrialsString(trials_string, &entries))
-    return false;
-
-  for (const auto& entry : entries) {
-    const std::string trial_name = entry.trial_name.as_string();
-    const std::string group_name = entry.group_name.as_string();
-
-    if (ContainsKey(ignored_trial_names, trial_name)) {
-      // This is to warn that the field trial forced through command-line
-      // input is unforcable.
-      // Use --enable-logging or --enable-logging=stderr to see this warning.
-      LOG(WARNING) << "Field trial: " << trial_name << " cannot be forced.";
-      continue;
-    }
-
-    FieldTrial* trial = CreateFieldTrial(trial_name, group_name);
-    if (!trial)
-      return false;
-    if (entry.activated) {
-      // Call |group()| to mark the trial as "used" and notify observers, if
-      // any. This is useful to ensure that field trials created in child
-      // processes are properly reported in crash reports.
-      trial->group();
-    }
-  }
-  return true;
-}
-
-// static
-void FieldTrialList::CreateTrialsFromCommandLine(
-    const CommandLine& cmd_line,
-    const char* field_trial_handle_switch,
-    int fd_key) {
-  global_->create_trials_from_command_line_called_ = true;
-
-#if defined(OS_WIN) || defined(OS_FUCHSIA)
-  if (cmd_line.HasSwitch(field_trial_handle_switch)) {
-    std::string switch_value =
-        cmd_line.GetSwitchValueASCII(field_trial_handle_switch);
-    bool result = CreateTrialsFromSwitchValue(switch_value);
-    DCHECK(result);
-  }
-#elif defined(OS_POSIX) && !defined(OS_NACL)
-  // On POSIX, we check if the handle is valid by seeing if the browser process
-  // sent over the switch (we don't care about the value). Invalid handles
-  // occur in some browser tests which don't initialize the allocator.
-  if (cmd_line.HasSwitch(field_trial_handle_switch)) {
-    std::string switch_value =
-        cmd_line.GetSwitchValueASCII(field_trial_handle_switch);
-    bool result = CreateTrialsFromDescriptor(fd_key, switch_value);
-    DCHECK(result);
-  }
-#endif
-
-  if (cmd_line.HasSwitch(switches::kForceFieldTrials)) {
-    bool result = FieldTrialList::CreateTrialsFromString(
-        cmd_line.GetSwitchValueASCII(switches::kForceFieldTrials),
-        std::set<std::string>());
-    DCHECK(result);
-  }
-}
-
-// static
-void FieldTrialList::CreateFeaturesFromCommandLine(
-    const base::CommandLine& command_line,
-    const char* enable_features_switch,
-    const char* disable_features_switch,
-    FeatureList* feature_list) {
-  // Fallback to command line if not using shared memory.
-  if (!kUseSharedMemoryForFieldTrials ||
-      !global_->field_trial_allocator_.get()) {
-    return feature_list->InitializeFromCommandLine(
-        command_line.GetSwitchValueASCII(enable_features_switch),
-        command_line.GetSwitchValueASCII(disable_features_switch));
-  }
-
-  feature_list->InitializeFromSharedMemory(
-      global_->field_trial_allocator_.get());
-}
-
-#if defined(OS_WIN)
-// static
-void FieldTrialList::AppendFieldTrialHandleIfNeeded(
-    HandlesToInheritVector* handles) {
-  if (!global_)
-    return;
-  if (kUseSharedMemoryForFieldTrials) {
-    InstantiateFieldTrialAllocatorIfNeeded();
-    if (global_->readonly_allocator_handle_.IsValid())
-      handles->push_back(global_->readonly_allocator_handle_.GetHandle());
-  }
-}
-#elif defined(OS_FUCHSIA)
-// TODO(fuchsia): Implement shared-memory configuration (crbug.com/752368).
-#elif defined(OS_POSIX) && !defined(OS_NACL)
-// static
-SharedMemoryHandle FieldTrialList::GetFieldTrialHandle() {
-  if (global_ && kUseSharedMemoryForFieldTrials) {
-    InstantiateFieldTrialAllocatorIfNeeded();
-    // We check for an invalid handle where this gets called.
-    return global_->readonly_allocator_handle_;
-  }
-  return SharedMemoryHandle();
-}
-#endif
-
-// static
-void FieldTrialList::CopyFieldTrialStateToFlags(
-    const char* field_trial_handle_switch,
-    const char* enable_features_switch,
-    const char* disable_features_switch,
-    CommandLine* cmd_line) {
-  // TODO(lawrencewu): Ideally, having the global would be guaranteed. However,
-  // content browser tests currently don't create a FieldTrialList because they
-  // don't run ChromeBrowserMainParts code where it's done for Chrome.
-  // Some tests depend on the enable and disable features flag switch, though,
-  // so we can still add those even though AllStatesToString() will be a no-op.
-  if (!global_) {
-    AddFeatureAndFieldTrialFlags(enable_features_switch,
-                                 disable_features_switch, cmd_line);
-    return;
-  }
-
-  // Use shared memory to pass the state if the feature is enabled, otherwise
-  // fallback to passing it via the command line as a string.
-  if (kUseSharedMemoryForFieldTrials) {
-    InstantiateFieldTrialAllocatorIfNeeded();
-    // If the readonly handle didn't get duplicated properly, then fallback to
-    // original behavior.
-    if (!global_->readonly_allocator_handle_.IsValid()) {
-      AddFeatureAndFieldTrialFlags(enable_features_switch,
-                                   disable_features_switch, cmd_line);
-      return;
-    }
-
-    global_->field_trial_allocator_->UpdateTrackingHistograms();
-    std::string switch_value = SerializeSharedMemoryHandleMetadata(
-        global_->readonly_allocator_handle_);
-    cmd_line->AppendSwitchASCII(field_trial_handle_switch, switch_value);
-
-    // Append --enable-features and --disable-features switches corresponding
-    // to the features enabled on the command-line, so that child and browser
-    // process command lines match and clearly show what has been specified
-    // explicitly by the user.
-    std::string enabled_features;
-    std::string disabled_features;
-    FeatureList::GetInstance()->GetCommandLineFeatureOverrides(
-        &enabled_features, &disabled_features);
-
-    if (!enabled_features.empty())
-      cmd_line->AppendSwitchASCII(enable_features_switch, enabled_features);
-    if (!disabled_features.empty())
-      cmd_line->AppendSwitchASCII(disable_features_switch, disabled_features);
-
-    return;
-  }
-
-  AddFeatureAndFieldTrialFlags(enable_features_switch, disable_features_switch,
-                               cmd_line);
-}
-
-// static
-FieldTrial* FieldTrialList::CreateFieldTrial(
-    const std::string& name,
-    const std::string& group_name) {
-  DCHECK(global_);
-  DCHECK_GE(name.size(), 0u);
-  DCHECK_GE(group_name.size(), 0u);
-  if (name.empty() || group_name.empty() || !global_)
-    return nullptr;
-
-  FieldTrial* field_trial = FieldTrialList::Find(name);
-  if (field_trial) {
-    // In single process mode, or when we force them from the command line,
-    // we may have already created the field trial.
-    if (field_trial->group_name_internal() != group_name)
-      return nullptr;
-    return field_trial;
-  }
-  const int kTotalProbability = 100;
-  field_trial = new FieldTrial(name, kTotalProbability, group_name, 0);
-  FieldTrialList::Register(field_trial);
-  // Force the trial, which will also finalize the group choice.
-  field_trial->SetForced();
-  return field_trial;
-}
-
-// static
-bool FieldTrialList::AddObserver(Observer* observer) {
-  if (!global_)
-    return false;
-  global_->observer_list_->AddObserver(observer);
-  return true;
-}
-
-// static
-void FieldTrialList::RemoveObserver(Observer* observer) {
-  if (!global_)
-    return;
-  global_->observer_list_->RemoveObserver(observer);
-}
-
-// static
-void FieldTrialList::SetSynchronousObserver(Observer* observer) {
-  DCHECK(!global_->synchronous_observer_);
-  global_->synchronous_observer_ = observer;
-}
-
-// static
-void FieldTrialList::RemoveSynchronousObserver(Observer* observer) {
-  DCHECK_EQ(global_->synchronous_observer_, observer);
-  global_->synchronous_observer_ = nullptr;
-}
-
-// static
-void FieldTrialList::OnGroupFinalized(bool is_locked, FieldTrial* field_trial) {
-  if (!global_)
-    return;
-  if (is_locked) {
-    AddToAllocatorWhileLocked(global_->field_trial_allocator_.get(),
-                              field_trial);
-  } else {
-    AutoLock auto_lock(global_->lock_);
-    AddToAllocatorWhileLocked(global_->field_trial_allocator_.get(),
-                              field_trial);
-  }
-}
-
-// static
-void FieldTrialList::NotifyFieldTrialGroupSelection(FieldTrial* field_trial) {
-  if (!global_)
-    return;
-
-  {
-    AutoLock auto_lock(global_->lock_);
-    if (field_trial->group_reported_)
-      return;
-    field_trial->group_reported_ = true;
-
-    if (!field_trial->enable_field_trial_)
-      return;
-
-    if (kUseSharedMemoryForFieldTrials)
-      ActivateFieldTrialEntryWhileLocked(field_trial);
-  }
-
-  // Recording for stability debugging has to be done inline as a task posted
-  // to an observer may not get executed before a crash.
-  base::debug::GlobalActivityTracker* tracker =
-      base::debug::GlobalActivityTracker::Get();
-  if (tracker) {
-    tracker->RecordFieldTrial(field_trial->trial_name(),
-                              field_trial->group_name_internal());
-  }
-
-  if (global_->synchronous_observer_) {
-    global_->synchronous_observer_->OnFieldTrialGroupFinalized(
-        field_trial->trial_name(), field_trial->group_name_internal());
-  }
-
-  global_->observer_list_->Notify(
-      FROM_HERE, &FieldTrialList::Observer::OnFieldTrialGroupFinalized,
-      field_trial->trial_name(), field_trial->group_name_internal());
-}
-
-// static
-size_t FieldTrialList::GetFieldTrialCount() {
-  if (!global_)
-    return 0;
-  AutoLock auto_lock(global_->lock_);
-  return global_->registered_.size();
-}
-
-// static
-bool FieldTrialList::GetParamsFromSharedMemory(
-    FieldTrial* field_trial,
-    std::map<std::string, std::string>* params) {
-  DCHECK(global_);
-  // If the field trial allocator is not set up yet, then there are several
-  // cases:
-  //   - We are in the browser process and the allocator has not been set up
-  //   yet. If we got here, then we couldn't find the params in
-  //   FieldTrialParamAssociator, so it's definitely not here. Return false.
-  //   - Using shared memory for field trials is not enabled. If we got here,
-  //   then there's nothing in shared memory. Return false.
-  //   - We are in the child process and the allocator has not been set up yet.
-  //   If this is the case, then you are calling this too early. The field trial
-  //   allocator should get set up very early in the lifecycle. Try to see if
-  //   you can call it after it's been set up.
-  AutoLock auto_lock(global_->lock_);
-  if (!global_->field_trial_allocator_)
-    return false;
-
-  // If ref_ isn't set, then the field trial data can't be in shared memory.
-  if (!field_trial->ref_)
-    return false;
-
-  const FieldTrial::FieldTrialEntry* entry =
-      global_->field_trial_allocator_->GetAsObject<FieldTrial::FieldTrialEntry>(
-          field_trial->ref_);
-
-  size_t allocated_size =
-      global_->field_trial_allocator_->GetAllocSize(field_trial->ref_);
-  size_t actual_size = sizeof(FieldTrial::FieldTrialEntry) + entry->pickle_size;
-  if (allocated_size < actual_size)
-    return false;
-
-  return entry->GetParams(params);
-}
-
-// static
-void FieldTrialList::ClearParamsFromSharedMemoryForTesting() {
-  if (!global_)
-    return;
-
-  AutoLock auto_lock(global_->lock_);
-  if (!global_->field_trial_allocator_)
-    return;
-
-  // To clear the params, we iterate through every item in the allocator, copy
-  // just the trial and group name into a newly-allocated segment and then clear
-  // the existing item.
-  FieldTrialAllocator* allocator = global_->field_trial_allocator_.get();
-  FieldTrialAllocator::Iterator mem_iter(allocator);
-
-  // List of refs to eventually be made iterable. We can't make it in the loop,
-  // since it would go on forever.
-  std::vector<FieldTrial::FieldTrialRef> new_refs;
-
-  FieldTrial::FieldTrialRef prev_ref;
-  while ((prev_ref = mem_iter.GetNextOfType<FieldTrial::FieldTrialEntry>()) !=
-         FieldTrialAllocator::kReferenceNull) {
-    // Get the existing field trial entry in shared memory.
-    const FieldTrial::FieldTrialEntry* prev_entry =
-        allocator->GetAsObject<FieldTrial::FieldTrialEntry>(prev_ref);
-    StringPiece trial_name;
-    StringPiece group_name;
-    if (!prev_entry->GetTrialAndGroupName(&trial_name, &group_name))
-      continue;
-
-    // Write a new entry, minus the params.
-    Pickle pickle;
-    pickle.WriteString(trial_name);
-    pickle.WriteString(group_name);
-    size_t total_size = sizeof(FieldTrial::FieldTrialEntry) + pickle.size();
-    FieldTrial::FieldTrialEntry* new_entry =
-        allocator->New<FieldTrial::FieldTrialEntry>(total_size);
-    subtle::NoBarrier_Store(&new_entry->activated,
-                            subtle::NoBarrier_Load(&prev_entry->activated));
-    new_entry->pickle_size = pickle.size();
-
-    // TODO(lawrencewu): Modify base::Pickle to be able to write over a section
-    // in memory, so we can avoid this memcpy.
-    char* dst = reinterpret_cast<char*>(new_entry) +
-                sizeof(FieldTrial::FieldTrialEntry);
-    memcpy(dst, pickle.data(), pickle.size());
-
-    // Update the ref on the field trial and add it to the list to be made
-    // iterable.
-    FieldTrial::FieldTrialRef new_ref = allocator->GetAsReference(new_entry);
-    FieldTrial* trial = global_->PreLockedFind(trial_name.as_string());
-    trial->ref_ = new_ref;
-    new_refs.push_back(new_ref);
-
-    // Mark the existing entry as unused.
-    allocator->ChangeType(prev_ref, 0,
-                          FieldTrial::FieldTrialEntry::kPersistentTypeId,
-                          /*clear=*/false);
-  }
-
-  for (const auto& ref : new_refs) {
-    allocator->MakeIterable(ref);
-  }
-}
-
-// static
-void FieldTrialList::DumpAllFieldTrialsToPersistentAllocator(
-    PersistentMemoryAllocator* allocator) {
-  if (!global_)
-    return;
-  AutoLock auto_lock(global_->lock_);
-  for (const auto& registered : global_->registered_) {
-    AddToAllocatorWhileLocked(allocator, registered.second);
-  }
-}
-
-// static
-std::vector<const FieldTrial::FieldTrialEntry*>
-FieldTrialList::GetAllFieldTrialsFromPersistentAllocator(
-    PersistentMemoryAllocator const& allocator) {
-  std::vector<const FieldTrial::FieldTrialEntry*> entries;
-  FieldTrialAllocator::Iterator iter(&allocator);
-  const FieldTrial::FieldTrialEntry* entry;
-  while ((entry = iter.GetNextOfObject<FieldTrial::FieldTrialEntry>()) !=
-         nullptr) {
-    entries.push_back(entry);
-  }
-  return entries;
-}
-
-// static
-bool FieldTrialList::IsGlobalSetForTesting() {
-  return global_ != nullptr;
-}
-
-// static
-std::string FieldTrialList::SerializeSharedMemoryHandleMetadata(
-    const SharedMemoryHandle& shm) {
-  std::stringstream ss;
-#if defined(OS_WIN)
-  // Tell the child process the name of the inherited HANDLE.
-  uintptr_t uintptr_handle = reinterpret_cast<uintptr_t>(shm.GetHandle());
-  ss << uintptr_handle << ",";
-#elif defined(OS_FUCHSIA)
-  ss << shm.GetHandle() << ",";
-#elif !defined(OS_POSIX)
-#error Unsupported OS
-#endif
-
-  base::UnguessableToken guid = shm.GetGUID();
-  ss << guid.GetHighForSerialization() << "," << guid.GetLowForSerialization();
-  ss << "," << shm.GetSize();
-  return ss.str();
-}
-
-#if defined(OS_WIN) || defined(OS_FUCHSIA)
-
-// static
-SharedMemoryHandle FieldTrialList::DeserializeSharedMemoryHandleMetadata(
-    const std::string& switch_value) {
-  std::vector<base::StringPiece> tokens = base::SplitStringPiece(
-      switch_value, ",", base::KEEP_WHITESPACE, base::SPLIT_WANT_ALL);
-
-  if (tokens.size() != 4)
-    return SharedMemoryHandle();
-
-  int field_trial_handle = 0;
-  if (!base::StringToInt(tokens[0], &field_trial_handle))
-    return SharedMemoryHandle();
-#if defined(OS_FUCHSIA)
-  zx_handle_t handle = static_cast<zx_handle_t>(field_trial_handle);
-#elif defined(OS_WIN)
-  HANDLE handle =
-      reinterpret_cast<HANDLE>(static_cast<uintptr_t>(field_trial_handle));
-  if (base::IsCurrentProcessElevated()) {
-    // base::LaunchElevatedProcess doesn't have a way to duplicate the handle,
-    // but this process can since by definition it's not sandboxed.
-    base::ProcessId parent_pid = base::GetParentProcessId(GetCurrentProcess());
-    HANDLE parent_handle = OpenProcess(PROCESS_ALL_ACCESS, FALSE, parent_pid);
-    DuplicateHandle(parent_handle, handle, GetCurrentProcess(), &handle, 0,
-                    FALSE, DUPLICATE_SAME_ACCESS);
-    CloseHandle(parent_handle);
-  }
-#endif  // defined(OS_WIN)
-
-  base::UnguessableToken guid;
-  if (!DeserializeGUIDFromStringPieces(tokens[1], tokens[2], &guid))
-    return SharedMemoryHandle();
-
-  int size;
-  if (!base::StringToInt(tokens[3], &size))
-    return SharedMemoryHandle();
-
-  return SharedMemoryHandle(handle, static_cast<size_t>(size), guid);
-}
-
-#elif defined(OS_POSIX) && !defined(OS_NACL)
-
-// static
-SharedMemoryHandle FieldTrialList::DeserializeSharedMemoryHandleMetadata(
-    int fd,
-    const std::string& switch_value) {
-  std::vector<base::StringPiece> tokens = base::SplitStringPiece(
-      switch_value, ",", base::KEEP_WHITESPACE, base::SPLIT_WANT_ALL);
-
-  if (tokens.size() != 3)
-    return SharedMemoryHandle();
-
-  base::UnguessableToken guid;
-  if (!DeserializeGUIDFromStringPieces(tokens[0], tokens[1], &guid))
-    return SharedMemoryHandle();
-
-  int size;
-  if (!base::StringToInt(tokens[2], &size))
-    return SharedMemoryHandle();
-
-  return SharedMemoryHandle(FileDescriptor(fd, true), static_cast<size_t>(size),
-                            guid);
-}
-
-#endif
-
-#if defined(OS_WIN) || defined(OS_FUCHSIA)
-// static
-bool FieldTrialList::CreateTrialsFromSwitchValue(
-    const std::string& switch_value) {
-  SharedMemoryHandle shm = DeserializeSharedMemoryHandleMetadata(switch_value);
-  if (!shm.IsValid())
-    return false;
-  return FieldTrialList::CreateTrialsFromSharedMemoryHandle(shm);
-}
-#elif defined(OS_POSIX) && !defined(OS_NACL)
-// static
-bool FieldTrialList::CreateTrialsFromDescriptor(
-    int fd_key,
-    const std::string& switch_value) {
-  if (!kUseSharedMemoryForFieldTrials)
-    return false;
-
-  if (fd_key == -1)
-    return false;
-
-  int fd = GlobalDescriptors::GetInstance()->MaybeGet(fd_key);
-  if (fd == -1)
-    return false;
-
-  SharedMemoryHandle shm =
-      DeserializeSharedMemoryHandleMetadata(fd, switch_value);
-  if (!shm.IsValid())
-    return false;
-
-  bool result = FieldTrialList::CreateTrialsFromSharedMemoryHandle(shm);
-  DCHECK(result);
-  return true;
-}
-#endif  // defined(OS_POSIX) && !defined(OS_NACL)
-
-// static
-bool FieldTrialList::CreateTrialsFromSharedMemoryHandle(
-    SharedMemoryHandle shm_handle) {
-  // shm gets deleted when it gets out of scope, but that's OK because we need
-  // it only for the duration of this method.
-  std::unique_ptr<SharedMemory> shm(new SharedMemory(shm_handle, true));
-  if (!shm.get()->Map(kFieldTrialAllocationSize))
-    OnOutOfMemory(kFieldTrialAllocationSize);
-
-  return FieldTrialList::CreateTrialsFromSharedMemory(std::move(shm));
-}
-
-// static
-bool FieldTrialList::CreateTrialsFromSharedMemory(
-    std::unique_ptr<SharedMemory> shm) {
-  global_->field_trial_allocator_.reset(
-      new FieldTrialAllocator(std::move(shm), 0, kAllocatorName, true));
-  FieldTrialAllocator* shalloc = global_->field_trial_allocator_.get();
-  FieldTrialAllocator::Iterator mem_iter(shalloc);
-
-  const FieldTrial::FieldTrialEntry* entry;
-  while ((entry = mem_iter.GetNextOfObject<FieldTrial::FieldTrialEntry>()) !=
-         nullptr) {
-    StringPiece trial_name;
-    StringPiece group_name;
-    if (!entry->GetTrialAndGroupName(&trial_name, &group_name))
-      return false;
-
-    // TODO(lawrencewu): Convert the API for CreateFieldTrial to take
-    // StringPieces.
-    FieldTrial* trial =
-        CreateFieldTrial(trial_name.as_string(), group_name.as_string());
-
-    trial->ref_ = mem_iter.GetAsReference(entry);
-    if (subtle::NoBarrier_Load(&entry->activated)) {
-      // Call |group()| to mark the trial as "used" and notify observers, if
-      // any. This is useful to ensure that field trials created in child
-      // processes are properly reported in crash reports.
-      trial->group();
-    }
-  }
-  return true;
-}
-
-// static
-void FieldTrialList::InstantiateFieldTrialAllocatorIfNeeded() {
-  if (!global_)
-    return;
-  AutoLock auto_lock(global_->lock_);
-  // Create the allocator if not already created and add all existing trials.
-  if (global_->field_trial_allocator_ != nullptr)
-    return;
-
-  SharedMemoryCreateOptions options;
-  options.size = kFieldTrialAllocationSize;
-  options.share_read_only = true;
-#if defined(OS_MACOSX) && !defined(OS_IOS)
-  options.type = SharedMemoryHandle::POSIX;
-#endif
-
-  std::unique_ptr<SharedMemory> shm(new SharedMemory());
-  if (!shm->Create(options))
-    OnOutOfMemory(kFieldTrialAllocationSize);
-
-  if (!shm->Map(kFieldTrialAllocationSize))
-    OnOutOfMemory(kFieldTrialAllocationSize);
-
-  global_->field_trial_allocator_.reset(
-      new FieldTrialAllocator(std::move(shm), 0, kAllocatorName, false));
-  global_->field_trial_allocator_->CreateTrackingHistograms(kAllocatorName);
-
-  // Add all existing field trials.
-  for (const auto& registered : global_->registered_) {
-    AddToAllocatorWhileLocked(global_->field_trial_allocator_.get(),
-                              registered.second);
-  }
-
-  // Add all existing features.
-  FeatureList::GetInstance()->AddFeaturesToAllocator(
-      global_->field_trial_allocator_.get());
-
-#if !defined(OS_NACL)
-  global_->readonly_allocator_handle_ = GetSharedMemoryReadOnlyHandle(
-      global_->field_trial_allocator_->shared_memory());
-#endif
-}
-
-// static
-void FieldTrialList::AddToAllocatorWhileLocked(
-    PersistentMemoryAllocator* allocator,
-    FieldTrial* field_trial) {
-  // Don't do anything if the allocator hasn't been instantiated yet.
-  if (allocator == nullptr)
-    return;
-
-  // Or if the allocator is read only, which means we are in a child process and
-  // shouldn't be writing to it.
-  if (allocator->IsReadonly())
-    return;
-
-  FieldTrial::State trial_state;
-  if (!field_trial->GetStateWhileLocked(&trial_state, false))
-    return;
-
-  // Or if we've already added it. We must check after GetState since it can
-  // also add to the allocator.
-  if (field_trial->ref_)
-    return;
-
-  Pickle pickle;
-  PickleFieldTrial(trial_state, &pickle);
-
-  size_t total_size = sizeof(FieldTrial::FieldTrialEntry) + pickle.size();
-  FieldTrial::FieldTrialRef ref = allocator->Allocate(
-      total_size, FieldTrial::FieldTrialEntry::kPersistentTypeId);
-  if (ref == FieldTrialAllocator::kReferenceNull) {
-    NOTREACHED();
-    return;
-  }
-
-  FieldTrial::FieldTrialEntry* entry =
-      allocator->GetAsObject<FieldTrial::FieldTrialEntry>(ref);
-  subtle::NoBarrier_Store(&entry->activated, trial_state.activated);
-  entry->pickle_size = pickle.size();
-
-  // TODO(lawrencewu): Modify base::Pickle to be able to write over a section in
-  // memory, so we can avoid this memcpy.
-  char* dst =
-      reinterpret_cast<char*>(entry) + sizeof(FieldTrial::FieldTrialEntry);
-  memcpy(dst, pickle.data(), pickle.size());
-
-  allocator->MakeIterable(ref);
-  field_trial->ref_ = ref;
-}
-
-// static
-void FieldTrialList::ActivateFieldTrialEntryWhileLocked(
-    FieldTrial* field_trial) {
-  FieldTrialAllocator* allocator = global_->field_trial_allocator_.get();
-
-  // Check if we're in the child process and return early if so.
-  if (!allocator || allocator->IsReadonly())
-    return;
-
-  FieldTrial::FieldTrialRef ref = field_trial->ref_;
-  if (ref == FieldTrialAllocator::kReferenceNull) {
-    // It's fine to do this even if the allocator hasn't been instantiated
-    // yet -- it'll just return early.
-    AddToAllocatorWhileLocked(allocator, field_trial);
-  } else {
-    // It's also okay to do this even though the callee doesn't have a lock --
-    // the only thing that happens on a stale read here is a slight performance
-    // hit from the child re-synchronizing activation state.
-    FieldTrial::FieldTrialEntry* entry =
-        allocator->GetAsObject<FieldTrial::FieldTrialEntry>(ref);
-    subtle::NoBarrier_Store(&entry->activated, 1);
-  }
-}
-
-// static
-const FieldTrial::EntropyProvider*
-    FieldTrialList::GetEntropyProviderForOneTimeRandomization() {
-  if (!global_) {
-    used_without_global_ = true;
-    return nullptr;
-  }
-
-  return global_->entropy_provider_.get();
-}
-
-FieldTrial* FieldTrialList::PreLockedFind(const std::string& name) {
-  RegistrationMap::iterator it = registered_.find(name);
-  if (registered_.end() == it)
-    return nullptr;
-  return it->second;
-}
-
-// static
-void FieldTrialList::Register(FieldTrial* trial) {
-  if (!global_) {
-    used_without_global_ = true;
-    return;
-  }
-  AutoLock auto_lock(global_->lock_);
-  CHECK(!global_->PreLockedFind(trial->trial_name())) << trial->trial_name();
-  trial->AddRef();
-  trial->SetTrialRegistered();
-  global_->registered_[trial->trial_name()] = trial;
-}
-
-// static
-FieldTrialList::RegistrationMap FieldTrialList::GetRegisteredTrials() {
-  RegistrationMap output;
-  if (global_) {
-    AutoLock auto_lock(global_->lock_);
-    output = global_->registered_;
-  }
-  return output;
-}
-
-}  // namespace base
diff --git a/base/metrics/field_trial.h b/base/metrics/field_trial.h
deleted file mode 100644
index d5d6cb8..0000000
--- a/base/metrics/field_trial.h
+++ /dev/null
@@ -1,802 +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.
-
-// FieldTrial is a class for handling details of statistical experiments
-// performed by actual users in the field (i.e., in a shipped or beta product).
-// All code is called exclusively on the UI thread currently.
-//
-// The simplest example is an experiment to see whether one of two options
-// produces "better" results across our user population.  In that scenario, UMA
-// data is uploaded to aggregate the test results, and this FieldTrial class
-// manages the state of each such experiment (state == which option was
-// pseudo-randomly selected).
-//
-// States are typically generated randomly, either based on a one time
-// randomization (which will yield the same results, in terms of selecting
-// the client for a field trial or not, for every run of the program on a
-// given machine), or by a session randomization (generated each time the
-// application starts up, but held constant during the duration of the
-// process).
-
-//------------------------------------------------------------------------------
-// Example:  Suppose we have an experiment involving memory, such as determining
-// the impact of some pruning algorithm.
-// We assume that we already have a histogram of memory usage, such as:
-
-//   UMA_HISTOGRAM_COUNTS("Memory.RendererTotal", count);
-
-// Somewhere in main thread initialization code, we'd probably define an
-// instance of a FieldTrial, with code such as:
-
-// // FieldTrials are reference counted, and persist automagically until
-// // process teardown, courtesy of their automatic registration in
-// // FieldTrialList.
-// // Note: This field trial will run in Chrome instances compiled through
-// //       8 July, 2015, and after that all instances will be in "StandardMem".
-// scoped_refptr<base::FieldTrial> trial(
-//     base::FieldTrialList::FactoryGetFieldTrial(
-//         "MemoryExperiment", 1000, "StandardMem", 2015, 7, 8,
-//         base::FieldTrial::ONE_TIME_RANDOMIZED, NULL));
-//
-// const int high_mem_group =
-//     trial->AppendGroup("HighMem", 20);  // 2% in HighMem group.
-// const int low_mem_group =
-//     trial->AppendGroup("LowMem", 20);   // 2% in LowMem group.
-// // Take action depending of which group we randomly land in.
-// if (trial->group() == high_mem_group)
-//   SetPruningAlgorithm(kType1);  // Sample setting of browser state.
-// else if (trial->group() == low_mem_group)
-//   SetPruningAlgorithm(kType2);  // Sample alternate setting.
-
-//------------------------------------------------------------------------------
-
-#ifndef BASE_METRICS_FIELD_TRIAL_H_
-#define BASE_METRICS_FIELD_TRIAL_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-#include <map>
-#include <memory>
-#include <set>
-#include <string>
-#include <vector>
-
-#include "base/atomicops.h"
-#include "base/base_export.h"
-#include "base/command_line.h"
-#include "base/feature_list.h"
-#include "base/files/file.h"
-#include "base/gtest_prod_util.h"
-#include "base/macros.h"
-#include "base/memory/ref_counted.h"
-#include "base/memory/shared_memory.h"
-#include "base/memory/shared_memory_handle.h"
-#include "base/metrics/persistent_memory_allocator.h"
-#include "base/observer_list_threadsafe.h"
-#include "base/pickle.h"
-#include "base/process/launch.h"
-#include "base/strings/string_piece.h"
-#include "base/synchronization/lock.h"
-#include "base/time/time.h"
-#include "build_config.h"
-
-namespace base {
-
-class FieldTrialList;
-
-class BASE_EXPORT FieldTrial : public RefCounted<FieldTrial> {
- public:
-  typedef int Probability;  // Probability type for being selected in a trial.
-
-  // TODO(665129): Make private again after crash has been resolved.
-  typedef SharedPersistentMemoryAllocator::Reference FieldTrialRef;
-
-  // Specifies the persistence of the field trial group choice.
-  enum RandomizationType {
-    // One time randomized trials will persist the group choice between
-    // restarts, which is recommended for most trials, especially those that
-    // change user visible behavior.
-    ONE_TIME_RANDOMIZED,
-    // Session randomized trials will roll the dice to select a group on every
-    // process restart.
-    SESSION_RANDOMIZED,
-  };
-
-  // EntropyProvider is an interface for providing entropy for one-time
-  // randomized (persistent) field trials.
-  class BASE_EXPORT EntropyProvider {
-   public:
-    virtual ~EntropyProvider();
-
-    // Returns a double in the range of [0, 1) to be used for the dice roll for
-    // the specified field trial. If |randomization_seed| is not 0, it will be
-    // used in preference to |trial_name| for generating the entropy by entropy
-    // providers that support it. A given instance should always return the same
-    // value given the same input |trial_name| and |randomization_seed| values.
-    virtual double GetEntropyForTrial(const std::string& trial_name,
-                                      uint32_t randomization_seed) const = 0;
-  };
-
-  // A pair representing a Field Trial and its selected group.
-  struct ActiveGroup {
-    std::string trial_name;
-    std::string group_name;
-  };
-
-  // A triplet representing a FieldTrial, its selected group and whether it's
-  // active. String members are pointers to the underlying strings owned by the
-  // FieldTrial object. Does not use StringPiece to avoid conversions back to
-  // std::string.
-  struct BASE_EXPORT State {
-    const std::string* trial_name = nullptr;
-    const std::string* group_name = nullptr;
-    bool activated = false;
-
-    State();
-    State(const State& other);
-    ~State();
-  };
-
-  // We create one FieldTrialEntry per field trial in shared memory, via
-  // AddToAllocatorWhileLocked. The FieldTrialEntry is followed by a
-  // base::Pickle object that we unpickle and read from.
-  struct BASE_EXPORT FieldTrialEntry {
-    // SHA1(FieldTrialEntry): Increment this if structure changes!
-    static constexpr uint32_t kPersistentTypeId = 0xABA17E13 + 2;
-
-    // Expected size for 32/64-bit check.
-    static constexpr size_t kExpectedInstanceSize = 8;
-
-    // Whether or not this field trial is activated. This is really just a
-    // boolean but using a 32 bit value for portability reasons. It should be
-    // accessed via NoBarrier_Load()/NoBarrier_Store() to prevent the compiler
-    // from doing unexpected optimizations because it thinks that only one
-    // thread is accessing the memory location.
-    subtle::Atomic32 activated;
-
-    // Size of the pickled structure, NOT the total size of this entry.
-    uint32_t pickle_size;
-
-    // Calling this is only valid when the entry is initialized. That is, it
-    // resides in shared memory and has a pickle containing the trial name and
-    // group name following it.
-    bool GetTrialAndGroupName(StringPiece* trial_name,
-                              StringPiece* group_name) const;
-
-    // Calling this is only valid when the entry is initialized as well. Reads
-    // the parameters following the trial and group name and stores them as
-    // key-value mappings in |params|.
-    bool GetParams(std::map<std::string, std::string>* params) const;
-
-   private:
-    // Returns an iterator over the data containing names and params.
-    PickleIterator GetPickleIterator() const;
-
-    // Takes the iterator and writes out the first two items into |trial_name|
-    // and |group_name|.
-    bool ReadStringPair(PickleIterator* iter,
-                        StringPiece* trial_name,
-                        StringPiece* group_name) const;
-  };
-
-  typedef std::vector<ActiveGroup> ActiveGroups;
-
-  // A return value to indicate that a given instance has not yet had a group
-  // assignment (and hence is not yet participating in the trial).
-  static const int kNotFinalized;
-
-  // Disables this trial, meaning it always determines the default group
-  // has been selected. May be called immediately after construction, or
-  // at any time after initialization (should not be interleaved with
-  // AppendGroup calls). Once disabled, there is no way to re-enable a
-  // trial.
-  // TODO(mad): http://code.google.com/p/chromium/issues/detail?id=121446
-  // This doesn't properly reset to Default when a group was forced.
-  void Disable();
-
-  // Establish the name and probability of the next group in this trial.
-  // Sometimes, based on construction randomization, this call may cause the
-  // provided group to be *THE* group selected for use in this instance.
-  // The return value is the group number of the new group.
-  int AppendGroup(const std::string& name, Probability group_probability);
-
-  // Return the name of the FieldTrial (excluding the group name).
-  const std::string& trial_name() const { return trial_name_; }
-
-  // Return the randomly selected group number that was assigned, and notify
-  // any/all observers that this finalized group number has presumably been used
-  // (queried), and will never change. Note that this will force an instance to
-  // participate, and make it illegal to attempt to probabilistically add any
-  // other groups to the trial.
-  int group();
-
-  // If the group's name is empty, a string version containing the group number
-  // is used as the group name. This causes a winner to be chosen if none was.
-  const std::string& group_name();
-
-  // Finalizes the group choice and returns the chosen group, but does not mark
-  // the trial as active - so its state will not be reported until group_name()
-  // or similar is called.
-  const std::string& GetGroupNameWithoutActivation();
-
-  // Set the field trial as forced, meaning that it was setup earlier than
-  // the hard coded registration of the field trial to override it.
-  // This allows the code that was hard coded to register the field trial to
-  // still succeed even though the field trial has already been registered.
-  // This must be called after appending all the groups, since we will make
-  // the group choice here. Note that this is a NOOP for already forced trials.
-  // And, as the rest of the FieldTrial code, this is not thread safe and must
-  // be done from the UI thread.
-  void SetForced();
-
-  // Enable benchmarking sets field trials to a common setting.
-  static void EnableBenchmarking();
-
-  // Creates a FieldTrial object with the specified parameters, to be used for
-  // simulation of group assignment without actually affecting global field
-  // trial state in the running process. Group assignment will be done based on
-  // |entropy_value|, which must have a range of [0, 1).
-  //
-  // Note: Using this function will not register the field trial globally in the
-  // running process - for that, use FieldTrialList::FactoryGetFieldTrial().
-  //
-  // The ownership of the returned FieldTrial is transfered to the caller which
-  // is responsible for deref'ing it (e.g. by using scoped_refptr<FieldTrial>).
-  static FieldTrial* CreateSimulatedFieldTrial(
-      const std::string& trial_name,
-      Probability total_probability,
-      const std::string& default_group_name,
-      double entropy_value);
-
- private:
-  // Allow tests to access our innards for testing purposes.
-  FRIEND_TEST_ALL_PREFIXES(FieldTrialTest, Registration);
-  FRIEND_TEST_ALL_PREFIXES(FieldTrialTest, AbsoluteProbabilities);
-  FRIEND_TEST_ALL_PREFIXES(FieldTrialTest, RemainingProbability);
-  FRIEND_TEST_ALL_PREFIXES(FieldTrialTest, FiftyFiftyProbability);
-  FRIEND_TEST_ALL_PREFIXES(FieldTrialTest, MiddleProbabilities);
-  FRIEND_TEST_ALL_PREFIXES(FieldTrialTest, OneWinner);
-  FRIEND_TEST_ALL_PREFIXES(FieldTrialTest, DisableProbability);
-  FRIEND_TEST_ALL_PREFIXES(FieldTrialTest, ActiveGroups);
-  FRIEND_TEST_ALL_PREFIXES(FieldTrialTest, AllGroups);
-  FRIEND_TEST_ALL_PREFIXES(FieldTrialTest, ActiveGroupsNotFinalized);
-  FRIEND_TEST_ALL_PREFIXES(FieldTrialTest, Save);
-  FRIEND_TEST_ALL_PREFIXES(FieldTrialTest, SaveAll);
-  FRIEND_TEST_ALL_PREFIXES(FieldTrialTest, DuplicateRestore);
-  FRIEND_TEST_ALL_PREFIXES(FieldTrialTest, SetForcedTurnFeatureOff);
-  FRIEND_TEST_ALL_PREFIXES(FieldTrialTest, SetForcedTurnFeatureOn);
-  FRIEND_TEST_ALL_PREFIXES(FieldTrialTest, SetForcedChangeDefault_Default);
-  FRIEND_TEST_ALL_PREFIXES(FieldTrialTest, SetForcedChangeDefault_NonDefault);
-  FRIEND_TEST_ALL_PREFIXES(FieldTrialTest, FloatBoundariesGiveEqualGroupSizes);
-  FRIEND_TEST_ALL_PREFIXES(FieldTrialTest, DoesNotSurpassTotalProbability);
-  FRIEND_TEST_ALL_PREFIXES(FieldTrialListTest,
-                           DoNotAddSimulatedFieldTrialsToAllocator);
-  FRIEND_TEST_ALL_PREFIXES(FieldTrialListTest, ClearParamsFromSharedMemory);
-
-  friend class base::FieldTrialList;
-
-  friend class RefCounted<FieldTrial>;
-
-  // This is the group number of the 'default' group when a choice wasn't forced
-  // by a call to FieldTrialList::CreateFieldTrial. It is kept private so that
-  // consumers don't use it by mistake in cases where the group was forced.
-  static const int kDefaultGroupNumber;
-
-  // Creates a field trial with the specified parameters. Group assignment will
-  // be done based on |entropy_value|, which must have a range of [0, 1).
-  FieldTrial(const std::string& trial_name,
-             Probability total_probability,
-             const std::string& default_group_name,
-             double entropy_value);
-  virtual ~FieldTrial();
-
-  // Return the default group name of the FieldTrial.
-  std::string default_group_name() const { return default_group_name_; }
-
-  // Marks this trial as having been registered with the FieldTrialList. Must be
-  // called no more than once and before any |group()| calls have occurred.
-  void SetTrialRegistered();
-
-  // Sets the chosen group name and number.
-  void SetGroupChoice(const std::string& group_name, int number);
-
-  // Ensures that a group is chosen, if it hasn't yet been. The field trial
-  // might yet be disabled, so this call will *not* notify observers of the
-  // status.
-  void FinalizeGroupChoice();
-
-  // Implements FinalizeGroupChoice() with the added flexibility of being
-  // deadlock-free if |is_locked| is true and the caller is holding a lock.
-  void FinalizeGroupChoiceImpl(bool is_locked);
-
-  // Returns the trial name and selected group name for this field trial via
-  // the output parameter |active_group|, but only if the group has already
-  // been chosen and has been externally observed via |group()| and the trial
-  // has not been disabled. In that case, true is returned and |active_group|
-  // is filled in; otherwise, the result is false and |active_group| is left
-  // untouched.
-  bool GetActiveGroup(ActiveGroup* active_group) const;
-
-  // Returns the trial name and selected group name for this field trial via
-  // the output parameter |field_trial_state| for all the studies when
-  // |bool include_expired| is true. In case when |bool include_expired| is
-  // false, if the trial has not been disabled true is returned and
-  // |field_trial_state| is filled in; otherwise, the result is false and
-  // |field_trial_state| is left untouched.
-  // This function is deadlock-free if the caller is holding a lock.
-  bool GetStateWhileLocked(State* field_trial_state, bool include_expired);
-
-  // Returns the group_name. A winner need not have been chosen.
-  std::string group_name_internal() const { return group_name_; }
-
-  // The name of the field trial, as can be found via the FieldTrialList.
-  const std::string trial_name_;
-
-  // The maximum sum of all probabilities supplied, which corresponds to 100%.
-  // This is the scaling factor used to adjust supplied probabilities.
-  const Probability divisor_;
-
-  // The name of the default group.
-  const std::string default_group_name_;
-
-  // The randomly selected probability that is used to select a group (or have
-  // the instance not participate).  It is the product of divisor_ and a random
-  // number between [0, 1).
-  Probability random_;
-
-  // Sum of the probabilities of all appended groups.
-  Probability accumulated_group_probability_;
-
-  // The number that will be returned by the next AppendGroup() call.
-  int next_group_number_;
-
-  // The pseudo-randomly assigned group number.
-  // This is kNotFinalized if no group has been assigned.
-  int group_;
-
-  // A textual name for the randomly selected group. Valid after |group()|
-  // has been called.
-  std::string group_name_;
-
-  // When enable_field_trial_ is false, field trial reverts to the 'default'
-  // group.
-  bool enable_field_trial_;
-
-  // When forced_ is true, we return the chosen group from AppendGroup when
-  // appropriate.
-  bool forced_;
-
-  // Specifies whether the group choice has been reported to observers.
-  bool group_reported_;
-
-  // Whether this trial is registered with the global FieldTrialList and thus
-  // should notify it when its group is queried.
-  bool trial_registered_;
-
-  // Reference to related field trial struct and data in shared memory.
-  FieldTrialRef ref_;
-
-  // When benchmarking is enabled, field trials all revert to the 'default'
-  // group.
-  static bool enable_benchmarking_;
-
-  DISALLOW_COPY_AND_ASSIGN(FieldTrial);
-};
-
-//------------------------------------------------------------------------------
-// Class with a list of all active field trials.  A trial is active if it has
-// been registered, which includes evaluating its state based on its probaility.
-// Only one instance of this class exists and outside of testing, will live for
-// the entire life time of the process.
-class BASE_EXPORT FieldTrialList {
- public:
-  typedef SharedPersistentMemoryAllocator FieldTrialAllocator;
-
-  // Type for function pointer passed to |AllParamsToString| used to escape
-  // special characters from |input|.
-  typedef std::string (*EscapeDataFunc)(const std::string& input);
-
-  // Year that is guaranteed to not be expired when instantiating a field trial
-  // via |FactoryGetFieldTrial()|.  Set to two years from the build date.
-  static int kNoExpirationYear;
-
-  // Observer is notified when a FieldTrial's group is selected.
-  class BASE_EXPORT Observer {
-   public:
-    // Notify observers when FieldTrials's group is selected.
-    virtual void OnFieldTrialGroupFinalized(const std::string& trial_name,
-                                            const std::string& group_name) = 0;
-
-   protected:
-    virtual ~Observer();
-  };
-
-  // This singleton holds the global list of registered FieldTrials.
-  //
-  // To support one-time randomized field trials, specify a non-null
-  // |entropy_provider| which should be a source of uniformly distributed
-  // entropy values. If one time randomization is not desired, pass in null for
-  // |entropy_provider|.
-  explicit FieldTrialList(
-      std::unique_ptr<const FieldTrial::EntropyProvider> entropy_provider);
-
-  // Destructor Release()'s references to all registered FieldTrial instances.
-  ~FieldTrialList();
-
-  // Get a FieldTrial instance from the factory.
-  //
-  // |name| is used to register the instance with the FieldTrialList class,
-  // and can be used to find the trial (only one trial can be present for each
-  // name). |default_group_name| is the name of the default group which will
-  // be chosen if none of the subsequent appended groups get to be chosen.
-  // |default_group_number| can receive the group number of the default group as
-  // AppendGroup returns the number of the subsequence groups. |trial_name| and
-  // |default_group_name| may not be empty but |default_group_number| can be
-  // NULL if the value is not needed.
-  //
-  // Group probabilities that are later supplied must sum to less than or equal
-  // to the |total_probability|. Arguments |year|, |month| and |day_of_month|
-  // specify the expiration time. If the build time is after the expiration time
-  // then the field trial reverts to the 'default' group.
-  //
-  // Use this static method to get a startup-randomized FieldTrial or a
-  // previously created forced FieldTrial.
-  static FieldTrial* FactoryGetFieldTrial(
-      const std::string& trial_name,
-      FieldTrial::Probability total_probability,
-      const std::string& default_group_name,
-      const int year,
-      const int month,
-      const int day_of_month,
-      FieldTrial::RandomizationType randomization_type,
-      int* default_group_number);
-
-  // Same as FactoryGetFieldTrial(), but allows specifying a custom seed to be
-  // used on one-time randomized field trials (instead of a hash of the trial
-  // name, which is used otherwise or if |randomization_seed| has value 0). The
-  // |randomization_seed| value (other than 0) should never be the same for two
-  // trials, else this would result in correlated group assignments.  Note:
-  // Using a custom randomization seed is only supported by the
-  // PermutedEntropyProvider (which is used when UMA is not enabled). If
-  // |override_entropy_provider| is not null, then it will be used for
-  // randomization instead of the provider given when the FieldTrialList was
-  // instantiated.
-  static FieldTrial* FactoryGetFieldTrialWithRandomizationSeed(
-      const std::string& trial_name,
-      FieldTrial::Probability total_probability,
-      const std::string& default_group_name,
-      const int year,
-      const int month,
-      const int day_of_month,
-      FieldTrial::RandomizationType randomization_type,
-      uint32_t randomization_seed,
-      int* default_group_number,
-      const FieldTrial::EntropyProvider* override_entropy_provider);
-
-  // The Find() method can be used to test to see if a named trial was already
-  // registered, or to retrieve a pointer to it from the global map.
-  static FieldTrial* Find(const std::string& trial_name);
-
-  // Returns the group number chosen for the named trial, or
-  // FieldTrial::kNotFinalized if the trial does not exist.
-  static int FindValue(const std::string& trial_name);
-
-  // Returns the group name chosen for the named trial, or the empty string if
-  // the trial does not exist. The first call of this function on a given field
-  // trial will mark it as active, so that its state will be reported with usage
-  // metrics, crashes, etc.
-  static std::string FindFullName(const std::string& trial_name);
-
-  // Returns true if the named trial has been registered.
-  static bool TrialExists(const std::string& trial_name);
-
-  // Returns true if the named trial exists and has been activated.
-  static bool IsTrialActive(const std::string& trial_name);
-
-  // Creates a persistent representation of active FieldTrial instances for
-  // resurrection in another process. This allows randomization to be done in
-  // one process, and secondary processes can be synchronized on the result.
-  // The resulting string contains the name and group name pairs of all
-  // registered FieldTrials for which the group has been chosen and externally
-  // observed (via |group()|) and which have not been disabled, with "/" used
-  // to separate all names and to terminate the string. This string is parsed
-  // by |CreateTrialsFromString()|.
-  static void StatesToString(std::string* output);
-
-  // Creates a persistent representation of all FieldTrial instances for
-  // resurrection in another process. This allows randomization to be done in
-  // one process, and secondary processes can be synchronized on the result.
-  // The resulting string contains the name and group name pairs of all
-  // registered FieldTrials including disabled based on |include_expired|,
-  // with "/" used to separate all names and to terminate the string. All
-  // activated trials have their name prefixed with "*". This string is parsed
-  // by |CreateTrialsFromString()|.
-  static void AllStatesToString(std::string* output, bool include_expired);
-
-  // Creates a persistent representation of all FieldTrial params for
-  // resurrection in another process. The returned string contains the trial
-  // name and group name pairs of all registered FieldTrials including disabled
-  // based on |include_expired| separated by '.'. The pair is followed by ':'
-  // separator and list of param name and values separated by '/'. It also takes
-  // |encode_data_func| function pointer for encodeing special charactors.
-  // This string is parsed by |AssociateParamsFromString()|.
-  static std::string AllParamsToString(bool include_expired,
-                                       EscapeDataFunc encode_data_func);
-
-  // Fills in the supplied vector |active_groups| (which must be empty when
-  // called) with a snapshot of all registered FieldTrials for which the group
-  // has been chosen and externally observed (via |group()|) and which have
-  // not been disabled.
-  static void GetActiveFieldTrialGroups(
-      FieldTrial::ActiveGroups* active_groups);
-
-  // Returns the field trials that are marked active in |trials_string|.
-  static void GetActiveFieldTrialGroupsFromString(
-      const std::string& trials_string,
-      FieldTrial::ActiveGroups* active_groups);
-
-  // Returns the field trials that were active when the process was
-  // created. Either parses the field trial string or the shared memory
-  // holding field trial information.
-  // Must be called only after a call to CreateTrialsFromCommandLine().
-  static void GetInitiallyActiveFieldTrials(
-      const base::CommandLine& command_line,
-      FieldTrial::ActiveGroups* active_groups);
-
-  // Use a state string (re: StatesToString()) to augment the current list of
-  // field trials to include the supplied trials, and using a 100% probability
-  // for each trial, force them to have the same group string. This is commonly
-  // used in a non-browser process, to carry randomly selected state in a
-  // browser process into this non-browser process, but could also be invoked
-  // through a command line argument to the browser process. Created field
-  // trials will be marked "used" for the purposes of active trial reporting
-  // if they are prefixed with |kActivationMarker|. Trial names in
-  // |ignored_trial_names| are ignored when parsing |trials_string|.
-  static bool CreateTrialsFromString(
-      const std::string& trials_string,
-      const std::set<std::string>& ignored_trial_names);
-
-  // Achieves the same thing as CreateTrialsFromString, except wraps the logic
-  // by taking in the trials from the command line, either via shared memory
-  // handle or command line argument. A bit of a misnomer since on POSIX we
-  // simply get the trials from opening |fd_key| if using shared memory. On
-  // Windows, we expect the |cmd_line| switch for |field_trial_handle_switch| to
-  // contain the shared memory handle that contains the field trial allocator.
-  // We need the |field_trial_handle_switch| and |fd_key| arguments to be passed
-  // in since base/ can't depend on content/.
-  static void CreateTrialsFromCommandLine(const base::CommandLine& cmd_line,
-                                          const char* field_trial_handle_switch,
-                                          int fd_key);
-
-  // Creates base::Feature overrides from the command line by first trying to
-  // use shared memory and then falling back to the command line if it fails.
-  static void CreateFeaturesFromCommandLine(
-      const base::CommandLine& command_line,
-      const char* enable_features_switch,
-      const char* disable_features_switch,
-      FeatureList* feature_list);
-
-#if defined(OS_WIN)
-  // On Windows, we need to explicitly pass down any handles to be inherited.
-  // This function adds the shared memory handle to field trial state to the
-  // list of handles to be inherited.
-  static void AppendFieldTrialHandleIfNeeded(
-      base::HandlesToInheritVector* handles);
-#elif defined(OS_FUCHSIA)
-  // TODO(fuchsia): Implement shared-memory configuration (crbug.com/752368).
-#elif defined(OS_POSIX) && !defined(OS_NACL)
-  // On POSIX, we also need to explicitly pass down this file descriptor that
-  // should be shared with the child process. Returns an invalid handle if it
-  // was not initialized properly.
-  static base::SharedMemoryHandle GetFieldTrialHandle();
-#endif
-
-  // Adds a switch to the command line containing the field trial state as a
-  // string (if not using shared memory to share field trial state), or the
-  // shared memory handle + length.
-  // Needs the |field_trial_handle_switch| argument to be passed in since base/
-  // can't depend on content/.
-  static void CopyFieldTrialStateToFlags(const char* field_trial_handle_switch,
-                                         const char* enable_features_switch,
-                                         const char* disable_features_switch,
-                                         base::CommandLine* cmd_line);
-
-  // Create a FieldTrial with the given |name| and using 100% probability for
-  // the FieldTrial, force FieldTrial to have the same group string as
-  // |group_name|. This is commonly used in a non-browser process, to carry
-  // randomly selected state in a browser process into this non-browser process.
-  // It returns NULL if there is a FieldTrial that is already registered with
-  // the same |name| but has different finalized group string (|group_name|).
-  static FieldTrial* CreateFieldTrial(const std::string& name,
-                                      const std::string& group_name);
-
-  // Add an observer to be notified when a field trial is irrevocably committed
-  // to being part of some specific field_group (and hence the group_name is
-  // also finalized for that field_trial). Returns false and does nothing if
-  // there is no FieldTrialList singleton.
-  static bool AddObserver(Observer* observer);
-
-  // Remove an observer.
-  static void RemoveObserver(Observer* observer);
-
-  // Similar to AddObserver(), but the passed observer will be notified
-  // synchronously when a field trial is activated and its group selected. It
-  // will be notified synchronously on the same thread where the activation and
-  // group selection happened. It is the responsibility of the observer to make
-  // sure that this is a safe operation and the operation must be fast, as this
-  // work is done synchronously as part of group() or related APIs. Only a
-  // single such observer is supported, exposed specifically for crash
-  // reporting. Must be called on the main thread before any other threads
-  // have been started.
-  static void SetSynchronousObserver(Observer* observer);
-
-  // Removes the single synchronous observer.
-  static void RemoveSynchronousObserver(Observer* observer);
-
-  // Grabs the lock if necessary and adds the field trial to the allocator. This
-  // should only be called from FinalizeGroupChoice().
-  static void OnGroupFinalized(bool is_locked, FieldTrial* field_trial);
-
-  // Notify all observers that a group has been finalized for |field_trial|.
-  static void NotifyFieldTrialGroupSelection(FieldTrial* field_trial);
-
-  // Return the number of active field trials.
-  static size_t GetFieldTrialCount();
-
-  // Gets the parameters for |field_trial| from shared memory and stores them in
-  // |params|. This is only exposed for use by FieldTrialParamAssociator and
-  // shouldn't be used by anything else.
-  static bool GetParamsFromSharedMemory(
-      FieldTrial* field_trial,
-      std::map<std::string, std::string>* params);
-
-  // Clears all the params in the allocator.
-  static void ClearParamsFromSharedMemoryForTesting();
-
-  // Dumps field trial state to an allocator so that it can be analyzed after a
-  // crash.
-  static void DumpAllFieldTrialsToPersistentAllocator(
-      PersistentMemoryAllocator* allocator);
-
-  // Retrieves field trial state from an allocator so that it can be analyzed
-  // after a crash. The pointers in the returned vector are into the persistent
-  // memory segment and so are only valid as long as the allocator is valid.
-  static std::vector<const FieldTrial::FieldTrialEntry*>
-  GetAllFieldTrialsFromPersistentAllocator(
-      PersistentMemoryAllocator const& allocator);
-
-  // Returns true if a global field trial list is set. Only used for testing.
-  static bool IsGlobalSetForTesting();
-
- private:
-  // Allow tests to access our innards for testing purposes.
-  FRIEND_TEST_ALL_PREFIXES(FieldTrialListTest, InstantiateAllocator);
-  FRIEND_TEST_ALL_PREFIXES(FieldTrialListTest, AddTrialsToAllocator);
-  FRIEND_TEST_ALL_PREFIXES(FieldTrialListTest,
-                           DoNotAddSimulatedFieldTrialsToAllocator);
-  FRIEND_TEST_ALL_PREFIXES(FieldTrialListTest, AssociateFieldTrialParams);
-  FRIEND_TEST_ALL_PREFIXES(FieldTrialListTest, ClearParamsFromSharedMemory);
-  FRIEND_TEST_ALL_PREFIXES(FieldTrialListTest,
-                           SerializeSharedMemoryHandleMetadata);
-  FRIEND_TEST_ALL_PREFIXES(FieldTrialListTest, CheckReadOnlySharedMemoryHandle);
-
-  // Serialization is used to pass information about the handle to child
-  // processes. It passes a reference to the relevant OS resource, and it passes
-  // a GUID. Serialization and deserialization doesn't actually transport the
-  // underlying OS resource - that must be done by the Process launcher.
-  static std::string SerializeSharedMemoryHandleMetadata(
-      const SharedMemoryHandle& shm);
-#if defined(OS_WIN) || defined(OS_FUCHSIA)
-  static SharedMemoryHandle DeserializeSharedMemoryHandleMetadata(
-      const std::string& switch_value);
-#elif defined(OS_POSIX) && !defined(OS_NACL)
-  static SharedMemoryHandle DeserializeSharedMemoryHandleMetadata(
-      int fd,
-      const std::string& switch_value);
-#endif
-
-#if defined(OS_WIN) || defined(OS_FUCHSIA)
-  // Takes in |handle_switch| from the command line which represents the shared
-  // memory handle for field trials, parses it, and creates the field trials.
-  // Returns true on success, false on failure.
-  // |switch_value| also contains the serialized GUID.
-  static bool CreateTrialsFromSwitchValue(const std::string& switch_value);
-#elif defined(OS_POSIX) && !defined(OS_NACL)
-  // On POSIX systems that use the zygote, we look up the correct fd that backs
-  // the shared memory segment containing the field trials by looking it up via
-  // an fd key in GlobalDescriptors. Returns true on success, false on failure.
-  // |switch_value| also contains the serialized GUID.
-  static bool CreateTrialsFromDescriptor(int fd_key,
-                                         const std::string& switch_value);
-#endif
-
-  // Takes an unmapped SharedMemoryHandle, creates a SharedMemory object from it
-  // and maps it with the correct size.
-  static bool CreateTrialsFromSharedMemoryHandle(SharedMemoryHandle shm_handle);
-
-  // Expects a mapped piece of shared memory |shm| that was created from the
-  // browser process's field_trial_allocator and shared via the command line.
-  // This function recreates the allocator, iterates through all the field
-  // trials in it, and creates them via CreateFieldTrial(). Returns true if
-  // successful and false otherwise.
-  static bool CreateTrialsFromSharedMemory(
-      std::unique_ptr<base::SharedMemory> shm);
-
-  // Instantiate the field trial allocator, add all existing field trials to it,
-  // and duplicates its handle to a read-only handle, which gets stored in
-  // |readonly_allocator_handle|.
-  static void InstantiateFieldTrialAllocatorIfNeeded();
-
-  // Adds the field trial to the allocator. Caller must hold a lock before
-  // calling this.
-  static void AddToAllocatorWhileLocked(PersistentMemoryAllocator* allocator,
-                                        FieldTrial* field_trial);
-
-  // Activate the corresponding field trial entry struct in shared memory.
-  static void ActivateFieldTrialEntryWhileLocked(FieldTrial* field_trial);
-
-  // A map from FieldTrial names to the actual instances.
-  typedef std::map<std::string, FieldTrial*> RegistrationMap;
-
-  // If one-time randomization is enabled, returns a weak pointer to the
-  // corresponding EntropyProvider. Otherwise, returns NULL.
-  static const FieldTrial::EntropyProvider*
-      GetEntropyProviderForOneTimeRandomization();
-
-  // Helper function should be called only while holding lock_.
-  FieldTrial* PreLockedFind(const std::string& name);
-
-  // Register() stores a pointer to the given trial in a global map.
-  // This method also AddRef's the indicated trial.
-  // This should always be called after creating a new FieldTrial instance.
-  static void Register(FieldTrial* trial);
-
-  // Returns all the registered trials.
-  static RegistrationMap GetRegisteredTrials();
-
-  static FieldTrialList* global_;  // The singleton of this class.
-
-  // This will tell us if there is an attempt to register a field
-  // trial or check if one-time randomization is enabled without
-  // creating the FieldTrialList. This is not an error, unless a
-  // FieldTrialList is created after that.
-  static bool used_without_global_;
-
-  // Lock for access to registered_ and field_trial_allocator_.
-  Lock lock_;
-  RegistrationMap registered_;
-
-  std::map<std::string, std::string> seen_states_;
-
-  // Entropy provider to be used for one-time randomized field trials. If NULL,
-  // one-time randomization is not supported.
-  std::unique_ptr<const FieldTrial::EntropyProvider> entropy_provider_;
-
-  // List of observers to be notified when a group is selected for a FieldTrial.
-  scoped_refptr<ObserverListThreadSafe<Observer> > observer_list_;
-
-  // Single synchronous observer to be notified when a trial group is chosen.
-  Observer* synchronous_observer_ = nullptr;
-
-  // Allocator in shared memory containing field trial data. Used in both
-  // browser and child processes, but readonly in the child.
-  // In the future, we may want to move this to a more generic place if we want
-  // to start passing more data other than field trials.
-  std::unique_ptr<FieldTrialAllocator> field_trial_allocator_ = nullptr;
-
-  // Readonly copy of the handle to the allocator. Needs to be a member variable
-  // because it's needed from both CopyFieldTrialStateToFlags() and
-  // AppendFieldTrialHandleIfNeeded().
-  base::SharedMemoryHandle readonly_allocator_handle_;
-
-  // Tracks whether CreateTrialsFromCommandLine() has been called.
-  bool create_trials_from_command_line_called_ = false;
-
-  DISALLOW_COPY_AND_ASSIGN(FieldTrialList);
-};
-
-}  // namespace base
-
-#endif  // BASE_METRICS_FIELD_TRIAL_H_
diff --git a/base/metrics/field_trial_param_associator.cc b/base/metrics/field_trial_param_associator.cc
deleted file mode 100644
index af76eaf..0000000
--- a/base/metrics/field_trial_param_associator.cc
+++ /dev/null
@@ -1,88 +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/metrics/field_trial_param_associator.h"
-
-#include "base/metrics/field_trial.h"
-
-namespace base {
-
-FieldTrialParamAssociator::FieldTrialParamAssociator() = default;
-FieldTrialParamAssociator::~FieldTrialParamAssociator() = default;
-
-// static
-FieldTrialParamAssociator* FieldTrialParamAssociator::GetInstance() {
-  return Singleton<FieldTrialParamAssociator,
-                   LeakySingletonTraits<FieldTrialParamAssociator>>::get();
-}
-
-bool FieldTrialParamAssociator::AssociateFieldTrialParams(
-    const std::string& trial_name,
-    const std::string& group_name,
-    const FieldTrialParams& params) {
-  if (FieldTrialList::IsTrialActive(trial_name))
-    return false;
-
-  AutoLock scoped_lock(lock_);
-  const FieldTrialKey key(trial_name, group_name);
-  if (ContainsKey(field_trial_params_, key))
-    return false;
-
-  field_trial_params_[key] = params;
-  return true;
-}
-
-bool FieldTrialParamAssociator::GetFieldTrialParams(
-    const std::string& trial_name,
-    FieldTrialParams* params) {
-  FieldTrial* field_trial = FieldTrialList::Find(trial_name);
-  if (!field_trial)
-    return false;
-
-  // First try the local map, falling back to getting it from shared memory.
-  if (GetFieldTrialParamsWithoutFallback(trial_name, field_trial->group_name(),
-                                         params)) {
-    return true;
-  }
-
-  // TODO(lawrencewu): add the params to field_trial_params_ for next time.
-  return FieldTrialList::GetParamsFromSharedMemory(field_trial, params);
-}
-
-bool FieldTrialParamAssociator::GetFieldTrialParamsWithoutFallback(
-    const std::string& trial_name,
-    const std::string& group_name,
-    FieldTrialParams* params) {
-  AutoLock scoped_lock(lock_);
-
-  const FieldTrialKey key(trial_name, group_name);
-  if (!ContainsKey(field_trial_params_, key))
-    return false;
-
-  *params = field_trial_params_[key];
-  return true;
-}
-
-void FieldTrialParamAssociator::ClearAllParamsForTesting() {
-  {
-    AutoLock scoped_lock(lock_);
-    field_trial_params_.clear();
-  }
-  FieldTrialList::ClearParamsFromSharedMemoryForTesting();
-}
-
-void FieldTrialParamAssociator::ClearParamsForTesting(
-    const std::string& trial_name,
-    const std::string& group_name) {
-  AutoLock scoped_lock(lock_);
-  const FieldTrialKey key(trial_name, group_name);
-  field_trial_params_.erase(key);
-}
-
-void FieldTrialParamAssociator::ClearAllCachedParamsForTesting() {
-  AutoLock scoped_lock(lock_);
-  field_trial_params_.clear();
-}
-
-}  // namespace base
diff --git a/base/metrics/field_trial_param_associator.h b/base/metrics/field_trial_param_associator.h
deleted file mode 100644
index b35e2cc..0000000
--- a/base/metrics/field_trial_param_associator.h
+++ /dev/null
@@ -1,76 +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_METRICS_FIELD_TRIAL_PARAM_ASSOCIATOR_H_
-#define BASE_METRICS_FIELD_TRIAL_PARAM_ASSOCIATOR_H_
-
-#include <map>
-#include <string>
-#include <utility>
-
-#include "base/base_export.h"
-#include "base/memory/singleton.h"
-#include "base/metrics/field_trial.h"
-#include "base/synchronization/lock.h"
-
-namespace base {
-
-// Keeps track of the parameters of all field trials and ensures access to them
-// is thread-safe.
-class BASE_EXPORT FieldTrialParamAssociator {
- public:
-  FieldTrialParamAssociator();
-  ~FieldTrialParamAssociator();
-
-  // Key-value mapping type for field trial parameters.
-  typedef std::map<std::string, std::string> FieldTrialParams;
-
-  // Retrieve the singleton.
-  static FieldTrialParamAssociator* GetInstance();
-
-  // Sets parameters for the given field trial name and group.
-  bool AssociateFieldTrialParams(const std::string& trial_name,
-                                 const std::string& group_name,
-                                 const FieldTrialParams& params);
-
-  // Gets the parameters for a field trial and its chosen group. If not found in
-  // field_trial_params_, then tries to looks it up in shared memory.
-  bool GetFieldTrialParams(const std::string& trial_name,
-                           FieldTrialParams* params);
-
-  // Gets the parameters for a field trial and its chosen group. Does not
-  // fallback to looking it up in shared memory. This should only be used if you
-  // know for sure the params are in the mapping, like if you're in the browser
-  // process, and even then you should probably just use GetFieldTrialParams().
-  bool GetFieldTrialParamsWithoutFallback(const std::string& trial_name,
-                                          const std::string& group_name,
-                                          FieldTrialParams* params);
-
-  // Clears the internal field_trial_params_ mapping, plus removes all params in
-  // shared memory.
-  void ClearAllParamsForTesting();
-
-  // Clears a single field trial param.
-  // Note: this does NOT remove the param in shared memory.
-  void ClearParamsForTesting(const std::string& trial_name,
-                             const std::string& group_name);
-
-  // Clears the internal field_trial_params_ mapping.
-  void ClearAllCachedParamsForTesting();
-
- private:
-  friend struct DefaultSingletonTraits<FieldTrialParamAssociator>;
-
-  // (field_trial_name, field_trial_group)
-  typedef std::pair<std::string, std::string> FieldTrialKey;
-
-  Lock lock_;
-  std::map<FieldTrialKey, FieldTrialParams> field_trial_params_;
-
-  DISALLOW_COPY_AND_ASSIGN(FieldTrialParamAssociator);
-};
-
-}  // namespace base
-
-#endif  // BASE_METRICS_FIELD_TRIAL_PARAM_ASSOCIATOR_H_
diff --git a/base/metrics/field_trial_params.cc b/base/metrics/field_trial_params.cc
deleted file mode 100644
index 7195f4a..0000000
--- a/base/metrics/field_trial_params.cc
+++ /dev/null
@@ -1,149 +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/metrics/field_trial_params.h"
-
-#include "base/feature_list.h"
-#include "base/metrics/field_trial.h"
-#include "base/metrics/field_trial_param_associator.h"
-#include "base/strings/string_number_conversions.h"
-
-namespace base {
-
-bool AssociateFieldTrialParams(
-    const std::string& trial_name,
-    const std::string& group_name,
-    const std::map<std::string, std::string>& params) {
-  return base::FieldTrialParamAssociator::GetInstance()
-      ->AssociateFieldTrialParams(trial_name, group_name, params);
-}
-
-bool GetFieldTrialParams(const std::string& trial_name,
-                         std::map<std::string, std::string>* params) {
-  return base::FieldTrialParamAssociator::GetInstance()->GetFieldTrialParams(
-      trial_name, params);
-}
-
-bool GetFieldTrialParamsByFeature(const base::Feature& feature,
-                                  std::map<std::string, std::string>* params) {
-  if (!base::FeatureList::IsEnabled(feature))
-    return false;
-
-  base::FieldTrial* trial = base::FeatureList::GetFieldTrial(feature);
-  if (!trial)
-    return false;
-
-  return GetFieldTrialParams(trial->trial_name(), params);
-}
-
-std::string GetFieldTrialParamValue(const std::string& trial_name,
-                                    const std::string& param_name) {
-  std::map<std::string, std::string> params;
-  if (GetFieldTrialParams(trial_name, &params)) {
-    std::map<std::string, std::string>::iterator it = params.find(param_name);
-    if (it != params.end())
-      return it->second;
-  }
-  return std::string();
-}
-
-std::string GetFieldTrialParamValueByFeature(const base::Feature& feature,
-                                             const std::string& param_name) {
-  if (!base::FeatureList::IsEnabled(feature))
-    return std::string();
-
-  base::FieldTrial* trial = base::FeatureList::GetFieldTrial(feature);
-  if (!trial)
-    return std::string();
-
-  return GetFieldTrialParamValue(trial->trial_name(), param_name);
-}
-
-int GetFieldTrialParamByFeatureAsInt(const base::Feature& feature,
-                                     const std::string& param_name,
-                                     int default_value) {
-  std::string value_as_string =
-      GetFieldTrialParamValueByFeature(feature, param_name);
-  int value_as_int = 0;
-  if (!base::StringToInt(value_as_string, &value_as_int)) {
-    if (!value_as_string.empty()) {
-      DLOG(WARNING) << "Failed to parse field trial param " << param_name
-                    << " with string value " << value_as_string
-                    << " under feature " << feature.name
-                    << " into an int. Falling back to default value of "
-                    << default_value;
-    }
-    value_as_int = default_value;
-  }
-  return value_as_int;
-}
-
-double GetFieldTrialParamByFeatureAsDouble(const base::Feature& feature,
-                                           const std::string& param_name,
-                                           double default_value) {
-  std::string value_as_string =
-      GetFieldTrialParamValueByFeature(feature, param_name);
-  double value_as_double = 0;
-  if (!base::StringToDouble(value_as_string, &value_as_double)) {
-    if (!value_as_string.empty()) {
-      DLOG(WARNING) << "Failed to parse field trial param " << param_name
-                    << " with string value " << value_as_string
-                    << " under feature " << feature.name
-                    << " into a double. Falling back to default value of "
-                    << default_value;
-    }
-    value_as_double = default_value;
-  }
-  return value_as_double;
-}
-
-bool GetFieldTrialParamByFeatureAsBool(const base::Feature& feature,
-                                       const std::string& param_name,
-                                       bool default_value) {
-  std::string value_as_string =
-      GetFieldTrialParamValueByFeature(feature, param_name);
-  if (value_as_string == "true")
-    return true;
-  if (value_as_string == "false")
-    return false;
-
-  if (!value_as_string.empty()) {
-    DLOG(WARNING) << "Failed to parse field trial param " << param_name
-                  << " with string value " << value_as_string
-                  << " under feature " << feature.name
-                  << " into a bool. Falling back to default value of "
-                  << default_value;
-  }
-  return default_value;
-}
-
-std::string FeatureParam<std::string>::Get() const {
-  const std::string value = GetFieldTrialParamValueByFeature(*feature, name);
-  return value.empty() ? default_value : value;
-}
-
-double FeatureParam<double>::Get() const {
-  return GetFieldTrialParamByFeatureAsDouble(*feature, name, default_value);
-}
-
-int FeatureParam<int>::Get() const {
-  return GetFieldTrialParamByFeatureAsInt(*feature, name, default_value);
-}
-
-bool FeatureParam<bool>::Get() const {
-  return GetFieldTrialParamByFeatureAsBool(*feature, name, default_value);
-}
-
-void LogInvalidEnumValue(const base::Feature& feature,
-                         const std::string& param_name,
-                         const std::string& value_as_string,
-                         int default_value_as_int) {
-  DLOG(WARNING) << "Failed to parse field trial param " << param_name
-                << " with string value " << value_as_string << " under feature "
-                << feature.name
-                << " into an enum. Falling back to default value of "
-                << default_value_as_int;
-}
-
-}  // namespace base
diff --git a/base/metrics/field_trial_params.h b/base/metrics/field_trial_params.h
deleted file mode 100644
index 8682226..0000000
--- a/base/metrics/field_trial_params.h
+++ /dev/null
@@ -1,258 +0,0 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_METRICS_FIELD_TRIAL_PARAMS_H_
-#define BASE_METRICS_FIELD_TRIAL_PARAMS_H_
-
-#include <map>
-#include <string>
-
-#include "base/base_export.h"
-
-namespace base {
-
-struct Feature;
-
-// Associates the specified set of key-value |params| with the field trial
-// specified by |trial_name| and |group_name|. Fails and returns false if the
-// specified field trial already has params associated with it or the trial
-// is already active (group() has been called on it). Thread safe.
-BASE_EXPORT bool AssociateFieldTrialParams(
-    const std::string& trial_name,
-    const std::string& group_name,
-    const std::map<std::string, std::string>& params);
-
-// Retrieves the set of key-value |params| for the specified field trial, based
-// on its selected group. If the field trial does not exist or its selected
-// group does not have any parameters associated with it, returns false and
-// does not modify |params|. Calling this function will result in the field
-// trial being marked as active if found (i.e. group() will be called on it),
-// if it wasn't already. Thread safe.
-BASE_EXPORT bool GetFieldTrialParams(
-    const std::string& trial_name,
-    std::map<std::string, std::string>* params);
-
-// Retrieves the set of key-value |params| for the field trial associated with
-// the specified |feature|. A feature is associated with at most one field
-// trial and selected group. See  base/feature_list.h for more information on
-// features. If the feature is not enabled, or if there's no associated params,
-// returns false and does not modify |params|. Calling this function will
-// result in the associated field trial being marked as active if found (i.e.
-// group() will be called on it), if it wasn't already. Thread safe.
-BASE_EXPORT bool GetFieldTrialParamsByFeature(
-    const base::Feature& feature,
-    std::map<std::string, std::string>* params);
-
-// Retrieves a specific parameter value corresponding to |param_name| for the
-// specified field trial, based on its selected group. If the field trial does
-// not exist or the specified parameter does not exist, returns an empty
-// string. Calling this function will result in the field trial being marked as
-// active if found (i.e. group() will be called on it), if it wasn't already.
-// Thread safe.
-BASE_EXPORT std::string GetFieldTrialParamValue(const std::string& trial_name,
-                                                const std::string& param_name);
-
-// Retrieves a specific parameter value corresponding to |param_name| for the
-// field trial associated with the specified |feature|. A feature is associated
-// with at most one field trial and selected group. See base/feature_list.h for
-// more information on features. If the feature is not enabled, or the
-// specified parameter does not exist, returns an empty string. Calling this
-// function will result in the associated field trial being marked as active if
-// found (i.e. group() will be called on it), if it wasn't already. Thread safe.
-BASE_EXPORT std::string GetFieldTrialParamValueByFeature(
-    const base::Feature& feature,
-    const std::string& param_name);
-
-// Same as GetFieldTrialParamValueByFeature(). On top of that, it converts the
-// string value into an int using base::StringToInt() and returns it, if
-// successful. Otherwise, it returns |default_value|. If the string value is not
-// empty and the conversion does not succeed, it produces a warning to LOG.
-BASE_EXPORT int GetFieldTrialParamByFeatureAsInt(const base::Feature& feature,
-                                                 const std::string& param_name,
-                                                 int default_value);
-
-// Same as GetFieldTrialParamValueByFeature(). On top of that, it converts the
-// string value into a double using base::StringToDouble() and returns it, if
-// successful. Otherwise, it returns |default_value|. If the string value is not
-// empty and the conversion does not succeed, it produces a warning to LOG.
-BASE_EXPORT double GetFieldTrialParamByFeatureAsDouble(
-    const base::Feature& feature,
-    const std::string& param_name,
-    double default_value);
-
-// Same as GetFieldTrialParamValueByFeature(). On top of that, it converts the
-// string value into a boolean and returns it, if successful. Otherwise, it
-// returns |default_value|. The only string representations accepted here are
-// "true" and "false". If the string value is not empty and the conversion does
-// not succeed, it produces a warning to LOG.
-BASE_EXPORT bool GetFieldTrialParamByFeatureAsBool(
-    const base::Feature& feature,
-    const std::string& param_name,
-    bool default_value);
-
-// Shared declaration for various FeatureParam<T> types.
-//
-// This template is defined for the following types T:
-//   bool
-//   int
-//   double
-//   std::string
-//   enum types
-//
-// See the individual definitions below for the appropriate interfaces.
-// Attempting to use it with any other type is a compile error.
-template <typename T, bool IsEnum = std::is_enum<T>::value>
-struct FeatureParam {
-  // Prevent use of FeatureParam<> with unsupported types (e.g. void*). Uses T
-  // in its definition so that evaluation is deferred until the template is
-  // instantiated.
-  static_assert(!std::is_same<T, T>::value, "unsupported FeatureParam<> type");
-};
-
-// Declares a string-valued parameter. Example:
-//
-//     constexpr FeatureParam<string> kAssistantName{
-//         &kAssistantFeature, "assistant_name", "HAL"};
-//
-// If the feature is not set, or set to the empty string, then Get() will return
-// the default value.
-template <>
-struct FeatureParam<std::string> {
-  constexpr FeatureParam(const Feature* feature,
-                         const char* name,
-                         const char* default_value)
-      : feature(feature), name(name), default_value(default_value) {}
-
-  BASE_EXPORT std::string Get() const;
-
-  const Feature* const feature;
-  const char* const name;
-  const char* const default_value;
-};
-
-// Declares a double-valued parameter. Example:
-//
-//     constexpr FeatureParam<double> kAssistantTriggerThreshold{
-//         &kAssistantFeature, "trigger_threshold", 0.10};
-//
-// If the feature is not set, or set to an invalid double value, then Get() will
-// return the default value.
-template <>
-struct FeatureParam<double> {
-  constexpr FeatureParam(const Feature* feature,
-                         const char* name,
-                         double default_value)
-      : feature(feature), name(name), default_value(default_value) {}
-
-  BASE_EXPORT double Get() const;
-
-  const Feature* const feature;
-  const char* const name;
-  const double default_value;
-};
-
-// Declares an int-valued parameter. Example:
-//
-//     constexpr FeatureParam<int> kAssistantParallelism{
-//         &kAssistantFeature, "parallelism", 4};
-//
-// If the feature is not set, or set to an invalid int value, then Get() will
-// return the default value.
-template <>
-struct FeatureParam<int> {
-  constexpr FeatureParam(const Feature* feature,
-                         const char* name,
-                         int default_value)
-      : feature(feature), name(name), default_value(default_value) {}
-
-  BASE_EXPORT int Get() const;
-
-  const Feature* const feature;
-  const char* const name;
-  const int default_value;
-};
-
-// Declares a bool-valued parameter. Example:
-//
-//     constexpr FeatureParam<int> kAssistantIsHelpful{
-//         &kAssistantFeature, "is_helpful", true};
-//
-// If the feature is not set, or set to value other than "true" or "false", then
-// Get() will return the default value.
-template <>
-struct FeatureParam<bool> {
-  constexpr FeatureParam(const Feature* feature,
-                         const char* name,
-                         bool default_value)
-      : feature(feature), name(name), default_value(default_value) {}
-
-  BASE_EXPORT bool Get() const;
-
-  const Feature* const feature;
-  const char* const name;
-  const bool default_value;
-};
-
-BASE_EXPORT void LogInvalidEnumValue(const Feature& feature,
-                                     const std::string& param_name,
-                                     const std::string& value_as_string,
-                                     int default_value_as_int);
-
-// Feature param declaration for an enum, with associated options. Example:
-//
-//     constexpr FeatureParam<ShapeEnum>::Option[] kShapeParamOptions[] = {
-//         {SHAPE_CIRCLE, "circle"},
-//         {SHAPE_CYLINDER, "cylinder"},
-//         {SHAPE_PAPERCLIP, "paperclip"}};
-//     constexpr FeatureParam<ShapeEnum> kAssistantShapeParam{
-//         &kAssistantFeature, "shape", SHAPE_CIRCLE, &kShapeParamOptions};
-//
-// With this declaration, the parameter may be set to "circle", "cylinder", or
-// "paperclip", and that will be translated to one of the three enum values. By
-// default, or if the param is set to an unknown value, the parameter will be
-// assumed to be SHAPE_CIRCLE.
-template <typename Enum>
-struct FeatureParam<Enum, true> {
-  struct Option {
-    constexpr Option(Enum value, const char* name) : value(value), name(name) {}
-
-    const Enum value;
-    const char* const name;
-  };
-
-  template <size_t option_count>
-  constexpr FeatureParam(const Feature* feature,
-                         const char* name,
-                         const Enum default_value,
-                         const Option (*options)[option_count])
-      : feature(feature),
-        name(name),
-        default_value(default_value),
-        options(*options),
-        option_count(option_count) {
-    static_assert(option_count >= 1, "FeatureParam<enum> has no options");
-  }
-
-  Enum Get() const {
-    std::string value = GetFieldTrialParamValueByFeature(*feature, name);
-    if (value.empty())
-      return default_value;
-    for (size_t i = 0; i < option_count; ++i) {
-      if (value == options[i].name)
-        return options[i].value;
-    }
-    LogInvalidEnumValue(*feature, name, value, static_cast<int>(default_value));
-    return default_value;
-  }
-
-  const base::Feature* const feature;
-  const char* const name;
-  const Enum default_value;
-  const Option* const options;
-  const size_t option_count;
-};
-
-}  // namespace base
-
-#endif  // BASE_METRICS_FIELD_TRIAL_PARAMS_H_
diff --git a/base/metrics/histogram.cc b/base/metrics/histogram.cc
deleted file mode 100644
index 07e09cf..0000000
--- a/base/metrics/histogram.cc
+++ /dev/null
@@ -1,1315 +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.
-
-// Histogram is an object that aggregates statistics, and can summarize them in
-// various forms, including ASCII graphical, HTML, and numerically (as a
-// vector of numbers corresponding to each of the aggregating buckets).
-// See header file for details and examples.
-
-#include "base/metrics/histogram.h"
-
-#include <inttypes.h>
-#include <limits.h>
-#include <math.h>
-
-#include <algorithm>
-#include <string>
-#include <utility>
-
-#include "base/compiler_specific.h"
-#include "base/debug/alias.h"
-#include "base/logging.h"
-#include "base/memory/ptr_util.h"
-#include "base/metrics/dummy_histogram.h"
-#include "base/metrics/histogram_functions.h"
-#include "base/metrics/metrics_hashes.h"
-#include "base/metrics/persistent_histogram_allocator.h"
-#include "base/metrics/persistent_memory_allocator.h"
-#include "base/metrics/sample_vector.h"
-#include "base/metrics/statistics_recorder.h"
-#include "base/pickle.h"
-#include "base/strings/string_util.h"
-#include "base/strings/stringprintf.h"
-#include "base/synchronization/lock.h"
-#include "base/sys_info.h"
-#include "base/values.h"
-#include "build_config.h"
-
-namespace base {
-
-namespace {
-
-bool ReadHistogramArguments(PickleIterator* iter,
-                            std::string* histogram_name,
-                            int* flags,
-                            int* declared_min,
-                            int* declared_max,
-                            uint32_t* bucket_count,
-                            uint32_t* range_checksum) {
-  if (!iter->ReadString(histogram_name) ||
-      !iter->ReadInt(flags) ||
-      !iter->ReadInt(declared_min) ||
-      !iter->ReadInt(declared_max) ||
-      !iter->ReadUInt32(bucket_count) ||
-      !iter->ReadUInt32(range_checksum)) {
-    DLOG(ERROR) << "Pickle error decoding Histogram: " << *histogram_name;
-    return false;
-  }
-
-  // Since these fields may have come from an untrusted renderer, do additional
-  // checks above and beyond those in Histogram::Initialize()
-  if (*declared_max <= 0 ||
-      *declared_min <= 0 ||
-      *declared_max < *declared_min ||
-      INT_MAX / sizeof(HistogramBase::Count) <= *bucket_count ||
-      *bucket_count < 2) {
-    DLOG(ERROR) << "Values error decoding Histogram: " << histogram_name;
-    return false;
-  }
-
-  // We use the arguments to find or create the local version of the histogram
-  // in this process, so we need to clear any IPC flag.
-  *flags &= ~HistogramBase::kIPCSerializationSourceFlag;
-
-  return true;
-}
-
-bool ValidateRangeChecksum(const HistogramBase& histogram,
-                           uint32_t range_checksum) {
-  // Normally, |histogram| should have type HISTOGRAM or be inherited from it.
-  // However, if it's expired, it will actually be a DUMMY_HISTOGRAM.
-  // Skip the checks in that case.
-  if (histogram.GetHistogramType() == DUMMY_HISTOGRAM)
-    return true;
-  const Histogram& casted_histogram =
-      static_cast<const Histogram&>(histogram);
-
-  return casted_histogram.bucket_ranges()->checksum() == range_checksum;
-}
-
-}  // namespace
-
-typedef HistogramBase::Count Count;
-typedef HistogramBase::Sample Sample;
-
-// static
-const uint32_t Histogram::kBucketCount_MAX = 16384u;
-
-class Histogram::Factory {
- public:
-  Factory(const std::string& name,
-          HistogramBase::Sample minimum,
-          HistogramBase::Sample maximum,
-          uint32_t bucket_count,
-          int32_t flags)
-    : Factory(name, HISTOGRAM, minimum, maximum, bucket_count, flags) {}
-
-  // Create histogram based on construction parameters. Caller takes
-  // ownership of the returned object.
-  HistogramBase* Build();
-
- protected:
-  Factory(const std::string& name,
-          HistogramType histogram_type,
-          HistogramBase::Sample minimum,
-          HistogramBase::Sample maximum,
-          uint32_t bucket_count,
-          int32_t flags)
-    : name_(name),
-      histogram_type_(histogram_type),
-      minimum_(minimum),
-      maximum_(maximum),
-      bucket_count_(bucket_count),
-      flags_(flags) {}
-
-  // Create a BucketRanges structure appropriate for this histogram.
-  virtual BucketRanges* CreateRanges() {
-    BucketRanges* ranges = new BucketRanges(bucket_count_ + 1);
-    Histogram::InitializeBucketRanges(minimum_, maximum_, ranges);
-    return ranges;
-  }
-
-  // Allocate the correct Histogram object off the heap (in case persistent
-  // memory is not available).
-  virtual std::unique_ptr<HistogramBase> HeapAlloc(const BucketRanges* ranges) {
-    return WrapUnique(
-        new Histogram(GetPermanentName(name_), minimum_, maximum_, ranges));
-  }
-
-  // Perform any required datafill on the just-created histogram.  If
-  // overridden, be sure to call the "super" version -- this method may not
-  // always remain empty.
-  virtual void FillHistogram(HistogramBase* histogram) {}
-
-  // These values are protected (instead of private) because they need to
-  // be accessible to methods of sub-classes in order to avoid passing
-  // unnecessary parameters everywhere.
-  const std::string& name_;
-  const HistogramType histogram_type_;
-  HistogramBase::Sample minimum_;
-  HistogramBase::Sample maximum_;
-  uint32_t bucket_count_;
-  int32_t flags_;
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(Factory);
-};
-
-HistogramBase* Histogram::Factory::Build() {
-  HistogramBase* histogram = StatisticsRecorder::FindHistogram(name_);
-  if (!histogram) {
-    // TODO(gayane): |HashMetricName()| is called again in Histogram
-    // constructor. Refactor code to avoid the additional call.
-    bool should_record =
-        StatisticsRecorder::ShouldRecordHistogram(HashMetricName(name_));
-    if (!should_record)
-      return DummyHistogram::GetInstance();
-    // To avoid racy destruction at shutdown, the following will be leaked.
-    const BucketRanges* created_ranges = CreateRanges();
-    const BucketRanges* registered_ranges =
-        StatisticsRecorder::RegisterOrDeleteDuplicateRanges(created_ranges);
-
-    // In most cases, the bucket-count, minimum, and maximum values are known
-    // when the code is written and so are passed in explicitly. In other
-    // cases (such as with a CustomHistogram), they are calculated dynamically
-    // at run-time. In the latter case, those ctor parameters are zero and
-    // the results extracted from the result of CreateRanges().
-    if (bucket_count_ == 0) {
-      bucket_count_ = static_cast<uint32_t>(registered_ranges->bucket_count());
-      minimum_ = registered_ranges->range(1);
-      maximum_ = registered_ranges->range(bucket_count_ - 1);
-    }
-    DCHECK_EQ(minimum_, registered_ranges->range(1));
-    DCHECK_EQ(maximum_, registered_ranges->range(bucket_count_ - 1));
-
-    // Try to create the histogram using a "persistent" allocator. As of
-    // 2016-02-25, the availability of such is controlled by a base::Feature
-    // that is off by default. If the allocator doesn't exist or if
-    // allocating from it fails, code below will allocate the histogram from
-    // the process heap.
-    PersistentHistogramAllocator::Reference histogram_ref = 0;
-    std::unique_ptr<HistogramBase> tentative_histogram;
-    PersistentHistogramAllocator* allocator = GlobalHistogramAllocator::Get();
-    if (allocator) {
-      tentative_histogram = allocator->AllocateHistogram(
-          histogram_type_,
-          name_,
-          minimum_,
-          maximum_,
-          registered_ranges,
-          flags_,
-          &histogram_ref);
-    }
-
-    // Handle the case where no persistent allocator is present or the
-    // persistent allocation fails (perhaps because it is full).
-    if (!tentative_histogram) {
-      DCHECK(!histogram_ref);  // Should never have been set.
-      DCHECK(!allocator);  // Shouldn't have failed.
-      flags_ &= ~HistogramBase::kIsPersistent;
-      tentative_histogram = HeapAlloc(registered_ranges);
-      tentative_histogram->SetFlags(flags_);
-    }
-
-    FillHistogram(tentative_histogram.get());
-
-    // Register this histogram with the StatisticsRecorder. Keep a copy of
-    // the pointer value to tell later whether the locally created histogram
-    // was registered or deleted. The type is "void" because it could point
-    // to released memory after the following line.
-    const void* tentative_histogram_ptr = tentative_histogram.get();
-    histogram = StatisticsRecorder::RegisterOrDeleteDuplicate(
-        tentative_histogram.release());
-
-    // Persistent histograms need some follow-up processing.
-    if (histogram_ref) {
-      allocator->FinalizeHistogram(histogram_ref,
-                                   histogram == tentative_histogram_ptr);
-    }
-  }
-
-  if (histogram_type_ != histogram->GetHistogramType() ||
-      (bucket_count_ != 0 && !histogram->HasConstructionArguments(
-                                 minimum_, maximum_, bucket_count_))) {
-    // The construction arguments do not match the existing histogram.  This can
-    // come about if an extension updates in the middle of a chrome run and has
-    // changed one of them, or simply by bad code within Chrome itself.  A NULL
-    // return would cause Chrome to crash; better to just record it for later
-    // analysis.
-    UmaHistogramSparse("Histogram.MismatchedConstructionArguments",
-                       static_cast<Sample>(HashMetricName(name_)));
-    DLOG(ERROR) << "Histogram " << name_
-                << " has mismatched construction arguments";
-    return DummyHistogram::GetInstance();
-  }
-  return histogram;
-}
-
-HistogramBase* Histogram::FactoryGet(const std::string& name,
-                                     Sample minimum,
-                                     Sample maximum,
-                                     uint32_t bucket_count,
-                                     int32_t flags) {
-  bool valid_arguments =
-      InspectConstructionArguments(name, &minimum, &maximum, &bucket_count);
-  DCHECK(valid_arguments);
-
-  return Factory(name, minimum, maximum, bucket_count, flags).Build();
-}
-
-HistogramBase* Histogram::FactoryTimeGet(const std::string& name,
-                                         TimeDelta minimum,
-                                         TimeDelta maximum,
-                                         uint32_t bucket_count,
-                                         int32_t flags) {
-  return FactoryGet(name, static_cast<Sample>(minimum.InMilliseconds()),
-                    static_cast<Sample>(maximum.InMilliseconds()), bucket_count,
-                    flags);
-}
-
-HistogramBase* Histogram::FactoryMicrosecondsTimeGet(const std::string& name,
-                                                     TimeDelta minimum,
-                                                     TimeDelta maximum,
-                                                     uint32_t bucket_count,
-                                                     int32_t flags) {
-  return FactoryGet(name, static_cast<Sample>(minimum.InMicroseconds()),
-                    static_cast<Sample>(maximum.InMicroseconds()), bucket_count,
-                    flags);
-}
-
-HistogramBase* Histogram::FactoryGet(const char* name,
-                                     Sample minimum,
-                                     Sample maximum,
-                                     uint32_t bucket_count,
-                                     int32_t flags) {
-  return FactoryGet(std::string(name), minimum, maximum, bucket_count, flags);
-}
-
-HistogramBase* Histogram::FactoryTimeGet(const char* name,
-                                         TimeDelta minimum,
-                                         TimeDelta maximum,
-                                         uint32_t bucket_count,
-                                         int32_t flags) {
-  return FactoryTimeGet(std::string(name), minimum, maximum, bucket_count,
-                        flags);
-}
-
-HistogramBase* Histogram::FactoryMicrosecondsTimeGet(const char* name,
-                                                     TimeDelta minimum,
-                                                     TimeDelta maximum,
-                                                     uint32_t bucket_count,
-                                                     int32_t flags) {
-  return FactoryMicrosecondsTimeGet(std::string(name), minimum, maximum,
-                                    bucket_count, flags);
-}
-
-std::unique_ptr<HistogramBase> Histogram::PersistentCreate(
-    const char* name,
-    Sample minimum,
-    Sample maximum,
-    const BucketRanges* ranges,
-    const DelayedPersistentAllocation& counts,
-    const DelayedPersistentAllocation& logged_counts,
-    HistogramSamples::Metadata* meta,
-    HistogramSamples::Metadata* logged_meta) {
-  return WrapUnique(new Histogram(name, minimum, maximum, ranges, counts,
-                                  logged_counts, meta, logged_meta));
-}
-
-// Calculate what range of values are held in each bucket.
-// We have to be careful that we don't pick a ratio between starting points in
-// consecutive buckets that is sooo small, that the integer bounds are the same
-// (effectively making one bucket get no values).  We need to avoid:
-//   ranges(i) == ranges(i + 1)
-// To avoid that, we just do a fine-grained bucket width as far as we need to
-// until we get a ratio that moves us along at least 2 units at a time.  From
-// that bucket onward we do use the exponential growth of buckets.
-//
-// static
-void Histogram::InitializeBucketRanges(Sample minimum,
-                                       Sample maximum,
-                                       BucketRanges* ranges) {
-  double log_max = log(static_cast<double>(maximum));
-  double log_ratio;
-  double log_next;
-  size_t bucket_index = 1;
-  Sample current = minimum;
-  ranges->set_range(bucket_index, current);
-  size_t bucket_count = ranges->bucket_count();
-  while (bucket_count > ++bucket_index) {
-    double log_current;
-    log_current = log(static_cast<double>(current));
-    // Calculate the count'th root of the range.
-    log_ratio = (log_max - log_current) / (bucket_count - bucket_index);
-    // See where the next bucket would start.
-    log_next = log_current + log_ratio;
-    Sample next;
-    next = static_cast<int>(std::round(exp(log_next)));
-    if (next > current)
-      current = next;
-    else
-      ++current;  // Just do a narrow bucket, and keep trying.
-    ranges->set_range(bucket_index, current);
-  }
-  ranges->set_range(ranges->bucket_count(), HistogramBase::kSampleType_MAX);
-  ranges->ResetChecksum();
-}
-
-// static
-const int Histogram::kCommonRaceBasedCountMismatch = 5;
-
-uint32_t Histogram::FindCorruption(const HistogramSamples& samples) const {
-  int inconsistencies = NO_INCONSISTENCIES;
-  Sample previous_range = -1;  // Bottom range is always 0.
-  for (uint32_t index = 0; index < bucket_count(); ++index) {
-    int new_range = ranges(index);
-    if (previous_range >= new_range)
-      inconsistencies |= BUCKET_ORDER_ERROR;
-    previous_range = new_range;
-  }
-
-  if (!bucket_ranges()->HasValidChecksum())
-    inconsistencies |= RANGE_CHECKSUM_ERROR;
-
-  int64_t delta64 = samples.redundant_count() - samples.TotalCount();
-  if (delta64 != 0) {
-    int delta = static_cast<int>(delta64);
-    if (delta != delta64)
-      delta = INT_MAX;  // Flag all giant errors as INT_MAX.
-    if (delta > 0) {
-      if (delta > kCommonRaceBasedCountMismatch)
-        inconsistencies |= COUNT_HIGH_ERROR;
-    } else {
-      DCHECK_GT(0, delta);
-      if (-delta > kCommonRaceBasedCountMismatch)
-        inconsistencies |= COUNT_LOW_ERROR;
-    }
-  }
-  return inconsistencies;
-}
-
-const BucketRanges* Histogram::bucket_ranges() const {
-  return unlogged_samples_->bucket_ranges();
-}
-
-Sample Histogram::declared_min() const {
-  const BucketRanges* ranges = bucket_ranges();
-  if (ranges->bucket_count() < 2)
-    return -1;
-  return ranges->range(1);
-}
-
-Sample Histogram::declared_max() const {
-  const BucketRanges* ranges = bucket_ranges();
-  if (ranges->bucket_count() < 2)
-    return -1;
-  return ranges->range(ranges->bucket_count() - 1);
-}
-
-Sample Histogram::ranges(uint32_t i) const {
-  return bucket_ranges()->range(i);
-}
-
-uint32_t Histogram::bucket_count() const {
-  return static_cast<uint32_t>(bucket_ranges()->bucket_count());
-}
-
-// static
-bool Histogram::InspectConstructionArguments(StringPiece name,
-                                             Sample* minimum,
-                                             Sample* maximum,
-                                             uint32_t* bucket_count) {
-  // Defensive code for backward compatibility.
-  if (*minimum < 1) {
-    DVLOG(1) << "Histogram: " << name << " has bad minimum: " << *minimum;
-    *minimum = 1;
-  }
-  if (*maximum >= kSampleType_MAX) {
-    DVLOG(1) << "Histogram: " << name << " has bad maximum: " << *maximum;
-    *maximum = kSampleType_MAX - 1;
-  }
-  if (*bucket_count >= kBucketCount_MAX) {
-    DVLOG(1) << "Histogram: " << name << " has bad bucket_count: "
-             << *bucket_count;
-    *bucket_count = kBucketCount_MAX - 1;
-  }
-
-  bool check_okay = true;
-
-  if (*minimum > *maximum) {
-    check_okay = false;
-    std::swap(*minimum, *maximum);
-  }
-  if (*maximum == *minimum) {
-    check_okay = false;
-    *maximum = *minimum + 1;
-  }
-  if (*bucket_count < 3) {
-    check_okay = false;
-    *bucket_count = 3;
-  }
-  // Very high bucket counts are wasteful. Use a sparse histogram instead.
-  // Value of 10002 equals a user-supplied value of 10k + 2 overflow buckets.
-  constexpr uint32_t kMaxBucketCount = 10002;
-  if (*bucket_count > kMaxBucketCount) {
-    check_okay = false;
-    *bucket_count = kMaxBucketCount;
-  }
-  if (*bucket_count > static_cast<uint32_t>(*maximum - *minimum + 2)) {
-    check_okay = false;
-    *bucket_count = static_cast<uint32_t>(*maximum - *minimum + 2);
-  }
-
-  if (!check_okay) {
-    UmaHistogramSparse("Histogram.BadConstructionArguments",
-                       static_cast<Sample>(HashMetricName(name)));
-  }
-
-  return check_okay;
-}
-
-uint64_t Histogram::name_hash() const {
-  return unlogged_samples_->id();
-}
-
-HistogramType Histogram::GetHistogramType() const {
-  return HISTOGRAM;
-}
-
-bool Histogram::HasConstructionArguments(Sample expected_minimum,
-                                         Sample expected_maximum,
-                                         uint32_t expected_bucket_count) const {
-  return (expected_bucket_count == bucket_count() &&
-          expected_minimum == declared_min() &&
-          expected_maximum == declared_max());
-}
-
-void Histogram::Add(int value) {
-  AddCount(value, 1);
-}
-
-void Histogram::AddCount(int value, int count) {
-  DCHECK_EQ(0, ranges(0));
-  DCHECK_EQ(kSampleType_MAX, ranges(bucket_count()));
-
-  if (value > kSampleType_MAX - 1)
-    value = kSampleType_MAX - 1;
-  if (value < 0)
-    value = 0;
-  if (count <= 0) {
-    NOTREACHED();
-    return;
-  }
-  unlogged_samples_->Accumulate(value, count);
-
-  FindAndRunCallback(value);
-}
-
-std::unique_ptr<HistogramSamples> Histogram::SnapshotSamples() const {
-  return SnapshotAllSamples();
-}
-
-std::unique_ptr<HistogramSamples> Histogram::SnapshotDelta() {
-#if DCHECK_IS_ON()
-  DCHECK(!final_delta_created_);
-#endif
-
-  // The code below has subtle thread-safety guarantees! All changes to
-  // the underlying SampleVectors use atomic integer operations, which guarantee
-  // eventual consistency, but do not guarantee full synchronization between
-  // different entries in the SampleVector. In particular, this means that
-  // concurrent updates to the histogram might result in the reported sum not
-  // matching the individual bucket counts; or there being some buckets that are
-  // logically updated "together", but end up being only partially updated when
-  // a snapshot is captured. Note that this is why it's important to subtract
-  // exactly the snapshotted unlogged samples, rather than simply resetting the
-  // vector: this way, the next snapshot will include any concurrent updates
-  // missed by the current snapshot.
-
-  std::unique_ptr<HistogramSamples> snapshot = SnapshotUnloggedSamples();
-  unlogged_samples_->Subtract(*snapshot);
-  logged_samples_->Add(*snapshot);
-
-  return snapshot;
-}
-
-std::unique_ptr<HistogramSamples> Histogram::SnapshotFinalDelta() const {
-#if DCHECK_IS_ON()
-  DCHECK(!final_delta_created_);
-  final_delta_created_ = true;
-#endif
-
-  return SnapshotUnloggedSamples();
-}
-
-void Histogram::AddSamples(const HistogramSamples& samples) {
-  unlogged_samples_->Add(samples);
-}
-
-bool Histogram::AddSamplesFromPickle(PickleIterator* iter) {
-  return unlogged_samples_->AddFromPickle(iter);
-}
-
-// The following methods provide a graphical histogram display.
-void Histogram::WriteHTMLGraph(std::string* output) const {
-  // TBD(jar) Write a nice HTML bar chart, with divs an mouse-overs etc.
-  output->append("<PRE>");
-  WriteAsciiImpl(true, "<br>", output);
-  output->append("</PRE>");
-}
-
-void Histogram::WriteAscii(std::string* output) const {
-  WriteAsciiImpl(true, "\n", output);
-}
-
-void Histogram::ValidateHistogramContents() const {
-  CHECK(unlogged_samples_);
-  CHECK(unlogged_samples_->bucket_ranges());
-  CHECK(logged_samples_);
-  CHECK(logged_samples_->bucket_ranges());
-#if !defined(OS_NACL)
-  if (0U == logged_samples_->id() && (flags() & kIsPersistent)) {
-    // ID should never be zero. If it is, then it's probably because the
-    // entire memory page was cleared. Check that this is true.
-    // TODO(bcwhite): Remove this.
-    // https://bugs.chromium.org/p/chromium/issues/detail?id=836875
-    size_t page_size = SysInfo::VMAllocationGranularity();
-    if (page_size == 0)
-      page_size = 1024;
-    const int* address = reinterpret_cast<const int*>(
-        reinterpret_cast<uintptr_t>(logged_samples_->meta()) &
-        ~(page_size - 1));
-    // Check a couple places so there is evidence in a crash report as to
-    // where it was non-zero.
-    CHECK_EQ(0, address[0]);
-    CHECK_EQ(0, address[1]);
-    CHECK_EQ(0, address[2]);
-    CHECK_EQ(0, address[4]);
-    CHECK_EQ(0, address[8]);
-    CHECK_EQ(0, address[16]);
-    CHECK_EQ(0, address[32]);
-    CHECK_EQ(0, address[64]);
-    CHECK_EQ(0, address[128]);
-    CHECK_EQ(0, address[256]);
-    CHECK_EQ(0, address[512]);
-    // Now check every address.
-    for (size_t i = 0; i < page_size / sizeof(int); ++i)
-      CHECK_EQ(0, address[i]);
-  }
-#endif
-  CHECK_NE(0U, logged_samples_->id());
-}
-
-void Histogram::SerializeInfoImpl(Pickle* pickle) const {
-  DCHECK(bucket_ranges()->HasValidChecksum());
-  pickle->WriteString(histogram_name());
-  pickle->WriteInt(flags());
-  pickle->WriteInt(declared_min());
-  pickle->WriteInt(declared_max());
-  pickle->WriteUInt32(bucket_count());
-  pickle->WriteUInt32(bucket_ranges()->checksum());
-}
-
-// TODO(bcwhite): Remove minimum/maximum parameters from here and call chain.
-Histogram::Histogram(const char* name,
-                     Sample minimum,
-                     Sample maximum,
-                     const BucketRanges* ranges)
-    : HistogramBase(name) {
-  DCHECK(ranges) << name << ": " << minimum << "-" << maximum;
-  unlogged_samples_.reset(new SampleVector(HashMetricName(name), ranges));
-  logged_samples_.reset(new SampleVector(unlogged_samples_->id(), ranges));
-}
-
-Histogram::Histogram(const char* name,
-                     Sample minimum,
-                     Sample maximum,
-                     const BucketRanges* ranges,
-                     const DelayedPersistentAllocation& counts,
-                     const DelayedPersistentAllocation& logged_counts,
-                     HistogramSamples::Metadata* meta,
-                     HistogramSamples::Metadata* logged_meta)
-    : HistogramBase(name) {
-  DCHECK(ranges) << name << ": " << minimum << "-" << maximum;
-  unlogged_samples_.reset(
-      new PersistentSampleVector(HashMetricName(name), ranges, meta, counts));
-  logged_samples_.reset(new PersistentSampleVector(
-      unlogged_samples_->id(), ranges, logged_meta, logged_counts));
-}
-
-Histogram::~Histogram() = default;
-
-bool Histogram::PrintEmptyBucket(uint32_t index) const {
-  return true;
-}
-
-// Use the actual bucket widths (like a linear histogram) until the widths get
-// over some transition value, and then use that transition width.  Exponentials
-// get so big so fast (and we don't expect to see a lot of entries in the large
-// buckets), so we need this to make it possible to see what is going on and
-// not have 0-graphical-height buckets.
-double Histogram::GetBucketSize(Count current, uint32_t i) const {
-  DCHECK_GT(ranges(i + 1), ranges(i));
-  static const double kTransitionWidth = 5;
-  double denominator = ranges(i + 1) - ranges(i);
-  if (denominator > kTransitionWidth)
-    denominator = kTransitionWidth;  // Stop trying to normalize.
-  return current/denominator;
-}
-
-const std::string Histogram::GetAsciiBucketRange(uint32_t i) const {
-  return GetSimpleAsciiBucketRange(ranges(i));
-}
-
-//------------------------------------------------------------------------------
-// Private methods
-
-// static
-HistogramBase* Histogram::DeserializeInfoImpl(PickleIterator* iter) {
-  std::string histogram_name;
-  int flags;
-  int declared_min;
-  int declared_max;
-  uint32_t bucket_count;
-  uint32_t range_checksum;
-
-  if (!ReadHistogramArguments(iter, &histogram_name, &flags, &declared_min,
-                              &declared_max, &bucket_count, &range_checksum)) {
-    return nullptr;
-  }
-
-  // Find or create the local version of the histogram in this process.
-  HistogramBase* histogram = Histogram::FactoryGet(
-      histogram_name, declared_min, declared_max, bucket_count, flags);
-  if (!histogram)
-    return nullptr;
-
-  // The serialized histogram might be corrupted.
-  if (!ValidateRangeChecksum(*histogram, range_checksum))
-    return nullptr;
-
-  return histogram;
-}
-
-std::unique_ptr<SampleVector> Histogram::SnapshotAllSamples() const {
-  std::unique_ptr<SampleVector> samples = SnapshotUnloggedSamples();
-  samples->Add(*logged_samples_);
-  return samples;
-}
-
-std::unique_ptr<SampleVector> Histogram::SnapshotUnloggedSamples() const {
-  std::unique_ptr<SampleVector> samples(
-      new SampleVector(unlogged_samples_->id(), bucket_ranges()));
-  samples->Add(*unlogged_samples_);
-  return samples;
-}
-
-void Histogram::WriteAsciiImpl(bool graph_it,
-                               const std::string& newline,
-                               std::string* output) const {
-  // Get local (stack) copies of all effectively volatile class data so that we
-  // are consistent across our output activities.
-  std::unique_ptr<SampleVector> snapshot = SnapshotAllSamples();
-  Count sample_count = snapshot->TotalCount();
-
-  WriteAsciiHeader(*snapshot, sample_count, output);
-  output->append(newline);
-
-  // Prepare to normalize graphical rendering of bucket contents.
-  double max_size = 0;
-  if (graph_it)
-    max_size = GetPeakBucketSize(*snapshot);
-
-  // Calculate space needed to print bucket range numbers.  Leave room to print
-  // nearly the largest bucket range without sliding over the histogram.
-  uint32_t largest_non_empty_bucket = bucket_count() - 1;
-  while (0 == snapshot->GetCountAtIndex(largest_non_empty_bucket)) {
-    if (0 == largest_non_empty_bucket)
-      break;  // All buckets are empty.
-    --largest_non_empty_bucket;
-  }
-
-  // Calculate largest print width needed for any of our bucket range displays.
-  size_t print_width = 1;
-  for (uint32_t i = 0; i < bucket_count(); ++i) {
-    if (snapshot->GetCountAtIndex(i)) {
-      size_t width = GetAsciiBucketRange(i).size() + 1;
-      if (width > print_width)
-        print_width = width;
-    }
-  }
-
-  int64_t remaining = sample_count;
-  int64_t past = 0;
-  // Output the actual histogram graph.
-  for (uint32_t i = 0; i < bucket_count(); ++i) {
-    Count current = snapshot->GetCountAtIndex(i);
-    if (!current && !PrintEmptyBucket(i))
-      continue;
-    remaining -= current;
-    std::string range = GetAsciiBucketRange(i);
-    output->append(range);
-    for (size_t j = 0; range.size() + j < print_width + 1; ++j)
-      output->push_back(' ');
-    if (0 == current && i < bucket_count() - 1 &&
-        0 == snapshot->GetCountAtIndex(i + 1)) {
-      while (i < bucket_count() - 1 &&
-             0 == snapshot->GetCountAtIndex(i + 1)) {
-        ++i;
-      }
-      output->append("... ");
-      output->append(newline);
-      continue;  // No reason to plot emptiness.
-    }
-    double current_size = GetBucketSize(current, i);
-    if (graph_it)
-      WriteAsciiBucketGraph(current_size, max_size, output);
-    WriteAsciiBucketContext(past, current, remaining, i, output);
-    output->append(newline);
-    past += current;
-  }
-  DCHECK_EQ(sample_count, past);
-}
-
-double Histogram::GetPeakBucketSize(const SampleVectorBase& samples) const {
-  double max = 0;
-  for (uint32_t i = 0; i < bucket_count() ; ++i) {
-    double current_size = GetBucketSize(samples.GetCountAtIndex(i), i);
-    if (current_size > max)
-      max = current_size;
-  }
-  return max;
-}
-
-void Histogram::WriteAsciiHeader(const SampleVectorBase& samples,
-                                 Count sample_count,
-                                 std::string* output) const {
-  StringAppendF(output, "Histogram: %s recorded %d samples", histogram_name(),
-                sample_count);
-  if (sample_count == 0) {
-    DCHECK_EQ(samples.sum(), 0);
-  } else {
-    double mean = static_cast<float>(samples.sum()) / sample_count;
-    StringAppendF(output, ", mean = %.1f", mean);
-  }
-  if (flags())
-    StringAppendF(output, " (flags = 0x%x)", flags());
-}
-
-void Histogram::WriteAsciiBucketContext(const int64_t past,
-                                        const Count current,
-                                        const int64_t remaining,
-                                        const uint32_t i,
-                                        std::string* output) const {
-  double scaled_sum = (past + current + remaining) / 100.0;
-  WriteAsciiBucketValue(current, scaled_sum, output);
-  if (0 < i) {
-    double percentage = past / scaled_sum;
-    StringAppendF(output, " {%3.1f%%}", percentage);
-  }
-}
-
-void Histogram::GetParameters(DictionaryValue* params) const {
-  params->SetString("type", HistogramTypeToString(GetHistogramType()));
-  params->SetInteger("min", declared_min());
-  params->SetInteger("max", declared_max());
-  params->SetInteger("bucket_count", static_cast<int>(bucket_count()));
-}
-
-void Histogram::GetCountAndBucketData(Count* count,
-                                      int64_t* sum,
-                                      ListValue* buckets) const {
-  std::unique_ptr<SampleVector> snapshot = SnapshotAllSamples();
-  *count = snapshot->TotalCount();
-  *sum = snapshot->sum();
-  uint32_t index = 0;
-  for (uint32_t i = 0; i < bucket_count(); ++i) {
-    Sample count_at_index = snapshot->GetCountAtIndex(i);
-    if (count_at_index > 0) {
-      std::unique_ptr<DictionaryValue> bucket_value(new DictionaryValue());
-      bucket_value->SetInteger("low", ranges(i));
-      if (i != bucket_count() - 1)
-        bucket_value->SetInteger("high", ranges(i + 1));
-      bucket_value->SetInteger("count", count_at_index);
-      buckets->Set(index, std::move(bucket_value));
-      ++index;
-    }
-  }
-}
-
-//------------------------------------------------------------------------------
-// LinearHistogram: This histogram uses a traditional set of evenly spaced
-// buckets.
-//------------------------------------------------------------------------------
-
-class LinearHistogram::Factory : public Histogram::Factory {
- public:
-  Factory(const std::string& name,
-          HistogramBase::Sample minimum,
-          HistogramBase::Sample maximum,
-          uint32_t bucket_count,
-          int32_t flags,
-          const DescriptionPair* descriptions)
-    : Histogram::Factory(name, LINEAR_HISTOGRAM, minimum, maximum,
-                         bucket_count, flags) {
-    descriptions_ = descriptions;
-  }
-
- protected:
-  BucketRanges* CreateRanges() override {
-    BucketRanges* ranges = new BucketRanges(bucket_count_ + 1);
-    LinearHistogram::InitializeBucketRanges(minimum_, maximum_, ranges);
-    return ranges;
-  }
-
-  std::unique_ptr<HistogramBase> HeapAlloc(
-      const BucketRanges* ranges) override {
-    return WrapUnique(new LinearHistogram(GetPermanentName(name_), minimum_,
-                                          maximum_, ranges));
-  }
-
-  void FillHistogram(HistogramBase* base_histogram) override {
-    Histogram::Factory::FillHistogram(base_histogram);
-    // Normally, |base_histogram| should have type LINEAR_HISTOGRAM or be
-    // inherited from it. However, if it's expired, it will actually be a
-    // DUMMY_HISTOGRAM. Skip filling in that case.
-    if (base_histogram->GetHistogramType() == DUMMY_HISTOGRAM)
-      return;
-    LinearHistogram* histogram = static_cast<LinearHistogram*>(base_histogram);
-    // Set range descriptions.
-    if (descriptions_) {
-      for (int i = 0; descriptions_[i].description; ++i) {
-        histogram->bucket_description_[descriptions_[i].sample] =
-            descriptions_[i].description;
-      }
-    }
-  }
-
- private:
-  const DescriptionPair* descriptions_;
-
-  DISALLOW_COPY_AND_ASSIGN(Factory);
-};
-
-LinearHistogram::~LinearHistogram() = default;
-
-HistogramBase* LinearHistogram::FactoryGet(const std::string& name,
-                                           Sample minimum,
-                                           Sample maximum,
-                                           uint32_t bucket_count,
-                                           int32_t flags) {
-  return FactoryGetWithRangeDescription(name, minimum, maximum, bucket_count,
-                                        flags, NULL);
-}
-
-HistogramBase* LinearHistogram::FactoryTimeGet(const std::string& name,
-                                               TimeDelta minimum,
-                                               TimeDelta maximum,
-                                               uint32_t bucket_count,
-                                               int32_t flags) {
-  return FactoryGet(name, static_cast<Sample>(minimum.InMilliseconds()),
-                    static_cast<Sample>(maximum.InMilliseconds()), bucket_count,
-                    flags);
-}
-
-HistogramBase* LinearHistogram::FactoryGet(const char* name,
-                                           Sample minimum,
-                                           Sample maximum,
-                                           uint32_t bucket_count,
-                                           int32_t flags) {
-  return FactoryGet(std::string(name), minimum, maximum, bucket_count, flags);
-}
-
-HistogramBase* LinearHistogram::FactoryTimeGet(const char* name,
-                                               TimeDelta minimum,
-                                               TimeDelta maximum,
-                                               uint32_t bucket_count,
-                                               int32_t flags) {
-  return FactoryTimeGet(std::string(name),  minimum, maximum, bucket_count,
-                        flags);
-}
-
-std::unique_ptr<HistogramBase> LinearHistogram::PersistentCreate(
-    const char* name,
-    Sample minimum,
-    Sample maximum,
-    const BucketRanges* ranges,
-    const DelayedPersistentAllocation& counts,
-    const DelayedPersistentAllocation& logged_counts,
-    HistogramSamples::Metadata* meta,
-    HistogramSamples::Metadata* logged_meta) {
-  return WrapUnique(new LinearHistogram(name, minimum, maximum, ranges, counts,
-                                        logged_counts, meta, logged_meta));
-}
-
-HistogramBase* LinearHistogram::FactoryGetWithRangeDescription(
-    const std::string& name,
-    Sample minimum,
-    Sample maximum,
-    uint32_t bucket_count,
-    int32_t flags,
-    const DescriptionPair descriptions[]) {
-  bool valid_arguments = Histogram::InspectConstructionArguments(
-      name, &minimum, &maximum, &bucket_count);
-  DCHECK(valid_arguments);
-
-  return Factory(name, minimum, maximum, bucket_count, flags, descriptions)
-      .Build();
-}
-
-HistogramType LinearHistogram::GetHistogramType() const {
-  return LINEAR_HISTOGRAM;
-}
-
-LinearHistogram::LinearHistogram(const char* name,
-                                 Sample minimum,
-                                 Sample maximum,
-                                 const BucketRanges* ranges)
-    : Histogram(name, minimum, maximum, ranges) {}
-
-LinearHistogram::LinearHistogram(
-    const char* name,
-    Sample minimum,
-    Sample maximum,
-    const BucketRanges* ranges,
-    const DelayedPersistentAllocation& counts,
-    const DelayedPersistentAllocation& logged_counts,
-    HistogramSamples::Metadata* meta,
-    HistogramSamples::Metadata* logged_meta)
-    : Histogram(name,
-                minimum,
-                maximum,
-                ranges,
-                counts,
-                logged_counts,
-                meta,
-                logged_meta) {}
-
-double LinearHistogram::GetBucketSize(Count current, uint32_t i) const {
-  DCHECK_GT(ranges(i + 1), ranges(i));
-  // Adjacent buckets with different widths would have "surprisingly" many (few)
-  // samples in a histogram if we didn't normalize this way.
-  double denominator = ranges(i + 1) - ranges(i);
-  return current/denominator;
-}
-
-const std::string LinearHistogram::GetAsciiBucketRange(uint32_t i) const {
-  int range = ranges(i);
-  BucketDescriptionMap::const_iterator it = bucket_description_.find(range);
-  if (it == bucket_description_.end())
-    return Histogram::GetAsciiBucketRange(i);
-  return it->second;
-}
-
-bool LinearHistogram::PrintEmptyBucket(uint32_t index) const {
-  return bucket_description_.find(ranges(index)) == bucket_description_.end();
-}
-
-// static
-void LinearHistogram::InitializeBucketRanges(Sample minimum,
-                                             Sample maximum,
-                                             BucketRanges* ranges) {
-  double min = minimum;
-  double max = maximum;
-  size_t bucket_count = ranges->bucket_count();
-  for (size_t i = 1; i < bucket_count; ++i) {
-    double linear_range =
-        (min * (bucket_count - 1 - i) + max * (i - 1)) / (bucket_count - 2);
-    ranges->set_range(i, static_cast<Sample>(linear_range + 0.5));
-  }
-  ranges->set_range(ranges->bucket_count(), HistogramBase::kSampleType_MAX);
-  ranges->ResetChecksum();
-}
-
-// static
-HistogramBase* LinearHistogram::DeserializeInfoImpl(PickleIterator* iter) {
-  std::string histogram_name;
-  int flags;
-  int declared_min;
-  int declared_max;
-  uint32_t bucket_count;
-  uint32_t range_checksum;
-
-  if (!ReadHistogramArguments(iter, &histogram_name, &flags, &declared_min,
-                              &declared_max, &bucket_count, &range_checksum)) {
-    return nullptr;
-  }
-
-  HistogramBase* histogram = LinearHistogram::FactoryGet(
-      histogram_name, declared_min, declared_max, bucket_count, flags);
-  if (!histogram)
-    return nullptr;
-
-  if (!ValidateRangeChecksum(*histogram, range_checksum)) {
-    // The serialized histogram might be corrupted.
-    return nullptr;
-  }
-  return histogram;
-}
-
-//------------------------------------------------------------------------------
-// This section provides implementation for BooleanHistogram.
-//------------------------------------------------------------------------------
-
-class BooleanHistogram::Factory : public Histogram::Factory {
- public:
-  Factory(const std::string& name, int32_t flags)
-    : Histogram::Factory(name, BOOLEAN_HISTOGRAM, 1, 2, 3, flags) {}
-
- protected:
-  BucketRanges* CreateRanges() override {
-    BucketRanges* ranges = new BucketRanges(3 + 1);
-    LinearHistogram::InitializeBucketRanges(1, 2, ranges);
-    return ranges;
-  }
-
-  std::unique_ptr<HistogramBase> HeapAlloc(
-      const BucketRanges* ranges) override {
-    return WrapUnique(new BooleanHistogram(GetPermanentName(name_), ranges));
-  }
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(Factory);
-};
-
-HistogramBase* BooleanHistogram::FactoryGet(const std::string& name,
-                                            int32_t flags) {
-  return Factory(name, flags).Build();
-}
-
-HistogramBase* BooleanHistogram::FactoryGet(const char* name, int32_t flags) {
-  return FactoryGet(std::string(name), flags);
-}
-
-std::unique_ptr<HistogramBase> BooleanHistogram::PersistentCreate(
-    const char* name,
-    const BucketRanges* ranges,
-    const DelayedPersistentAllocation& counts,
-    const DelayedPersistentAllocation& logged_counts,
-    HistogramSamples::Metadata* meta,
-    HistogramSamples::Metadata* logged_meta) {
-  return WrapUnique(new BooleanHistogram(name, ranges, counts, logged_counts,
-                                         meta, logged_meta));
-}
-
-HistogramType BooleanHistogram::GetHistogramType() const {
-  return BOOLEAN_HISTOGRAM;
-}
-
-BooleanHistogram::BooleanHistogram(const char* name, const BucketRanges* ranges)
-    : LinearHistogram(name, 1, 2, ranges) {}
-
-BooleanHistogram::BooleanHistogram(
-    const char* name,
-    const BucketRanges* ranges,
-    const DelayedPersistentAllocation& counts,
-    const DelayedPersistentAllocation& logged_counts,
-    HistogramSamples::Metadata* meta,
-    HistogramSamples::Metadata* logged_meta)
-    : LinearHistogram(name,
-                      1,
-                      2,
-                      ranges,
-                      counts,
-                      logged_counts,
-                      meta,
-                      logged_meta) {}
-
-HistogramBase* BooleanHistogram::DeserializeInfoImpl(PickleIterator* iter) {
-  std::string histogram_name;
-  int flags;
-  int declared_min;
-  int declared_max;
-  uint32_t bucket_count;
-  uint32_t range_checksum;
-
-  if (!ReadHistogramArguments(iter, &histogram_name, &flags, &declared_min,
-                              &declared_max, &bucket_count, &range_checksum)) {
-    return nullptr;
-  }
-
-  HistogramBase* histogram = BooleanHistogram::FactoryGet(
-      histogram_name, flags);
-  if (!histogram)
-    return nullptr;
-
-  if (!ValidateRangeChecksum(*histogram, range_checksum)) {
-    // The serialized histogram might be corrupted.
-    return nullptr;
-  }
-  return histogram;
-}
-
-//------------------------------------------------------------------------------
-// CustomHistogram:
-//------------------------------------------------------------------------------
-
-class CustomHistogram::Factory : public Histogram::Factory {
- public:
-  Factory(const std::string& name,
-          const std::vector<Sample>* custom_ranges,
-          int32_t flags)
-    : Histogram::Factory(name, CUSTOM_HISTOGRAM, 0, 0, 0, flags) {
-    custom_ranges_ = custom_ranges;
-  }
-
- protected:
-  BucketRanges* CreateRanges() override {
-    // Remove the duplicates in the custom ranges array.
-    std::vector<int> ranges = *custom_ranges_;
-    ranges.push_back(0);  // Ensure we have a zero value.
-    ranges.push_back(HistogramBase::kSampleType_MAX);
-    std::sort(ranges.begin(), ranges.end());
-    ranges.erase(std::unique(ranges.begin(), ranges.end()), ranges.end());
-
-    BucketRanges* bucket_ranges = new BucketRanges(ranges.size());
-    for (uint32_t i = 0; i < ranges.size(); i++) {
-      bucket_ranges->set_range(i, ranges[i]);
-    }
-    bucket_ranges->ResetChecksum();
-    return bucket_ranges;
-  }
-
-  std::unique_ptr<HistogramBase> HeapAlloc(
-      const BucketRanges* ranges) override {
-    return WrapUnique(new CustomHistogram(GetPermanentName(name_), ranges));
-  }
-
- private:
-  const std::vector<Sample>* custom_ranges_;
-
-  DISALLOW_COPY_AND_ASSIGN(Factory);
-};
-
-HistogramBase* CustomHistogram::FactoryGet(
-    const std::string& name,
-    const std::vector<Sample>& custom_ranges,
-    int32_t flags) {
-  CHECK(ValidateCustomRanges(custom_ranges));
-
-  return Factory(name, &custom_ranges, flags).Build();
-}
-
-HistogramBase* CustomHistogram::FactoryGet(
-    const char* name,
-    const std::vector<Sample>& custom_ranges,
-    int32_t flags) {
-  return FactoryGet(std::string(name), custom_ranges, flags);
-}
-
-std::unique_ptr<HistogramBase> CustomHistogram::PersistentCreate(
-    const char* name,
-    const BucketRanges* ranges,
-    const DelayedPersistentAllocation& counts,
-    const DelayedPersistentAllocation& logged_counts,
-    HistogramSamples::Metadata* meta,
-    HistogramSamples::Metadata* logged_meta) {
-  return WrapUnique(new CustomHistogram(name, ranges, counts, logged_counts,
-                                        meta, logged_meta));
-}
-
-HistogramType CustomHistogram::GetHistogramType() const {
-  return CUSTOM_HISTOGRAM;
-}
-
-// static
-std::vector<Sample> CustomHistogram::ArrayToCustomEnumRanges(
-    base::span<const Sample> values) {
-  std::vector<Sample> all_values;
-  for (Sample value : values) {
-    all_values.push_back(value);
-
-    // Ensure that a guard bucket is added. If we end up with duplicate
-    // values, FactoryGet will take care of removing them.
-    all_values.push_back(value + 1);
-  }
-  return all_values;
-}
-
-CustomHistogram::CustomHistogram(const char* name, const BucketRanges* ranges)
-    : Histogram(name,
-                ranges->range(1),
-                ranges->range(ranges->bucket_count() - 1),
-                ranges) {}
-
-CustomHistogram::CustomHistogram(
-    const char* name,
-    const BucketRanges* ranges,
-    const DelayedPersistentAllocation& counts,
-    const DelayedPersistentAllocation& logged_counts,
-    HistogramSamples::Metadata* meta,
-    HistogramSamples::Metadata* logged_meta)
-    : Histogram(name,
-                ranges->range(1),
-                ranges->range(ranges->bucket_count() - 1),
-                ranges,
-                counts,
-                logged_counts,
-                meta,
-                logged_meta) {}
-
-void CustomHistogram::SerializeInfoImpl(Pickle* pickle) const {
-  Histogram::SerializeInfoImpl(pickle);
-
-  // Serialize ranges. First and last ranges are alwasy 0 and INT_MAX, so don't
-  // write them.
-  for (uint32_t i = 1; i < bucket_ranges()->bucket_count(); ++i)
-    pickle->WriteInt(bucket_ranges()->range(i));
-}
-
-double CustomHistogram::GetBucketSize(Count current, uint32_t i) const {
-  // If this is a histogram of enum values, normalizing the bucket count
-  // by the bucket range is not helpful, so just return the bucket count.
-  return current;
-}
-
-// static
-HistogramBase* CustomHistogram::DeserializeInfoImpl(PickleIterator* iter) {
-  std::string histogram_name;
-  int flags;
-  int declared_min;
-  int declared_max;
-  uint32_t bucket_count;
-  uint32_t range_checksum;
-
-  if (!ReadHistogramArguments(iter, &histogram_name, &flags, &declared_min,
-                              &declared_max, &bucket_count, &range_checksum)) {
-    return nullptr;
-  }
-
-  // First and last ranges are not serialized.
-  std::vector<Sample> sample_ranges(bucket_count - 1);
-
-  for (uint32_t i = 0; i < sample_ranges.size(); ++i) {
-    if (!iter->ReadInt(&sample_ranges[i]))
-      return nullptr;
-  }
-
-  HistogramBase* histogram = CustomHistogram::FactoryGet(
-      histogram_name, sample_ranges, flags);
-  if (!histogram)
-    return nullptr;
-
-  if (!ValidateRangeChecksum(*histogram, range_checksum)) {
-    // The serialized histogram might be corrupted.
-    return nullptr;
-  }
-  return histogram;
-}
-
-// static
-bool CustomHistogram::ValidateCustomRanges(
-    const std::vector<Sample>& custom_ranges) {
-  bool has_valid_range = false;
-  for (uint32_t i = 0; i < custom_ranges.size(); i++) {
-    Sample sample = custom_ranges[i];
-    if (sample < 0 || sample > HistogramBase::kSampleType_MAX - 1)
-      return false;
-    if (sample != 0)
-      has_valid_range = true;
-  }
-  return has_valid_range;
-}
-
-}  // namespace base
diff --git a/base/metrics/histogram.h b/base/metrics/histogram.h
deleted file mode 100644
index 35d8370..0000000
--- a/base/metrics/histogram.h
+++ /dev/null
@@ -1,559 +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.
-
-// Histogram is an object that aggregates statistics, and can summarize them in
-// various forms, including ASCII graphical, HTML, and numerically (as a
-// vector of numbers corresponding to each of the aggregating buckets).
-
-// It supports calls to accumulate either time intervals (which are processed
-// as integral number of milliseconds), or arbitrary integral units.
-
-// For Histogram (exponential histogram), LinearHistogram and CustomHistogram,
-// the minimum for a declared range is 1 (instead of 0), while the maximum is
-// (HistogramBase::kSampleType_MAX - 1). However, there will always be underflow
-// and overflow buckets added automatically, so a 0 bucket will always exist
-// even when a minimum value of 1 is specified.
-
-// Each use of a histogram with the same name will reference the same underlying
-// data, so it is safe to record to the same histogram from multiple locations
-// in the code. It is a runtime error if all uses of the same histogram do not
-// agree exactly in type, bucket size and range.
-
-// For Histogram and LinearHistogram, the maximum for a declared range should
-// always be larger (not equal) than minimal range. Zero and
-// HistogramBase::kSampleType_MAX are implicitly added as first and last ranges,
-// so the smallest legal bucket_count is 3. However CustomHistogram can have
-// bucket count as 2 (when you give a custom ranges vector containing only 1
-// range).
-// For these 3 kinds of histograms, the max bucket count is always
-// (Histogram::kBucketCount_MAX - 1).
-
-// The buckets layout of class Histogram is exponential. For example, buckets
-// might contain (sequentially) the count of values in the following intervals:
-// [0,1), [1,2), [2,4), [4,8), [8,16), [16,32), [32,64), [64,infinity)
-// That bucket allocation would actually result from construction of a histogram
-// for values between 1 and 64, with 8 buckets, such as:
-// Histogram count("some name", 1, 64, 8);
-// Note that the underflow bucket [0,1) and the overflow bucket [64,infinity)
-// are also counted by the constructor in the user supplied "bucket_count"
-// argument.
-// The above example has an exponential ratio of 2 (doubling the bucket width
-// in each consecutive bucket).  The Histogram class automatically calculates
-// the smallest ratio that it can use to construct the number of buckets
-// selected in the constructor.  An another example, if you had 50 buckets,
-// and millisecond time values from 1 to 10000, then the ratio between
-// consecutive bucket widths will be approximately somewhere around the 50th
-// root of 10000.  This approach provides very fine grain (narrow) buckets
-// at the low end of the histogram scale, but allows the histogram to cover a
-// gigantic range with the addition of very few buckets.
-
-// Usually we use macros to define and use a histogram, which are defined in
-// base/metrics/histogram_macros.h. Note: Callers should include that header
-// directly if they only access the histogram APIs through macros.
-//
-// Macros use a pattern involving a function static variable, that is a pointer
-// to a histogram.  This static is explicitly initialized on any thread
-// that detects a uninitialized (NULL) pointer.  The potentially racy
-// initialization is not a problem as it is always set to point to the same
-// value (i.e., the FactoryGet always returns the same value).  FactoryGet
-// is also completely thread safe, which results in a completely thread safe,
-// and relatively fast, set of counters.  To avoid races at shutdown, the static
-// pointer is NOT deleted, and we leak the histograms at process termination.
-
-#ifndef BASE_METRICS_HISTOGRAM_H_
-#define BASE_METRICS_HISTOGRAM_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-#include <map>
-#include <memory>
-#include <string>
-#include <vector>
-
-#include "base/base_export.h"
-#include "base/compiler_specific.h"
-#include "base/containers/span.h"
-#include "base/gtest_prod_util.h"
-#include "base/logging.h"
-#include "base/macros.h"
-#include "base/metrics/bucket_ranges.h"
-#include "base/metrics/histogram_base.h"
-#include "base/metrics/histogram_samples.h"
-#include "base/strings/string_piece.h"
-#include "base/time/time.h"
-
-namespace base {
-
-class BooleanHistogram;
-class CustomHistogram;
-class DelayedPersistentAllocation;
-class Histogram;
-class LinearHistogram;
-class Pickle;
-class PickleIterator;
-class SampleVector;
-class SampleVectorBase;
-
-class BASE_EXPORT Histogram : public HistogramBase {
- public:
-  // Initialize maximum number of buckets in histograms as 16,384.
-  static const uint32_t kBucketCount_MAX;
-
-  typedef std::vector<Count> Counts;
-
-  ~Histogram() override;
-
-  //----------------------------------------------------------------------------
-  // For a valid histogram, input should follow these restrictions:
-  // minimum > 0 (if a minimum below 1 is specified, it will implicitly be
-  //              normalized up to 1)
-  // maximum > minimum
-  // buckets > 2 [minimum buckets needed: underflow, overflow and the range]
-  // Additionally,
-  // buckets <= (maximum - minimum + 2) - this is to ensure that we don't have
-  // more buckets than the range of numbers; having more buckets than 1 per
-  // value in the range would be nonsensical.
-  static HistogramBase* FactoryGet(const std::string& name,
-                                   Sample minimum,
-                                   Sample maximum,
-                                   uint32_t bucket_count,
-                                   int32_t flags);
-  static HistogramBase* FactoryTimeGet(const std::string& name,
-                                       base::TimeDelta minimum,
-                                       base::TimeDelta maximum,
-                                       uint32_t bucket_count,
-                                       int32_t flags);
-  static HistogramBase* FactoryMicrosecondsTimeGet(const std::string& name,
-                                                   base::TimeDelta minimum,
-                                                   base::TimeDelta maximum,
-                                                   uint32_t bucket_count,
-                                                   int32_t flags);
-
-  // Overloads of the above functions that take a const char* |name| param, to
-  // avoid code bloat from the std::string constructor being inlined into call
-  // sites.
-  static HistogramBase* FactoryGet(const char* name,
-                                   Sample minimum,
-                                   Sample maximum,
-                                   uint32_t bucket_count,
-                                   int32_t flags);
-  static HistogramBase* FactoryTimeGet(const char* name,
-                                       base::TimeDelta minimum,
-                                       base::TimeDelta maximum,
-                                       uint32_t bucket_count,
-                                       int32_t flags);
-  static HistogramBase* FactoryMicrosecondsTimeGet(const char* name,
-                                                   base::TimeDelta minimum,
-                                                   base::TimeDelta maximum,
-                                                   uint32_t bucket_count,
-                                                   int32_t flags);
-
-  // Create a histogram using data in persistent storage.
-  static std::unique_ptr<HistogramBase> PersistentCreate(
-      const char* name,
-      Sample minimum,
-      Sample maximum,
-      const BucketRanges* ranges,
-      const DelayedPersistentAllocation& counts,
-      const DelayedPersistentAllocation& logged_counts,
-      HistogramSamples::Metadata* meta,
-      HistogramSamples::Metadata* logged_meta);
-
-  static void InitializeBucketRanges(Sample minimum,
-                                     Sample maximum,
-                                     BucketRanges* ranges);
-
-  // This constant if for FindCorruption. Since snapshots of histograms are
-  // taken asynchronously relative to sampling, and our counting code currently
-  // does not prevent race conditions, it is pretty likely that we'll catch a
-  // redundant count that doesn't match the sample count.  We allow for a
-  // certain amount of slop before flagging this as an inconsistency. Even with
-  // an inconsistency, we'll snapshot it again (for UMA in about a half hour),
-  // so we'll eventually get the data, if it was not the result of a corruption.
-  static const int kCommonRaceBasedCountMismatch;
-
-  // Check to see if bucket ranges, counts and tallies in the snapshot are
-  // consistent with the bucket ranges and checksums in our histogram.  This can
-  // produce a false-alarm if a race occurred in the reading of the data during
-  // a SnapShot process, but should otherwise be false at all times (unless we
-  // have memory over-writes, or DRAM failures). Flag definitions are located
-  // under "enum Inconsistency" in base/metrics/histogram_base.h.
-  uint32_t FindCorruption(const HistogramSamples& samples) const override;
-
-  //----------------------------------------------------------------------------
-  // Accessors for factory construction, serialization and testing.
-  //----------------------------------------------------------------------------
-  const BucketRanges* bucket_ranges() const;
-  Sample declared_min() const;
-  Sample declared_max() const;
-  virtual Sample ranges(uint32_t i) const;
-  virtual uint32_t bucket_count() const;
-
-  // This function validates histogram construction arguments. It returns false
-  // if some of the arguments are bad but also corrects them so they should
-  // function on non-dcheck builds without crashing.
-  // Note. Currently it allow some bad input, e.g. 0 as minimum, but silently
-  // converts it to good input: 1.
-  // TODO(bcwhite): Use false returns to create "sink" histograms so that bad
-  // data doesn't create confusion on the servers.
-  static bool InspectConstructionArguments(StringPiece name,
-                                           Sample* minimum,
-                                           Sample* maximum,
-                                           uint32_t* bucket_count);
-
-  // HistogramBase implementation:
-  uint64_t name_hash() const override;
-  HistogramType GetHistogramType() const override;
-  bool HasConstructionArguments(Sample expected_minimum,
-                                Sample expected_maximum,
-                                uint32_t expected_bucket_count) const override;
-  void Add(Sample value) override;
-  void AddCount(Sample value, int count) override;
-  std::unique_ptr<HistogramSamples> SnapshotSamples() const override;
-  std::unique_ptr<HistogramSamples> SnapshotDelta() override;
-  std::unique_ptr<HistogramSamples> SnapshotFinalDelta() const override;
-  void AddSamples(const HistogramSamples& samples) override;
-  bool AddSamplesFromPickle(base::PickleIterator* iter) override;
-  void WriteHTMLGraph(std::string* output) const override;
-  void WriteAscii(std::string* output) const override;
-
-  // Validates the histogram contents and CHECKs on errors.
-  // TODO(bcwhite): Remove this after https://crbug/836875.
-  void ValidateHistogramContents() const override;
-
- protected:
-  // This class, defined entirely within the .cc file, contains all the
-  // common logic for building a Histogram and can be overridden by more
-  // specific types to alter details of how the creation is done. It is
-  // defined as an embedded class (rather than an anonymous one) so it
-  // can access the protected constructors.
-  class Factory;
-
-  // |ranges| should contain the underflow and overflow buckets. See top
-  // comments for example.
-  Histogram(const char* name,
-            Sample minimum,
-            Sample maximum,
-            const BucketRanges* ranges);
-
-  // Traditionally, histograms allocate their own memory for the bucket
-  // vector but "shared" histograms use memory regions allocated from a
-  // special memory segment that is passed in here.  It is assumed that
-  // the life of this memory is managed externally and exceeds the lifetime
-  // of this object. Practically, this memory is never released until the
-  // process exits and the OS cleans it up.
-  Histogram(const char* name,
-            Sample minimum,
-            Sample maximum,
-            const BucketRanges* ranges,
-            const DelayedPersistentAllocation& counts,
-            const DelayedPersistentAllocation& logged_counts,
-            HistogramSamples::Metadata* meta,
-            HistogramSamples::Metadata* logged_meta);
-
-  // HistogramBase implementation:
-  void SerializeInfoImpl(base::Pickle* pickle) const override;
-
-  // Method to override to skip the display of the i'th bucket if it's empty.
-  virtual bool PrintEmptyBucket(uint32_t index) const;
-
-  // Get normalized size, relative to the ranges(i).
-  virtual double GetBucketSize(Count current, uint32_t i) const;
-
-  // Return a string description of what goes in a given bucket.
-  // Most commonly this is the numeric value, but in derived classes it may
-  // be a name (or string description) given to the bucket.
-  virtual const std::string GetAsciiBucketRange(uint32_t it) const;
-
- private:
-  // Allow tests to corrupt our innards for testing purposes.
-  FRIEND_TEST_ALL_PREFIXES(HistogramTest, BoundsTest);
-  FRIEND_TEST_ALL_PREFIXES(HistogramTest, BucketPlacementTest);
-  FRIEND_TEST_ALL_PREFIXES(HistogramTest, CorruptSampleCounts);
-
-  friend class StatisticsRecorder;  // To allow it to delete duplicates.
-  friend class StatisticsRecorderTest;
-
-  friend BASE_EXPORT HistogramBase* DeserializeHistogramInfo(
-      base::PickleIterator* iter);
-  static HistogramBase* DeserializeInfoImpl(base::PickleIterator* iter);
-
-  // Create a snapshot containing all samples (both logged and unlogged).
-  // Implementation of SnapshotSamples method with a more specific type for
-  // internal use.
-  std::unique_ptr<SampleVector> SnapshotAllSamples() const;
-
-  // Create a copy of unlogged samples.
-  std::unique_ptr<SampleVector> SnapshotUnloggedSamples() const;
-
-  //----------------------------------------------------------------------------
-  // Helpers for emitting Ascii graphic.  Each method appends data to output.
-
-  void WriteAsciiImpl(bool graph_it,
-                      const std::string& newline,
-                      std::string* output) const;
-
-  // Find out how large (graphically) the largest bucket will appear to be.
-  double GetPeakBucketSize(const SampleVectorBase& samples) const;
-
-  // Write a common header message describing this histogram.
-  void WriteAsciiHeader(const SampleVectorBase& samples,
-                        Count sample_count,
-                        std::string* output) const;
-
-  // Write information about previous, current, and next buckets.
-  // Information such as cumulative percentage, etc.
-  void WriteAsciiBucketContext(const int64_t past,
-                               const Count current,
-                               const int64_t remaining,
-                               const uint32_t i,
-                               std::string* output) const;
-
-  // WriteJSON calls these.
-  void GetParameters(DictionaryValue* params) const override;
-
-  void GetCountAndBucketData(Count* count,
-                             int64_t* sum,
-                             ListValue* buckets) const override;
-
-  // Samples that have not yet been logged with SnapshotDelta().
-  std::unique_ptr<SampleVectorBase> unlogged_samples_;
-
-  // Accumulation of all samples that have been logged with SnapshotDelta().
-  std::unique_ptr<SampleVectorBase> logged_samples_;
-
-#if DCHECK_IS_ON()  // Don't waste memory if it won't be used.
-  // Flag to indicate if PrepareFinalDelta has been previously called. It is
-  // used to DCHECK that a final delta is not created multiple times.
-  mutable bool final_delta_created_ = false;
-#endif
-
-  DISALLOW_COPY_AND_ASSIGN(Histogram);
-};
-
-//------------------------------------------------------------------------------
-
-// LinearHistogram is a more traditional histogram, with evenly spaced
-// buckets.
-class BASE_EXPORT LinearHistogram : public Histogram {
- public:
-  ~LinearHistogram() override;
-
-  /* minimum should start from 1. 0 is as minimum is invalid. 0 is an implicit
-     default underflow bucket. */
-  static HistogramBase* FactoryGet(const std::string& name,
-                                   Sample minimum,
-                                   Sample maximum,
-                                   uint32_t bucket_count,
-                                   int32_t flags);
-  static HistogramBase* FactoryTimeGet(const std::string& name,
-                                       TimeDelta minimum,
-                                       TimeDelta maximum,
-                                       uint32_t bucket_count,
-                                       int32_t flags);
-
-  // Overloads of the above two functions that take a const char* |name| param,
-  // to avoid code bloat from the std::string constructor being inlined into
-  // call sites.
-  static HistogramBase* FactoryGet(const char* name,
-                                   Sample minimum,
-                                   Sample maximum,
-                                   uint32_t bucket_count,
-                                   int32_t flags);
-  static HistogramBase* FactoryTimeGet(const char* name,
-                                       TimeDelta minimum,
-                                       TimeDelta maximum,
-                                       uint32_t bucket_count,
-                                       int32_t flags);
-
-  // Create a histogram using data in persistent storage.
-  static std::unique_ptr<HistogramBase> PersistentCreate(
-      const char* name,
-      Sample minimum,
-      Sample maximum,
-      const BucketRanges* ranges,
-      const DelayedPersistentAllocation& counts,
-      const DelayedPersistentAllocation& logged_counts,
-      HistogramSamples::Metadata* meta,
-      HistogramSamples::Metadata* logged_meta);
-
-  struct DescriptionPair {
-    Sample sample;
-    const char* description;  // Null means end of a list of pairs.
-  };
-
-  // Create a LinearHistogram and store a list of number/text values for use in
-  // writing the histogram graph.
-  // |descriptions| can be NULL, which means no special descriptions to set. If
-  // it's not NULL, the last element in the array must has a NULL in its
-  // "description" field.
-  static HistogramBase* FactoryGetWithRangeDescription(
-      const std::string& name,
-      Sample minimum,
-      Sample maximum,
-      uint32_t bucket_count,
-      int32_t flags,
-      const DescriptionPair descriptions[]);
-
-  static void InitializeBucketRanges(Sample minimum,
-                                     Sample maximum,
-                                     BucketRanges* ranges);
-
-  // Overridden from Histogram:
-  HistogramType GetHistogramType() const override;
-
- protected:
-  class Factory;
-
-  LinearHistogram(const char* name,
-                  Sample minimum,
-                  Sample maximum,
-                  const BucketRanges* ranges);
-
-  LinearHistogram(const char* name,
-                  Sample minimum,
-                  Sample maximum,
-                  const BucketRanges* ranges,
-                  const DelayedPersistentAllocation& counts,
-                  const DelayedPersistentAllocation& logged_counts,
-                  HistogramSamples::Metadata* meta,
-                  HistogramSamples::Metadata* logged_meta);
-
-  double GetBucketSize(Count current, uint32_t i) const override;
-
-  // If we have a description for a bucket, then return that.  Otherwise
-  // let parent class provide a (numeric) description.
-  const std::string GetAsciiBucketRange(uint32_t i) const override;
-
-  // Skip printing of name for numeric range if we have a name (and if this is
-  // an empty bucket).
-  bool PrintEmptyBucket(uint32_t index) const override;
-
- private:
-  friend BASE_EXPORT HistogramBase* DeserializeHistogramInfo(
-      base::PickleIterator* iter);
-  static HistogramBase* DeserializeInfoImpl(base::PickleIterator* iter);
-
-  // For some ranges, we store a printable description of a bucket range.
-  // If there is no description, then GetAsciiBucketRange() uses parent class
-  // to provide a description.
-  typedef std::map<Sample, std::string> BucketDescriptionMap;
-  BucketDescriptionMap bucket_description_;
-
-  DISALLOW_COPY_AND_ASSIGN(LinearHistogram);
-};
-
-//------------------------------------------------------------------------------
-
-// BooleanHistogram is a histogram for booleans.
-class BASE_EXPORT BooleanHistogram : public LinearHistogram {
- public:
-  static HistogramBase* FactoryGet(const std::string& name, int32_t flags);
-
-  // Overload of the above function that takes a const char* |name| param,
-  // to avoid code bloat from the std::string constructor being inlined into
-  // call sites.
-  static HistogramBase* FactoryGet(const char* name, int32_t flags);
-
-  // Create a histogram using data in persistent storage.
-  static std::unique_ptr<HistogramBase> PersistentCreate(
-      const char* name,
-      const BucketRanges* ranges,
-      const DelayedPersistentAllocation& counts,
-      const DelayedPersistentAllocation& logged_counts,
-      HistogramSamples::Metadata* meta,
-      HistogramSamples::Metadata* logged_meta);
-
-  HistogramType GetHistogramType() const override;
-
- protected:
-  class Factory;
-
- private:
-  BooleanHistogram(const char* name, const BucketRanges* ranges);
-  BooleanHistogram(const char* name,
-                   const BucketRanges* ranges,
-                   const DelayedPersistentAllocation& counts,
-                   const DelayedPersistentAllocation& logged_counts,
-                   HistogramSamples::Metadata* meta,
-                   HistogramSamples::Metadata* logged_meta);
-
-  friend BASE_EXPORT HistogramBase* DeserializeHistogramInfo(
-      base::PickleIterator* iter);
-  static HistogramBase* DeserializeInfoImpl(base::PickleIterator* iter);
-
-  DISALLOW_COPY_AND_ASSIGN(BooleanHistogram);
-};
-
-//------------------------------------------------------------------------------
-
-// CustomHistogram is a histogram for a set of custom integers.
-class BASE_EXPORT CustomHistogram : public Histogram {
- public:
-  // |custom_ranges| contains a vector of limits on ranges. Each limit should be
-  // > 0 and < kSampleType_MAX. (Currently 0 is still accepted for backward
-  // compatibility). The limits can be unordered or contain duplication, but
-  // client should not depend on this.
-  static HistogramBase* FactoryGet(const std::string& name,
-                                   const std::vector<Sample>& custom_ranges,
-                                   int32_t flags);
-
-  // Overload of the above function that takes a const char* |name| param,
-  // to avoid code bloat from the std::string constructor being inlined into
-  // call sites.
-  static HistogramBase* FactoryGet(const char* name,
-                                   const std::vector<Sample>& custom_ranges,
-                                   int32_t flags);
-
-  // Create a histogram using data in persistent storage.
-  static std::unique_ptr<HistogramBase> PersistentCreate(
-      const char* name,
-      const BucketRanges* ranges,
-      const DelayedPersistentAllocation& counts,
-      const DelayedPersistentAllocation& logged_counts,
-      HistogramSamples::Metadata* meta,
-      HistogramSamples::Metadata* logged_meta);
-
-  // Overridden from Histogram:
-  HistogramType GetHistogramType() const override;
-
-  // Helper method for transforming an array of valid enumeration values
-  // to the std::vector<int> expected by UMA_HISTOGRAM_CUSTOM_ENUMERATION.
-  // This function ensures that a guard bucket exists right after any
-  // valid sample value (unless the next higher sample is also a valid value),
-  // so that invalid samples never fall into the same bucket as valid samples.
-  static std::vector<Sample> ArrayToCustomEnumRanges(
-      base::span<const Sample> values);
-
- protected:
-  class Factory;
-
-  CustomHistogram(const char* name, const BucketRanges* ranges);
-
-  CustomHistogram(const char* name,
-                  const BucketRanges* ranges,
-                  const DelayedPersistentAllocation& counts,
-                  const DelayedPersistentAllocation& logged_counts,
-                  HistogramSamples::Metadata* meta,
-                  HistogramSamples::Metadata* logged_meta);
-
-  // HistogramBase implementation:
-  void SerializeInfoImpl(base::Pickle* pickle) const override;
-
-  double GetBucketSize(Count current, uint32_t i) const override;
-
- private:
-  friend BASE_EXPORT HistogramBase* DeserializeHistogramInfo(
-      base::PickleIterator* iter);
-  static HistogramBase* DeserializeInfoImpl(base::PickleIterator* iter);
-
-  static bool ValidateCustomRanges(const std::vector<Sample>& custom_ranges);
-
-  DISALLOW_COPY_AND_ASSIGN(CustomHistogram);
-};
-
-}  // namespace base
-
-#endif  // BASE_METRICS_HISTOGRAM_H_
diff --git a/base/metrics/histogram_base.cc b/base/metrics/histogram_base.cc
deleted file mode 100644
index da3ae93..0000000
--- a/base/metrics/histogram_base.cc
+++ /dev/null
@@ -1,214 +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/metrics/histogram_base.h"
-
-#include <limits.h>
-
-#include <memory>
-#include <set>
-#include <utility>
-
-#include "base/json/json_string_value_serializer.h"
-#include "base/lazy_instance.h"
-#include "base/logging.h"
-#include "base/metrics/histogram.h"
-#include "base/metrics/histogram_macros.h"
-#include "base/metrics/histogram_samples.h"
-#include "base/metrics/sparse_histogram.h"
-#include "base/metrics/statistics_recorder.h"
-#include "base/pickle.h"
-#include "base/process/process_handle.h"
-#include "base/rand_util.h"
-#include "base/strings/stringprintf.h"
-#include "base/synchronization/lock.h"
-#include "base/values.h"
-
-namespace base {
-
-std::string HistogramTypeToString(HistogramType type) {
-  switch (type) {
-    case HISTOGRAM:
-      return "HISTOGRAM";
-    case LINEAR_HISTOGRAM:
-      return "LINEAR_HISTOGRAM";
-    case BOOLEAN_HISTOGRAM:
-      return "BOOLEAN_HISTOGRAM";
-    case CUSTOM_HISTOGRAM:
-      return "CUSTOM_HISTOGRAM";
-    case SPARSE_HISTOGRAM:
-      return "SPARSE_HISTOGRAM";
-    case DUMMY_HISTOGRAM:
-      return "DUMMY_HISTOGRAM";
-  }
-  NOTREACHED();
-  return "UNKNOWN";
-}
-
-HistogramBase* DeserializeHistogramInfo(PickleIterator* iter) {
-  int type;
-  if (!iter->ReadInt(&type))
-    return nullptr;
-
-  switch (type) {
-    case HISTOGRAM:
-      return Histogram::DeserializeInfoImpl(iter);
-    case LINEAR_HISTOGRAM:
-      return LinearHistogram::DeserializeInfoImpl(iter);
-    case BOOLEAN_HISTOGRAM:
-      return BooleanHistogram::DeserializeInfoImpl(iter);
-    case CUSTOM_HISTOGRAM:
-      return CustomHistogram::DeserializeInfoImpl(iter);
-    case SPARSE_HISTOGRAM:
-      return SparseHistogram::DeserializeInfoImpl(iter);
-    default:
-      return nullptr;
-  }
-}
-
-const HistogramBase::Sample HistogramBase::kSampleType_MAX = INT_MAX;
-
-HistogramBase::HistogramBase(const char* name)
-    : histogram_name_(name), flags_(kNoFlags) {}
-
-HistogramBase::~HistogramBase() = default;
-
-void HistogramBase::CheckName(const StringPiece& name) const {
-  DCHECK_EQ(StringPiece(histogram_name()), name);
-}
-
-void HistogramBase::SetFlags(int32_t flags) {
-  HistogramBase::Count old_flags = subtle::NoBarrier_Load(&flags_);
-  subtle::NoBarrier_Store(&flags_, old_flags | flags);
-}
-
-void HistogramBase::ClearFlags(int32_t flags) {
-  HistogramBase::Count old_flags = subtle::NoBarrier_Load(&flags_);
-  subtle::NoBarrier_Store(&flags_, old_flags & ~flags);
-}
-
-void HistogramBase::AddScaled(Sample value, int count, int scale) {
-  DCHECK_LT(0, scale);
-
-  // Convert raw count and probabilistically round up/down if the remainder
-  // is more than a random number [0, scale). This gives a more accurate
-  // count when there are a large number of records. RandInt is "inclusive",
-  // hence the -1 for the max value.
-  int64_t count_scaled = count / scale;
-  if (count - (count_scaled * scale) > base::RandInt(0, scale - 1))
-    count_scaled += 1;
-  if (count_scaled == 0)
-    return;
-
-  AddCount(value, count_scaled);
-}
-
-void HistogramBase::AddKilo(Sample value, int count) {
-  AddScaled(value, count, 1000);
-}
-
-void HistogramBase::AddKiB(Sample value, int count) {
-  AddScaled(value, count, 1024);
-}
-
-void HistogramBase::AddTimeMillisecondsGranularity(const TimeDelta& time) {
-  Add(static_cast<Sample>(time.InMilliseconds()));
-}
-
-void HistogramBase::AddTimeMicrosecondsGranularity(const TimeDelta& time) {
-  // Intentionally drop high-resolution reports on clients with low-resolution
-  // clocks. High-resolution metrics cannot make use of low-resolution data and
-  // reporting it merely adds noise to the metric. https://crbug.com/807615#c16
-  if (TimeTicks::IsHighResolution())
-    Add(static_cast<Sample>(time.InMicroseconds()));
-}
-
-void HistogramBase::AddBoolean(bool value) {
-  Add(value ? 1 : 0);
-}
-
-void HistogramBase::SerializeInfo(Pickle* pickle) const {
-  pickle->WriteInt(GetHistogramType());
-  SerializeInfoImpl(pickle);
-}
-
-uint32_t HistogramBase::FindCorruption(const HistogramSamples& samples) const {
-  // Not supported by default.
-  return NO_INCONSISTENCIES;
-}
-
-void HistogramBase::ValidateHistogramContents() const {}
-
-void HistogramBase::WriteJSON(std::string* output,
-                              JSONVerbosityLevel verbosity_level) const {
-  Count count;
-  int64_t sum;
-  std::unique_ptr<ListValue> buckets(new ListValue());
-  GetCountAndBucketData(&count, &sum, buckets.get());
-  std::unique_ptr<DictionaryValue> parameters(new DictionaryValue());
-  GetParameters(parameters.get());
-
-  JSONStringValueSerializer serializer(output);
-  DictionaryValue root;
-  root.SetString("name", histogram_name());
-  root.SetInteger("count", count);
-  root.SetDouble("sum", static_cast<double>(sum));
-  root.SetInteger("flags", flags());
-  root.Set("params", std::move(parameters));
-  if (verbosity_level != JSON_VERBOSITY_LEVEL_OMIT_BUCKETS)
-    root.Set("buckets", std::move(buckets));
-  root.SetInteger("pid", GetUniqueIdForProcess());
-  serializer.Serialize(root);
-}
-
-void HistogramBase::FindAndRunCallback(HistogramBase::Sample sample) const {
-  if ((flags() & kCallbackExists) == 0)
-    return;
-
-  StatisticsRecorder::OnSampleCallback cb =
-      StatisticsRecorder::FindCallback(histogram_name());
-  if (!cb.is_null())
-    cb.Run(sample);
-}
-
-void HistogramBase::WriteAsciiBucketGraph(double current_size,
-                                          double max_size,
-                                          std::string* output) const {
-  const int k_line_length = 72;  // Maximal horizontal width of graph.
-  int x_count = static_cast<int>(k_line_length * (current_size / max_size)
-                                 + 0.5);
-  int x_remainder = k_line_length - x_count;
-
-  while (0 < x_count--)
-    output->append("-");
-  output->append("O");
-  while (0 < x_remainder--)
-    output->append(" ");
-}
-
-const std::string HistogramBase::GetSimpleAsciiBucketRange(
-    Sample sample) const {
-  return StringPrintf("%d", sample);
-}
-
-void HistogramBase::WriteAsciiBucketValue(Count current,
-                                          double scaled_sum,
-                                          std::string* output) const {
-  StringAppendF(output, " (%d = %3.1f%%)", current, current/scaled_sum);
-}
-
-// static
-char const* HistogramBase::GetPermanentName(const std::string& name) {
-  // A set of histogram names that provides the "permanent" lifetime required
-  // by histogram objects for those strings that are not already code constants
-  // or held in persistent memory.
-  static LazyInstance<std::set<std::string>>::Leaky permanent_names;
-  static LazyInstance<Lock>::Leaky permanent_names_lock;
-
-  AutoLock lock(permanent_names_lock.Get());
-  auto result = permanent_names.Get().insert(name);
-  return result.first->c_str();
-}
-
-}  // namespace base
diff --git a/base/metrics/histogram_base.h b/base/metrics/histogram_base.h
deleted file mode 100644
index 010dc55..0000000
--- a/base/metrics/histogram_base.h
+++ /dev/null
@@ -1,305 +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_METRICS_HISTOGRAM_BASE_H_
-#define BASE_METRICS_HISTOGRAM_BASE_H_
-
-#include <limits.h>
-#include <stddef.h>
-#include <stdint.h>
-
-#include <memory>
-#include <string>
-#include <vector>
-
-#include "base/atomicops.h"
-#include "base/base_export.h"
-#include "base/macros.h"
-#include "base/strings/string_piece.h"
-#include "base/time/time.h"
-
-namespace base {
-
-class DictionaryValue;
-class HistogramBase;
-class HistogramSamples;
-class ListValue;
-class Pickle;
-class PickleIterator;
-
-////////////////////////////////////////////////////////////////////////////////
-// This enum is used to facilitate deserialization of histograms from other
-// processes into the browser. If you create another class that inherits from
-// HistogramBase, add new histogram types and names below.
-
-enum HistogramType {
-  HISTOGRAM,
-  LINEAR_HISTOGRAM,
-  BOOLEAN_HISTOGRAM,
-  CUSTOM_HISTOGRAM,
-  SPARSE_HISTOGRAM,
-  DUMMY_HISTOGRAM,
-};
-
-// Controls the verbosity of the information when the histogram is serialized to
-// a JSON.
-// GENERATED_JAVA_ENUM_PACKAGE: org.chromium.base.metrics
-enum JSONVerbosityLevel {
-  // The histogram is completely serialized.
-  JSON_VERBOSITY_LEVEL_FULL,
-  // The bucket information is not serialized.
-  JSON_VERBOSITY_LEVEL_OMIT_BUCKETS,
-};
-
-std::string HistogramTypeToString(HistogramType type);
-
-// This enum is used for reporting how many histograms and of what types and
-// variations are being created. It has to be in the main .h file so it is
-// visible to files that define the various histogram types.
-enum HistogramReport {
-  // Count the number of reports created. The other counts divided by this
-  // number will give the average per run of the program.
-  HISTOGRAM_REPORT_CREATED = 0,
-
-  // Count the total number of histograms created. It is the limit against
-  // which all others are compared.
-  HISTOGRAM_REPORT_HISTOGRAM_CREATED = 1,
-
-  // Count the total number of histograms looked-up. It's better to cache
-  // the result of a single lookup rather than do it repeatedly.
-  HISTOGRAM_REPORT_HISTOGRAM_LOOKUP = 2,
-
-  // These count the individual histogram types. This must follow the order
-  // of HistogramType above.
-  HISTOGRAM_REPORT_TYPE_LOGARITHMIC = 3,
-  HISTOGRAM_REPORT_TYPE_LINEAR = 4,
-  HISTOGRAM_REPORT_TYPE_BOOLEAN = 5,
-  HISTOGRAM_REPORT_TYPE_CUSTOM = 6,
-  HISTOGRAM_REPORT_TYPE_SPARSE = 7,
-
-  // These indicate the individual flags that were set.
-  HISTOGRAM_REPORT_FLAG_UMA_TARGETED = 8,
-  HISTOGRAM_REPORT_FLAG_UMA_STABILITY = 9,
-  HISTOGRAM_REPORT_FLAG_PERSISTENT = 10,
-
-  // This must be last.
-  HISTOGRAM_REPORT_MAX = 11
-};
-
-// Create or find existing histogram that matches the pickled info.
-// Returns NULL if the pickled data has problems.
-BASE_EXPORT HistogramBase* DeserializeHistogramInfo(base::PickleIterator* iter);
-
-////////////////////////////////////////////////////////////////////////////////
-
-class BASE_EXPORT HistogramBase {
- public:
-  typedef int32_t Sample;                // Used for samples.
-  typedef subtle::Atomic32 AtomicCount;  // Used to count samples.
-  typedef int32_t Count;  // Used to manipulate counts in temporaries.
-
-  static const Sample kSampleType_MAX;  // INT_MAX
-
-  enum Flags {
-    kNoFlags = 0x0,
-
-    // Histogram should be UMA uploaded.
-    kUmaTargetedHistogramFlag = 0x1,
-
-    // Indicates that this is a stability histogram. This flag exists to specify
-    // which histograms should be included in the initial stability log. Please
-    // refer to |MetricsService::PrepareInitialStabilityLog|.
-    kUmaStabilityHistogramFlag = kUmaTargetedHistogramFlag | 0x2,
-
-    // Indicates that the histogram was pickled to be sent across an IPC
-    // Channel. If we observe this flag on a histogram being aggregated into
-    // after IPC, then we are running in a single process mode, and the
-    // aggregation should not take place (as we would be aggregating back into
-    // the source histogram!).
-    kIPCSerializationSourceFlag = 0x10,
-
-    // Indicates that a callback exists for when a new sample is recorded on
-    // this histogram. We store this as a flag with the histogram since
-    // histograms can be in performance critical code, and this allows us
-    // to shortcut looking up the callback if it doesn't exist.
-    kCallbackExists = 0x20,
-
-    // Indicates that the histogram is held in "persistent" memory and may
-    // be accessible between processes. This is only possible if such a
-    // memory segment has been created/attached, used to create a Persistent-
-    // MemoryAllocator, and that loaded into the Histogram module before this
-    // histogram is created.
-    kIsPersistent = 0x40,
-  };
-
-  // Histogram data inconsistency types.
-  enum Inconsistency : uint32_t {
-    NO_INCONSISTENCIES = 0x0,
-    RANGE_CHECKSUM_ERROR = 0x1,
-    BUCKET_ORDER_ERROR = 0x2,
-    COUNT_HIGH_ERROR = 0x4,
-    COUNT_LOW_ERROR = 0x8,
-
-    NEVER_EXCEEDED_VALUE = 0x10,
-  };
-
-  // Construct the base histogram. The name is not copied; it's up to the
-  // caller to ensure that it lives at least as long as this object.
-  explicit HistogramBase(const char* name);
-  virtual ~HistogramBase();
-
-  const char* histogram_name() const { return histogram_name_; }
-
-  // Compares |name| to the histogram name and triggers a DCHECK if they do not
-  // match. This is a helper function used by histogram macros, which results in
-  // in more compact machine code being generated by the macros.
-  virtual void CheckName(const StringPiece& name) const;
-
-  // Get a unique ID for this histogram's samples.
-  virtual uint64_t name_hash() const = 0;
-
-  // Operations with Flags enum.
-  int32_t flags() const { return subtle::NoBarrier_Load(&flags_); }
-  void SetFlags(int32_t flags);
-  void ClearFlags(int32_t flags);
-
-  virtual HistogramType GetHistogramType() const = 0;
-
-  // Whether the histogram has construction arguments as parameters specified.
-  // For histograms that don't have the concept of minimum, maximum or
-  // bucket_count, this function always returns false.
-  virtual bool HasConstructionArguments(
-      Sample expected_minimum,
-      Sample expected_maximum,
-      uint32_t expected_bucket_count) const = 0;
-
-  virtual void Add(Sample value) = 0;
-
-  // In Add function the |value| bucket is increased by one, but in some use
-  // cases we need to increase this value by an arbitrary integer. AddCount
-  // function increases the |value| bucket by |count|. |count| should be greater
-  // than or equal to 1.
-  virtual void AddCount(Sample value, int count) = 0;
-
-  // Similar to above but divides |count| by the |scale| amount. Probabilistic
-  // rounding is used to yield a reasonably accurate total when many samples
-  // are added. Methods for common cases of scales 1000 and 1024 are included.
-  void AddScaled(Sample value, int count, int scale);
-  void AddKilo(Sample value, int count);  // scale=1000
-  void AddKiB(Sample value, int count);   // scale=1024
-
-  // Convenient functions that call Add(Sample).
-  void AddTime(const TimeDelta& time) { AddTimeMillisecondsGranularity(time); }
-  void AddTimeMillisecondsGranularity(const TimeDelta& time);
-  // Note: AddTimeMicrosecondsGranularity() drops the report if this client
-  // doesn't have a high-resolution clock.
-  void AddTimeMicrosecondsGranularity(const TimeDelta& time);
-  void AddBoolean(bool value);
-
-  virtual void AddSamples(const HistogramSamples& samples) = 0;
-  virtual bool AddSamplesFromPickle(base::PickleIterator* iter) = 0;
-
-  // Serialize the histogram info into |pickle|.
-  // Note: This only serializes the construction arguments of the histogram, but
-  // does not serialize the samples.
-  void SerializeInfo(base::Pickle* pickle) const;
-
-  // Try to find out data corruption from histogram and the samples.
-  // The returned value is a combination of Inconsistency enum.
-  virtual uint32_t FindCorruption(const HistogramSamples& samples) const;
-
-  // Snapshot the current complete set of sample data.
-  // Override with atomic/locked snapshot if needed.
-  // NOTE: this data can overflow for long-running sessions. It should be
-  // handled with care and this method is recommended to be used only
-  // in about:histograms and test code.
-  virtual std::unique_ptr<HistogramSamples> SnapshotSamples() const = 0;
-
-  // Calculate the change (delta) in histogram counts since the previous call
-  // to this method. Each successive call will return only those counts
-  // changed since the last call.
-  virtual std::unique_ptr<HistogramSamples> SnapshotDelta() = 0;
-
-  // Calculate the change (delta) in histogram counts since the previous call
-  // to SnapshotDelta() but do so without modifying any internal data as to
-  // what was previous logged. After such a call, no further calls to this
-  // method or to SnapshotDelta() should be done as the result would include
-  // data previously returned. Because no internal data is changed, this call
-  // can be made on "const" histograms such as those with data held in
-  // read-only memory.
-  virtual std::unique_ptr<HistogramSamples> SnapshotFinalDelta() const = 0;
-
-  // The following methods provide graphical histogram displays.
-  virtual void WriteHTMLGraph(std::string* output) const = 0;
-  virtual void WriteAscii(std::string* output) const = 0;
-
-  // TODO(bcwhite): Remove this after https://crbug/836875.
-  virtual void ValidateHistogramContents() const;
-
-  // Produce a JSON representation of the histogram with |verbosity_level| as
-  // the serialization verbosity. This is implemented with the help of
-  // GetParameters and GetCountAndBucketData; overwrite them to customize the
-  // output.
-  void WriteJSON(std::string* output, JSONVerbosityLevel verbosity_level) const;
-
- protected:
-  enum ReportActivity { HISTOGRAM_CREATED, HISTOGRAM_LOOKUP };
-
-  // Subclasses should implement this function to make SerializeInfo work.
-  virtual void SerializeInfoImpl(base::Pickle* pickle) const = 0;
-
-  // Writes information about the construction parameters in |params|.
-  virtual void GetParameters(DictionaryValue* params) const = 0;
-
-  // Writes information about the current (non-empty) buckets and their sample
-  // counts to |buckets|, the total sample count to |count| and the total sum
-  // to |sum|.
-  virtual void GetCountAndBucketData(Count* count,
-                                     int64_t* sum,
-                                     ListValue* buckets) const = 0;
-
-  //// Produce actual graph (set of blank vs non blank char's) for a bucket.
-  void WriteAsciiBucketGraph(double current_size,
-                             double max_size,
-                             std::string* output) const;
-
-  // Return a string description of what goes in a given bucket.
-  const std::string GetSimpleAsciiBucketRange(Sample sample) const;
-
-  // Write textual description of the bucket contents (relative to histogram).
-  // Output is the count in the buckets, as well as the percentage.
-  void WriteAsciiBucketValue(Count current,
-                             double scaled_sum,
-                             std::string* output) const;
-
-  // Retrieves the callback for this histogram, if one exists, and runs it
-  // passing |sample| as the parameter.
-  void FindAndRunCallback(Sample sample) const;
-
-  // Gets a permanent string that can be used for histogram objects when the
-  // original is not a code constant or held in persistent memory.
-  static const char* GetPermanentName(const std::string& name);
-
- private:
-  friend class HistogramBaseTest;
-
-  // A pointer to permanent storage where the histogram name is held. This can
-  // be code space or the output of GetPermanentName() or any other storage
-  // that is known to never change. This is not StringPiece because (a) char*
-  // is 1/2 the size and (b) StringPiece transparently casts from std::string
-  // which can easily lead to a pointer to non-permanent space.
-  // For persistent histograms, this will simply point into the persistent
-  // memory segment, thus avoiding duplication. For heap histograms, the
-  // GetPermanentName method will create the necessary copy.
-  const char* const histogram_name_;
-
-  // Additional information about the histogram.
-  AtomicCount flags_;
-
-  DISALLOW_COPY_AND_ASSIGN(HistogramBase);
-};
-
-}  // namespace base
-
-#endif  // BASE_METRICS_HISTOGRAM_BASE_H_
diff --git a/base/metrics/histogram_delta_serialization.cc b/base/metrics/histogram_delta_serialization.cc
deleted file mode 100644
index a74b87f..0000000
--- a/base/metrics/histogram_delta_serialization.cc
+++ /dev/null
@@ -1,81 +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/metrics/histogram_delta_serialization.h"
-
-#include "base/logging.h"
-#include "base/metrics/histogram_base.h"
-#include "base/metrics/histogram_snapshot_manager.h"
-#include "base/metrics/statistics_recorder.h"
-#include "base/numerics/safe_conversions.h"
-#include "base/pickle.h"
-#include "base/values.h"
-
-namespace base {
-
-namespace {
-
-// Create or find existing histogram and add the samples from pickle.
-// Silently returns when seeing any data problem in the pickle.
-void DeserializeHistogramAndAddSamples(PickleIterator* iter) {
-  HistogramBase* histogram = DeserializeHistogramInfo(iter);
-  if (!histogram)
-    return;
-
-  if (histogram->flags() & HistogramBase::kIPCSerializationSourceFlag) {
-    DVLOG(1) << "Single process mode, histogram observed and not copied: "
-             << histogram->histogram_name();
-    return;
-  }
-  histogram->AddSamplesFromPickle(iter);
-}
-
-}  // namespace
-
-HistogramDeltaSerialization::HistogramDeltaSerialization(
-    const std::string& caller_name)
-    : histogram_snapshot_manager_(this), serialized_deltas_(nullptr) {}
-
-HistogramDeltaSerialization::~HistogramDeltaSerialization() = default;
-
-void HistogramDeltaSerialization::PrepareAndSerializeDeltas(
-    std::vector<std::string>* serialized_deltas,
-    bool include_persistent) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-
-  serialized_deltas_ = serialized_deltas;
-  // Note: Before serializing, we set the kIPCSerializationSourceFlag for all
-  // the histograms, so that the receiving process can distinguish them from the
-  // local histograms.
-  StatisticsRecorder::PrepareDeltas(
-      include_persistent, Histogram::kIPCSerializationSourceFlag,
-      Histogram::kNoFlags, &histogram_snapshot_manager_);
-  serialized_deltas_ = nullptr;
-}
-
-// static
-void HistogramDeltaSerialization::DeserializeAndAddSamples(
-    const std::vector<std::string>& serialized_deltas) {
-  for (std::vector<std::string>::const_iterator it = serialized_deltas.begin();
-       it != serialized_deltas.end(); ++it) {
-    Pickle pickle(it->data(), checked_cast<int>(it->size()));
-    PickleIterator iter(pickle);
-    DeserializeHistogramAndAddSamples(&iter);
-  }
-}
-
-void HistogramDeltaSerialization::RecordDelta(
-    const HistogramBase& histogram,
-    const HistogramSamples& snapshot) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  DCHECK_NE(0, snapshot.TotalCount());
-
-  Pickle pickle;
-  histogram.SerializeInfo(&pickle);
-  snapshot.Serialize(&pickle);
-  serialized_deltas_->push_back(
-      std::string(static_cast<const char*>(pickle.data()), pickle.size()));
-}
-
-}  // namespace base
diff --git a/base/metrics/histogram_delta_serialization.h b/base/metrics/histogram_delta_serialization.h
deleted file mode 100644
index 57ebd2c..0000000
--- a/base/metrics/histogram_delta_serialization.h
+++ /dev/null
@@ -1,61 +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_METRICS_HISTOGRAM_DELTA_SERIALIZATION_H_
-#define BASE_METRICS_HISTOGRAM_DELTA_SERIALIZATION_H_
-
-#include <memory>
-#include <string>
-#include <vector>
-
-#include "base/base_export.h"
-#include "base/macros.h"
-#include "base/metrics/histogram_flattener.h"
-#include "base/metrics/histogram_snapshot_manager.h"
-#include "base/threading/thread_checker.h"
-
-namespace base {
-
-class HistogramBase;
-
-// Serializes and restores histograms deltas.
-class BASE_EXPORT HistogramDeltaSerialization : public HistogramFlattener {
- public:
-  // |caller_name| is string used in histograms for counting inconsistencies.
-  explicit HistogramDeltaSerialization(const std::string& caller_name);
-  ~HistogramDeltaSerialization() override;
-
-  // Computes deltas in histogram bucket counts relative to the previous call to
-  // this method. Stores the deltas in serialized form into |serialized_deltas|.
-  // If |serialized_deltas| is null, no data is serialized, though the next call
-  // will compute the deltas relative to this one. Setting |include_persistent|
-  // will include histograms held in persistent memory (and thus may be reported
-  // elsewhere); otherwise only histograms local to this process are serialized.
-  void PrepareAndSerializeDeltas(std::vector<std::string>* serialized_deltas,
-                                 bool include_persistent);
-
-  // Deserialize deltas and add samples to corresponding histograms, creating
-  // them if necessary. Silently ignores errors in |serialized_deltas|.
-  static void DeserializeAndAddSamples(
-      const std::vector<std::string>& serialized_deltas);
-
- private:
-  // HistogramFlattener implementation.
-  void RecordDelta(const HistogramBase& histogram,
-                   const HistogramSamples& snapshot) override;
-
-  ThreadChecker thread_checker_;
-
-  // Calculates deltas in histogram counters.
-  HistogramSnapshotManager histogram_snapshot_manager_;
-
-  // Output buffer for serialized deltas.
-  std::vector<std::string>* serialized_deltas_;
-
-  DISALLOW_COPY_AND_ASSIGN(HistogramDeltaSerialization);
-};
-
-}  // namespace base
-
-#endif  // BASE_METRICS_HISTOGRAM_DELTA_SERIALIZATION_H_
diff --git a/base/metrics/histogram_flattener.h b/base/metrics/histogram_flattener.h
deleted file mode 100644
index 6a5e3f4..0000000
--- a/base/metrics/histogram_flattener.h
+++ /dev/null
@@ -1,35 +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_METRICS_HISTOGRAM_FLATTENER_H_
-#define BASE_METRICS_HISTOGRAM_FLATTENER_H_
-
-#include <map>
-#include <string>
-
-#include "base/macros.h"
-#include "base/metrics/histogram.h"
-
-namespace base {
-
-class HistogramSamples;
-
-// HistogramFlattener is an interface used by HistogramSnapshotManager, which
-// handles the logistics of gathering up available histograms for recording.
-class BASE_EXPORT HistogramFlattener {
- public:
-  virtual void RecordDelta(const HistogramBase& histogram,
-                           const HistogramSamples& snapshot) = 0;
-
- protected:
-  HistogramFlattener() = default;
-  virtual ~HistogramFlattener() = default;
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(HistogramFlattener);
-};
-
-}  // namespace base
-
-#endif  // BASE_METRICS_HISTOGRAM_FLATTENER_H_
diff --git a/base/metrics/histogram_functions.cc b/base/metrics/histogram_functions.cc
deleted file mode 100644
index 31bf219..0000000
--- a/base/metrics/histogram_functions.cc
+++ /dev/null
@@ -1,110 +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/metrics/histogram_functions.h"
-
-#include "base/metrics/histogram.h"
-#include "base/metrics/histogram_base.h"
-#include "base/metrics/sparse_histogram.h"
-#include "base/time/time.h"
-
-namespace base {
-
-void UmaHistogramBoolean(const std::string& name, bool sample) {
-  HistogramBase* histogram = BooleanHistogram::FactoryGet(
-      name, HistogramBase::kUmaTargetedHistogramFlag);
-  histogram->Add(sample);
-}
-
-void UmaHistogramExactLinear(const std::string& name,
-                             int sample,
-                             int value_max) {
-  HistogramBase* histogram =
-      LinearHistogram::FactoryGet(name, 1, value_max, value_max + 1,
-                                  HistogramBase::kUmaTargetedHistogramFlag);
-  histogram->Add(sample);
-}
-
-void UmaHistogramPercentage(const std::string& name, int percent) {
-  UmaHistogramExactLinear(name, percent, 100);
-}
-
-void UmaHistogramCustomCounts(const std::string& name,
-                              int sample,
-                              int min,
-                              int max,
-                              int buckets) {
-  HistogramBase* histogram = Histogram::FactoryGet(
-      name, min, max, buckets, HistogramBase::kUmaTargetedHistogramFlag);
-  histogram->Add(sample);
-}
-
-void UmaHistogramCounts100(const std::string& name, int sample) {
-  UmaHistogramCustomCounts(name, sample, 1, 100, 50);
-}
-
-void UmaHistogramCounts1000(const std::string& name, int sample) {
-  UmaHistogramCustomCounts(name, sample, 1, 1000, 50);
-}
-
-void UmaHistogramCounts10000(const std::string& name, int sample) {
-  UmaHistogramCustomCounts(name, sample, 1, 10000, 50);
-}
-
-void UmaHistogramCounts100000(const std::string& name, int sample) {
-  UmaHistogramCustomCounts(name, sample, 1, 100000, 50);
-}
-
-void UmaHistogramCounts1M(const std::string& name, int sample) {
-  UmaHistogramCustomCounts(name, sample, 1, 1000000, 50);
-}
-
-void UmaHistogramCounts10M(const std::string& name, int sample) {
-  UmaHistogramCustomCounts(name, sample, 1, 10000000, 50);
-}
-
-void UmaHistogramCustomTimes(const std::string& name,
-                             TimeDelta sample,
-                             TimeDelta min,
-                             TimeDelta max,
-                             int buckets) {
-  HistogramBase* histogram = Histogram::FactoryTimeGet(
-      name, min, max, buckets, HistogramBase::kUmaTargetedHistogramFlag);
-  histogram->AddTimeMillisecondsGranularity(sample);
-}
-
-void UmaHistogramTimes(const std::string& name, TimeDelta sample) {
-  UmaHistogramCustomTimes(name, sample, TimeDelta::FromMilliseconds(1),
-                          TimeDelta::FromSeconds(10), 50);
-}
-
-void UmaHistogramMediumTimes(const std::string& name, TimeDelta sample) {
-  UmaHistogramCustomTimes(name, sample, TimeDelta::FromMilliseconds(1),
-                          TimeDelta::FromMinutes(3), 50);
-}
-
-void UmaHistogramLongTimes(const std::string& name, TimeDelta sample) {
-  UmaHistogramCustomTimes(name, sample, TimeDelta::FromMilliseconds(1),
-                          TimeDelta::FromHours(1), 50);
-}
-
-void UmaHistogramMemoryKB(const std::string& name, int sample) {
-  UmaHistogramCustomCounts(name, sample, 1000, 500000, 50);
-}
-
-void UmaHistogramMemoryMB(const std::string& name, int sample) {
-  UmaHistogramCustomCounts(name, sample, 1, 1000, 50);
-}
-
-void UmaHistogramMemoryLargeMB(const std::string& name, int sample) {
-  UmaHistogramCustomCounts(name, sample, 1, 64000, 100);
-}
-
-void UmaHistogramSparse(const std::string& name, int sample) {
-  HistogramBase* histogram = SparseHistogram::FactoryGet(
-      name, HistogramBase::kUmaTargetedHistogramFlag);
-  histogram->Add(sample);
-}
-
-}  // namespace base
diff --git a/base/metrics/histogram_functions.h b/base/metrics/histogram_functions.h
deleted file mode 100644
index 60c0057..0000000
--- a/base/metrics/histogram_functions.h
+++ /dev/null
@@ -1,158 +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_METRICS_HISTOGRAM_FUNCTIONS_H_
-#define BASE_METRICS_HISTOGRAM_FUNCTIONS_H_
-
-#include "base/metrics/histogram.h"
-#include "base/metrics/histogram_base.h"
-#include "base/time/time.h"
-
-// Functions for recording metrics.
-//
-// For best practices on deciding when to emit to a histogram and what form
-// the histogram should take, see
-// https://chromium.googlesource.com/chromium/src.git/+/HEAD/tools/metrics/histograms/README.md
-
-// Functions for recording UMA histograms. These can be used for cases
-// when the histogram name is generated at runtime. The functionality is
-// equivalent to macros defined in histogram_macros.h but allowing non-constant
-// histogram names. These functions are slower compared to their macro
-// equivalent because the histogram objects are not cached between calls.
-// So, these shouldn't be used in performance critical code.
-namespace base {
-
-// For histograms with linear buckets.
-// Used for capturing integer data with a linear bucketing scheme. This can be
-// used when you want the exact value of some small numeric count, with a max of
-// 100 or less. If you need to capture a range of greater than 100, we recommend
-// the use of the COUNT histograms below.
-// Sample usage:
-//   base::UmaHistogramExactLinear("Histogram.Linear", some_value, 10);
-BASE_EXPORT void UmaHistogramExactLinear(const std::string& name,
-                                         int sample,
-                                         int value_max);
-
-// For adding a sample to an enumerated histogram.
-// Sample usage:
-//   // These values are persisted to logs. Entries should not be renumbered and
-//   // numeric values should never be reused.
-//   enum class MyEnum {
-//     FIRST_VALUE = 0,
-//     SECOND_VALUE = 1,
-//     ...
-//     FINAL_VALUE = N,
-//     COUNT
-//   };
-//   base::UmaHistogramEnumeration("My.Enumeration",
-//                                 MyEnum::SOME_VALUE, MyEnum::COUNT);
-//
-// Note: The value in |sample| must be strictly less than |enum_size|.
-template <typename T>
-void UmaHistogramEnumeration(const std::string& name, T sample, T enum_size) {
-  static_assert(std::is_enum<T>::value,
-                "Non enum passed to UmaHistogramEnumeration");
-  DCHECK_LE(static_cast<uintmax_t>(enum_size), static_cast<uintmax_t>(INT_MAX));
-  DCHECK_LT(static_cast<uintmax_t>(sample), static_cast<uintmax_t>(enum_size));
-  return UmaHistogramExactLinear(name, static_cast<int>(sample),
-                                 static_cast<int>(enum_size));
-}
-
-// Same as above, but uses T::kMaxValue as the inclusive maximum value of the
-// enum.
-template <typename T>
-void UmaHistogramEnumeration(const std::string& name, T sample) {
-  static_assert(std::is_enum<T>::value,
-                "Non enum passed to UmaHistogramEnumeration");
-  DCHECK_LE(static_cast<uintmax_t>(T::kMaxValue),
-            static_cast<uintmax_t>(INT_MAX) - 1);
-  DCHECK_LE(static_cast<uintmax_t>(sample),
-            static_cast<uintmax_t>(T::kMaxValue));
-  return UmaHistogramExactLinear(name, static_cast<int>(sample),
-                                 static_cast<int>(T::kMaxValue) + 1);
-}
-
-// For adding boolean sample to histogram.
-// Sample usage:
-//   base::UmaHistogramBoolean("My.Boolean", true)
-BASE_EXPORT void UmaHistogramBoolean(const std::string& name, bool sample);
-
-// For adding histogram with percent.
-// Percents are integer between 1 and 100.
-// Sample usage:
-//   base::UmaHistogramPercentage("My.Percent", 69)
-BASE_EXPORT void UmaHistogramPercentage(const std::string& name, int percent);
-
-// For adding counts histogram.
-// Sample usage:
-//   base::UmaHistogramCustomCounts("My.Counts", some_value, 1, 600, 30)
-BASE_EXPORT void UmaHistogramCustomCounts(const std::string& name,
-                                          int sample,
-                                          int min,
-                                          int max,
-                                          int buckets);
-
-// Counts specialization for maximum counts 100, 1000, 10k, 100k, 1M and 10M.
-BASE_EXPORT void UmaHistogramCounts100(const std::string& name, int sample);
-BASE_EXPORT void UmaHistogramCounts1000(const std::string& name, int sample);
-BASE_EXPORT void UmaHistogramCounts10000(const std::string& name, int sample);
-BASE_EXPORT void UmaHistogramCounts100000(const std::string& name, int sample);
-BASE_EXPORT void UmaHistogramCounts1M(const std::string& name, int sample);
-BASE_EXPORT void UmaHistogramCounts10M(const std::string& name, int sample);
-
-// For histograms storing times.
-BASE_EXPORT void UmaHistogramCustomTimes(const std::string& name,
-                                         TimeDelta sample,
-                                         TimeDelta min,
-                                         TimeDelta max,
-                                         int buckets);
-// For short timings from 1 ms up to 10 seconds (50 buckets).
-BASE_EXPORT void UmaHistogramTimes(const std::string& name, TimeDelta sample);
-// For medium timings up to 3 minutes (50 buckets).
-BASE_EXPORT void UmaHistogramMediumTimes(const std::string& name,
-                                         TimeDelta sample);
-// For time intervals up to 1 hr (50 buckets).
-BASE_EXPORT void UmaHistogramLongTimes(const std::string& name,
-                                       TimeDelta sample);
-
-// For recording memory related histograms.
-// Used to measure common KB-granularity memory stats. Range is up to 500M.
-BASE_EXPORT void UmaHistogramMemoryKB(const std::string& name, int sample);
-// Used to measure common MB-granularity memory stats. Range is up to ~1G.
-BASE_EXPORT void UmaHistogramMemoryMB(const std::string& name, int sample);
-// Used to measure common MB-granularity memory stats. Range is up to ~64G.
-BASE_EXPORT void UmaHistogramMemoryLargeMB(const std::string& name, int sample);
-
-// For recording sparse histograms.
-// The |sample| can be a negative or non-negative number.
-//
-// Sparse histograms are well suited for recording counts of exact sample values
-// that are sparsely distributed over a relatively large range, in cases where
-// ultra-fast performance is not critical. For instance, Sqlite.Version.* are
-// sparse because for any given database, there's going to be exactly one
-// version logged.
-//
-// Performance:
-// ------------
-// Sparse histograms are typically more memory-efficient but less time-efficient
-// than other histograms. Essentially, they sparse histograms use a map rather
-// than a vector for their backing storage; they also require lock acquisition
-// to increment a sample, whereas other histogram do not. Hence, each increment
-// operation is a bit slower than for other histograms. But, if the data is
-// sparse, then they use less memory client-side, because they allocate buckets
-// on demand rather than preallocating.
-//
-// Data size:
-// ----------
-// Note that server-side, we still need to load all buckets, across all users,
-// at once. Thus, please avoid exploding such histograms, i.e. uploading many
-// many distinct values to the server (across all users). Concretely, keep the
-// number of distinct values <= 100 ideally, definitely <= 1000. If you have no
-// guarantees on the range of your data, use clamping, e.g.:
-//   UmaHistogramSparse("MyHistogram", ClampToRange(value, 0, 200));
-BASE_EXPORT void UmaHistogramSparse(const std::string& name, int sample);
-
-}  // namespace base
-
-#endif  // BASE_METRICS_HISTOGRAM_FUNCTIONS_H_
diff --git a/base/metrics/histogram_macros.h b/base/metrics/histogram_macros.h
deleted file mode 100644
index 0960b19..0000000
--- a/base/metrics/histogram_macros.h
+++ /dev/null
@@ -1,359 +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_METRICS_HISTOGRAM_MACROS_H_
-#define BASE_METRICS_HISTOGRAM_MACROS_H_
-
-#include "base/macros.h"
-#include "base/metrics/histogram.h"
-#include "base/metrics/histogram_macros_internal.h"
-#include "base/metrics/histogram_macros_local.h"
-#include "base/time/time.h"
-
-
-// Macros for efficient use of histograms.
-//
-// For best practices on deciding when to emit to a histogram and what form
-// the histogram should take, see
-// https://chromium.googlesource.com/chromium/src.git/+/HEAD/tools/metrics/histograms/README.md
-
-// TODO(rkaplow): Link to proper documentation on metric creation once we have
-// it in a good state.
-
-// All of these macros must be called with |name| as a runtime constant - it
-// doesn't have to literally be a constant, but it must be the same string on
-// all calls from a particular call site. If this rule is violated, it is
-// possible the data will be written to the wrong histogram.
-
-//------------------------------------------------------------------------------
-// Enumeration histograms.
-
-// These macros create histograms for enumerated data. Ideally, the data should
-// be of the form of "event occurs, log the result". We recommended not putting
-// related but not directly connected data as enums within the same histogram.
-// You should be defining an associated Enum, and the input sample should be
-// an element of the Enum.
-// All of these macros must be called with |name| as a runtime constant.
-
-// The first variant of UMA_HISTOGRAM_ENUMERATION accepts two arguments: the
-// histogram name and the enum sample. It deduces the correct boundary value to
-// use by looking for an enumerator with the name kMaxValue. kMaxValue should
-// share the value of the highest enumerator: this avoids switch statements
-// having to handle a sentinel no-op value.
-//
-// Sample usage:
-//   // These values are persisted to logs. Entries should not be renumbered and
-//   // numeric values should never be reused.
-//   enum class MyEnum {
-//     kFirstValue = 0,
-//     kSecondValue = 1,
-//     ...
-//     kFinalValue = N,
-//     kMaxValue = kFinalValue,
-//   };
-//   UMA_HISTOGRAM_ENUMERATION("My.Enumeration", MyEnum::kSomeValue);
-//
-// The second variant requires three arguments: the first two are the same as
-// before, and the third argument is the enum boundary: this must be strictly
-// greater than any other enumerator that will be sampled.
-//
-// Sample usage:
-//   // These values are persisted to logs. Entries should not be renumbered and
-//   // numeric values should never be reused.
-//   enum class MyEnum {
-//     FIRST_VALUE = 0,
-//     SECOND_VALUE = 1,
-//     ...
-//     FINAL_VALUE = N,
-//     COUNT
-//   };
-//   UMA_HISTOGRAM_ENUMERATION("My.Enumeration",
-//                             MyEnum::SOME_VALUE, MyEnum::COUNT);
-//
-// Note: If the enum is used in a switch, it is often desirable to avoid writing
-// a case statement to handle an unused sentinel value (i.e. COUNT in the above
-// example). For scoped enums, this is awkward since it requires casting the
-// enum to an arithmetic type and adding one. Instead, prefer the two argument
-// version of the macro which automatically deduces the boundary from kMaxValue.
-#define UMA_HISTOGRAM_ENUMERATION(name, ...)                            \
-  CR_EXPAND_ARG(INTERNAL_UMA_HISTOGRAM_ENUMERATION_GET_MACRO(           \
-      __VA_ARGS__, INTERNAL_UMA_HISTOGRAM_ENUMERATION_SPECIFY_BOUNDARY, \
-      INTERNAL_UMA_HISTOGRAM_ENUMERATION_DEDUCE_BOUNDARY)(              \
-      name, __VA_ARGS__, base::HistogramBase::kUmaTargetedHistogramFlag))
-
-// Histogram for boolean values.
-
-// Sample usage:
-//   UMA_HISTOGRAM_BOOLEAN("Histogram.Boolean", bool);
-#define UMA_HISTOGRAM_BOOLEAN(name, sample)                                    \
-    STATIC_HISTOGRAM_POINTER_BLOCK(name, AddBoolean(sample),                   \
-        base::BooleanHistogram::FactoryGet(name,                               \
-            base::HistogramBase::kUmaTargetedHistogramFlag))
-
-//------------------------------------------------------------------------------
-// Linear histograms.
-
-// All of these macros must be called with |name| as a runtime constant.
-
-// Used for capturing integer data with a linear bucketing scheme. This can be
-// used when you want the exact value of some small numeric count, with a max of
-// 100 or less. If you need to capture a range of greater than 100, we recommend
-// the use of the COUNT histograms below.
-
-// Sample usage:
-//   UMA_HISTOGRAM_EXACT_LINEAR("Histogram.Linear", count, 10);
-#define UMA_HISTOGRAM_EXACT_LINEAR(name, sample, value_max) \
-  INTERNAL_HISTOGRAM_EXACT_LINEAR_WITH_FLAG(                \
-      name, sample, value_max, base::HistogramBase::kUmaTargetedHistogramFlag)
-
-// Used for capturing basic percentages. This will be 100 buckets of size 1.
-
-// Sample usage:
-//   UMA_HISTOGRAM_PERCENTAGE("Histogram.Percent", percent_as_int);
-#define UMA_HISTOGRAM_PERCENTAGE(name, percent_as_int) \
-  UMA_HISTOGRAM_EXACT_LINEAR(name, percent_as_int, 101)
-
-//------------------------------------------------------------------------------
-// Count histograms. These are used for collecting numeric data. Note that we
-// have macros for more specialized use cases below (memory, time, percentages).
-
-// The number suffixes here refer to the max size of the sample, i.e. COUNT_1000
-// will be able to collect samples of counts up to 1000. The default number of
-// buckets in all default macros is 50. We recommend erring on the side of too
-// large a range versus too short a range.
-// These macros default to exponential histograms - i.e. the lengths of the
-// bucket ranges exponentially increase as the sample range increases.
-// These should *not* be used if you are interested in exact counts, i.e. a
-// bucket range of 1. In these cases, you should use the ENUMERATION macros
-// defined later. These should also not be used to capture the number of some
-// event, i.e. "button X was clicked N times". In this cases, an enum should be
-// used, ideally with an appropriate baseline enum entry included.
-// All of these macros must be called with |name| as a runtime constant.
-
-// Sample usage:
-//   UMA_HISTOGRAM_COUNTS_1M("My.Histogram", sample);
-
-#define UMA_HISTOGRAM_COUNTS_100(name, sample) UMA_HISTOGRAM_CUSTOM_COUNTS(    \
-    name, sample, 1, 100, 50)
-
-#define UMA_HISTOGRAM_COUNTS_1000(name, sample) UMA_HISTOGRAM_CUSTOM_COUNTS(   \
-    name, sample, 1, 1000, 50)
-
-#define UMA_HISTOGRAM_COUNTS_10000(name, sample) UMA_HISTOGRAM_CUSTOM_COUNTS(  \
-    name, sample, 1, 10000, 50)
-
-#define UMA_HISTOGRAM_COUNTS_100000(name, sample) UMA_HISTOGRAM_CUSTOM_COUNTS( \
-    name, sample, 1, 100000, 50)
-
-#define UMA_HISTOGRAM_COUNTS_1M(name, sample) UMA_HISTOGRAM_CUSTOM_COUNTS(     \
-    name, sample, 1, 1000000, 50)
-
-#define UMA_HISTOGRAM_COUNTS_10M(name, sample) UMA_HISTOGRAM_CUSTOM_COUNTS(    \
-    name, sample, 1, 10000000, 50)
-
-// This can be used when the default ranges are not sufficient. This macro lets
-// the metric developer customize the min and max of the sampled range, as well
-// as the number of buckets recorded.
-// Any data outside the range here will be put in underflow and overflow
-// buckets. Min values should be >=1 as emitted 0s will still go into the
-// underflow bucket.
-
-// Sample usage:
-//   UMA_HISTOGRAM_CUSTOM_COUNTS("My.Histogram", 1, 100000000, 100);
-#define UMA_HISTOGRAM_CUSTOM_COUNTS(name, sample, min, max, bucket_count)      \
-    INTERNAL_HISTOGRAM_CUSTOM_COUNTS_WITH_FLAG(                                \
-        name, sample, min, max, bucket_count,                                  \
-        base::HistogramBase::kUmaTargetedHistogramFlag)
-
-//------------------------------------------------------------------------------
-// Timing histograms. These are used for collecting timing data (generally
-// latencies).
-
-// These macros create exponentially sized histograms (lengths of the bucket
-// ranges exponentially increase as the sample range increases). The input
-// sample is a base::TimeDelta. The output data is measured in ms granularity.
-// All of these macros must be called with |name| as a runtime constant.
-
-// Sample usage:
-//   UMA_HISTOGRAM_TIMES("My.Timing.Histogram", time_delta);
-
-// Short timings - up to 10 seconds. For high-resolution (microseconds) timings,
-// see UMA_HISTOGRAM_CUSTOM_MICROSECONDS_TIMES.
-#define UMA_HISTOGRAM_TIMES(name, sample) UMA_HISTOGRAM_CUSTOM_TIMES(          \
-    name, sample, base::TimeDelta::FromMilliseconds(1),                        \
-    base::TimeDelta::FromSeconds(10), 50)
-
-// Medium timings - up to 3 minutes. Note this starts at 10ms (no good reason,
-// but not worth changing).
-#define UMA_HISTOGRAM_MEDIUM_TIMES(name, sample) UMA_HISTOGRAM_CUSTOM_TIMES(   \
-    name, sample, base::TimeDelta::FromMilliseconds(10),                       \
-    base::TimeDelta::FromMinutes(3), 50)
-
-// Long timings - up to an hour.
-#define UMA_HISTOGRAM_LONG_TIMES(name, sample) UMA_HISTOGRAM_CUSTOM_TIMES(     \
-    name, sample, base::TimeDelta::FromMilliseconds(1),                        \
-    base::TimeDelta::FromHours(1), 50)
-
-// Long timings with higher granularity - up to an hour with 100 buckets.
-#define UMA_HISTOGRAM_LONG_TIMES_100(name, sample) UMA_HISTOGRAM_CUSTOM_TIMES( \
-    name, sample, base::TimeDelta::FromMilliseconds(1),                        \
-    base::TimeDelta::FromHours(1), 100)
-
-// This can be used when the default ranges are not sufficient. This macro lets
-// the metric developer customize the min and max of the sampled range, as well
-// as the number of buckets recorded.
-
-// Sample usage:
-//   UMA_HISTOGRAM_CUSTOM_TIMES("Very.Long.Timing.Histogram", time_delta,
-//       base::TimeDelta::FromSeconds(1), base::TimeDelta::FromDays(1), 100);
-#define UMA_HISTOGRAM_CUSTOM_TIMES(name, sample, min, max, bucket_count) \
-  STATIC_HISTOGRAM_POINTER_BLOCK(                                        \
-      name, AddTimeMillisecondsGranularity(sample),                      \
-      base::Histogram::FactoryTimeGet(                                   \
-          name, min, max, bucket_count,                                  \
-          base::HistogramBase::kUmaTargetedHistogramFlag))
-
-// Same as UMA_HISTOGRAM_CUSTOM_TIMES but reports |sample| in microseconds,
-// dropping the report if this client doesn't have a high-resolution clock.
-//
-// Note: dropping reports on clients with low-resolution clocks means these
-// reports will be biased to a portion of the population on Windows. See
-// Windows.HasHighResolutionTimeTicks for the affected sample.
-//
-// Sample usage:
-//  UMA_HISTOGRAM_CUSTOM_MICROSECONDS_TIMES(
-//      "High.Resolution.TimingMicroseconds.Histogram", time_delta,
-//      base::TimeDelta::FromMicroseconds(1),
-//      base::TimeDelta::FromMilliseconds(10), 100);
-#define UMA_HISTOGRAM_CUSTOM_MICROSECONDS_TIMES(name, sample, min, max, \
-                                                bucket_count)           \
-  STATIC_HISTOGRAM_POINTER_BLOCK(                                       \
-      name, AddTimeMicrosecondsGranularity(sample),                     \
-      base::Histogram::FactoryMicrosecondsTimeGet(                      \
-          name, min, max, bucket_count,                                 \
-          base::HistogramBase::kUmaTargetedHistogramFlag))
-
-// Scoped class which logs its time on this earth as a UMA statistic. This is
-// recommended for when you want a histogram which measures the time it takes
-// for a method to execute. This measures up to 10 seconds. It uses
-// UMA_HISTOGRAM_TIMES under the hood.
-
-// Sample usage:
-//   void Function() {
-//     SCOPED_UMA_HISTOGRAM_TIMER("Component.FunctionTime");
-//     ...
-//   }
-#define SCOPED_UMA_HISTOGRAM_TIMER(name)                                       \
-  INTERNAL_SCOPED_UMA_HISTOGRAM_TIMER_EXPANDER(name, false, __COUNTER__)
-
-// Similar scoped histogram timer, but this uses UMA_HISTOGRAM_LONG_TIMES_100,
-// which measures up to an hour, and uses 100 buckets. This is more expensive
-// to store, so only use if this often takes >10 seconds.
-#define SCOPED_UMA_HISTOGRAM_LONG_TIMER(name)                                  \
-  INTERNAL_SCOPED_UMA_HISTOGRAM_TIMER_EXPANDER(name, true, __COUNTER__)
-
-
-//------------------------------------------------------------------------------
-// Memory histograms.
-
-// These macros create exponentially sized histograms (lengths of the bucket
-// ranges exponentially increase as the sample range increases). The input
-// sample must be a number measured in kilobytes.
-// All of these macros must be called with |name| as a runtime constant.
-
-// Sample usage:
-//   UMA_HISTOGRAM_MEMORY_KB("My.Memory.Histogram", memory_in_kb);
-
-// Used to measure common KB-granularity memory stats. Range is up to 500000KB -
-// approximately 500M.
-#define UMA_HISTOGRAM_MEMORY_KB(name, sample)                                  \
-    UMA_HISTOGRAM_CUSTOM_COUNTS(name, sample, 1000, 500000, 50)
-
-// Used to measure common MB-granularity memory stats. Range is up to ~64G.
-#define UMA_HISTOGRAM_MEMORY_LARGE_MB(name, sample)                            \
-    UMA_HISTOGRAM_CUSTOM_COUNTS(name, sample, 1, 64000, 100)
-
-
-//------------------------------------------------------------------------------
-// Stability-specific histograms.
-
-// Histograms logged in as stability histograms will be included in the initial
-// stability log. See comments by declaration of
-// MetricsService::PrepareInitialStabilityLog().
-// All of these macros must be called with |name| as a runtime constant.
-
-// For details on usage, see the documentation on the non-stability equivalents.
-
-#define UMA_STABILITY_HISTOGRAM_COUNTS_100(name, sample)                       \
-    UMA_STABILITY_HISTOGRAM_CUSTOM_COUNTS(name, sample, 1, 100, 50)
-
-#define UMA_STABILITY_HISTOGRAM_CUSTOM_COUNTS(name, sample, min, max,          \
-                                              bucket_count)                    \
-    INTERNAL_HISTOGRAM_CUSTOM_COUNTS_WITH_FLAG(                                \
-        name, sample, min, max, bucket_count,                                  \
-        base::HistogramBase::kUmaStabilityHistogramFlag)
-
-#define UMA_STABILITY_HISTOGRAM_ENUMERATION(name, sample, enum_max)            \
-    INTERNAL_HISTOGRAM_ENUMERATION_WITH_FLAG(                                  \
-        name, sample, enum_max,                                                \
-        base::HistogramBase::kUmaStabilityHistogramFlag)
-
-//------------------------------------------------------------------------------
-// Histogram instantiation helpers.
-
-// Support a collection of histograms, perhaps one for each entry in an
-// enumeration. This macro manages a block of pointers, adding to a specific
-// one by its index.
-//
-// A typical instantiation looks something like this:
-//  STATIC_HISTOGRAM_POINTER_GROUP(
-//      GetHistogramNameForIndex(histogram_index),
-//      histogram_index, MAXIMUM_HISTOGRAM_INDEX, Add(some_delta),
-//      base::Histogram::FactoryGet(
-//          GetHistogramNameForIndex(histogram_index),
-//          MINIMUM_SAMPLE, MAXIMUM_SAMPLE, BUCKET_COUNT,
-//          base::HistogramBase::kUmaTargetedHistogramFlag));
-//
-// Though it seems inefficient to generate the name twice, the first
-// instance will be used only for DCHECK builds and the second will
-// execute only during the first access to the given index, after which
-// the pointer is cached and the name never needed again.
-#define STATIC_HISTOGRAM_POINTER_GROUP(constant_histogram_name, index,        \
-                                       constant_maximum,                      \
-                                       histogram_add_method_invocation,       \
-                                       histogram_factory_get_invocation)      \
-  do {                                                                        \
-    static base::subtle::AtomicWord atomic_histograms[constant_maximum];      \
-    DCHECK_LE(0, index);                                                      \
-    DCHECK_LT(index, constant_maximum);                                       \
-    HISTOGRAM_POINTER_USE(&atomic_histograms[index], constant_histogram_name, \
-                          histogram_add_method_invocation,                    \
-                          histogram_factory_get_invocation);                  \
-  } while (0)
-
-//------------------------------------------------------------------------------
-// Deprecated histogram macros. Not recommended for current use.
-
-// Legacy name for UMA_HISTOGRAM_COUNTS_1M. Suggest using explicit naming
-// and not using this macro going forward.
-#define UMA_HISTOGRAM_COUNTS(name, sample) UMA_HISTOGRAM_CUSTOM_COUNTS(        \
-    name, sample, 1, 1000000, 50)
-
-// MB-granularity memory metric. This has a short max (1G).
-#define UMA_HISTOGRAM_MEMORY_MB(name, sample)                                  \
-    UMA_HISTOGRAM_CUSTOM_COUNTS(name, sample, 1, 1000, 50)
-
-// For an enum with customized range. In general, sparse histograms should be
-// used instead.
-// Samples should be one of the std::vector<int> list provided via
-// |custom_ranges|. See comments above CustomRanges::FactoryGet about the
-// requirement of |custom_ranges|. You can use the helper function
-// CustomHistogram::ArrayToCustomEnumRanges to transform a C-style array of
-// valid sample values to a std::vector<int>.
-#define UMA_HISTOGRAM_CUSTOM_ENUMERATION(name, sample, custom_ranges)          \
-    STATIC_HISTOGRAM_POINTER_BLOCK(name, Add(sample),                          \
-        base::CustomHistogram::FactoryGet(name, custom_ranges,                 \
-            base::HistogramBase::kUmaTargetedHistogramFlag))
-
-#endif  // BASE_METRICS_HISTOGRAM_MACROS_H_
diff --git a/base/metrics/histogram_macros_internal.h b/base/metrics/histogram_macros_internal.h
deleted file mode 100644
index ff3702b..0000000
--- a/base/metrics/histogram_macros_internal.h
+++ /dev/null
@@ -1,226 +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_METRICS_HISTOGRAM_MACROS_INTERNAL_H_
-#define BASE_METRICS_HISTOGRAM_MACROS_INTERNAL_H_
-
-#include <stdint.h>
-
-#include <limits>
-#include <type_traits>
-
-#include "base/atomicops.h"
-#include "base/logging.h"
-#include "base/metrics/histogram.h"
-#include "base/metrics/sparse_histogram.h"
-#include "base/time/time.h"
-
-// This is for macros and helpers internal to base/metrics. They should not be
-// used outside of this directory. For writing to UMA histograms, see
-// histogram_macros.h.
-
-namespace base {
-namespace internal {
-
-// Helper traits for deducing the boundary value for enums.
-template <typename Enum, typename SFINAE = void>
-struct EnumSizeTraits {
-  static constexpr Enum Count() {
-    static_assert(
-        sizeof(Enum) == 0,
-        "enumerator must define kMaxValue enumerator to use this macro!");
-    return Enum();
-  }
-};
-
-// Since the UMA histogram macros expect a value one larger than the max defined
-// enumerator value, add one.
-template <typename Enum>
-struct EnumSizeTraits<
-    Enum,
-    std::enable_if_t<std::is_enum<decltype(Enum::kMaxValue)>::value>> {
-  static constexpr Enum Count() {
-    return static_cast<Enum>(
-        static_cast<std::underlying_type_t<Enum>>(Enum::kMaxValue) + 1);
-  }
-};
-
-}  // namespace internal
-}  // namespace base
-
-// TODO(rkaplow): Improve commenting of these methods.
-//------------------------------------------------------------------------------
-// Histograms are often put in areas where they are called many many times, and
-// performance is critical.  As a result, they are designed to have a very low
-// recurring cost of executing (adding additional samples). Toward that end,
-// the macros declare a static pointer to the histogram in question, and only
-// take a "slow path" to construct (or find) the histogram on the first run
-// through the macro. We leak the histograms at shutdown time so that we don't
-// have to validate using the pointers at any time during the running of the
-// process.
-
-// In some cases (integration into 3rd party code), it's useful to separate the
-// definition of |atomic_histogram_pointer| from its use. To achieve this we
-// define HISTOGRAM_POINTER_USE, which uses an |atomic_histogram_pointer|, and
-// STATIC_HISTOGRAM_POINTER_BLOCK, which defines an |atomic_histogram_pointer|
-// and forwards to HISTOGRAM_POINTER_USE.
-#define HISTOGRAM_POINTER_USE(atomic_histogram_pointer,                        \
-                              constant_histogram_name,                         \
-                              histogram_add_method_invocation,                 \
-                              histogram_factory_get_invocation)                \
-  do {                                                                         \
-    /*                                                                         \
-     * Acquire_Load() ensures that we acquire visibility to the                \
-     * pointed-to data in the histogram.                                       \
-     */                                                                        \
-    base::HistogramBase* histogram_pointer(                                    \
-        reinterpret_cast<base::HistogramBase*>(                                \
-            base::subtle::Acquire_Load(atomic_histogram_pointer)));            \
-    if (!histogram_pointer) {                                                  \
-      /*                                                                       \
-       * This is the slow path, which will construct OR find the               \
-       * matching histogram.  histogram_factory_get_invocation includes        \
-       * locks on a global histogram name map and is completely thread         \
-       * safe.                                                                 \
-       */                                                                      \
-      histogram_pointer = histogram_factory_get_invocation;                    \
-                                                                               \
-      /*                                                                       \
-       * Use Release_Store to ensure that the histogram data is made           \
-       * available globally before we make the pointer visible. Several        \
-       * threads may perform this store, but the same value will be            \
-       * stored in all cases (for a given named/spec'ed histogram).            \
-       * We could do this without any barrier, since FactoryGet entered        \
-       * and exited a lock after construction, but this barrier makes          \
-       * things clear.                                                         \
-       */                                                                      \
-      base::subtle::Release_Store(                                             \
-          atomic_histogram_pointer,                                            \
-          reinterpret_cast<base::subtle::AtomicWord>(histogram_pointer));      \
-    }                                                                          \
-    if (DCHECK_IS_ON())                                                        \
-      histogram_pointer->CheckName(constant_histogram_name);                   \
-    histogram_pointer->histogram_add_method_invocation;                        \
-  } while (0)
-
-// This is a helper macro used by other macros and shouldn't be used directly.
-// Defines the static |atomic_histogram_pointer| and forwards to
-// HISTOGRAM_POINTER_USE.
-#define STATIC_HISTOGRAM_POINTER_BLOCK(constant_histogram_name,                \
-                                       histogram_add_method_invocation,        \
-                                       histogram_factory_get_invocation)       \
-  do {                                                                         \
-    /*                                                                         \
-     * The pointer's presence indicates that the initialization is complete.   \
-     * Initialization is idempotent, so it can safely be atomically repeated.  \
-     */                                                                        \
-    static base::subtle::AtomicWord atomic_histogram_pointer = 0;              \
-    HISTOGRAM_POINTER_USE(&atomic_histogram_pointer, constant_histogram_name,  \
-                          histogram_add_method_invocation,                     \
-                          histogram_factory_get_invocation);                   \
-  } while (0)
-
-// This is a helper macro used by other macros and shouldn't be used directly.
-#define INTERNAL_HISTOGRAM_CUSTOM_COUNTS_WITH_FLAG(name, sample, min, max,     \
-                                                   bucket_count, flag)         \
-    STATIC_HISTOGRAM_POINTER_BLOCK(                                            \
-        name, Add(sample),                                                     \
-        base::Histogram::FactoryGet(name, min, max, bucket_count, flag))
-
-// This is a helper macro used by other macros and shouldn't be used directly.
-// The bucketing scheme is linear with a bucket size of 1. For N items,
-// recording values in the range [0, N - 1] creates a linear histogram with N +
-// 1 buckets:
-//   [0, 1), [1, 2), ..., [N - 1, N)
-// and an overflow bucket [N, infinity).
-//
-// Code should never emit to the overflow bucket; only to the other N buckets.
-// This allows future versions of Chrome to safely increase the boundary size.
-// Otherwise, the histogram would have [N - 1, infinity) as its overflow bucket,
-// and so the maximal value (N - 1) would be emitted to this overflow bucket.
-// But, if an additional value were later added, the bucket label for
-// the value (N - 1) would change to [N - 1, N), which would result in different
-// versions of Chrome using different bucket labels for identical data.
-#define INTERNAL_HISTOGRAM_EXACT_LINEAR_WITH_FLAG(name, sample, boundary,  \
-                                                  flag)                    \
-  do {                                                                     \
-    static_assert(!std::is_enum<decltype(sample)>::value,                  \
-                  "|sample| should not be an enum type!");                 \
-    static_assert(!std::is_enum<decltype(boundary)>::value,                \
-                  "|boundary| should not be an enum type!");               \
-    STATIC_HISTOGRAM_POINTER_BLOCK(                                        \
-        name, Add(sample),                                                 \
-        base::LinearHistogram::FactoryGet(name, 1, boundary, boundary + 1, \
-                                          flag));                          \
-  } while (0)
-
-// Helper for 'overloading' UMA_HISTOGRAM_ENUMERATION with a variable number of
-// arguments.
-#define INTERNAL_UMA_HISTOGRAM_ENUMERATION_GET_MACRO(_1, _2, NAME, ...) NAME
-
-#define INTERNAL_UMA_HISTOGRAM_ENUMERATION_DEDUCE_BOUNDARY(name, sample,       \
-                                                           flags)              \
-  INTERNAL_HISTOGRAM_ENUMERATION_WITH_FLAG(                                    \
-      name, sample, base::internal::EnumSizeTraits<decltype(sample)>::Count(), \
-      flags)
-
-// Note: The value in |sample| must be strictly less than |enum_size|.
-#define INTERNAL_UMA_HISTOGRAM_ENUMERATION_SPECIFY_BOUNDARY(name, sample,     \
-                                                            enum_size, flags) \
-  INTERNAL_HISTOGRAM_ENUMERATION_WITH_FLAG(name, sample, enum_size, flags)
-
-// Similar to the previous macro but intended for enumerations. This delegates
-// the work to the previous macro, but supports scoped enumerations as well by
-// forcing an explicit cast to the HistogramBase::Sample integral type.
-//
-// Note the range checks verify two separate issues:
-// - that the declared enum size isn't out of range of HistogramBase::Sample
-// - that the declared enum size is > 0
-//
-// TODO(dcheng): This should assert that the passed in types are actually enum
-// types.
-#define INTERNAL_HISTOGRAM_ENUMERATION_WITH_FLAG(name, sample, boundary, flag) \
-  do {                                                                         \
-    using decayed_sample = std::decay<decltype(sample)>::type;                 \
-    using decayed_boundary = std::decay<decltype(boundary)>::type;             \
-    static_assert(!std::is_enum<decayed_boundary>::value ||                    \
-                      std::is_enum<decayed_sample>::value,                     \
-                  "Unexpected: |boundary| is enum, but |sample| is not.");     \
-    static_assert(!std::is_enum<decayed_sample>::value ||                      \
-                      !std::is_enum<decayed_boundary>::value ||                \
-                      std::is_same<decayed_sample, decayed_boundary>::value,   \
-                  "|sample| and |boundary| shouldn't be of different enums");  \
-    static_assert(                                                             \
-        static_cast<uintmax_t>(boundary) <                                     \
-            static_cast<uintmax_t>(                                            \
-                std::numeric_limits<base::HistogramBase::Sample>::max()),      \
-        "|boundary| is out of range of HistogramBase::Sample");                \
-    INTERNAL_HISTOGRAM_EXACT_LINEAR_WITH_FLAG(                                 \
-        name, static_cast<base::HistogramBase::Sample>(sample),                \
-        static_cast<base::HistogramBase::Sample>(boundary), flag);             \
-  } while (0)
-
-// This is a helper macro used by other macros and shouldn't be used directly.
-// This is necessary to expand __COUNTER__ to an actual value.
-#define INTERNAL_SCOPED_UMA_HISTOGRAM_TIMER_EXPANDER(name, is_long, key)       \
-  INTERNAL_SCOPED_UMA_HISTOGRAM_TIMER_UNIQUE(name, is_long, key)
-
-// This is a helper macro used by other macros and shouldn't be used directly.
-#define INTERNAL_SCOPED_UMA_HISTOGRAM_TIMER_UNIQUE(name, is_long, key)         \
-  class ScopedHistogramTimer##key {                                            \
-   public:                                                                     \
-    ScopedHistogramTimer##key() : constructed_(base::TimeTicks::Now()) {}      \
-    ~ScopedHistogramTimer##key() {                                             \
-      base::TimeDelta elapsed = base::TimeTicks::Now() - constructed_;         \
-      if (is_long) {                                                           \
-        UMA_HISTOGRAM_LONG_TIMES_100(name, elapsed);                           \
-      } else {                                                                 \
-        UMA_HISTOGRAM_TIMES(name, elapsed);                                    \
-      }                                                                        \
-    }                                                                          \
-   private:                                                                    \
-    base::TimeTicks constructed_;                                              \
-  } scoped_histogram_timer_##key
-
-#endif  // BASE_METRICS_HISTOGRAM_MACROS_INTERNAL_H_
diff --git a/base/metrics/histogram_macros_local.h b/base/metrics/histogram_macros_local.h
deleted file mode 100644
index c4d333b..0000000
--- a/base/metrics/histogram_macros_local.h
+++ /dev/null
@@ -1,90 +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_METRICS_HISTOGRAM_MACROS_LOCAL_H_
-#define BASE_METRICS_HISTOGRAM_MACROS_LOCAL_H_
-
-#include "base/logging.h"
-#include "base/metrics/histogram.h"
-#include "base/metrics/histogram_macros_internal.h"
-#include "base/time/time.h"
-
-// TODO(rkaplow): Migrate all LOCAL_* usage within Chromium to include this
-// file instead of the histogram_macros.h file.
-
-//------------------------------------------------------------------------------
-// Enumeration histograms.
-//
-// For usage details, see the equivalents in histogram_macros.h.
-
-#define LOCAL_HISTOGRAM_ENUMERATION(name, ...)                          \
-  CR_EXPAND_ARG(INTERNAL_UMA_HISTOGRAM_ENUMERATION_GET_MACRO(           \
-      __VA_ARGS__, INTERNAL_UMA_HISTOGRAM_ENUMERATION_SPECIFY_BOUNDARY, \
-      INTERNAL_UMA_HISTOGRAM_ENUMERATION_DEDUCE_BOUNDARY)(              \
-      name, __VA_ARGS__, base::HistogramBase::kNoFlags))
-
-#define LOCAL_HISTOGRAM_BOOLEAN(name, sample)                                  \
-    STATIC_HISTOGRAM_POINTER_BLOCK(name, AddBoolean(sample),                   \
-        base::BooleanHistogram::FactoryGet(name, base::Histogram::kNoFlags))
-
-//------------------------------------------------------------------------------
-// Percentage histograms.
-//
-// For usage details, see the equivalents in histogram_macros.h
-
-#define LOCAL_HISTOGRAM_PERCENTAGE(name, under_one_hundred)                    \
-    LOCAL_HISTOGRAM_ENUMERATION(name, under_one_hundred, 101)
-
-//------------------------------------------------------------------------------
-// Count histograms. These are used for collecting numeric data. Note that we
-// have macros for more specialized use cases below (memory, time, percentages).
-// For usage details, see the equivalents in histogram_macros.h.
-
-#define LOCAL_HISTOGRAM_COUNTS_100(name, sample)                               \
-    LOCAL_HISTOGRAM_CUSTOM_COUNTS(name, sample, 1, 100, 50)
-
-#define LOCAL_HISTOGRAM_COUNTS_10000(name, sample)                             \
-    LOCAL_HISTOGRAM_CUSTOM_COUNTS(name, sample, 1, 10000, 50)
-
-#define LOCAL_HISTOGRAM_COUNTS_1000000(name, sample)                           \
-    LOCAL_HISTOGRAM_CUSTOM_COUNTS(name, sample, 1, 1000000, 50)
-
-#define LOCAL_HISTOGRAM_CUSTOM_COUNTS(name, sample, min, max, bucket_count)    \
-    INTERNAL_HISTOGRAM_CUSTOM_COUNTS_WITH_FLAG(                                \
-        name, sample, min, max, bucket_count, base::HistogramBase::kNoFlags)
-
-//------------------------------------------------------------------------------
-// Timing histograms. These are used for collecting timing data (generally
-// latencies).
-//
-// For usage details, see the equivalents in histogram_macros.h.
-
-#define LOCAL_HISTOGRAM_TIMES(name, sample) LOCAL_HISTOGRAM_CUSTOM_TIMES(      \
-    name, sample, base::TimeDelta::FromMilliseconds(1),                        \
-    base::TimeDelta::FromSeconds(10), 50)
-
-#define LOCAL_HISTOGRAM_CUSTOM_TIMES(name, sample, min, max, bucket_count) \
-  STATIC_HISTOGRAM_POINTER_BLOCK(                                          \
-      name, AddTimeMillisecondsGranularity(sample),                        \
-      base::Histogram::FactoryTimeGet(name, min, max, bucket_count,        \
-                                      base::HistogramBase::kNoFlags))
-
-//------------------------------------------------------------------------------
-// Memory histograms.
-//
-// For usage details, see the equivalents in histogram_macros.h.
-
-#define LOCAL_HISTOGRAM_MEMORY_KB(name, sample) LOCAL_HISTOGRAM_CUSTOM_COUNTS( \
-    name, sample, 1000, 500000, 50)
-
-//------------------------------------------------------------------------------
-// Deprecated histograms. Not recommended for current use.
-
-// TODO(rkaplow): See if we can clean up this macro and usage.
-// Legacy non-explicit version. We suggest using LOCAL_HISTOGRAM_COUNTS_1000000
-// instead.
-#define LOCAL_HISTOGRAM_COUNTS(name, sample)                                   \
-    LOCAL_HISTOGRAM_CUSTOM_COUNTS(name, sample, 1, 1000000, 50)
-
-#endif  // BASE_METRICS_HISTOGRAM_MACROS_LOCAL_H_
diff --git a/base/metrics/histogram_samples.cc b/base/metrics/histogram_samples.cc
deleted file mode 100644
index 6830637..0000000
--- a/base/metrics/histogram_samples.cc
+++ /dev/null
@@ -1,315 +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/metrics/histogram_samples.h"
-
-#include <limits>
-
-#include "base/compiler_specific.h"
-#include "base/metrics/histogram_functions.h"
-#include "base/metrics/histogram_macros.h"
-#include "base/numerics/safe_conversions.h"
-#include "base/numerics/safe_math.h"
-#include "base/pickle.h"
-
-namespace base {
-
-namespace {
-
-// A shorthand constant for the max value of size_t.
-constexpr size_t kSizeMax = std::numeric_limits<size_t>::max();
-
-// A constant stored in an AtomicSingleSample (as_atomic) to indicate that the
-// sample is "disabled" and no further accumulation should be done with it. The
-// value is chosen such that it will be MAX_UINT16 for both |bucket| & |count|,
-// and thus less likely to conflict with real use. Conflicts are explicitly
-// handled in the code but it's worth making them as unlikely as possible.
-constexpr int32_t kDisabledSingleSample = -1;
-
-class SampleCountPickleIterator : public SampleCountIterator {
- public:
-  explicit SampleCountPickleIterator(PickleIterator* iter);
-
-  bool Done() const override;
-  void Next() override;
-  void Get(HistogramBase::Sample* min,
-           int64_t* max,
-           HistogramBase::Count* count) const override;
-
- private:
-  PickleIterator* const iter_;
-
-  HistogramBase::Sample min_;
-  int64_t max_;
-  HistogramBase::Count count_;
-  bool is_done_;
-};
-
-SampleCountPickleIterator::SampleCountPickleIterator(PickleIterator* iter)
-    : iter_(iter),
-      is_done_(false) {
-  Next();
-}
-
-bool SampleCountPickleIterator::Done() const {
-  return is_done_;
-}
-
-void SampleCountPickleIterator::Next() {
-  DCHECK(!Done());
-  if (!iter_->ReadInt(&min_) || !iter_->ReadInt64(&max_) ||
-      !iter_->ReadInt(&count_)) {
-    is_done_ = true;
-  }
-}
-
-void SampleCountPickleIterator::Get(HistogramBase::Sample* min,
-                                    int64_t* max,
-                                    HistogramBase::Count* count) const {
-  DCHECK(!Done());
-  *min = min_;
-  *max = max_;
-  *count = count_;
-}
-
-}  // namespace
-
-static_assert(sizeof(HistogramSamples::AtomicSingleSample) ==
-                  sizeof(subtle::Atomic32),
-              "AtomicSingleSample isn't 32 bits");
-
-HistogramSamples::SingleSample HistogramSamples::AtomicSingleSample::Load()
-    const {
-  AtomicSingleSample single_sample = subtle::Acquire_Load(&as_atomic);
-
-  // If the sample was extracted/disabled, it's still zero to the outside.
-  if (single_sample.as_atomic == kDisabledSingleSample)
-    single_sample.as_atomic = 0;
-
-  return single_sample.as_parts;
-}
-
-HistogramSamples::SingleSample HistogramSamples::AtomicSingleSample::Extract(
-    bool disable) {
-  AtomicSingleSample single_sample = subtle::NoBarrier_AtomicExchange(
-      &as_atomic, disable ? kDisabledSingleSample : 0);
-  if (single_sample.as_atomic == kDisabledSingleSample)
-    single_sample.as_atomic = 0;
-  return single_sample.as_parts;
-}
-
-bool HistogramSamples::AtomicSingleSample::Accumulate(
-    size_t bucket,
-    HistogramBase::Count count) {
-  if (count == 0)
-    return true;
-
-  // Convert the parameters to 16-bit variables because it's all 16-bit below.
-  // To support decrements/subtractions, divide the |count| into sign/value and
-  // do the proper operation below. The alternative is to change the single-
-  // sample's count to be a signed integer (int16_t) and just add an int16_t
-  // |count16| but that is somewhat wasteful given that the single-sample is
-  // never expected to have a count less than zero.
-  if (count < -std::numeric_limits<uint16_t>::max() ||
-      count > std::numeric_limits<uint16_t>::max() ||
-      bucket > std::numeric_limits<uint16_t>::max()) {
-    return false;
-  }
-  bool count_is_negative = count < 0;
-  uint16_t count16 = static_cast<uint16_t>(count_is_negative ? -count : count);
-  uint16_t bucket16 = static_cast<uint16_t>(bucket);
-
-  // A local, unshared copy of the single-sample is necessary so the parts
-  // can be manipulated without worrying about atomicity.
-  AtomicSingleSample single_sample;
-
-  bool sample_updated;
-  do {
-    subtle::Atomic32 original = subtle::Acquire_Load(&as_atomic);
-    if (original == kDisabledSingleSample)
-      return false;
-    single_sample.as_atomic = original;
-    if (single_sample.as_atomic != 0) {
-      // Only the same bucket (parameter and stored) can be counted multiple
-      // times.
-      if (single_sample.as_parts.bucket != bucket16)
-        return false;
-    } else {
-      // The |single_ sample| was zero so becomes the |bucket| parameter, the
-      // contents of which were checked above to fit in 16 bits.
-      single_sample.as_parts.bucket = bucket16;
-    }
-
-    // Update count, making sure that it doesn't overflow.
-    CheckedNumeric<uint16_t> new_count(single_sample.as_parts.count);
-    if (count_is_negative)
-      new_count -= count16;
-    else
-      new_count += count16;
-    if (!new_count.AssignIfValid(&single_sample.as_parts.count))
-      return false;
-
-    // Don't let this become equivalent to the "disabled" value.
-    if (single_sample.as_atomic == kDisabledSingleSample)
-      return false;
-
-    // Store the updated single-sample back into memory. |existing| is what
-    // was in that memory location at the time of the call; if it doesn't
-    // match |original| then the swap didn't happen so loop again.
-    subtle::Atomic32 existing = subtle::Release_CompareAndSwap(
-        &as_atomic, original, single_sample.as_atomic);
-    sample_updated = (existing == original);
-  } while (!sample_updated);
-
-  return true;
-}
-
-bool HistogramSamples::AtomicSingleSample::IsDisabled() const {
-  return subtle::Acquire_Load(&as_atomic) == kDisabledSingleSample;
-}
-
-HistogramSamples::LocalMetadata::LocalMetadata() {
-  // This is the same way it's done for persistent metadata since no ctor
-  // is called for the data members in that case.
-  memset(this, 0, sizeof(*this));
-}
-
-HistogramSamples::HistogramSamples(uint64_t id, Metadata* meta)
-    : meta_(meta) {
-  DCHECK(meta_->id == 0 || meta_->id == id);
-
-  // It's possible that |meta| is contained in initialized, read-only memory
-  // so it's essential that no write be done in that case.
-  if (!meta_->id)
-    meta_->id = id;
-}
-
-// This mustn't do anything with |meta_|. It was passed to the ctor and may
-// be invalid by the time this dtor gets called.
-HistogramSamples::~HistogramSamples() = default;
-
-void HistogramSamples::Add(const HistogramSamples& other) {
-  IncreaseSumAndCount(other.sum(), other.redundant_count());
-  std::unique_ptr<SampleCountIterator> it = other.Iterator();
-  bool success = AddSubtractImpl(it.get(), ADD);
-  DCHECK(success);
-}
-
-bool HistogramSamples::AddFromPickle(PickleIterator* iter) {
-  int64_t sum;
-  HistogramBase::Count redundant_count;
-
-  if (!iter->ReadInt64(&sum) || !iter->ReadInt(&redundant_count))
-    return false;
-
-  IncreaseSumAndCount(sum, redundant_count);
-
-  SampleCountPickleIterator pickle_iter(iter);
-  return AddSubtractImpl(&pickle_iter, ADD);
-}
-
-void HistogramSamples::Subtract(const HistogramSamples& other) {
-  IncreaseSumAndCount(-other.sum(), -other.redundant_count());
-  std::unique_ptr<SampleCountIterator> it = other.Iterator();
-  bool success = AddSubtractImpl(it.get(), SUBTRACT);
-  DCHECK(success);
-}
-
-void HistogramSamples::Serialize(Pickle* pickle) const {
-  pickle->WriteInt64(sum());
-  pickle->WriteInt(redundant_count());
-
-  HistogramBase::Sample min;
-  int64_t max;
-  HistogramBase::Count count;
-  for (std::unique_ptr<SampleCountIterator> it = Iterator(); !it->Done();
-       it->Next()) {
-    it->Get(&min, &max, &count);
-    pickle->WriteInt(min);
-    pickle->WriteInt64(max);
-    pickle->WriteInt(count);
-  }
-}
-
-bool HistogramSamples::AccumulateSingleSample(HistogramBase::Sample value,
-                                              HistogramBase::Count count,
-                                              size_t bucket) {
-  if (single_sample().Accumulate(bucket, count)) {
-    // Success. Update the (separate) sum and redundant-count.
-    IncreaseSumAndCount(strict_cast<int64_t>(value) * count, count);
-    return true;
-  }
-  return false;
-}
-
-void HistogramSamples::IncreaseSumAndCount(int64_t sum,
-                                           HistogramBase::Count count) {
-#ifdef ARCH_CPU_64_BITS
-  subtle::NoBarrier_AtomicIncrement(&meta_->sum, sum);
-#else
-  meta_->sum += sum;
-#endif
-  subtle::NoBarrier_AtomicIncrement(&meta_->redundant_count, count);
-}
-
-void HistogramSamples::RecordNegativeSample(NegativeSampleReason reason,
-                                            HistogramBase::Count increment) {
-  UMA_HISTOGRAM_ENUMERATION("UMA.NegativeSamples.Reason", reason,
-                            MAX_NEGATIVE_SAMPLE_REASONS);
-  UMA_HISTOGRAM_CUSTOM_COUNTS("UMA.NegativeSamples.Increment", increment, 1,
-                              1 << 30, 100);
-  UmaHistogramSparse("UMA.NegativeSamples.Histogram",
-                     static_cast<int32_t>(id()));
-}
-
-SampleCountIterator::~SampleCountIterator() = default;
-
-bool SampleCountIterator::GetBucketIndex(size_t* index) const {
-  DCHECK(!Done());
-  return false;
-}
-
-SingleSampleIterator::SingleSampleIterator(HistogramBase::Sample min,
-                                           int64_t max,
-                                           HistogramBase::Count count)
-    : SingleSampleIterator(min, max, count, kSizeMax) {}
-
-SingleSampleIterator::SingleSampleIterator(HistogramBase::Sample min,
-                                           int64_t max,
-                                           HistogramBase::Count count,
-                                           size_t bucket_index)
-    : min_(min), max_(max), bucket_index_(bucket_index), count_(count) {}
-
-SingleSampleIterator::~SingleSampleIterator() = default;
-
-bool SingleSampleIterator::Done() const {
-  return count_ == 0;
-}
-
-void SingleSampleIterator::Next() {
-  DCHECK(!Done());
-  count_ = 0;
-}
-
-void SingleSampleIterator::Get(HistogramBase::Sample* min,
-                               int64_t* max,
-                               HistogramBase::Count* count) const {
-  DCHECK(!Done());
-  if (min != nullptr)
-    *min = min_;
-  if (max != nullptr)
-    *max = max_;
-  if (count != nullptr)
-    *count = count_;
-}
-
-bool SingleSampleIterator::GetBucketIndex(size_t* index) const {
-  DCHECK(!Done());
-  if (bucket_index_ == kSizeMax)
-    return false;
-  *index = bucket_index_;
-  return true;
-}
-
-}  // namespace base
diff --git a/base/metrics/histogram_samples.h b/base/metrics/histogram_samples.h
deleted file mode 100644
index 059fd3c..0000000
--- a/base/metrics/histogram_samples.h
+++ /dev/null
@@ -1,270 +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_METRICS_HISTOGRAM_SAMPLES_H_
-#define BASE_METRICS_HISTOGRAM_SAMPLES_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-#include <limits>
-#include <memory>
-
-#include "base/atomicops.h"
-#include "base/macros.h"
-#include "base/metrics/histogram_base.h"
-
-namespace base {
-
-class Pickle;
-class PickleIterator;
-class SampleCountIterator;
-
-// HistogramSamples is a container storing all samples of a histogram. All
-// elements must be of a fixed width to ensure 32/64-bit interoperability.
-// If this structure changes, bump the version number for kTypeIdHistogram
-// in persistent_histogram_allocator.cc.
-//
-// Note that though these samples are individually consistent (through the use
-// of atomic operations on the counts), there is only "eventual consistency"
-// overall when multiple threads are accessing this data. That means that the
-// sum, redundant-count, etc. could be momentarily out-of-sync with the stored
-// counts but will settle to a consistent "steady state" once all threads have
-// exited this code.
-class BASE_EXPORT HistogramSamples {
- public:
-  // A single bucket and count. To fit within a single atomic on 32-bit build
-  // architectures, both |bucket| and |count| are limited in size to 16 bits.
-  // This limits the functionality somewhat but if an entry can't fit then
-  // the full array of samples can be allocated and used.
-  struct SingleSample {
-    uint16_t bucket;
-    uint16_t count;
-  };
-
-  // A structure for managing an atomic single sample. Because this is generally
-  // used in association with other atomic values, the defined methods use
-  // acquire/release operations to guarantee ordering with outside values.
-  union BASE_EXPORT AtomicSingleSample {
-    AtomicSingleSample() : as_atomic(0) {}
-    AtomicSingleSample(subtle::Atomic32 rhs) : as_atomic(rhs) {}
-
-    // Returns the single sample in an atomic manner. This in an "acquire"
-    // load. The returned sample isn't shared and thus its fields can be safely
-    // accessed.
-    SingleSample Load() const;
-
-    // Extracts the single sample in an atomic manner. If |disable| is true
-    // then this object will be set so it will never accumulate another value.
-    // This is "no barrier" so doesn't enforce ordering with other atomic ops.
-    SingleSample Extract(bool disable);
-
-    // Adds a given count to the held bucket. If not possible, it returns false
-    // and leaves the parts unchanged. Once extracted/disabled, this always
-    // returns false. This in an "acquire/release" operation.
-    bool Accumulate(size_t bucket, HistogramBase::Count count);
-
-    // Returns if the sample has been "disabled" (via Extract) and thus not
-    // allowed to accept further accumulation.
-    bool IsDisabled() const;
-
-   private:
-    // union field: The actual sample bucket and count.
-    SingleSample as_parts;
-
-    // union field: The sample as an atomic value. Atomic64 would provide
-    // more flexibility but isn't available on all builds. This can hold a
-    // special, internal "disabled" value indicating that it must not accept
-    // further accumulation.
-    subtle::Atomic32 as_atomic;
-  };
-
-  // A structure of information about the data, common to all sample containers.
-  // Because of how this is used in persistent memory, it must be a POD object
-  // that makes sense when initialized to all zeros.
-  struct Metadata {
-    // Expected size for 32/64-bit check.
-    static constexpr size_t kExpectedInstanceSize = 24;
-
-    // Initialized when the sample-set is first created with a value provided
-    // by the caller. It is generally used to identify the sample-set across
-    // threads and processes, though not necessarily uniquely as it is possible
-    // to have multiple sample-sets representing subsets of the data.
-    uint64_t id;
-
-    // The sum of all the entries, effectivly the sum(sample * count) for
-    // all samples. Despite being atomic, no guarantees are made on the
-    // accuracy of this value; there may be races during histogram
-    // accumulation and snapshotting that we choose to accept. It should
-    // be treated as approximate.
-#ifdef ARCH_CPU_64_BITS
-    subtle::Atomic64 sum;
-#else
-    // 32-bit systems don't have atomic 64-bit operations. Use a basic type
-    // and don't worry about "shearing".
-    int64_t sum;
-#endif
-
-    // A "redundant" count helps identify memory corruption. It redundantly
-    // stores the total number of samples accumulated in the histogram. We
-    // can compare this count to the sum of the counts (TotalCount() function),
-    // and detect problems. Note, depending on the implementation of different
-    // histogram types, there might be races during histogram accumulation
-    // and snapshotting that we choose to accept. In this case, the tallies
-    // might mismatch even when no memory corruption has happened.
-    HistogramBase::AtomicCount redundant_count;
-
-    // A single histogram value and associated count. This allows histograms
-    // that typically report only a single value to not require full storage
-    // to be allocated.
-    AtomicSingleSample single_sample;  // 32 bits
-  };
-
-  // Because structures held in persistent memory must be POD, there can be no
-  // default constructor to clear the fields. This derived class exists just
-  // to clear them when being allocated on the heap.
-  struct BASE_EXPORT LocalMetadata : Metadata {
-    LocalMetadata();
-  };
-
-  HistogramSamples(uint64_t id, Metadata* meta);
-  virtual ~HistogramSamples();
-
-  virtual void Accumulate(HistogramBase::Sample value,
-                          HistogramBase::Count count) = 0;
-  virtual HistogramBase::Count GetCount(HistogramBase::Sample value) const = 0;
-  virtual HistogramBase::Count TotalCount() const = 0;
-
-  virtual void Add(const HistogramSamples& other);
-
-  // Add from serialized samples.
-  virtual bool AddFromPickle(PickleIterator* iter);
-
-  virtual void Subtract(const HistogramSamples& other);
-
-  virtual std::unique_ptr<SampleCountIterator> Iterator() const = 0;
-  virtual void Serialize(Pickle* pickle) const;
-
-  // Accessor fuctions.
-  uint64_t id() const { return meta_->id; }
-  int64_t sum() const {
-#ifdef ARCH_CPU_64_BITS
-    return subtle::NoBarrier_Load(&meta_->sum);
-#else
-    return meta_->sum;
-#endif
-  }
-  HistogramBase::Count redundant_count() const {
-    return subtle::NoBarrier_Load(&meta_->redundant_count);
-  }
-
-  // Temporarily visible for crash debugging. Should be protected.
-  // TODO(bcwhite): Move this back where it belongs.
-  // https://bugs.chromium.org/p/chromium/issues/detail?id=836875
-  Metadata* meta() { return meta_; }
-
- protected:
-  enum NegativeSampleReason {
-    SAMPLES_HAVE_LOGGED_BUT_NOT_SAMPLE,
-    SAMPLES_SAMPLE_LESS_THAN_LOGGED,
-    SAMPLES_ADDED_NEGATIVE_COUNT,
-    SAMPLES_ADD_WENT_NEGATIVE,
-    SAMPLES_ADD_OVERFLOW,
-    SAMPLES_ACCUMULATE_NEGATIVE_COUNT,
-    SAMPLES_ACCUMULATE_WENT_NEGATIVE,
-    DEPRECATED_SAMPLES_ACCUMULATE_OVERFLOW,
-    SAMPLES_ACCUMULATE_OVERFLOW,
-    MAX_NEGATIVE_SAMPLE_REASONS
-  };
-
-  // Based on |op| type, add or subtract sample counts data from the iterator.
-  enum Operator { ADD, SUBTRACT };
-  virtual bool AddSubtractImpl(SampleCountIterator* iter, Operator op) = 0;
-
-  // Accumulates to the embedded single-sample field if possible. Returns true
-  // on success, false otherwise. Sum and redundant-count are also updated in
-  // the success case.
-  bool AccumulateSingleSample(HistogramBase::Sample value,
-                              HistogramBase::Count count,
-                              size_t bucket);
-
-  // Atomically adjust the sum and redundant-count.
-  void IncreaseSumAndCount(int64_t sum, HistogramBase::Count count);
-
-  // Record a negative-sample observation and the reason why.
-  void RecordNegativeSample(NegativeSampleReason reason,
-                            HistogramBase::Count increment);
-
-  AtomicSingleSample& single_sample() { return meta_->single_sample; }
-  const AtomicSingleSample& single_sample() const {
-    return meta_->single_sample;
-  }
-
- private:
-  // Depending on derived class meta values can come from local stoarge or
-  // external storage in which case HistogramSamples class cannot take ownership
-  // of Metadata*.
-  Metadata* meta_;
-
-  DISALLOW_COPY_AND_ASSIGN(HistogramSamples);
-};
-
-class BASE_EXPORT SampleCountIterator {
- public:
-  virtual ~SampleCountIterator();
-
-  virtual bool Done() const = 0;
-  virtual void Next() = 0;
-
-  // Get the sample and count at current position.
-  // |min| |max| and |count| can be NULL if the value is not of interest.
-  // Note: |max| is int64_t because histograms support logged values in the
-  // full int32_t range and bucket max is exclusive, so it needs to support
-  // values up to MAXINT32+1.
-  // Requires: !Done();
-  virtual void Get(HistogramBase::Sample* min,
-                   int64_t* max,
-                   HistogramBase::Count* count) const = 0;
-  static_assert(std::numeric_limits<HistogramBase::Sample>::max() <
-                    std::numeric_limits<int64_t>::max(),
-                "Get() |max| must be able to hold Histogram::Sample max + 1");
-
-  // Get the index of current histogram bucket.
-  // For histograms that don't use predefined buckets, it returns false.
-  // Requires: !Done();
-  virtual bool GetBucketIndex(size_t* index) const;
-};
-
-class BASE_EXPORT SingleSampleIterator : public SampleCountIterator {
- public:
-  SingleSampleIterator(HistogramBase::Sample min,
-                       int64_t max,
-                       HistogramBase::Count count);
-  SingleSampleIterator(HistogramBase::Sample min,
-                       int64_t max,
-                       HistogramBase::Count count,
-                       size_t bucket_index);
-  ~SingleSampleIterator() override;
-
-  // SampleCountIterator:
-  bool Done() const override;
-  void Next() override;
-  void Get(HistogramBase::Sample* min,
-           int64_t* max,
-           HistogramBase::Count* count) const override;
-
-  // SampleVector uses predefined buckets so iterator can return bucket index.
-  bool GetBucketIndex(size_t* index) const override;
-
- private:
-  // Information about the single value to return.
-  const HistogramBase::Sample min_;
-  const int64_t max_;
-  const size_t bucket_index_;
-  HistogramBase::Count count_;
-};
-
-}  // namespace base
-
-#endif  // BASE_METRICS_HISTOGRAM_SAMPLES_H_
diff --git a/base/metrics/histogram_snapshot_manager.cc b/base/metrics/histogram_snapshot_manager.cc
deleted file mode 100644
index c1b804e..0000000
--- a/base/metrics/histogram_snapshot_manager.cc
+++ /dev/null
@@ -1,123 +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/metrics/histogram_snapshot_manager.h"
-
-#include <memory>
-
-#include "base/debug/alias.h"
-#include "base/metrics/histogram_flattener.h"
-#include "base/metrics/histogram_samples.h"
-#include "base/metrics/statistics_recorder.h"
-#include "base/stl_util.h"
-
-namespace base {
-
-namespace {
-
-// A simple object to set an "active" flag and clear it upon destruction. It is
-// an error if the flag is already set.
-class MakeActive {
- public:
-  MakeActive(std::atomic<bool>* is_active) : is_active_(is_active) {
-    bool was_active = is_active_->exchange(true, std::memory_order_relaxed);
-    CHECK(!was_active);
-  }
-  ~MakeActive() { is_active_->store(false, std::memory_order_relaxed); }
-
- private:
-  std::atomic<bool>* is_active_;
-
-  DISALLOW_COPY_AND_ASSIGN(MakeActive);
-};
-
-}  // namespace
-
-HistogramSnapshotManager::HistogramSnapshotManager(
-    HistogramFlattener* histogram_flattener)
-    : histogram_flattener_(histogram_flattener) {
-  DCHECK(histogram_flattener_);
-  is_active_.store(false, std::memory_order_relaxed);
-}
-
-HistogramSnapshotManager::~HistogramSnapshotManager() = default;
-
-void HistogramSnapshotManager::PrepareDeltas(
-    const std::vector<HistogramBase*>& histograms,
-    HistogramBase::Flags flags_to_set,
-    HistogramBase::Flags required_flags) {
-  for (HistogramBase* const histogram : histograms) {
-    histogram->SetFlags(flags_to_set);
-    if ((histogram->flags() & required_flags) == required_flags)
-      PrepareDelta(histogram);
-  }
-}
-
-void HistogramSnapshotManager::PrepareDelta(HistogramBase* histogram) {
-  histogram->ValidateHistogramContents();
-  PrepareSamples(histogram, histogram->SnapshotDelta());
-}
-
-void HistogramSnapshotManager::PrepareFinalDelta(
-    const HistogramBase* histogram) {
-  histogram->ValidateHistogramContents();
-  PrepareSamples(histogram, histogram->SnapshotFinalDelta());
-}
-
-void HistogramSnapshotManager::PrepareSamples(
-    const HistogramBase* histogram,
-    std::unique_ptr<HistogramSamples> samples) {
-  DCHECK(histogram_flattener_);
-
-  // Ensure that there is no concurrent access going on while accessing the
-  // set of known histograms. The flag will be reset when this object goes
-  // out of scope.
-  MakeActive make_active(&is_active_);
-
-  // Get information known about this histogram. If it did not previously
-  // exist, one will be created and initialized.
-  SampleInfo* sample_info = &known_histograms_[histogram->name_hash()];
-
-  // Crash if we detect that our histograms have been overwritten.  This may be
-  // a fair distance from the memory smasher, but we hope to correlate these
-  // crashes with other events, such as plugins, or usage patterns, etc.
-  uint32_t corruption = histogram->FindCorruption(*samples);
-  if (HistogramBase::BUCKET_ORDER_ERROR & corruption) {
-    // Extract fields useful during debug.
-    const BucketRanges* ranges =
-        static_cast<const Histogram*>(histogram)->bucket_ranges();
-    uint32_t ranges_checksum = ranges->checksum();
-    uint32_t ranges_calc_checksum = ranges->CalculateChecksum();
-    int32_t flags = histogram->flags();
-    // The checksum should have caught this, so crash separately if it didn't.
-    CHECK_NE(0U, HistogramBase::RANGE_CHECKSUM_ERROR & corruption);
-    CHECK(false);  // Crash for the bucket order corruption.
-    // Ensure that compiler keeps around pointers to |histogram| and its
-    // internal |bucket_ranges_| for any minidumps.
-    base::debug::Alias(&ranges_checksum);
-    base::debug::Alias(&ranges_calc_checksum);
-    base::debug::Alias(&flags);
-  }
-  // Checksum corruption might not have caused order corruption.
-  CHECK_EQ(0U, HistogramBase::RANGE_CHECKSUM_ERROR & corruption);
-
-  // Note, at this point corruption can only be COUNT_HIGH_ERROR or
-  // COUNT_LOW_ERROR and they never arise together, so we don't need to extract
-  // bits from corruption.
-  if (corruption) {
-    DLOG(ERROR) << "Histogram: \"" << histogram->histogram_name()
-                << "\" has data corruption: " << corruption;
-    // Don't record corrupt data to metrics services.
-    const uint32_t old_corruption = sample_info->inconsistencies;
-    if (old_corruption == (corruption | old_corruption))
-      return;  // We've already seen this corruption for this histogram.
-    sample_info->inconsistencies |= corruption;
-    return;
-  }
-
-  if (samples->TotalCount() > 0)
-    histogram_flattener_->RecordDelta(*histogram, *samples);
-}
-
-}  // namespace base
diff --git a/base/metrics/histogram_snapshot_manager.h b/base/metrics/histogram_snapshot_manager.h
deleted file mode 100644
index cf7c149..0000000
--- a/base/metrics/histogram_snapshot_manager.h
+++ /dev/null
@@ -1,90 +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_METRICS_HISTOGRAM_SNAPSHOT_MANAGER_H_
-#define BASE_METRICS_HISTOGRAM_SNAPSHOT_MANAGER_H_
-
-#include <stdint.h>
-
-#include <atomic>
-#include <map>
-#include <string>
-#include <vector>
-
-#include "base/gtest_prod_util.h"
-#include "base/macros.h"
-#include "base/metrics/histogram_base.h"
-
-namespace base {
-
-class HistogramSamples;
-class HistogramFlattener;
-
-// HistogramSnapshotManager handles the logistics of gathering up available
-// histograms for recording either to disk or for transmission (such as from
-// renderer to browser, or from browser to UMA upload). Since histograms can sit
-// in memory for an extended period of time, and are vulnerable to memory
-// corruption, this class also validates as much redundancy as it can before
-// calling for the marginal change (a.k.a., delta) in a histogram to be
-// recorded.
-class BASE_EXPORT HistogramSnapshotManager final {
- public:
-  explicit HistogramSnapshotManager(HistogramFlattener* histogram_flattener);
-  ~HistogramSnapshotManager();
-
-  // Snapshot all histograms, and ask |histogram_flattener_| to record the
-  // delta. |flags_to_set| is used to set flags for each histogram.
-  // |required_flags| is used to select histograms to be recorded.
-  // Only histograms that have all the flags specified by the argument will be
-  // chosen. If all histograms should be recorded, set it to
-  // |Histogram::kNoFlags|.
-  void PrepareDeltas(const std::vector<HistogramBase*>& histograms,
-                     HistogramBase::Flags flags_to_set,
-                     HistogramBase::Flags required_flags);
-
-  // When the collection is not so simple as can be done using a single
-  // iterator, the steps can be performed separately. Call PerpareDelta()
-  // as many times as necessary. PrepareFinalDelta() works like PrepareDelta()
-  // except that it does not update the previous logged values and can thus
-  // be used with read-only files.
-  void PrepareDelta(HistogramBase* histogram);
-  void PrepareFinalDelta(const HistogramBase* histogram);
-
- private:
-  FRIEND_TEST_ALL_PREFIXES(HistogramSnapshotManagerTest, CheckMerge);
-
-  // During a snapshot, samples are acquired and aggregated. This structure
-  // contains all the information for a given histogram that persists between
-  // collections.
-  struct SampleInfo {
-    // The set of inconsistencies (flags) already seen for the histogram.
-    // See HistogramBase::Inconsistency for values.
-    uint32_t inconsistencies = 0;
-  };
-
-  // Capture and hold samples from a histogram. This does all the heavy
-  // lifting for PrepareDelta() and PrepareAbsolute().
-  void PrepareSamples(const HistogramBase* histogram,
-                      std::unique_ptr<HistogramSamples> samples);
-
-  // |histogram_flattener_| handles the logistics of recording the histogram
-  // deltas.
-  HistogramFlattener* const histogram_flattener_;  // Weak.
-
-  // For histograms, track what has been previously seen, indexed
-  // by the hash of the histogram name.
-  std::map<uint64_t, SampleInfo> known_histograms_;
-
-  // A flag indicating if a thread is currently doing an operation. This is
-  // used to check against concurrent access which is not supported. A Thread-
-  // Checker is not sufficient because it may be guarded by at outside lock
-  // (as is the case with cronet).
-  std::atomic<bool> is_active_;
-
-  DISALLOW_COPY_AND_ASSIGN(HistogramSnapshotManager);
-};
-
-}  // namespace base
-
-#endif  // BASE_METRICS_HISTOGRAM_SNAPSHOT_MANAGER_H_
diff --git a/base/metrics/metrics_hashes.cc b/base/metrics/metrics_hashes.cc
deleted file mode 100644
index 5672b06..0000000
--- a/base/metrics/metrics_hashes.cc
+++ /dev/null
@@ -1,31 +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/metrics/metrics_hashes.h"
-
-#include "base/logging.h"
-#include "base/md5.h"
-#include "base/sys_byteorder.h"
-
-namespace base {
-
-namespace {
-
-// Converts the 8-byte prefix of an MD5 hash into a uint64_t value.
-inline uint64_t DigestToUInt64(const base::MD5Digest& digest) {
-  uint64_t value;
-  DCHECK_GE(sizeof(digest.a), sizeof(value));
-  memcpy(&value, digest.a, sizeof(value));
-  return base::NetToHost64(value);
-}
-
-}  // namespace
-
-uint64_t HashMetricName(base::StringPiece name) {
-  base::MD5Digest digest;
-  base::MD5Sum(name.data(), name.size(), &digest);
-  return DigestToUInt64(digest);
-}
-
-}  // namespace metrics
diff --git a/base/metrics/metrics_hashes.h b/base/metrics/metrics_hashes.h
deleted file mode 100644
index d05c4ba..0000000
--- a/base/metrics/metrics_hashes.h
+++ /dev/null
@@ -1,21 +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_METRICS_METRICS_HASHES_H_
-#define BASE_METRICS_METRICS_HASHES_H_
-
-#include <stdint.h>
-
-#include "base/base_export.h"
-#include "base/strings/string_piece.h"
-
-namespace base {
-
-// Computes a uint64_t hash of a given string based on its MD5 hash. Suitable
-// for metric names.
-BASE_EXPORT uint64_t HashMetricName(base::StringPiece name);
-
-}  // namespace metrics
-
-#endif  // BASE_METRICS_METRICS_HASHES_H_
diff --git a/base/metrics/persistent_histogram_allocator.cc b/base/metrics/persistent_histogram_allocator.cc
deleted file mode 100644
index bfbb44b..0000000
--- a/base/metrics/persistent_histogram_allocator.cc
+++ /dev/null
@@ -1,1024 +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/metrics/persistent_histogram_allocator.h"
-
-#include <memory>
-
-#include "base/atomicops.h"
-#include "base/files/file_path.h"
-#include "base/files/file_util.h"
-#include "base/files/important_file_writer.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.h"
-#include "base/metrics/histogram_base.h"
-#include "base/metrics/histogram_samples.h"
-#include "base/metrics/metrics_hashes.h"
-#include "base/metrics/persistent_sample_map.h"
-#include "base/metrics/sparse_histogram.h"
-#include "base/metrics/statistics_recorder.h"
-#include "base/numerics/safe_conversions.h"
-#include "base/pickle.h"
-#include "base/process/process_handle.h"
-#include "base/strings/string_number_conversions.h"
-#include "base/strings/string_split.h"
-#include "base/strings/stringprintf.h"
-#include "base/synchronization/lock.h"
-
-namespace base {
-
-namespace {
-
-// Type identifiers used when storing in persistent memory so they can be
-// identified during extraction; the first 4 bytes of the SHA1 of the name
-// is used as a unique integer. A "version number" is added to the base
-// so that, if the structure of that object changes, stored older versions
-// will be safely ignored.
-enum : uint32_t {
-  kTypeIdRangesArray = 0xBCEA225A + 1,  // SHA1(RangesArray) v1
-  kTypeIdCountsArray = 0x53215530 + 1,  // SHA1(CountsArray) v1
-};
-
-// The current globally-active persistent allocator for all new histograms.
-// The object held here will obviously not be destructed at process exit
-// but that's best since PersistentMemoryAllocator objects (that underlie
-// GlobalHistogramAllocator objects) are explicitly forbidden from doing
-// anything essential at exit anyway due to the fact that they depend on data
-// managed elsewhere and which could be destructed first. An AtomicWord is
-// used instead of std::atomic because the latter can create global ctors
-// and dtors.
-subtle::AtomicWord g_histogram_allocator = 0;
-
-// Take an array of range boundaries and create a proper BucketRanges object
-// which is returned to the caller. A return of nullptr indicates that the
-// passed boundaries are invalid.
-std::unique_ptr<BucketRanges> CreateRangesFromData(
-    HistogramBase::Sample* ranges_data,
-    uint32_t ranges_checksum,
-    size_t count) {
-  // To avoid racy destruction at shutdown, the following may be leaked.
-  std::unique_ptr<BucketRanges> ranges(new BucketRanges(count));
-  DCHECK_EQ(count, ranges->size());
-  for (size_t i = 0; i < count; ++i) {
-    if (i > 0 && ranges_data[i] <= ranges_data[i - 1])
-      return nullptr;
-    ranges->set_range(i, ranges_data[i]);
-  }
-
-  ranges->ResetChecksum();
-  if (ranges->checksum() != ranges_checksum)
-    return nullptr;
-
-  return ranges;
-}
-
-// Calculate the number of bytes required to store all of a histogram's
-// "counts". This will return zero (0) if |bucket_count| is not valid.
-size_t CalculateRequiredCountsBytes(size_t bucket_count) {
-  // 2 because each "sample count" also requires a backup "logged count"
-  // used for calculating the delta during snapshot operations.
-  const size_t kBytesPerBucket = 2 * sizeof(HistogramBase::AtomicCount);
-
-  // If the |bucket_count| is such that it would overflow the return type,
-  // perhaps as the result of a malicious actor, then return zero to
-  // indicate the problem to the caller.
-  if (bucket_count > std::numeric_limits<size_t>::max() / kBytesPerBucket)
-    return 0;
-
-  return bucket_count * kBytesPerBucket;
-}
-
-}  // namespace
-
-const Feature kPersistentHistogramsFeature{
-  "PersistentHistograms", FEATURE_DISABLED_BY_DEFAULT
-};
-
-
-PersistentSparseHistogramDataManager::PersistentSparseHistogramDataManager(
-    PersistentMemoryAllocator* allocator)
-    : allocator_(allocator), record_iterator_(allocator) {}
-
-PersistentSparseHistogramDataManager::~PersistentSparseHistogramDataManager() =
-    default;
-
-PersistentSampleMapRecords*
-PersistentSparseHistogramDataManager::UseSampleMapRecords(uint64_t id,
-                                                          const void* user) {
-  base::AutoLock auto_lock(lock_);
-  return GetSampleMapRecordsWhileLocked(id)->Acquire(user);
-}
-
-PersistentSampleMapRecords*
-PersistentSparseHistogramDataManager::GetSampleMapRecordsWhileLocked(
-    uint64_t id) {
-  lock_.AssertAcquired();
-
-  auto found = sample_records_.find(id);
-  if (found != sample_records_.end())
-    return found->second.get();
-
-  std::unique_ptr<PersistentSampleMapRecords>& samples = sample_records_[id];
-  samples = std::make_unique<PersistentSampleMapRecords>(this, id);
-  return samples.get();
-}
-
-bool PersistentSparseHistogramDataManager::LoadRecords(
-    PersistentSampleMapRecords* sample_map_records) {
-  // DataManager must be locked in order to access the found_ field of any
-  // PersistentSampleMapRecords object.
-  base::AutoLock auto_lock(lock_);
-  bool found = false;
-
-  // If there are already "found" entries for the passed object, move them.
-  if (!sample_map_records->found_.empty()) {
-    sample_map_records->records_.reserve(sample_map_records->records_.size() +
-                                         sample_map_records->found_.size());
-    sample_map_records->records_.insert(sample_map_records->records_.end(),
-                                        sample_map_records->found_.begin(),
-                                        sample_map_records->found_.end());
-    sample_map_records->found_.clear();
-    found = true;
-  }
-
-  // Acquiring a lock is a semi-expensive operation so load some records with
-  // each call. More than this number may be loaded if it takes longer to
-  // find at least one matching record for the passed object.
-  const int kMinimumNumberToLoad = 10;
-  const uint64_t match_id = sample_map_records->sample_map_id_;
-
-  // Loop while no enty is found OR we haven't yet loaded the minimum number.
-  // This will continue reading even after a match is found.
-  for (int count = 0; !found || count < kMinimumNumberToLoad; ++count) {
-    // Get the next sample-record. The iterator will always resume from where
-    // it left off even if it previously had nothing further to return.
-    uint64_t found_id;
-    PersistentMemoryAllocator::Reference ref =
-        PersistentSampleMap::GetNextPersistentRecord(record_iterator_,
-                                                     &found_id);
-
-    // Stop immediately if there are none.
-    if (!ref)
-      break;
-
-    // The sample-record could be for any sparse histogram. Add the reference
-    // to the appropriate collection for later use.
-    if (found_id == match_id) {
-      sample_map_records->records_.push_back(ref);
-      found = true;
-    } else {
-      PersistentSampleMapRecords* samples =
-          GetSampleMapRecordsWhileLocked(found_id);
-      DCHECK(samples);
-      samples->found_.push_back(ref);
-    }
-  }
-
-  return found;
-}
-
-
-PersistentSampleMapRecords::PersistentSampleMapRecords(
-    PersistentSparseHistogramDataManager* data_manager,
-    uint64_t sample_map_id)
-    : data_manager_(data_manager), sample_map_id_(sample_map_id) {}
-
-PersistentSampleMapRecords::~PersistentSampleMapRecords() = default;
-
-PersistentSampleMapRecords* PersistentSampleMapRecords::Acquire(
-    const void* user) {
-  DCHECK(!user_);
-  user_ = user;
-  seen_ = 0;
-  return this;
-}
-
-void PersistentSampleMapRecords::Release(const void* user) {
-  DCHECK_EQ(user_, user);
-  user_ = nullptr;
-}
-
-PersistentMemoryAllocator::Reference PersistentSampleMapRecords::GetNext() {
-  DCHECK(user_);
-
-  // If there are no unseen records, lock and swap in all the found ones.
-  if (records_.size() == seen_) {
-    if (!data_manager_->LoadRecords(this))
-      return false;
-  }
-
-  // Return the next record. Records *must* be returned in the same order
-  // they are found in the persistent memory in order to ensure that all
-  // objects using this data always have the same state. Race conditions
-  // can cause duplicate records so using the "first found" is the only
-  // guarantee that all objects always access the same one.
-  DCHECK_LT(seen_, records_.size());
-  return records_[seen_++];
-}
-
-PersistentMemoryAllocator::Reference PersistentSampleMapRecords::CreateNew(
-    HistogramBase::Sample value) {
-  return PersistentSampleMap::CreatePersistentRecord(data_manager_->allocator_,
-                                                     sample_map_id_, value);
-}
-
-
-// This data will be held in persistent memory in order for processes to
-// locate and use histograms created elsewhere.
-struct PersistentHistogramAllocator::PersistentHistogramData {
-  // SHA1(Histogram): Increment this if structure changes!
-  static constexpr uint32_t kPersistentTypeId = 0xF1645910 + 3;
-
-  // Expected size for 32/64-bit check.
-  static constexpr size_t kExpectedInstanceSize =
-      40 + 2 * HistogramSamples::Metadata::kExpectedInstanceSize;
-
-  int32_t histogram_type;
-  int32_t flags;
-  int32_t minimum;
-  int32_t maximum;
-  uint32_t bucket_count;
-  PersistentMemoryAllocator::Reference ranges_ref;
-  uint32_t ranges_checksum;
-  subtle::Atomic32 counts_ref;  // PersistentMemoryAllocator::Reference
-  HistogramSamples::Metadata samples_metadata;
-  HistogramSamples::Metadata logged_metadata;
-
-  // Space for the histogram name will be added during the actual allocation
-  // request. This must be the last field of the structure. A zero-size array
-  // or a "flexible" array would be preferred but is not (yet) valid C++.
-  char name[sizeof(uint64_t)];  // Force 64-bit alignment on 32-bit builds.
-};
-
-PersistentHistogramAllocator::Iterator::Iterator(
-    PersistentHistogramAllocator* allocator)
-    : allocator_(allocator), memory_iter_(allocator->memory_allocator()) {}
-
-std::unique_ptr<HistogramBase>
-PersistentHistogramAllocator::Iterator::GetNextWithIgnore(Reference ignore) {
-  PersistentMemoryAllocator::Reference ref;
-  while ((ref = memory_iter_.GetNextOfType<PersistentHistogramData>()) != 0) {
-    if (ref != ignore)
-      return allocator_->GetHistogram(ref);
-  }
-  return nullptr;
-}
-
-
-PersistentHistogramAllocator::PersistentHistogramAllocator(
-    std::unique_ptr<PersistentMemoryAllocator> memory)
-    : memory_allocator_(std::move(memory)),
-      sparse_histogram_data_manager_(memory_allocator_.get()) {}
-
-PersistentHistogramAllocator::~PersistentHistogramAllocator() = default;
-
-std::unique_ptr<HistogramBase> PersistentHistogramAllocator::GetHistogram(
-    Reference ref) {
-  // Unfortunately, the histogram "pickle" methods cannot be used as part of
-  // the persistance because the deserialization methods always create local
-  // count data (while these must reference the persistent counts) and always
-  // add it to the local list of known histograms (while these may be simple
-  // references to histograms in other processes).
-  PersistentHistogramData* data =
-      memory_allocator_->GetAsObject<PersistentHistogramData>(ref);
-  const size_t length = memory_allocator_->GetAllocSize(ref);
-
-  // Check that metadata is reasonable: name is null-terminated and non-empty,
-  // ID fields have been loaded with a hash of the name (0 is considered
-  // unset/invalid).
-  if (!data || data->name[0] == '\0' ||
-      reinterpret_cast<char*>(data)[length - 1] != '\0' ||
-      data->samples_metadata.id == 0 || data->logged_metadata.id == 0 ||
-      // Note: Sparse histograms use |id + 1| in |logged_metadata|.
-      (data->logged_metadata.id != data->samples_metadata.id &&
-       data->logged_metadata.id != data->samples_metadata.id + 1) ||
-      // Most non-matching values happen due to truncated names. Ideally, we
-      // could just verify the name length based on the overall alloc length,
-      // but that doesn't work because the allocated block may have been
-      // aligned to the next boundary value.
-      HashMetricName(data->name) != data->samples_metadata.id) {
-    NOTREACHED();
-    return nullptr;
-  }
-  return CreateHistogram(data);
-}
-
-std::unique_ptr<HistogramBase> PersistentHistogramAllocator::AllocateHistogram(
-    HistogramType histogram_type,
-    const std::string& name,
-    int minimum,
-    int maximum,
-    const BucketRanges* bucket_ranges,
-    int32_t flags,
-    Reference* ref_ptr) {
-  // If the allocator is corrupt, don't waste time trying anything else.
-  // This also allows differentiating on the dashboard between allocations
-  // failed due to a corrupt allocator and the number of process instances
-  // with one, the latter being idicated by "newly corrupt", below.
-  if (memory_allocator_->IsCorrupt())
-    return nullptr;
-
-  // Create the metadata necessary for a persistent sparse histogram. This
-  // is done first because it is a small subset of what is required for
-  // other histograms. The type is "under construction" so that a crash
-  // during the datafill doesn't leave a bad record around that could cause
-  // confusion by another process trying to read it. It will be corrected
-  // once histogram construction is complete.
-  PersistentHistogramData* histogram_data =
-      memory_allocator_->New<PersistentHistogramData>(
-          offsetof(PersistentHistogramData, name) + name.length() + 1);
-  if (histogram_data) {
-    memcpy(histogram_data->name, name.c_str(), name.size() + 1);
-    histogram_data->histogram_type = histogram_type;
-    histogram_data->flags = flags | HistogramBase::kIsPersistent;
-  }
-
-  // Create the remaining metadata necessary for regular histograms.
-  if (histogram_type != SPARSE_HISTOGRAM) {
-    size_t bucket_count = bucket_ranges->bucket_count();
-    size_t counts_bytes = CalculateRequiredCountsBytes(bucket_count);
-    if (counts_bytes == 0) {
-      // |bucket_count| was out-of-range.
-      NOTREACHED();
-      return nullptr;
-    }
-
-    // Since the StasticsRecorder keeps a global collection of BucketRanges
-    // objects for re-use, it would be dangerous for one to hold a reference
-    // from a persistent allocator that is not the global one (which is
-    // permanent once set). If this stops being the case, this check can
-    // become an "if" condition beside "!ranges_ref" below and before
-    // set_persistent_reference() farther down.
-    DCHECK_EQ(this, GlobalHistogramAllocator::Get());
-
-    // Re-use an existing BucketRanges persistent allocation if one is known;
-    // otherwise, create one.
-    PersistentMemoryAllocator::Reference ranges_ref =
-        bucket_ranges->persistent_reference();
-    if (!ranges_ref) {
-      size_t ranges_count = bucket_count + 1;
-      size_t ranges_bytes = ranges_count * sizeof(HistogramBase::Sample);
-      ranges_ref =
-          memory_allocator_->Allocate(ranges_bytes, kTypeIdRangesArray);
-      if (ranges_ref) {
-        HistogramBase::Sample* ranges_data =
-            memory_allocator_->GetAsArray<HistogramBase::Sample>(
-                ranges_ref, kTypeIdRangesArray, ranges_count);
-        if (ranges_data) {
-          for (size_t i = 0; i < bucket_ranges->size(); ++i)
-            ranges_data[i] = bucket_ranges->range(i);
-          bucket_ranges->set_persistent_reference(ranges_ref);
-        } else {
-          // This should never happen but be tolerant if it does.
-          NOTREACHED();
-          ranges_ref = PersistentMemoryAllocator::kReferenceNull;
-        }
-      }
-    } else {
-      DCHECK_EQ(kTypeIdRangesArray, memory_allocator_->GetType(ranges_ref));
-    }
-
-
-    // Only continue here if all allocations were successful. If they weren't,
-    // there is no way to free the space but that's not really a problem since
-    // the allocations only fail because the space is full or corrupt and so
-    // any future attempts will also fail.
-    if (ranges_ref && histogram_data) {
-      histogram_data->minimum = minimum;
-      histogram_data->maximum = maximum;
-      // |bucket_count| must fit within 32-bits or the allocation of the counts
-      // array would have failed for being too large; the allocator supports
-      // less than 4GB total size.
-      histogram_data->bucket_count = static_cast<uint32_t>(bucket_count);
-      histogram_data->ranges_ref = ranges_ref;
-      histogram_data->ranges_checksum = bucket_ranges->checksum();
-    } else {
-      histogram_data = nullptr;  // Clear this for proper handling below.
-    }
-  }
-
-  if (histogram_data) {
-    // Create the histogram using resources in persistent memory. This ends up
-    // resolving the "ref" values stored in histogram_data instad of just
-    // using what is already known above but avoids duplicating the switch
-    // statement here and serves as a double-check that everything is
-    // correct before commiting the new histogram to persistent space.
-    std::unique_ptr<HistogramBase> histogram = CreateHistogram(histogram_data);
-    DCHECK(histogram);
-    DCHECK_NE(0U, histogram_data->samples_metadata.id);
-    DCHECK_NE(0U, histogram_data->logged_metadata.id);
-
-    PersistentMemoryAllocator::Reference histogram_ref =
-        memory_allocator_->GetAsReference(histogram_data);
-    if (ref_ptr != nullptr)
-      *ref_ptr = histogram_ref;
-
-    // By storing the reference within the allocator to this histogram, the
-    // next import (which will happen before the next histogram creation)
-    // will know to skip it.
-    // See also the comment in ImportHistogramsToStatisticsRecorder().
-    subtle::NoBarrier_Store(&last_created_, histogram_ref);
-    return histogram;
-  }
-
-  if (memory_allocator_->IsCorrupt())
-    NOTREACHED() << memory_allocator_->Name() << " is corrupt!";
-
-  return nullptr;
-}
-
-void PersistentHistogramAllocator::FinalizeHistogram(Reference ref,
-                                                     bool registered) {
-  if (registered) {
-    // If the created persistent histogram was registered then it needs to
-    // be marked as "iterable" in order to be found by other processes. This
-    // happens only after the histogram is fully formed so it's impossible for
-    // code iterating through the allocator to read a partially created record.
-    memory_allocator_->MakeIterable(ref);
-  } else {
-    // If it wasn't registered then a race condition must have caused two to
-    // be created. The allocator does not support releasing the acquired memory
-    // so just change the type to be empty.
-    memory_allocator_->ChangeType(ref, 0,
-                                  PersistentHistogramData::kPersistentTypeId,
-                                  /*clear=*/false);
-  }
-}
-
-void PersistentHistogramAllocator::MergeHistogramDeltaToStatisticsRecorder(
-    HistogramBase* histogram) {
-  DCHECK(histogram);
-
-  HistogramBase* existing = GetOrCreateStatisticsRecorderHistogram(histogram);
-  if (!existing) {
-    // The above should never fail but if it does, no real harm is done.
-    // The data won't be merged but it also won't be recorded as merged
-    // so a future try, if successful, will get what was missed. If it
-    // continues to fail, some metric data will be lost but that is better
-    // than crashing.
-    NOTREACHED();
-    return;
-  }
-
-  // Merge the delta from the passed object to the one in the SR.
-  existing->AddSamples(*histogram->SnapshotDelta());
-}
-
-void PersistentHistogramAllocator::MergeHistogramFinalDeltaToStatisticsRecorder(
-    const HistogramBase* histogram) {
-  DCHECK(histogram);
-
-  HistogramBase* existing = GetOrCreateStatisticsRecorderHistogram(histogram);
-  if (!existing) {
-    // The above should never fail but if it does, no real harm is done.
-    // Some metric data will be lost but that is better than crashing.
-    NOTREACHED();
-    return;
-  }
-
-  // Merge the delta from the passed object to the one in the SR.
-  existing->AddSamples(*histogram->SnapshotFinalDelta());
-}
-
-PersistentSampleMapRecords* PersistentHistogramAllocator::UseSampleMapRecords(
-    uint64_t id,
-    const void* user) {
-  return sparse_histogram_data_manager_.UseSampleMapRecords(id, user);
-}
-
-void PersistentHistogramAllocator::CreateTrackingHistograms(StringPiece name) {
-  memory_allocator_->CreateTrackingHistograms(name);
-}
-
-void PersistentHistogramAllocator::UpdateTrackingHistograms() {
-  memory_allocator_->UpdateTrackingHistograms();
-}
-
-void PersistentHistogramAllocator::ClearLastCreatedReferenceForTesting() {
-  subtle::NoBarrier_Store(&last_created_, 0);
-}
-
-std::unique_ptr<HistogramBase> PersistentHistogramAllocator::CreateHistogram(
-    PersistentHistogramData* histogram_data_ptr) {
-  if (!histogram_data_ptr) {
-    NOTREACHED();
-    return nullptr;
-  }
-
-  // Sparse histograms are quite different so handle them as a special case.
-  if (histogram_data_ptr->histogram_type == SPARSE_HISTOGRAM) {
-    std::unique_ptr<HistogramBase> histogram =
-        SparseHistogram::PersistentCreate(this, histogram_data_ptr->name,
-                                          &histogram_data_ptr->samples_metadata,
-                                          &histogram_data_ptr->logged_metadata);
-    DCHECK(histogram);
-    histogram->SetFlags(histogram_data_ptr->flags);
-    return histogram;
-  }
-
-  // Copy the configuration fields from histogram_data_ptr to local storage
-  // because anything in persistent memory cannot be trusted as it could be
-  // changed at any moment by a malicious actor that shares access. The local
-  // values are validated below and then used to create the histogram, knowing
-  // they haven't changed between validation and use.
-  int32_t histogram_type = histogram_data_ptr->histogram_type;
-  int32_t histogram_flags = histogram_data_ptr->flags;
-  int32_t histogram_minimum = histogram_data_ptr->minimum;
-  int32_t histogram_maximum = histogram_data_ptr->maximum;
-  uint32_t histogram_bucket_count = histogram_data_ptr->bucket_count;
-  uint32_t histogram_ranges_ref = histogram_data_ptr->ranges_ref;
-  uint32_t histogram_ranges_checksum = histogram_data_ptr->ranges_checksum;
-
-  HistogramBase::Sample* ranges_data =
-      memory_allocator_->GetAsArray<HistogramBase::Sample>(
-          histogram_ranges_ref, kTypeIdRangesArray,
-          PersistentMemoryAllocator::kSizeAny);
-
-  const uint32_t max_buckets =
-      std::numeric_limits<uint32_t>::max() / sizeof(HistogramBase::Sample);
-  size_t required_bytes =
-      (histogram_bucket_count + 1) * sizeof(HistogramBase::Sample);
-  size_t allocated_bytes =
-      memory_allocator_->GetAllocSize(histogram_ranges_ref);
-  if (!ranges_data || histogram_bucket_count < 2 ||
-      histogram_bucket_count >= max_buckets ||
-      allocated_bytes < required_bytes) {
-    NOTREACHED();
-    return nullptr;
-  }
-
-  std::unique_ptr<const BucketRanges> created_ranges = CreateRangesFromData(
-      ranges_data, histogram_ranges_checksum, histogram_bucket_count + 1);
-  if (!created_ranges) {
-    NOTREACHED();
-    return nullptr;
-  }
-  const BucketRanges* ranges =
-      StatisticsRecorder::RegisterOrDeleteDuplicateRanges(
-          created_ranges.release());
-
-  size_t counts_bytes = CalculateRequiredCountsBytes(histogram_bucket_count);
-  PersistentMemoryAllocator::Reference counts_ref =
-      subtle::Acquire_Load(&histogram_data_ptr->counts_ref);
-  if (counts_bytes == 0 ||
-      (counts_ref != 0 &&
-       memory_allocator_->GetAllocSize(counts_ref) < counts_bytes)) {
-    NOTREACHED();
-    return nullptr;
-  }
-
-  // The "counts" data (including both samples and logged samples) is a delayed
-  // persistent allocation meaning that though its size and storage for a
-  // reference is defined, no space is reserved until actually needed. When
-  // it is needed, memory will be allocated from the persistent segment and
-  // a reference to it stored at the passed address. Other threads can then
-  // notice the valid reference and access the same data.
-  DelayedPersistentAllocation counts_data(memory_allocator_.get(),
-                                          &histogram_data_ptr->counts_ref,
-                                          kTypeIdCountsArray, counts_bytes, 0);
-
-  // A second delayed allocations is defined using the same reference storage
-  // location as the first so the allocation of one will automatically be found
-  // by the other. Within the block, the first half of the space is for "counts"
-  // and the second half is for "logged counts".
-  DelayedPersistentAllocation logged_data(
-      memory_allocator_.get(), &histogram_data_ptr->counts_ref,
-      kTypeIdCountsArray, counts_bytes, counts_bytes / 2,
-      /*make_iterable=*/false);
-
-  // Create the right type of histogram.
-  const char* name = histogram_data_ptr->name;
-  std::unique_ptr<HistogramBase> histogram;
-  switch (histogram_type) {
-    case HISTOGRAM:
-      histogram = Histogram::PersistentCreate(
-          name, histogram_minimum, histogram_maximum, ranges, counts_data,
-          logged_data, &histogram_data_ptr->samples_metadata,
-          &histogram_data_ptr->logged_metadata);
-      DCHECK(histogram);
-      break;
-    case LINEAR_HISTOGRAM:
-      histogram = LinearHistogram::PersistentCreate(
-          name, histogram_minimum, histogram_maximum, ranges, counts_data,
-          logged_data, &histogram_data_ptr->samples_metadata,
-          &histogram_data_ptr->logged_metadata);
-      DCHECK(histogram);
-      break;
-    case BOOLEAN_HISTOGRAM:
-      histogram = BooleanHistogram::PersistentCreate(
-          name, ranges, counts_data, logged_data,
-          &histogram_data_ptr->samples_metadata,
-          &histogram_data_ptr->logged_metadata);
-      DCHECK(histogram);
-      break;
-    case CUSTOM_HISTOGRAM:
-      histogram = CustomHistogram::PersistentCreate(
-          name, ranges, counts_data, logged_data,
-          &histogram_data_ptr->samples_metadata,
-          &histogram_data_ptr->logged_metadata);
-      DCHECK(histogram);
-      break;
-    default:
-      NOTREACHED();
-  }
-
-  if (histogram) {
-    DCHECK_EQ(histogram_type, histogram->GetHistogramType());
-    histogram->SetFlags(histogram_flags);
-  }
-
-  return histogram;
-}
-
-HistogramBase*
-PersistentHistogramAllocator::GetOrCreateStatisticsRecorderHistogram(
-    const HistogramBase* histogram) {
-  // This should never be called on the global histogram allocator as objects
-  // created there are already within the global statistics recorder.
-  DCHECK_NE(GlobalHistogramAllocator::Get(), this);
-  DCHECK(histogram);
-
-  HistogramBase* existing =
-      StatisticsRecorder::FindHistogram(histogram->histogram_name());
-  if (existing)
-    return existing;
-
-  // Adding the passed histogram to the SR would cause a problem if the
-  // allocator that holds it eventually goes away. Instead, create a new
-  // one from a serialized version. Deserialization calls the appropriate
-  // FactoryGet() which will create the histogram in the global persistent-
-  // histogram allocator if such is set.
-  base::Pickle pickle;
-  histogram->SerializeInfo(&pickle);
-  PickleIterator iter(pickle);
-  existing = DeserializeHistogramInfo(&iter);
-  if (!existing)
-    return nullptr;
-
-  // Make sure there is no "serialization" flag set.
-  DCHECK_EQ(0, existing->flags() & HistogramBase::kIPCSerializationSourceFlag);
-  // Record the newly created histogram in the SR.
-  return StatisticsRecorder::RegisterOrDeleteDuplicate(existing);
-}
-
-GlobalHistogramAllocator::~GlobalHistogramAllocator() = default;
-
-// static
-void GlobalHistogramAllocator::CreateWithPersistentMemory(
-    void* base,
-    size_t size,
-    size_t page_size,
-    uint64_t id,
-    StringPiece name) {
-  Set(WrapUnique(
-      new GlobalHistogramAllocator(std::make_unique<PersistentMemoryAllocator>(
-          base, size, page_size, id, name, false))));
-}
-
-// static
-void GlobalHistogramAllocator::CreateWithLocalMemory(
-    size_t size,
-    uint64_t id,
-    StringPiece name) {
-  Set(WrapUnique(new GlobalHistogramAllocator(
-      std::make_unique<LocalPersistentMemoryAllocator>(size, id, name))));
-}
-
-#if !defined(OS_NACL)
-// static
-bool GlobalHistogramAllocator::CreateWithFile(
-    const FilePath& file_path,
-    size_t size,
-    uint64_t id,
-    StringPiece name) {
-  bool exists = PathExists(file_path);
-  File file(
-      file_path, File::FLAG_OPEN_ALWAYS | File::FLAG_SHARE_DELETE |
-                 File::FLAG_READ | File::FLAG_WRITE);
-
-  std::unique_ptr<MemoryMappedFile> mmfile(new MemoryMappedFile());
-  if (exists) {
-    size = saturated_cast<size_t>(file.GetLength());
-    mmfile->Initialize(std::move(file), MemoryMappedFile::READ_WRITE);
-  } else {
-    mmfile->Initialize(std::move(file), {0, size},
-                       MemoryMappedFile::READ_WRITE_EXTEND);
-  }
-  if (!mmfile->IsValid() ||
-      !FilePersistentMemoryAllocator::IsFileAcceptable(*mmfile, true)) {
-    NOTREACHED() << file_path;
-    return false;
-  }
-
-  Set(WrapUnique(new GlobalHistogramAllocator(
-      std::make_unique<FilePersistentMemoryAllocator>(std::move(mmfile), size,
-                                                      id, name, false))));
-  Get()->SetPersistentLocation(file_path);
-  return true;
-}
-
-// static
-bool GlobalHistogramAllocator::CreateWithActiveFile(const FilePath& base_path,
-                                                    const FilePath& active_path,
-                                                    const FilePath& spare_path,
-                                                    size_t size,
-                                                    uint64_t id,
-                                                    StringPiece name) {
-  // Old "active" becomes "base".
-  if (!base::ReplaceFile(active_path, base_path, nullptr))
-    base::DeleteFile(base_path, /*recursive=*/false);
-  DCHECK(!base::PathExists(active_path));
-
-  // Move any "spare" into "active". Okay to continue if file doesn't exist.
-  if (!spare_path.empty()) {
-    base::ReplaceFile(spare_path, active_path, nullptr);
-    DCHECK(!base::PathExists(spare_path));
-  }
-
-  return base::GlobalHistogramAllocator::CreateWithFile(active_path, size, id,
-                                                        name);
-}
-
-// static
-bool GlobalHistogramAllocator::CreateWithActiveFileInDir(const FilePath& dir,
-                                                         size_t size,
-                                                         uint64_t id,
-                                                         StringPiece name) {
-  FilePath base_path, active_path, spare_path;
-  ConstructFilePaths(dir, name, &base_path, &active_path, &spare_path);
-  return CreateWithActiveFile(base_path, active_path, spare_path, size, id,
-                              name);
-}
-
-// static
-FilePath GlobalHistogramAllocator::ConstructFilePath(const FilePath& dir,
-                                                     StringPiece name) {
-  return dir.AppendASCII(name).AddExtension(
-      PersistentMemoryAllocator::kFileExtension);
-}
-
-// static
-FilePath GlobalHistogramAllocator::ConstructFilePathForUploadDir(
-    const FilePath& dir,
-    StringPiece name,
-    base::Time stamp,
-    ProcessId pid) {
-  return ConstructFilePath(
-      dir,
-      StringPrintf("%.*s-%lX-%lX", static_cast<int>(name.length()), name.data(),
-                   static_cast<long>(stamp.ToTimeT()), static_cast<long>(pid)));
-}
-
-// static
-bool GlobalHistogramAllocator::ParseFilePath(const FilePath& path,
-                                             std::string* out_name,
-                                             Time* out_stamp,
-                                             ProcessId* out_pid) {
-  std::string filename = path.BaseName().AsUTF8Unsafe();
-  std::vector<base::StringPiece> parts = base::SplitStringPiece(
-      filename, "-.", base::KEEP_WHITESPACE, base::SPLIT_WANT_ALL);
-  if (parts.size() != 4)
-    return false;
-
-  if (out_name)
-    *out_name = parts[0].as_string();
-
-  if (out_stamp) {
-    int64_t stamp;
-    if (!HexStringToInt64(parts[1], &stamp))
-      return false;
-    *out_stamp = Time::FromTimeT(static_cast<time_t>(stamp));
-  }
-
-  if (out_pid) {
-    int64_t pid;
-    if (!HexStringToInt64(parts[2], &pid))
-      return false;
-    *out_pid = static_cast<ProcessId>(pid);
-  }
-
-  return true;
-}
-
-// static
-void GlobalHistogramAllocator::ConstructFilePaths(const FilePath& dir,
-                                                  StringPiece name,
-                                                  FilePath* out_base_path,
-                                                  FilePath* out_active_path,
-                                                  FilePath* out_spare_path) {
-  if (out_base_path)
-    *out_base_path = ConstructFilePath(dir, name);
-
-  if (out_active_path) {
-    *out_active_path =
-        ConstructFilePath(dir, name.as_string().append("-active"));
-  }
-
-  if (out_spare_path) {
-    *out_spare_path = ConstructFilePath(dir, name.as_string().append("-spare"));
-  }
-}
-
-// static
-void GlobalHistogramAllocator::ConstructFilePathsForUploadDir(
-    const FilePath& active_dir,
-    const FilePath& upload_dir,
-    const std::string& name,
-    FilePath* out_upload_path,
-    FilePath* out_active_path,
-    FilePath* out_spare_path) {
-  if (out_upload_path) {
-    *out_upload_path = ConstructFilePathForUploadDir(
-        upload_dir, name, Time::Now(), GetCurrentProcId());
-  }
-
-  if (out_active_path) {
-    *out_active_path =
-        ConstructFilePath(active_dir, name + std::string("-active"));
-  }
-
-  if (out_spare_path) {
-    *out_spare_path =
-        ConstructFilePath(active_dir, name + std::string("-spare"));
-  }
-}
-
-// static
-bool GlobalHistogramAllocator::CreateSpareFile(const FilePath& spare_path,
-                                               size_t size) {
-  FilePath temp_spare_path = spare_path.AddExtension(FILE_PATH_LITERAL(".tmp"));
-  bool success = true;
-  {
-    File spare_file(temp_spare_path, File::FLAG_CREATE_ALWAYS |
-                                         File::FLAG_READ | File::FLAG_WRITE);
-    if (!spare_file.IsValid())
-      return false;
-
-    MemoryMappedFile mmfile;
-    mmfile.Initialize(std::move(spare_file), {0, size},
-                      MemoryMappedFile::READ_WRITE_EXTEND);
-    success = mmfile.IsValid();
-  }
-
-  if (success)
-    success = ReplaceFile(temp_spare_path, spare_path, nullptr);
-
-  if (!success)
-    DeleteFile(temp_spare_path, /*recursive=*/false);
-
-  return success;
-}
-
-// static
-bool GlobalHistogramAllocator::CreateSpareFileInDir(const FilePath& dir,
-                                                    size_t size,
-                                                    StringPiece name) {
-  FilePath spare_path;
-  ConstructFilePaths(dir, name, nullptr, nullptr, &spare_path);
-  return CreateSpareFile(spare_path, size);
-}
-#endif  // !defined(OS_NACL)
-
-// static
-void GlobalHistogramAllocator::CreateWithSharedMemoryHandle(
-    const SharedMemoryHandle& handle,
-    size_t size) {
-  std::unique_ptr<SharedMemory> shm(
-      new SharedMemory(handle, /*readonly=*/false));
-  if (!shm->Map(size) ||
-      !SharedPersistentMemoryAllocator::IsSharedMemoryAcceptable(*shm)) {
-    NOTREACHED();
-    return;
-  }
-
-  Set(WrapUnique(new GlobalHistogramAllocator(
-      std::make_unique<SharedPersistentMemoryAllocator>(
-          std::move(shm), 0, StringPiece(), /*readonly=*/false))));
-}
-
-// static
-void GlobalHistogramAllocator::Set(
-    std::unique_ptr<GlobalHistogramAllocator> allocator) {
-  // Releasing or changing an allocator is extremely dangerous because it
-  // likely has histograms stored within it. If the backing memory is also
-  // also released, future accesses to those histograms will seg-fault.
-  CHECK(!subtle::NoBarrier_Load(&g_histogram_allocator));
-  subtle::Release_Store(&g_histogram_allocator,
-                        reinterpret_cast<uintptr_t>(allocator.release()));
-  size_t existing = StatisticsRecorder::GetHistogramCount();
-
-  DVLOG_IF(1, existing)
-      << existing << " histograms were created before persistence was enabled.";
-}
-
-// static
-GlobalHistogramAllocator* GlobalHistogramAllocator::Get() {
-  return reinterpret_cast<GlobalHistogramAllocator*>(
-      subtle::Acquire_Load(&g_histogram_allocator));
-}
-
-// static
-std::unique_ptr<GlobalHistogramAllocator>
-GlobalHistogramAllocator::ReleaseForTesting() {
-  GlobalHistogramAllocator* histogram_allocator = Get();
-  if (!histogram_allocator)
-    return nullptr;
-  PersistentMemoryAllocator* memory_allocator =
-      histogram_allocator->memory_allocator();
-
-  // Before releasing the memory, it's necessary to have the Statistics-
-  // Recorder forget about the histograms contained therein; otherwise,
-  // some operations will try to access them and the released memory.
-  PersistentMemoryAllocator::Iterator iter(memory_allocator);
-  const PersistentHistogramData* data;
-  while ((data = iter.GetNextOfObject<PersistentHistogramData>()) != nullptr) {
-    StatisticsRecorder::ForgetHistogramForTesting(data->name);
-  }
-
-  subtle::Release_Store(&g_histogram_allocator, 0);
-  return WrapUnique(histogram_allocator);
-};
-
-void GlobalHistogramAllocator::SetPersistentLocation(const FilePath& location) {
-  persistent_location_ = location;
-}
-
-const FilePath& GlobalHistogramAllocator::GetPersistentLocation() const {
-  return persistent_location_;
-}
-
-bool GlobalHistogramAllocator::WriteToPersistentLocation() {
-#if defined(OS_NACL)
-  // NACL doesn't support file operations, including ImportantFileWriter.
-  NOTREACHED();
-  return false;
-#else
-  // Stop if no destination is set.
-  if (persistent_location_.empty()) {
-    NOTREACHED() << "Could not write \"" << Name() << "\" persistent histograms"
-                 << " to file because no location was set.";
-    return false;
-  }
-
-  StringPiece contents(static_cast<const char*>(data()), used());
-  if (!ImportantFileWriter::WriteFileAtomically(persistent_location_,
-                                                contents)) {
-    LOG(ERROR) << "Could not write \"" << Name() << "\" persistent histograms"
-               << " to file: " << persistent_location_.value();
-    return false;
-  }
-
-  return true;
-#endif
-}
-
-void GlobalHistogramAllocator::DeletePersistentLocation() {
-  memory_allocator()->SetMemoryState(PersistentMemoryAllocator::MEMORY_DELETED);
-
-#if defined(OS_NACL)
-  NOTREACHED();
-#else
-  if (persistent_location_.empty())
-    return;
-
-  // Open (with delete) and then immediately close the file by going out of
-  // scope. This is the only cross-platform safe way to delete a file that may
-  // be open elsewhere. Open handles will continue to operate normally but
-  // new opens will not be possible.
-  File file(persistent_location_,
-            File::FLAG_OPEN | File::FLAG_READ | File::FLAG_DELETE_ON_CLOSE);
-#endif
-}
-
-GlobalHistogramAllocator::GlobalHistogramAllocator(
-    std::unique_ptr<PersistentMemoryAllocator> memory)
-    : PersistentHistogramAllocator(std::move(memory)),
-      import_iterator_(this) {
-}
-
-void GlobalHistogramAllocator::ImportHistogramsToStatisticsRecorder() {
-  // Skip the import if it's the histogram that was last created. Should a
-  // race condition cause the "last created" to be overwritten before it
-  // is recognized here then the histogram will be created and be ignored
-  // when it is detected as a duplicate by the statistics-recorder. This
-  // simple check reduces the time of creating persistent histograms by
-  // about 40%.
-  Reference record_to_ignore = last_created();
-
-  // There is no lock on this because the iterator is lock-free while still
-  // guaranteed to only return each entry only once. The StatisticsRecorder
-  // has its own lock so the Register operation is safe.
-  while (true) {
-    std::unique_ptr<HistogramBase> histogram =
-        import_iterator_.GetNextWithIgnore(record_to_ignore);
-    if (!histogram)
-      break;
-    StatisticsRecorder::RegisterOrDeleteDuplicate(histogram.release());
-  }
-}
-
-}  // namespace base
diff --git a/base/metrics/persistent_histogram_allocator.h b/base/metrics/persistent_histogram_allocator.h
deleted file mode 100644
index 395511f..0000000
--- a/base/metrics/persistent_histogram_allocator.h
+++ /dev/null
@@ -1,505 +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_METRICS_HISTOGRAM_PERSISTENCE_H_
-#define BASE_METRICS_HISTOGRAM_PERSISTENCE_H_
-
-#include <map>
-#include <memory>
-
-#include "base/atomicops.h"
-#include "base/base_export.h"
-#include "base/feature_list.h"
-#include "base/memory/shared_memory.h"
-#include "base/metrics/histogram_base.h"
-#include "base/metrics/persistent_memory_allocator.h"
-#include "base/strings/string_piece.h"
-#include "base/synchronization/lock.h"
-
-namespace base {
-
-class BucketRanges;
-class FilePath;
-class PersistentSampleMapRecords;
-class PersistentSparseHistogramDataManager;
-
-// Feature definition for enabling histogram persistence.
-BASE_EXPORT extern const Feature kPersistentHistogramsFeature;
-
-
-// A data manager for sparse histograms so each instance of such doesn't have
-// to separately iterate over the entire memory segment. Though this class
-// will generally be accessed through the PersistentHistogramAllocator above,
-// it can be used independently on any PersistentMemoryAllocator (making it
-// useable for testing). This object supports only one instance of a sparse
-// histogram for a given id. Tests that create multiple identical histograms,
-// perhaps to simulate multiple processes, should create a separate manager
-// for each.
-class BASE_EXPORT PersistentSparseHistogramDataManager {
- public:
-  // Constructs the data manager. The allocator must live longer than any
-  // managers that reference it.
-  explicit PersistentSparseHistogramDataManager(
-      PersistentMemoryAllocator* allocator);
-
-  ~PersistentSparseHistogramDataManager();
-
-  // Returns the object that manages the persistent-sample-map records for a
-  // given |id|. Only one |user| of this data is allowed at a time. This does
-  // an automatic Acquire() on the records. The user must call Release() on
-  // the returned object when it is finished with it. Ownership of the records
-  // object stays with this manager.
-  PersistentSampleMapRecords* UseSampleMapRecords(uint64_t id,
-                                                  const void* user);
-
-  // Convenience method that gets the object for a given reference so callers
-  // don't have to also keep their own pointer to the appropriate allocator.
-  template <typename T>
-  T* GetAsObject(PersistentMemoryAllocator::Reference ref) {
-    return allocator_->GetAsObject<T>(ref);
-  }
-
- private:
-  friend class PersistentSampleMapRecords;
-
-  // Gets the object holding records for a given sample-map id when |lock_|
-  // has already been acquired.
-  PersistentSampleMapRecords* GetSampleMapRecordsWhileLocked(uint64_t id);
-
-  // Loads sample-map records looking for those belonging to the specified
-  // |load_id|. Records found for other sample-maps are held for later use
-  // without having to iterate again. This should be called only from a
-  // PersistentSampleMapRecords object because those objects have a contract
-  // that there are no other threads accessing the internal records_ field
-  // of the object that is passed in.
-  bool LoadRecords(PersistentSampleMapRecords* sample_map_records);
-
-  // Weak-pointer to the allocator used by the sparse histograms.
-  PersistentMemoryAllocator* allocator_;
-
-  // Iterator within the allocator for finding sample records.
-  PersistentMemoryAllocator::Iterator record_iterator_;
-
-  // Mapping of sample-map IDs to their sample records.
-  std::map<uint64_t, std::unique_ptr<PersistentSampleMapRecords>>
-      sample_records_;
-
-  // A lock used for synchronizing changes to sample_records_.
-  base::Lock lock_;
-
-  DISALLOW_COPY_AND_ASSIGN(PersistentSparseHistogramDataManager);
-};
-
-
-// This class manages sample-records used by a PersistentSampleMap container
-// that underlies a persistent SparseHistogram object. It is broken out into a
-// top-level class so that it can be forward-declared in other header files
-// rather than include this entire file as would be necessary if it were
-// declared within the PersistentSparseHistogramDataManager class above.
-class BASE_EXPORT PersistentSampleMapRecords {
- public:
-  // Constructs an instance of this class. The manager object must live longer
-  // than all instances of this class that reference it, which is not usually
-  // a problem since these objects are generally managed from within that
-  // manager instance.
-  PersistentSampleMapRecords(PersistentSparseHistogramDataManager* data_manager,
-                             uint64_t sample_map_id);
-
-  ~PersistentSampleMapRecords();
-
-  // Resets the internal state for a new object using this data. The return
-  // value is "this" as a convenience.
-  PersistentSampleMapRecords* Acquire(const void* user);
-
-  // Indicates that the using object is done with this data.
-  void Release(const void* user);
-
-  // Gets the next reference to a persistent sample-map record. The type and
-  // layout of the data being referenced is defined entirely within the
-  // PersistentSampleMap class.
-  PersistentMemoryAllocator::Reference GetNext();
-
-  // Creates a new persistent sample-map record for sample |value| and returns
-  // a reference to it.
-  PersistentMemoryAllocator::Reference CreateNew(HistogramBase::Sample value);
-
-  // Convenience method that gets the object for a given reference so callers
-  // don't have to also keep their own pointer to the appropriate allocator.
-  // This is expected to be used with the SampleRecord structure defined inside
-  // the persistent_sample_map.cc file but since that isn't exported (for
-  // cleanliness of the interface), a template is defined that will be
-  // resolved when used inside that file.
-  template <typename T>
-  T* GetAsObject(PersistentMemoryAllocator::Reference ref) {
-    return data_manager_->GetAsObject<T>(ref);
-  }
-
- private:
-  friend PersistentSparseHistogramDataManager;
-
-  // Weak-pointer to the parent data-manager object.
-  PersistentSparseHistogramDataManager* data_manager_;
-
-  // ID of PersistentSampleMap to which these records apply.
-  const uint64_t sample_map_id_;
-
-  // The current user of this set of records. It is used to ensure that no
-  // more than one object is using these records at a given time.
-  const void* user_ = nullptr;
-
-  // This is the count of how many "records" have already been read by the
-  // owning sample-map.
-  size_t seen_ = 0;
-
-  // This is the set of records previously found for a sample map. Because
-  // there is ever only one object with a given ID (typically a hash of a
-  // histogram name) and because the parent SparseHistogram has acquired
-  // its own lock before accessing the PersistentSampleMap it controls, this
-  // list can be accessed without acquiring any additional lock.
-  std::vector<PersistentMemoryAllocator::Reference> records_;
-
-  // This is the set of records found during iteration through memory. It
-  // is appended in bulk to "records". Access to this vector can be done
-  // only while holding the parent manager's lock.
-  std::vector<PersistentMemoryAllocator::Reference> found_;
-
-  DISALLOW_COPY_AND_ASSIGN(PersistentSampleMapRecords);
-};
-
-
-// This class manages histograms created within a PersistentMemoryAllocator.
-class BASE_EXPORT PersistentHistogramAllocator {
- public:
-  // A reference to a histogram. While this is implemented as PMA::Reference,
-  // it is not conceptually the same thing. Outside callers should always use
-  // a Reference matching the class it is for and not mix the two.
-  using Reference = PersistentMemoryAllocator::Reference;
-
-  // Iterator used for fetching persistent histograms from an allocator.
-  // It is lock-free and thread-safe.
-  // See PersistentMemoryAllocator::Iterator for more information.
-  class BASE_EXPORT Iterator {
-   public:
-    // Constructs an iterator on a given |allocator|, starting at the beginning.
-    // The allocator must live beyond the lifetime of the iterator.
-    explicit Iterator(PersistentHistogramAllocator* allocator);
-
-    // Gets the next histogram from persistent memory; returns null if there
-    // are no more histograms to be found. This may still be called again
-    // later to retrieve any new histograms added in the meantime.
-    std::unique_ptr<HistogramBase> GetNext() { return GetNextWithIgnore(0); }
-
-    // Gets the next histogram from persistent memory, ignoring one particular
-    // reference in the process. Pass |ignore| of zero (0) to ignore nothing.
-    std::unique_ptr<HistogramBase> GetNextWithIgnore(Reference ignore);
-
-   private:
-    // Weak-pointer to histogram allocator being iterated over.
-    PersistentHistogramAllocator* allocator_;
-
-    // The iterator used for stepping through objects in persistent memory.
-    // It is lock-free and thread-safe which is why this class is also such.
-    PersistentMemoryAllocator::Iterator memory_iter_;
-
-    DISALLOW_COPY_AND_ASSIGN(Iterator);
-  };
-
-  // A PersistentHistogramAllocator is constructed from a PersistentMemory-
-  // Allocator object of which it takes ownership.
-  explicit PersistentHistogramAllocator(
-      std::unique_ptr<PersistentMemoryAllocator> memory);
-  virtual ~PersistentHistogramAllocator();
-
-  // Direct access to underlying memory allocator. If the segment is shared
-  // across threads or processes, reading data through these values does
-  // not guarantee consistency. Use with care. Do not write.
-  PersistentMemoryAllocator* memory_allocator() {
-    return memory_allocator_.get();
-  }
-
-  // Implement the "metadata" API of a PersistentMemoryAllocator, forwarding
-  // those requests to the real one.
-  uint64_t Id() const { return memory_allocator_->Id(); }
-  const char* Name() const { return memory_allocator_->Name(); }
-  const void* data() const { return memory_allocator_->data(); }
-  size_t length() const { return memory_allocator_->length(); }
-  size_t size() const { return memory_allocator_->size(); }
-  size_t used() const { return memory_allocator_->used(); }
-
-  // Recreate a Histogram from data held in persistent memory. Though this
-  // object will be local to the current process, the sample data will be
-  // shared with all other threads referencing it. This method takes a |ref|
-  // to where the top-level histogram data may be found in this allocator.
-  // This method will return null if any problem is detected with the data.
-  std::unique_ptr<HistogramBase> GetHistogram(Reference ref);
-
-  // Allocate a new persistent histogram. The returned histogram will not
-  // be able to be located by other allocators until it is "finalized".
-  std::unique_ptr<HistogramBase> AllocateHistogram(
-      HistogramType histogram_type,
-      const std::string& name,
-      int minimum,
-      int maximum,
-      const BucketRanges* bucket_ranges,
-      int32_t flags,
-      Reference* ref_ptr);
-
-  // Finalize the creation of the histogram, making it available to other
-  // processes if |registered| (as in: added to the StatisticsRecorder) is
-  // True, forgetting it otherwise.
-  void FinalizeHistogram(Reference ref, bool registered);
-
-  // Merges the data in a persistent histogram with one held globally by the
-  // StatisticsRecorder, updating the "logged" samples within the passed
-  // object so that repeated merges are allowed. Don't call this on a "global"
-  // allocator because histograms created there will already be in the SR.
-  void MergeHistogramDeltaToStatisticsRecorder(HistogramBase* histogram);
-
-  // As above but merge the "final" delta. No update of "logged" samples is
-  // done which means it can operate on read-only objects. It's essential,
-  // however, not to call this more than once or those final samples will
-  // get recorded again.
-  void MergeHistogramFinalDeltaToStatisticsRecorder(
-      const HistogramBase* histogram);
-
-  // Returns the object that manages the persistent-sample-map records for a
-  // given |id|. Only one |user| of this data is allowed at a time. This does
-  // an automatic Acquire() on the records. The user must call Release() on
-  // the returned object when it is finished with it. Ownership stays with
-  // this allocator.
-  PersistentSampleMapRecords* UseSampleMapRecords(uint64_t id,
-                                                  const void* user);
-
-  // Create internal histograms for tracking memory use and allocation sizes
-  // for allocator of |name| (which can simply be the result of Name()). This
-  // is done seperately from construction for situations such as when the
-  // histograms will be backed by memory provided by this very allocator.
-  //
-  // IMPORTANT: Callers must update tools/metrics/histograms/histograms.xml
-  // with the following histograms:
-  //    UMA.PersistentAllocator.name.Allocs
-  //    UMA.PersistentAllocator.name.UsedPct
-  void CreateTrackingHistograms(StringPiece name);
-  void UpdateTrackingHistograms();
-
-  // Clears the internal |last_created_| reference so testing can validate
-  // operation without that optimization.
-  void ClearLastCreatedReferenceForTesting();
-
- protected:
-  // The structure used to hold histogram data in persistent memory. It is
-  // defined and used entirely within the .cc file.
-  struct PersistentHistogramData;
-
-  // Gets the reference of the last histogram created, used to avoid
-  // trying to import what was just created.
-  PersistentHistogramAllocator::Reference last_created() {
-    return subtle::NoBarrier_Load(&last_created_);
-  }
-
-  // Gets the next histogram in persistent data based on iterator while
-  // ignoring a particular reference if it is found.
-  std::unique_ptr<HistogramBase> GetNextHistogramWithIgnore(Iterator* iter,
-                                                            Reference ignore);
-
- private:
-  // Create a histogram based on saved (persistent) information about it.
-  std::unique_ptr<HistogramBase> CreateHistogram(
-      PersistentHistogramData* histogram_data_ptr);
-
-  // Gets or creates an object in the global StatisticsRecorder matching
-  // the |histogram| passed. Null is returned if one was not found and
-  // one could not be created.
-  HistogramBase* GetOrCreateStatisticsRecorderHistogram(
-      const HistogramBase* histogram);
-
-  // The memory allocator that provides the actual histogram storage.
-  std::unique_ptr<PersistentMemoryAllocator> memory_allocator_;
-
-  // The data-manager used to improve performance of sparse histograms.
-  PersistentSparseHistogramDataManager sparse_histogram_data_manager_;
-
-  // A reference to the last-created histogram in the allocator, used to avoid
-  // trying to import what was just created.
-  // TODO(bcwhite): Change this to std::atomic<PMA::Reference> when available.
-  subtle::Atomic32 last_created_ = 0;
-
-  DISALLOW_COPY_AND_ASSIGN(PersistentHistogramAllocator);
-};
-
-
-// A special case of the PersistentHistogramAllocator that operates on a
-// global scale, collecting histograms created through standard macros and
-// the FactoryGet() method.
-class BASE_EXPORT GlobalHistogramAllocator
-    : public PersistentHistogramAllocator {
- public:
-  ~GlobalHistogramAllocator() override;
-
-  // Create a global allocator using the passed-in memory |base|, |size|, and
-  // other parameters. Ownership of the memory segment remains with the caller.
-  static void CreateWithPersistentMemory(void* base,
-                                         size_t size,
-                                         size_t page_size,
-                                         uint64_t id,
-                                         StringPiece name);
-
-  // Create a global allocator using an internal block of memory of the
-  // specified |size| taken from the heap.
-  static void CreateWithLocalMemory(size_t size, uint64_t id, StringPiece name);
-
-#if !defined(OS_NACL)
-  // Create a global allocator by memory-mapping a |file|. If the file does
-  // not exist, it will be created with the specified |size|. If the file does
-  // exist, the allocator will use and add to its contents, ignoring the passed
-  // size in favor of the existing size. Returns whether the global allocator
-  // was set.
-  static bool CreateWithFile(const FilePath& file_path,
-                             size_t size,
-                             uint64_t id,
-                             StringPiece name);
-
-  // Creates a new file at |active_path|. If it already exists, it will first be
-  // moved to |base_path|. In all cases, any old file at |base_path| will be
-  // removed. If |spare_path| is non-empty and exists, that will be renamed and
-  // used as the active file. Otherwise, the file will be created using the
-  // given size, id, and name. Returns whether the global allocator was set.
-  static bool CreateWithActiveFile(const FilePath& base_path,
-                                   const FilePath& active_path,
-                                   const FilePath& spare_path,
-                                   size_t size,
-                                   uint64_t id,
-                                   StringPiece name);
-
-  // Uses ConstructBaseActivePairFilePaths() to build a pair of file names which
-  // are then used for CreateWithActiveFile(). |name| is used for both the
-  // internal name for the allocator and also for the name of the file inside
-  // |dir|.
-  static bool CreateWithActiveFileInDir(const FilePath& dir,
-                                        size_t size,
-                                        uint64_t id,
-                                        StringPiece name);
-
-  // Constructs a filename using a name.
-  static FilePath ConstructFilePath(const FilePath& dir, StringPiece name);
-
-  // Like above but with timestamp and pid for use in upload directories.
-  static FilePath ConstructFilePathForUploadDir(const FilePath& dir,
-                                                StringPiece name,
-                                                base::Time stamp,
-                                                ProcessId pid);
-
-  // Parses a filename to extract name, timestamp, and pid.
-  static bool ParseFilePath(const FilePath& path,
-                            std::string* out_name,
-                            Time* out_stamp,
-                            ProcessId* out_pid);
-
-  // Constructs a set of names in |dir| based on name that can be used for a
-  // base + active persistent memory mapped location for CreateWithActiveFile().
-  // The spare path is a file that can be pre-created and moved to be active
-  // without any startup penalty that comes from constructing the file. |name|
-  // will be used as the basename of the file inside |dir|. |out_base_path|,
-  // |out_active_path|, or |out_spare_path| may be null if not needed.
-  static void ConstructFilePaths(const FilePath& dir,
-                                 StringPiece name,
-                                 FilePath* out_base_path,
-                                 FilePath* out_active_path,
-                                 FilePath* out_spare_path);
-
-  // As above but puts the base files in a different "upload" directory. This
-  // is useful when moving all completed files into a single directory for easy
-  // upload management.
-  static void ConstructFilePathsForUploadDir(const FilePath& active_dir,
-                                             const FilePath& upload_dir,
-                                             const std::string& name,
-                                             FilePath* out_upload_path,
-                                             FilePath* out_active_path,
-                                             FilePath* out_spare_path);
-
-  // Create a "spare" file that can later be made the "active" file. This
-  // should be done on a background thread if possible.
-  static bool CreateSpareFile(const FilePath& spare_path, size_t size);
-
-  // Same as above but uses standard names. |name| is the name of the allocator
-  // and is also used to create the correct filename.
-  static bool CreateSpareFileInDir(const FilePath& dir_path,
-                                   size_t size,
-                                   StringPiece name);
-#endif
-
-  // Create a global allocator using a block of shared memory accessed
-  // through the given |handle| and |size|. The allocator takes ownership
-  // of the handle and closes it upon destruction, though the memory will
-  // continue to live if other processes have access to it.
-  static void CreateWithSharedMemoryHandle(const SharedMemoryHandle& handle,
-                                           size_t size);
-
-  // Sets a GlobalHistogramAllocator for globally storing histograms in
-  // a space that can be persisted or shared between processes. There is only
-  // ever one allocator for all such histograms created by a single process.
-  // This takes ownership of the object and should be called as soon as
-  // possible during startup to capture as many histograms as possible and
-  // while operating single-threaded so there are no race-conditions.
-  static void Set(std::unique_ptr<GlobalHistogramAllocator> allocator);
-
-  // Gets a pointer to the global histogram allocator. Returns null if none
-  // exists.
-  static GlobalHistogramAllocator* Get();
-
-  // This access to the persistent allocator is only for testing; it extracts
-  // the current allocator completely. This allows easy creation of histograms
-  // within persistent memory segments which can then be extracted and used in
-  // other ways.
-  static std::unique_ptr<GlobalHistogramAllocator> ReleaseForTesting();
-
-  // Stores a pathname to which the contents of this allocator should be saved
-  // in order to persist the data for a later use.
-  void SetPersistentLocation(const FilePath& location);
-
-  // Retrieves a previously set pathname to which the contents of this allocator
-  // are to be saved.
-  const FilePath& GetPersistentLocation() const;
-
-  // Writes the internal data to a previously set location. This is generally
-  // called when a process is exiting from a section of code that may not know
-  // the filesystem. The data is written in an atomic manner. The return value
-  // indicates success.
-  bool WriteToPersistentLocation();
-
-  // If there is a global metrics file being updated on disk, mark it to be
-  // deleted when the process exits.
-  void DeletePersistentLocation();
-
- private:
-  friend class StatisticsRecorder;
-
-  // Creates a new global histogram allocator.
-  explicit GlobalHistogramAllocator(
-      std::unique_ptr<PersistentMemoryAllocator> memory);
-
-  // Import new histograms from the global histogram allocator. It's possible
-  // for other processes to create histograms in the active memory segment;
-  // this adds those to the internal list of known histograms to avoid creating
-  // duplicates that would have to be merged during reporting. Every call to
-  // this method resumes from the last entry it saw; it costs nothing if
-  // nothing new has been added.
-  void ImportHistogramsToStatisticsRecorder();
-
-  // Builds a FilePath for a metrics file.
-  static FilePath MakeMetricsFilePath(const FilePath& dir, StringPiece name);
-
-  // Import always continues from where it left off, making use of a single
-  // iterator to continue the work.
-  Iterator import_iterator_;
-
-  // The location to which the data should be persisted.
-  FilePath persistent_location_;
-
-  DISALLOW_COPY_AND_ASSIGN(GlobalHistogramAllocator);
-};
-
-}  // namespace base
-
-#endif  // BASE_METRICS_HISTOGRAM_PERSISTENCE_H_
diff --git a/base/metrics/persistent_histogram_storage.cc b/base/metrics/persistent_histogram_storage.cc
deleted file mode 100644
index 8f527b0..0000000
--- a/base/metrics/persistent_histogram_storage.cc
+++ /dev/null
@@ -1,103 +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/metrics/persistent_histogram_storage.h"
-
-#include "base/files/file_util.h"
-#include "base/files/important_file_writer.h"
-#include "base/logging.h"
-#include "base/metrics/persistent_histogram_allocator.h"
-#include "base/metrics/persistent_memory_allocator.h"
-#include "base/strings/string_util.h"
-#include "base/strings/stringprintf.h"
-#include "base/time/time.h"
-#include "build_config.h"
-
-namespace {
-
-constexpr size_t kAllocSize = 1 << 20;  // 1 MiB
-
-}  // namespace
-
-namespace base {
-
-PersistentHistogramStorage::PersistentHistogramStorage(
-    StringPiece allocator_name,
-    StorageDirManagement storage_dir_management)
-    : storage_dir_management_(storage_dir_management) {
-  DCHECK(!allocator_name.empty());
-  DCHECK(IsStringASCII(allocator_name));
-
-  GlobalHistogramAllocator::CreateWithLocalMemory(kAllocSize,
-                                                  0,  // No identifier.
-                                                  allocator_name);
-  GlobalHistogramAllocator::Get()->CreateTrackingHistograms(allocator_name);
-}
-
-PersistentHistogramStorage::~PersistentHistogramStorage() {
-  PersistentHistogramAllocator* allocator = GlobalHistogramAllocator::Get();
-  allocator->UpdateTrackingHistograms();
-
-  // TODO(chengx): Investigate making early return depend on whethere there are
-  // metrics to report at this point or not.
-  if (disabled_)
-    return;
-
-  // Stop if the storage base directory has not been properly set.
-  if (storage_base_dir_.empty()) {
-    LOG(ERROR)
-        << "Could not write \"" << allocator->Name()
-        << "\" persistent histograms to file as the storage base directory "
-           "is not properly set.";
-    return;
-  }
-
-  FilePath storage_dir = storage_base_dir_.AppendASCII(allocator->Name());
-
-  switch (storage_dir_management_) {
-    case StorageDirManagement::kCreate:
-      if (!CreateDirectory(storage_dir)) {
-        LOG(ERROR)
-            << "Could not write \"" << allocator->Name()
-            << "\" persistent histograms to file as the storage directory "
-               "cannot be created.";
-        return;
-      }
-      break;
-    case StorageDirManagement::kUseExisting:
-      if (!DirectoryExists(storage_dir)) {
-        // When the consumer of this class decides to use an existing storage
-        // directory, it should ensure the directory's existence if it's
-        // essential.
-        LOG(ERROR)
-            << "Could not write \"" << allocator->Name()
-            << "\" persistent histograms to file as the storage directory "
-               "does not exist.";
-        return;
-      }
-      break;
-  }
-
-  // Save data using the current time as the filename. The actual filename
-  // doesn't matter (so long as it ends with the correct extension) but this
-  // works as well as anything.
-  Time::Exploded exploded;
-  Time::Now().LocalExplode(&exploded);
-  const FilePath file_path =
-      storage_dir
-          .AppendASCII(StringPrintf("%04d%02d%02d%02d%02d%02d", exploded.year,
-                                    exploded.month, exploded.day_of_month,
-                                    exploded.hour, exploded.minute,
-                                    exploded.second))
-          .AddExtension(PersistentMemoryAllocator::kFileExtension);
-
-  StringPiece contents(static_cast<const char*>(allocator->data()),
-                       allocator->used());
-  if (!ImportantFileWriter::WriteFileAtomically(file_path, contents)) {
-    LOG(ERROR) << "Persistent histograms fail to write to file: "
-               << file_path.value();
-  }
-}
-
-}  // namespace base
diff --git a/base/metrics/persistent_histogram_storage.h b/base/metrics/persistent_histogram_storage.h
deleted file mode 100644
index 397236d..0000000
--- a/base/metrics/persistent_histogram_storage.h
+++ /dev/null
@@ -1,68 +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_METRICS_PERSISTENT_HISTOGRAM_STORAGE_H_
-#define BASE_METRICS_PERSISTENT_HISTOGRAM_STORAGE_H_
-
-#include "base/base_export.h"
-#include "base/files/file_path.h"
-#include "base/macros.h"
-#include "base/strings/string_piece.h"
-
-namespace base {
-
-// This class creates a fixed sized persistent memory to allow histograms to be
-// stored in it. When a PersistentHistogramStorage is destructed, histograms
-// recorded during its lifetime are persisted in the directory
-// |storage_base_dir_|/|allocator_name| (see the ctor for allocator_name).
-// Histograms are not persisted if the storage directory does not exist on
-// destruction. PersistentHistogramStorage should be instantiated as early as
-// possible in the process lifetime and should never be instantiated again.
-// Persisted histograms will eventually be reported by Chrome.
-class BASE_EXPORT PersistentHistogramStorage {
- public:
-  enum class StorageDirManagement { kCreate, kUseExisting };
-
-  // Creates a process-wide storage location for histograms that will be written
-  // to a file within a directory provided by |set_storage_base_dir()| on
-  // destruction.
-  // The |allocator_name| is used both as an internal name for the allocator,
-  // well as the leaf directory name for the file to which the histograms are
-  // persisted. The string must be ASCII.
-  // |storage_dir_management| specifies if this instance reuses an existing
-  // storage directory, or is responsible for creating one.
-  PersistentHistogramStorage(StringPiece allocator_name,
-                             StorageDirManagement storage_dir_management);
-
-  ~PersistentHistogramStorage();
-
-  // The storage directory isn't always known during initial construction so
-  // it's set separately. The last one wins if there are multiple calls to this
-  // method.
-  void set_storage_base_dir(const FilePath& storage_base_dir) {
-    storage_base_dir_ = storage_base_dir;
-  }
-
-  // Disables histogram storage.
-  void Disable() { disabled_ = true; }
-
- private:
-  // Metrics files are written into directory
-  // |storage_base_dir_|/|allocator_name| (see the ctor for allocator_name).
-  FilePath storage_base_dir_;
-
-  // The setting of the storage directory management.
-  const StorageDirManagement storage_dir_management_;
-
-  // A flag indicating if histogram storage is disabled. It starts with false,
-  // but can be set to true by the caller who decides to throw away its
-  // histogram data.
-  bool disabled_ = false;
-
-  DISALLOW_COPY_AND_ASSIGN(PersistentHistogramStorage);
-};
-
-}  // namespace base
-
-#endif  // BASE_METRICS_PERSISTENT_HISTOGRAM_STORAGE_H_
diff --git a/base/metrics/persistent_memory_allocator.cc b/base/metrics/persistent_memory_allocator.cc
deleted file mode 100644
index 7d9c03d..0000000
--- a/base/metrics/persistent_memory_allocator.cc
+++ /dev/null
@@ -1,1204 +0,0 @@
-// Copyright (c) 2015 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/metrics/persistent_memory_allocator.h"
-
-#include <assert.h>
-#include <algorithm>
-
-#if defined(OS_WIN)
-#include <windows.h>
-#include "winbase.h"
-#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
-#include <sys/mman.h>
-#endif
-
-#include "base/files/memory_mapped_file.h"
-#include "base/logging.h"
-#include "base/memory/shared_memory.h"
-#include "base/metrics/histogram_functions.h"
-#include "base/metrics/sparse_histogram.h"
-#include "base/numerics/safe_conversions.h"
-#include "base/sys_info.h"
-#include "base/threading/thread_restrictions.h"
-#include "build_config.h"
-
-namespace {
-
-// Limit of memory segment size. It has to fit in an unsigned 32-bit number
-// and should be a power of 2 in order to accomodate almost any page size.
-const uint32_t kSegmentMaxSize = 1 << 30;  // 1 GiB
-
-// A constant (random) value placed in the shared metadata to identify
-// an already initialized memory segment.
-const uint32_t kGlobalCookie = 0x408305DC;
-
-// The current version of the metadata. If updates are made that change
-// the metadata, the version number can be queried to operate in a backward-
-// compatible manner until the memory segment is completely re-initalized.
-const uint32_t kGlobalVersion = 2;
-
-// Constant values placed in the block headers to indicate its state.
-const uint32_t kBlockCookieFree = 0;
-const uint32_t kBlockCookieQueue = 1;
-const uint32_t kBlockCookieWasted = (uint32_t)-1;
-const uint32_t kBlockCookieAllocated = 0xC8799269;
-
-// TODO(bcwhite): When acceptable, consider moving flags to std::atomic<char>
-// types rather than combined bitfield.
-
-// Flags stored in the flags_ field of the SharedMetadata structure below.
-enum : int {
-  kFlagCorrupt = 1 << 0,
-  kFlagFull    = 1 << 1
-};
-
-// Errors that are logged in "errors" histogram.
-enum AllocatorError : int {
-  kMemoryIsCorrupt = 1,
-};
-
-bool CheckFlag(const volatile std::atomic<uint32_t>* flags, int flag) {
-  uint32_t loaded_flags = flags->load(std::memory_order_relaxed);
-  return (loaded_flags & flag) != 0;
-}
-
-void SetFlag(volatile std::atomic<uint32_t>* flags, int flag) {
-  uint32_t loaded_flags = flags->load(std::memory_order_relaxed);
-  for (;;) {
-    uint32_t new_flags = (loaded_flags & ~flag) | flag;
-    // In the failue case, actual "flags" value stored in loaded_flags.
-    // These access are "relaxed" because they are completely independent
-    // of all other values.
-    if (flags->compare_exchange_weak(loaded_flags, new_flags,
-                                     std::memory_order_relaxed,
-                                     std::memory_order_relaxed)) {
-      break;
-    }
-  }
-}
-
-}  // namespace
-
-namespace base {
-
-// All allocations and data-structures must be aligned to this byte boundary.
-// Alignment as large as the physical bus between CPU and RAM is _required_
-// for some architectures, is simply more efficient on other CPUs, and
-// generally a Good Idea(tm) for all platforms as it reduces/eliminates the
-// chance that a type will span cache lines. Alignment mustn't be less
-// than 8 to ensure proper alignment for all types. The rest is a balance
-// between reducing spans across multiple cache lines and wasted space spent
-// padding out allocations. An alignment of 16 would ensure that the block
-// header structure always sits in a single cache line. An average of about
-// 1/2 this value will be wasted with every allocation.
-const uint32_t PersistentMemoryAllocator::kAllocAlignment = 8;
-
-// The block-header is placed at the top of every allocation within the
-// segment to describe the data that follows it.
-struct PersistentMemoryAllocator::BlockHeader {
-  uint32_t size;       // Number of bytes in this block, including header.
-  uint32_t cookie;     // Constant value indicating completed allocation.
-  std::atomic<uint32_t> type_id;  // Arbitrary number indicating data type.
-  std::atomic<uint32_t> next;     // Pointer to the next block when iterating.
-};
-
-// The shared metadata exists once at the top of the memory segment to
-// describe the state of the allocator to all processes. The size of this
-// structure must be a multiple of 64-bits to ensure compatibility between
-// architectures.
-struct PersistentMemoryAllocator::SharedMetadata {
-  uint32_t cookie;     // Some value that indicates complete initialization.
-  uint32_t size;       // Total size of memory segment.
-  uint32_t page_size;  // Paging size within memory segment.
-  uint32_t version;    // Version code so upgrades don't break.
-  uint64_t id;         // Arbitrary ID number given by creator.
-  uint32_t name;       // Reference to stored name string.
-  uint32_t padding1;   // Pad-out read-only data to 64-bit alignment.
-
-  // Above is read-only after first construction. Below may be changed and
-  // so must be marked "volatile" to provide correct inter-process behavior.
-
-  // State of the memory, plus some padding to keep alignment.
-  volatile std::atomic<uint8_t> memory_state;  // MemoryState enum values.
-  uint8_t padding2[3];
-
-  // Bitfield of information flags. Access to this should be done through
-  // the CheckFlag() and SetFlag() methods defined above.
-  volatile std::atomic<uint32_t> flags;
-
-  // Offset/reference to first free space in segment.
-  volatile std::atomic<uint32_t> freeptr;
-
-  // The "iterable" queue is an M&S Queue as described here, append-only:
-  // https://www.research.ibm.com/people/m/michael/podc-1996.pdf
-  // |queue| needs to be 64-bit aligned and is itself a multiple of 64 bits.
-  volatile std::atomic<uint32_t> tailptr;  // Last block of iteration queue.
-  volatile BlockHeader queue;   // Empty block for linked-list head/tail.
-};
-
-// The "queue" block header is used to detect "last node" so that zero/null
-// can be used to indicate that it hasn't been added at all. It is part of
-// the SharedMetadata structure which itself is always located at offset zero.
-const PersistentMemoryAllocator::Reference
-    PersistentMemoryAllocator::kReferenceQueue =
-        offsetof(SharedMetadata, queue);
-
-const base::FilePath::CharType PersistentMemoryAllocator::kFileExtension[] =
-    FILE_PATH_LITERAL(".pma");
-
-
-PersistentMemoryAllocator::Iterator::Iterator(
-    const PersistentMemoryAllocator* allocator)
-    : allocator_(allocator), last_record_(kReferenceQueue), record_count_(0) {}
-
-PersistentMemoryAllocator::Iterator::Iterator(
-    const PersistentMemoryAllocator* allocator,
-    Reference starting_after)
-    : allocator_(allocator), last_record_(0), record_count_(0) {
-  Reset(starting_after);
-}
-
-void PersistentMemoryAllocator::Iterator::Reset() {
-  last_record_.store(kReferenceQueue, std::memory_order_relaxed);
-  record_count_.store(0, std::memory_order_relaxed);
-}
-
-void PersistentMemoryAllocator::Iterator::Reset(Reference starting_after) {
-  if (starting_after == 0) {
-    Reset();
-    return;
-  }
-
-  last_record_.store(starting_after, std::memory_order_relaxed);
-  record_count_.store(0, std::memory_order_relaxed);
-
-  // Ensure that the starting point is a valid, iterable block (meaning it can
-  // be read and has a non-zero "next" pointer).
-  const volatile BlockHeader* block =
-      allocator_->GetBlock(starting_after, 0, 0, false, false);
-  if (!block || block->next.load(std::memory_order_relaxed) == 0) {
-    NOTREACHED();
-    last_record_.store(kReferenceQueue, std::memory_order_release);
-  }
-}
-
-PersistentMemoryAllocator::Reference
-PersistentMemoryAllocator::Iterator::GetLast() {
-  Reference last = last_record_.load(std::memory_order_relaxed);
-  if (last == kReferenceQueue)
-    return kReferenceNull;
-  return last;
-}
-
-PersistentMemoryAllocator::Reference
-PersistentMemoryAllocator::Iterator::GetNext(uint32_t* type_return) {
-  // Make a copy of the existing count of found-records, acquiring all changes
-  // made to the allocator, notably "freeptr" (see comment in loop for why
-  // the load of that value cannot be moved above here) that occurred during
-  // any previous runs of this method, including those by parallel threads
-  // that interrupted it. It pairs with the Release at the end of this method.
-  //
-  // Otherwise, if the compiler were to arrange the two loads such that
-  // "count" was fetched _after_ "freeptr" then it would be possible for
-  // this thread to be interrupted between them and other threads perform
-  // multiple allocations, make-iterables, and iterations (with the included
-  // increment of |record_count_|) culminating in the check at the bottom
-  // mistakenly determining that a loop exists. Isn't this stuff fun?
-  uint32_t count = record_count_.load(std::memory_order_acquire);
-
-  Reference last = last_record_.load(std::memory_order_acquire);
-  Reference next;
-  while (true) {
-    const volatile BlockHeader* block =
-        allocator_->GetBlock(last, 0, 0, true, false);
-    if (!block)  // Invalid iterator state.
-      return kReferenceNull;
-
-    // The compiler and CPU can freely reorder all memory accesses on which
-    // there are no dependencies. It could, for example, move the load of
-    // "freeptr" to above this point because there are no explicit dependencies
-    // between it and "next". If it did, however, then another block could
-    // be queued after that but before the following load meaning there is
-    // one more queued block than the future "detect loop by having more
-    // blocks that could fit before freeptr" will allow.
-    //
-    // By "acquiring" the "next" value here, it's synchronized to the enqueue
-    // of the node which in turn is synchronized to the allocation (which sets
-    // freeptr). Thus, the scenario above cannot happen.
-    next = block->next.load(std::memory_order_acquire);
-    if (next == kReferenceQueue)  // No next allocation in queue.
-      return kReferenceNull;
-    block = allocator_->GetBlock(next, 0, 0, false, false);
-    if (!block) {  // Memory is corrupt.
-      allocator_->SetCorrupt();
-      return kReferenceNull;
-    }
-
-    // Update the "last_record" pointer to be the reference being returned.
-    // If it fails then another thread has already iterated past it so loop
-    // again. Failing will also load the existing value into "last" so there
-    // is no need to do another such load when the while-loop restarts. A
-    // "strong" compare-exchange is used because failing unnecessarily would
-    // mean repeating some fairly costly validations above.
-    if (last_record_.compare_exchange_strong(
-            last, next, std::memory_order_acq_rel, std::memory_order_acquire)) {
-      *type_return = block->type_id.load(std::memory_order_relaxed);
-      break;
-    }
-  }
-
-  // Memory corruption could cause a loop in the list. Such must be detected
-  // so as to not cause an infinite loop in the caller. This is done by simply
-  // making sure it doesn't iterate more times than the absolute maximum
-  // number of allocations that could have been made. Callers are likely
-  // to loop multiple times before it is detected but at least it stops.
-  const uint32_t freeptr = std::min(
-      allocator_->shared_meta()->freeptr.load(std::memory_order_relaxed),
-      allocator_->mem_size_);
-  const uint32_t max_records =
-      freeptr / (sizeof(BlockHeader) + kAllocAlignment);
-  if (count > max_records) {
-    allocator_->SetCorrupt();
-    return kReferenceNull;
-  }
-
-  // Increment the count and release the changes made above. It pairs with
-  // the Acquire at the top of this method. Note that this operation is not
-  // strictly synchonized with fetching of the object to return, which would
-  // have to be done inside the loop and is somewhat complicated to achieve.
-  // It does not matter if it falls behind temporarily so long as it never
-  // gets ahead.
-  record_count_.fetch_add(1, std::memory_order_release);
-  return next;
-}
-
-PersistentMemoryAllocator::Reference
-PersistentMemoryAllocator::Iterator::GetNextOfType(uint32_t type_match) {
-  Reference ref;
-  uint32_t type_found;
-  while ((ref = GetNext(&type_found)) != 0) {
-    if (type_found == type_match)
-      return ref;
-  }
-  return kReferenceNull;
-}
-
-
-// static
-bool PersistentMemoryAllocator::IsMemoryAcceptable(const void* base,
-                                                   size_t size,
-                                                   size_t page_size,
-                                                   bool readonly) {
-  return ((base && reinterpret_cast<uintptr_t>(base) % kAllocAlignment == 0) &&
-          (size >= sizeof(SharedMetadata) && size <= kSegmentMaxSize) &&
-          (size % kAllocAlignment == 0 || readonly) &&
-          (page_size == 0 || size % page_size == 0 || readonly));
-}
-
-PersistentMemoryAllocator::PersistentMemoryAllocator(void* base,
-                                                     size_t size,
-                                                     size_t page_size,
-                                                     uint64_t id,
-                                                     base::StringPiece name,
-                                                     bool readonly)
-    : PersistentMemoryAllocator(Memory(base, MEM_EXTERNAL),
-                                size,
-                                page_size,
-                                id,
-                                name,
-                                readonly) {}
-
-PersistentMemoryAllocator::PersistentMemoryAllocator(Memory memory,
-                                                     size_t size,
-                                                     size_t page_size,
-                                                     uint64_t id,
-                                                     base::StringPiece name,
-                                                     bool readonly)
-    : mem_base_(static_cast<char*>(memory.base)),
-      mem_type_(memory.type),
-      mem_size_(static_cast<uint32_t>(size)),
-      mem_page_(static_cast<uint32_t>((page_size ? page_size : size))),
-#if defined(OS_NACL)
-      vm_page_size_(4096U),  // SysInfo is not built for NACL.
-#else
-      vm_page_size_(SysInfo::VMAllocationGranularity()),
-#endif
-      readonly_(readonly),
-      corrupt_(0),
-      allocs_histogram_(nullptr),
-      used_histogram_(nullptr),
-      errors_histogram_(nullptr) {
-  // These asserts ensure that the structures are 32/64-bit agnostic and meet
-  // all the requirements of use within the allocator. They access private
-  // definitions and so cannot be moved to the global scope.
-  static_assert(sizeof(PersistentMemoryAllocator::BlockHeader) == 16,
-                "struct is not portable across different natural word widths");
-  static_assert(sizeof(PersistentMemoryAllocator::SharedMetadata) == 64,
-                "struct is not portable across different natural word widths");
-
-  static_assert(sizeof(BlockHeader) % kAllocAlignment == 0,
-                "BlockHeader is not a multiple of kAllocAlignment");
-  static_assert(sizeof(SharedMetadata) % kAllocAlignment == 0,
-                "SharedMetadata is not a multiple of kAllocAlignment");
-  static_assert(kReferenceQueue % kAllocAlignment == 0,
-                "\"queue\" is not aligned properly; must be at end of struct");
-
-  // Ensure that memory segment is of acceptable size.
-  CHECK(IsMemoryAcceptable(memory.base, size, page_size, readonly));
-
-  // These atomics operate inter-process and so must be lock-free. The local
-  // casts are to make sure it can be evaluated at compile time to a constant.
-  CHECK(((SharedMetadata*)nullptr)->freeptr.is_lock_free());
-  CHECK(((SharedMetadata*)nullptr)->flags.is_lock_free());
-  CHECK(((BlockHeader*)nullptr)->next.is_lock_free());
-  CHECK(corrupt_.is_lock_free());
-
-  if (shared_meta()->cookie != kGlobalCookie) {
-    if (readonly) {
-      SetCorrupt();
-      return;
-    }
-
-    // This block is only executed when a completely new memory segment is
-    // being initialized. It's unshared and single-threaded...
-    volatile BlockHeader* const first_block =
-        reinterpret_cast<volatile BlockHeader*>(mem_base_ +
-                                                sizeof(SharedMetadata));
-    if (shared_meta()->cookie != 0 ||
-        shared_meta()->size != 0 ||
-        shared_meta()->version != 0 ||
-        shared_meta()->freeptr.load(std::memory_order_relaxed) != 0 ||
-        shared_meta()->flags.load(std::memory_order_relaxed) != 0 ||
-        shared_meta()->id != 0 ||
-        shared_meta()->name != 0 ||
-        shared_meta()->tailptr != 0 ||
-        shared_meta()->queue.cookie != 0 ||
-        shared_meta()->queue.next.load(std::memory_order_relaxed) != 0 ||
-        first_block->size != 0 ||
-        first_block->cookie != 0 ||
-        first_block->type_id.load(std::memory_order_relaxed) != 0 ||
-        first_block->next != 0) {
-      // ...or something malicious has been playing with the metadata.
-      SetCorrupt();
-    }
-
-    // This is still safe to do even if corruption has been detected.
-    shared_meta()->cookie = kGlobalCookie;
-    shared_meta()->size = mem_size_;
-    shared_meta()->page_size = mem_page_;
-    shared_meta()->version = kGlobalVersion;
-    shared_meta()->id = id;
-    shared_meta()->freeptr.store(sizeof(SharedMetadata),
-                                 std::memory_order_release);
-
-    // Set up the queue of iterable allocations.
-    shared_meta()->queue.size = sizeof(BlockHeader);
-    shared_meta()->queue.cookie = kBlockCookieQueue;
-    shared_meta()->queue.next.store(kReferenceQueue, std::memory_order_release);
-    shared_meta()->tailptr.store(kReferenceQueue, std::memory_order_release);
-
-    // Allocate space for the name so other processes can learn it.
-    if (!name.empty()) {
-      const size_t name_length = name.length() + 1;
-      shared_meta()->name = Allocate(name_length, 0);
-      char* name_cstr = GetAsArray<char>(shared_meta()->name, 0, name_length);
-      if (name_cstr)
-        memcpy(name_cstr, name.data(), name.length());
-    }
-
-    shared_meta()->memory_state.store(MEMORY_INITIALIZED,
-                                      std::memory_order_release);
-  } else {
-    if (shared_meta()->size == 0 || shared_meta()->version != kGlobalVersion ||
-        shared_meta()->freeptr.load(std::memory_order_relaxed) == 0 ||
-        shared_meta()->tailptr == 0 || shared_meta()->queue.cookie == 0 ||
-        shared_meta()->queue.next.load(std::memory_order_relaxed) == 0) {
-      SetCorrupt();
-    }
-    if (!readonly) {
-      // The allocator is attaching to a previously initialized segment of
-      // memory. If the initialization parameters differ, make the best of it
-      // by reducing the local construction parameters to match those of
-      // the actual memory area. This ensures that the local object never
-      // tries to write outside of the original bounds.
-      // Because the fields are const to ensure that no code other than the
-      // constructor makes changes to them as well as to give optimization
-      // hints to the compiler, it's necessary to const-cast them for changes
-      // here.
-      if (shared_meta()->size < mem_size_)
-        *const_cast<uint32_t*>(&mem_size_) = shared_meta()->size;
-      if (shared_meta()->page_size < mem_page_)
-        *const_cast<uint32_t*>(&mem_page_) = shared_meta()->page_size;
-
-      // Ensure that settings are still valid after the above adjustments.
-      if (!IsMemoryAcceptable(memory.base, mem_size_, mem_page_, readonly))
-        SetCorrupt();
-    }
-  }
-}
-
-PersistentMemoryAllocator::~PersistentMemoryAllocator() {
-  // It's strictly forbidden to do any memory access here in case there is
-  // some issue with the underlying memory segment. The "Local" allocator
-  // makes use of this to allow deletion of the segment on the heap from
-  // within its destructor.
-}
-
-uint64_t PersistentMemoryAllocator::Id() const {
-  return shared_meta()->id;
-}
-
-const char* PersistentMemoryAllocator::Name() const {
-  Reference name_ref = shared_meta()->name;
-  const char* name_cstr =
-      GetAsArray<char>(name_ref, 0, PersistentMemoryAllocator::kSizeAny);
-  if (!name_cstr)
-    return "";
-
-  size_t name_length = GetAllocSize(name_ref);
-  if (name_cstr[name_length - 1] != '\0') {
-    NOTREACHED();
-    SetCorrupt();
-    return "";
-  }
-
-  return name_cstr;
-}
-
-void PersistentMemoryAllocator::CreateTrackingHistograms(
-    base::StringPiece name) {
-  if (name.empty() || readonly_)
-    return;
-  std::string name_string = name.as_string();
-
-#if 0
-  // This histogram wasn't being used so has been disabled. It is left here
-  // in case development of a new use of the allocator could benefit from
-  // recording (temporarily and locally) the allocation sizes.
-  DCHECK(!allocs_histogram_);
-  allocs_histogram_ = Histogram::FactoryGet(
-      "UMA.PersistentAllocator." + name_string + ".Allocs", 1, 10000, 50,
-      HistogramBase::kUmaTargetedHistogramFlag);
-#endif
-
-  DCHECK(!used_histogram_);
-  used_histogram_ = LinearHistogram::FactoryGet(
-      "UMA.PersistentAllocator." + name_string + ".UsedPct", 1, 101, 21,
-      HistogramBase::kUmaTargetedHistogramFlag);
-
-  DCHECK(!errors_histogram_);
-  errors_histogram_ = SparseHistogram::FactoryGet(
-      "UMA.PersistentAllocator." + name_string + ".Errors",
-      HistogramBase::kUmaTargetedHistogramFlag);
-}
-
-void PersistentMemoryAllocator::Flush(bool sync) {
-  FlushPartial(used(), sync);
-}
-
-void PersistentMemoryAllocator::SetMemoryState(uint8_t memory_state) {
-  shared_meta()->memory_state.store(memory_state, std::memory_order_relaxed);
-  FlushPartial(sizeof(SharedMetadata), false);
-}
-
-uint8_t PersistentMemoryAllocator::GetMemoryState() const {
-  return shared_meta()->memory_state.load(std::memory_order_relaxed);
-}
-
-size_t PersistentMemoryAllocator::used() const {
-  return std::min(shared_meta()->freeptr.load(std::memory_order_relaxed),
-                  mem_size_);
-}
-
-PersistentMemoryAllocator::Reference PersistentMemoryAllocator::GetAsReference(
-    const void* memory,
-    uint32_t type_id) const {
-  uintptr_t address = reinterpret_cast<uintptr_t>(memory);
-  if (address < reinterpret_cast<uintptr_t>(mem_base_))
-    return kReferenceNull;
-
-  uintptr_t offset = address - reinterpret_cast<uintptr_t>(mem_base_);
-  if (offset >= mem_size_ || offset < sizeof(BlockHeader))
-    return kReferenceNull;
-
-  Reference ref = static_cast<Reference>(offset) - sizeof(BlockHeader);
-  if (!GetBlockData(ref, type_id, kSizeAny))
-    return kReferenceNull;
-
-  return ref;
-}
-
-size_t PersistentMemoryAllocator::GetAllocSize(Reference ref) const {
-  const volatile BlockHeader* const block = GetBlock(ref, 0, 0, false, false);
-  if (!block)
-    return 0;
-  uint32_t size = block->size;
-  // Header was verified by GetBlock() but a malicious actor could change
-  // the value between there and here. Check it again.
-  if (size <= sizeof(BlockHeader) || ref + size > mem_size_) {
-    SetCorrupt();
-    return 0;
-  }
-  return size - sizeof(BlockHeader);
-}
-
-uint32_t PersistentMemoryAllocator::GetType(Reference ref) const {
-  const volatile BlockHeader* const block = GetBlock(ref, 0, 0, false, false);
-  if (!block)
-    return 0;
-  return block->type_id.load(std::memory_order_relaxed);
-}
-
-bool PersistentMemoryAllocator::ChangeType(Reference ref,
-                                           uint32_t to_type_id,
-                                           uint32_t from_type_id,
-                                           bool clear) {
-  DCHECK(!readonly_);
-  volatile BlockHeader* const block = GetBlock(ref, 0, 0, false, false);
-  if (!block)
-    return false;
-
-  // "Strong" exchanges are used below because there is no loop that can retry
-  // in the wake of spurious failures possible with "weak" exchanges. It is,
-  // in aggregate, an "acquire-release" operation so no memory accesses can be
-  // reordered either before or after this method (since changes based on type
-  // could happen on either side).
-
-  if (clear) {
-    // If clearing the memory, first change it to the "transitioning" type so
-    // there can be no confusion by other threads. After the memory is cleared,
-    // it can be changed to its final type.
-    if (!block->type_id.compare_exchange_strong(
-            from_type_id, kTypeIdTransitioning, std::memory_order_acquire,
-            std::memory_order_acquire)) {
-      // Existing type wasn't what was expected: fail (with no changes)
-      return false;
-    }
-
-    // Clear the memory in an atomic manner. Using "release" stores force
-    // every write to be done after the ones before it. This is better than
-    // using memset because (a) it supports "volatile" and (b) it creates a
-    // reliable pattern upon which other threads may rely.
-    volatile std::atomic<int>* data =
-        reinterpret_cast<volatile std::atomic<int>*>(
-            reinterpret_cast<volatile char*>(block) + sizeof(BlockHeader));
-    const uint32_t words = (block->size - sizeof(BlockHeader)) / sizeof(int);
-    DCHECK_EQ(0U, (block->size - sizeof(BlockHeader)) % sizeof(int));
-    for (uint32_t i = 0; i < words; ++i) {
-      data->store(0, std::memory_order_release);
-      ++data;
-    }
-
-    // If the destination type is "transitioning" then skip the final exchange.
-    if (to_type_id == kTypeIdTransitioning)
-      return true;
-
-    // Finish the change to the desired type.
-    from_type_id = kTypeIdTransitioning;  // Exchange needs modifiable original.
-    bool success = block->type_id.compare_exchange_strong(
-        from_type_id, to_type_id, std::memory_order_release,
-        std::memory_order_relaxed);
-    DCHECK(success);  // Should never fail.
-    return success;
-  }
-
-  // One step change to the new type. Will return false if the existing value
-  // doesn't match what is expected.
-  return block->type_id.compare_exchange_strong(from_type_id, to_type_id,
-                                                std::memory_order_acq_rel,
-                                                std::memory_order_acquire);
-}
-
-PersistentMemoryAllocator::Reference PersistentMemoryAllocator::Allocate(
-    size_t req_size,
-    uint32_t type_id) {
-  Reference ref = AllocateImpl(req_size, type_id);
-  if (ref) {
-    // Success: Record this allocation in usage stats (if active).
-    if (allocs_histogram_)
-      allocs_histogram_->Add(static_cast<HistogramBase::Sample>(req_size));
-  } else {
-    // Failure: Record an allocation of zero for tracking.
-    if (allocs_histogram_)
-      allocs_histogram_->Add(0);
-  }
-  return ref;
-}
-
-PersistentMemoryAllocator::Reference PersistentMemoryAllocator::AllocateImpl(
-    size_t req_size,
-    uint32_t type_id) {
-  DCHECK(!readonly_);
-
-  // Validate req_size to ensure it won't overflow when used as 32-bit value.
-  if (req_size > kSegmentMaxSize - sizeof(BlockHeader)) {
-    NOTREACHED();
-    return kReferenceNull;
-  }
-
-  // Round up the requested size, plus header, to the next allocation alignment.
-  uint32_t size = static_cast<uint32_t>(req_size + sizeof(BlockHeader));
-  size = (size + (kAllocAlignment - 1)) & ~(kAllocAlignment - 1);
-  if (size <= sizeof(BlockHeader) || size > mem_page_) {
-    NOTREACHED();
-    return kReferenceNull;
-  }
-
-  // Get the current start of unallocated memory. Other threads may
-  // update this at any time and cause us to retry these operations.
-  // This value should be treated as "const" to avoid confusion through
-  // the code below but recognize that any failed compare-exchange operation
-  // involving it will cause it to be loaded with a more recent value. The
-  // code should either exit or restart the loop in that case.
-  /* const */ uint32_t freeptr =
-      shared_meta()->freeptr.load(std::memory_order_acquire);
-
-  // Allocation is lockless so we do all our caculation and then, if saving
-  // indicates a change has occurred since we started, scrap everything and
-  // start over.
-  for (;;) {
-    if (IsCorrupt())
-      return kReferenceNull;
-
-    if (freeptr + size > mem_size_) {
-      SetFlag(&shared_meta()->flags, kFlagFull);
-      return kReferenceNull;
-    }
-
-    // Get pointer to the "free" block. If something has been allocated since
-    // the load of freeptr above, it is still safe as nothing will be written
-    // to that location until after the compare-exchange below.
-    volatile BlockHeader* const block = GetBlock(freeptr, 0, 0, false, true);
-    if (!block) {
-      SetCorrupt();
-      return kReferenceNull;
-    }
-
-    // An allocation cannot cross page boundaries. If it would, create a
-    // "wasted" block and begin again at the top of the next page. This
-    // area could just be left empty but we fill in the block header just
-    // for completeness sake.
-    const uint32_t page_free = mem_page_ - freeptr % mem_page_;
-    if (size > page_free) {
-      if (page_free <= sizeof(BlockHeader)) {
-        SetCorrupt();
-        return kReferenceNull;
-      }
-      const uint32_t new_freeptr = freeptr + page_free;
-      if (shared_meta()->freeptr.compare_exchange_strong(
-              freeptr, new_freeptr, std::memory_order_acq_rel,
-              std::memory_order_acquire)) {
-        block->size = page_free;
-        block->cookie = kBlockCookieWasted;
-      }
-      continue;
-    }
-
-    // Don't leave a slice at the end of a page too small for anything. This
-    // can result in an allocation up to two alignment-sizes greater than the
-    // minimum required by requested-size + header + alignment.
-    if (page_free - size < sizeof(BlockHeader) + kAllocAlignment)
-      size = page_free;
-
-    const uint32_t new_freeptr = freeptr + size;
-    if (new_freeptr > mem_size_) {
-      SetCorrupt();
-      return kReferenceNull;
-    }
-
-    // Save our work. Try again if another thread has completed an allocation
-    // while we were processing. A "weak" exchange would be permissable here
-    // because the code will just loop and try again but the above processing
-    // is significant so make the extra effort of a "strong" exchange.
-    if (!shared_meta()->freeptr.compare_exchange_strong(
-            freeptr, new_freeptr, std::memory_order_acq_rel,
-            std::memory_order_acquire)) {
-      continue;
-    }
-
-    // Given that all memory was zeroed before ever being given to an instance
-    // of this class and given that we only allocate in a monotomic fashion
-    // going forward, it must be that the newly allocated block is completely
-    // full of zeros. If we find anything in the block header that is NOT a
-    // zero then something must have previously run amuck through memory,
-    // writing beyond the allocated space and into unallocated space.
-    if (block->size != 0 ||
-        block->cookie != kBlockCookieFree ||
-        block->type_id.load(std::memory_order_relaxed) != 0 ||
-        block->next.load(std::memory_order_relaxed) != 0) {
-      SetCorrupt();
-      return kReferenceNull;
-    }
-
-    // Make sure the memory exists by writing to the first byte of every memory
-    // page it touches beyond the one containing the block header itself.
-    // As the underlying storage is often memory mapped from disk or shared
-    // space, sometimes things go wrong and those address don't actually exist
-    // leading to a SIGBUS (or Windows equivalent) at some arbitrary location
-    // in the code. This should concentrate all those failures into this
-    // location for easy tracking and, eventually, proper handling.
-    volatile char* mem_end = reinterpret_cast<volatile char*>(block) + size;
-    volatile char* mem_begin = reinterpret_cast<volatile char*>(
-        (reinterpret_cast<uintptr_t>(block) + sizeof(BlockHeader) +
-         (vm_page_size_ - 1)) &
-        ~static_cast<uintptr_t>(vm_page_size_ - 1));
-    for (volatile char* memory = mem_begin; memory < mem_end;
-         memory += vm_page_size_) {
-      // It's required that a memory segment start as all zeros and thus the
-      // newly allocated block is all zeros at this point. Thus, writing a
-      // zero to it allows testing that the memory exists without actually
-      // changing its contents. The compiler doesn't know about the requirement
-      // and so cannot optimize-away these writes.
-      *memory = 0;
-    }
-
-    // Load information into the block header. There is no "release" of the
-    // data here because this memory can, currently, be seen only by the thread
-    // performing the allocation. When it comes time to share this, the thread
-    // will call MakeIterable() which does the release operation.
-    block->size = size;
-    block->cookie = kBlockCookieAllocated;
-    block->type_id.store(type_id, std::memory_order_relaxed);
-    return freeptr;
-  }
-}
-
-void PersistentMemoryAllocator::GetMemoryInfo(MemoryInfo* meminfo) const {
-  uint32_t remaining = std::max(
-      mem_size_ - shared_meta()->freeptr.load(std::memory_order_relaxed),
-      (uint32_t)sizeof(BlockHeader));
-  meminfo->total = mem_size_;
-  meminfo->free = remaining - sizeof(BlockHeader);
-}
-
-void PersistentMemoryAllocator::MakeIterable(Reference ref) {
-  DCHECK(!readonly_);
-  if (IsCorrupt())
-    return;
-  volatile BlockHeader* block = GetBlock(ref, 0, 0, false, false);
-  if (!block)  // invalid reference
-    return;
-  if (block->next.load(std::memory_order_acquire) != 0)  // Already iterable.
-    return;
-  block->next.store(kReferenceQueue, std::memory_order_release);  // New tail.
-
-  // Try to add this block to the tail of the queue. May take multiple tries.
-  // If so, tail will be automatically updated with a more recent value during
-  // compare-exchange operations.
-  uint32_t tail = shared_meta()->tailptr.load(std::memory_order_acquire);
-  for (;;) {
-    // Acquire the current tail-pointer released by previous call to this
-    // method and validate it.
-    block = GetBlock(tail, 0, 0, true, false);
-    if (!block) {
-      SetCorrupt();
-      return;
-    }
-
-    // Try to insert the block at the tail of the queue. The tail node always
-    // has an existing value of kReferenceQueue; if that is somehow not the
-    // existing value then another thread has acted in the meantime. A "strong"
-    // exchange is necessary so the "else" block does not get executed when
-    // that is not actually the case (which can happen with a "weak" exchange).
-    uint32_t next = kReferenceQueue;  // Will get replaced with existing value.
-    if (block->next.compare_exchange_strong(next, ref,
-                                            std::memory_order_acq_rel,
-                                            std::memory_order_acquire)) {
-      // Update the tail pointer to the new offset. If the "else" clause did
-      // not exist, then this could be a simple Release_Store to set the new
-      // value but because it does, it's possible that other threads could add
-      // one or more nodes at the tail before reaching this point. We don't
-      // have to check the return value because it either operates correctly
-      // or the exact same operation has already been done (by the "else"
-      // clause) on some other thread.
-      shared_meta()->tailptr.compare_exchange_strong(tail, ref,
-                                                     std::memory_order_release,
-                                                     std::memory_order_relaxed);
-      return;
-    } else {
-      // In the unlikely case that a thread crashed or was killed between the
-      // update of "next" and the update of "tailptr", it is necessary to
-      // perform the operation that would have been done. There's no explicit
-      // check for crash/kill which means that this operation may also happen
-      // even when the other thread is in perfect working order which is what
-      // necessitates the CompareAndSwap above.
-      shared_meta()->tailptr.compare_exchange_strong(tail, next,
-                                                     std::memory_order_acq_rel,
-                                                     std::memory_order_acquire);
-    }
-  }
-}
-
-// The "corrupted" state is held both locally and globally (shared). The
-// shared flag can't be trusted since a malicious actor could overwrite it.
-// Because corruption can be detected during read-only operations such as
-// iteration, this method may be called by other "const" methods. In this
-// case, it's safe to discard the constness and modify the local flag and
-// maybe even the shared flag if the underlying data isn't actually read-only.
-void PersistentMemoryAllocator::SetCorrupt() const {
-  if (!corrupt_.load(std::memory_order_relaxed) &&
-      !CheckFlag(
-          const_cast<volatile std::atomic<uint32_t>*>(&shared_meta()->flags),
-          kFlagCorrupt)) {
-    LOG(ERROR) << "Corruption detected in shared-memory segment.";
-    RecordError(kMemoryIsCorrupt);
-  }
-
-  corrupt_.store(true, std::memory_order_relaxed);
-  if (!readonly_) {
-    SetFlag(const_cast<volatile std::atomic<uint32_t>*>(&shared_meta()->flags),
-            kFlagCorrupt);
-  }
-}
-
-bool PersistentMemoryAllocator::IsCorrupt() const {
-  if (corrupt_.load(std::memory_order_relaxed) ||
-      CheckFlag(&shared_meta()->flags, kFlagCorrupt)) {
-    SetCorrupt();  // Make sure all indicators are set.
-    return true;
-  }
-  return false;
-}
-
-bool PersistentMemoryAllocator::IsFull() const {
-  return CheckFlag(&shared_meta()->flags, kFlagFull);
-}
-
-// Dereference a block |ref| and ensure that it's valid for the desired
-// |type_id| and |size|. |special| indicates that we may try to access block
-// headers not available to callers but still accessed by this module. By
-// having internal dereferences go through this same function, the allocator
-// is hardened against corruption.
-const volatile PersistentMemoryAllocator::BlockHeader*
-PersistentMemoryAllocator::GetBlock(Reference ref, uint32_t type_id,
-                                    uint32_t size, bool queue_ok,
-                                    bool free_ok) const {
-  // Handle special cases.
-  if (ref == kReferenceQueue && queue_ok)
-    return reinterpret_cast<const volatile BlockHeader*>(mem_base_ + ref);
-
-  // Validation of parameters.
-  if (ref < sizeof(SharedMetadata))
-    return nullptr;
-  if (ref % kAllocAlignment != 0)
-    return nullptr;
-  size += sizeof(BlockHeader);
-  if (ref + size > mem_size_)
-    return nullptr;
-
-  // Validation of referenced block-header.
-  if (!free_ok) {
-    const volatile BlockHeader* const block =
-        reinterpret_cast<volatile BlockHeader*>(mem_base_ + ref);
-    if (block->cookie != kBlockCookieAllocated)
-      return nullptr;
-    if (block->size < size)
-      return nullptr;
-    if (ref + block->size > mem_size_)
-      return nullptr;
-    if (type_id != 0 &&
-        block->type_id.load(std::memory_order_relaxed) != type_id) {
-      return nullptr;
-    }
-  }
-
-  // Return pointer to block data.
-  return reinterpret_cast<const volatile BlockHeader*>(mem_base_ + ref);
-}
-
-void PersistentMemoryAllocator::FlushPartial(size_t length, bool sync) {
-  // Generally there is nothing to do as every write is done through volatile
-  // memory with atomic instructions to guarantee consistency. This (virtual)
-  // method exists so that derivced classes can do special things, such as
-  // tell the OS to write changes to disk now rather than when convenient.
-}
-
-void PersistentMemoryAllocator::RecordError(int error) const {
-  if (errors_histogram_)
-    errors_histogram_->Add(error);
-}
-
-const volatile void* PersistentMemoryAllocator::GetBlockData(
-    Reference ref,
-    uint32_t type_id,
-    uint32_t size) const {
-  DCHECK(size > 0);
-  const volatile BlockHeader* block =
-      GetBlock(ref, type_id, size, false, false);
-  if (!block)
-    return nullptr;
-  return reinterpret_cast<const volatile char*>(block) + sizeof(BlockHeader);
-}
-
-void PersistentMemoryAllocator::UpdateTrackingHistograms() {
-  DCHECK(!readonly_);
-  if (used_histogram_) {
-    MemoryInfo meminfo;
-    GetMemoryInfo(&meminfo);
-    HistogramBase::Sample used_percent = static_cast<HistogramBase::Sample>(
-        ((meminfo.total - meminfo.free) * 100ULL / meminfo.total));
-    used_histogram_->Add(used_percent);
-  }
-}
-
-
-//----- LocalPersistentMemoryAllocator -----------------------------------------
-
-LocalPersistentMemoryAllocator::LocalPersistentMemoryAllocator(
-    size_t size,
-    uint64_t id,
-    base::StringPiece name)
-    : PersistentMemoryAllocator(AllocateLocalMemory(size),
-                                size, 0, id, name, false) {}
-
-LocalPersistentMemoryAllocator::~LocalPersistentMemoryAllocator() {
-  DeallocateLocalMemory(const_cast<char*>(mem_base_), mem_size_, mem_type_);
-}
-
-// static
-PersistentMemoryAllocator::Memory
-LocalPersistentMemoryAllocator::AllocateLocalMemory(size_t size) {
-  void* address;
-
-#if defined(OS_WIN)
-  address =
-      ::VirtualAlloc(nullptr, size, MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);
-  if (address)
-    return Memory(address, MEM_VIRTUAL);
-  UmaHistogramSparse("UMA.LocalPersistentMemoryAllocator.Failures.Win",
-                     ::GetLastError());
-#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
-  // MAP_ANON is deprecated on Linux but MAP_ANONYMOUS is not universal on Mac.
-  // MAP_SHARED is not available on Linux <2.4 but required on Mac.
-  address = ::mmap(nullptr, size, PROT_READ | PROT_WRITE,
-                   MAP_ANON | MAP_SHARED, -1, 0);
-  if (address != MAP_FAILED)
-    return Memory(address, MEM_VIRTUAL);
-  UmaHistogramSparse("UMA.LocalPersistentMemoryAllocator.Failures.Posix",
-                     errno);
-#else
-#error This architecture is not (yet) supported.
-#endif
-
-  // As a last resort, just allocate the memory from the heap. This will
-  // achieve the same basic result but the acquired memory has to be
-  // explicitly zeroed and thus realized immediately (i.e. all pages are
-  // added to the process now istead of only when first accessed).
-  address = malloc(size);
-  DPCHECK(address);
-  memset(address, 0, size);
-  return Memory(address, MEM_MALLOC);
-}
-
-// static
-void LocalPersistentMemoryAllocator::DeallocateLocalMemory(void* memory,
-                                                           size_t size,
-                                                           MemoryType type) {
-  if (type == MEM_MALLOC) {
-    free(memory);
-    return;
-  }
-
-  DCHECK_EQ(MEM_VIRTUAL, type);
-#if defined(OS_WIN)
-  BOOL success = ::VirtualFree(memory, 0, MEM_DECOMMIT);
-  DCHECK(success);
-#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
-  int result = ::munmap(memory, size);
-  DCHECK_EQ(0, result);
-#else
-#error This architecture is not (yet) supported.
-#endif
-}
-
-
-//----- SharedPersistentMemoryAllocator ----------------------------------------
-
-SharedPersistentMemoryAllocator::SharedPersistentMemoryAllocator(
-    std::unique_ptr<SharedMemory> memory,
-    uint64_t id,
-    base::StringPiece name,
-    bool read_only)
-    : PersistentMemoryAllocator(
-          Memory(static_cast<uint8_t*>(memory->memory()), MEM_SHARED),
-          memory->mapped_size(),
-          0,
-          id,
-          name,
-          read_only),
-      shared_memory_(std::move(memory)) {}
-
-SharedPersistentMemoryAllocator::~SharedPersistentMemoryAllocator() = default;
-
-// static
-bool SharedPersistentMemoryAllocator::IsSharedMemoryAcceptable(
-    const SharedMemory& memory) {
-  return IsMemoryAcceptable(memory.memory(), memory.mapped_size(), 0, false);
-}
-
-
-#if !defined(OS_NACL)
-//----- FilePersistentMemoryAllocator ------------------------------------------
-
-FilePersistentMemoryAllocator::FilePersistentMemoryAllocator(
-    std::unique_ptr<MemoryMappedFile> file,
-    size_t max_size,
-    uint64_t id,
-    base::StringPiece name,
-    bool read_only)
-    : PersistentMemoryAllocator(
-          Memory(const_cast<uint8_t*>(file->data()), MEM_FILE),
-          max_size != 0 ? max_size : file->length(),
-          0,
-          id,
-          name,
-          read_only),
-      mapped_file_(std::move(file)) {}
-
-FilePersistentMemoryAllocator::~FilePersistentMemoryAllocator() = default;
-
-// static
-bool FilePersistentMemoryAllocator::IsFileAcceptable(
-    const MemoryMappedFile& file,
-    bool read_only) {
-  return IsMemoryAcceptable(file.data(), file.length(), 0, read_only);
-}
-
-void FilePersistentMemoryAllocator::FlushPartial(size_t length, bool sync) {
-  if (sync)
-    AssertBlockingAllowed();
-  if (IsReadonly())
-    return;
-
-#if defined(OS_WIN)
-  // Windows doesn't support asynchronous flush.
-  AssertBlockingAllowed();
-  BOOL success = ::FlushViewOfFile(data(), length);
-  DPCHECK(success);
-#elif defined(OS_MACOSX)
-  // On OSX, "invalidate" removes all cached pages, forcing a re-read from
-  // disk. That's not applicable to "flush" so omit it.
-  int result =
-      ::msync(const_cast<void*>(data()), length, sync ? MS_SYNC : MS_ASYNC);
-  DCHECK_NE(EINVAL, result);
-#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
-  // On POSIX, "invalidate" forces _other_ processes to recognize what has
-  // been written to disk and so is applicable to "flush".
-  int result = ::msync(const_cast<void*>(data()), length,
-                       MS_INVALIDATE | (sync ? MS_SYNC : MS_ASYNC));
-  DCHECK_NE(EINVAL, result);
-#else
-#error Unsupported OS.
-#endif
-}
-#endif  // !defined(OS_NACL)
-
-//----- DelayedPersistentAllocation --------------------------------------------
-
-// Forwarding constructors.
-DelayedPersistentAllocation::DelayedPersistentAllocation(
-    PersistentMemoryAllocator* allocator,
-    subtle::Atomic32* ref,
-    uint32_t type,
-    size_t size,
-    bool make_iterable)
-    : DelayedPersistentAllocation(
-          allocator,
-          reinterpret_cast<std::atomic<Reference>*>(ref),
-          type,
-          size,
-          0,
-          make_iterable) {}
-
-DelayedPersistentAllocation::DelayedPersistentAllocation(
-    PersistentMemoryAllocator* allocator,
-    subtle::Atomic32* ref,
-    uint32_t type,
-    size_t size,
-    size_t offset,
-    bool make_iterable)
-    : DelayedPersistentAllocation(
-          allocator,
-          reinterpret_cast<std::atomic<Reference>*>(ref),
-          type,
-          size,
-          offset,
-          make_iterable) {}
-
-DelayedPersistentAllocation::DelayedPersistentAllocation(
-    PersistentMemoryAllocator* allocator,
-    std::atomic<Reference>* ref,
-    uint32_t type,
-    size_t size,
-    bool make_iterable)
-    : DelayedPersistentAllocation(allocator,
-                                  ref,
-                                  type,
-                                  size,
-                                  0,
-                                  make_iterable) {}
-
-// Real constructor.
-DelayedPersistentAllocation::DelayedPersistentAllocation(
-    PersistentMemoryAllocator* allocator,
-    std::atomic<Reference>* ref,
-    uint32_t type,
-    size_t size,
-    size_t offset,
-    bool make_iterable)
-    : allocator_(allocator),
-      type_(type),
-      size_(checked_cast<uint32_t>(size)),
-      offset_(checked_cast<uint32_t>(offset)),
-      make_iterable_(make_iterable),
-      reference_(ref) {
-  DCHECK(allocator_);
-  DCHECK_NE(0U, type_);
-  DCHECK_LT(0U, size_);
-  DCHECK(reference_);
-}
-
-DelayedPersistentAllocation::~DelayedPersistentAllocation() = default;
-
-void* DelayedPersistentAllocation::Get() const {
-  // Relaxed operations are acceptable here because it's not protecting the
-  // contents of the allocation in any way.
-  Reference ref = reference_->load(std::memory_order_acquire);
-  if (!ref) {
-    ref = allocator_->Allocate(size_, type_);
-    if (!ref)
-      return nullptr;
-
-    // Store the new reference in its proper location using compare-and-swap.
-    // Use a "strong" exchange to ensure no false-negatives since the operation
-    // cannot be retried.
-    Reference existing = 0;  // Must be mutable; receives actual value.
-    if (reference_->compare_exchange_strong(existing, ref,
-                                            std::memory_order_release,
-                                            std::memory_order_relaxed)) {
-      if (make_iterable_)
-        allocator_->MakeIterable(ref);
-    } else {
-      // Failure indicates that something else has raced ahead, performed the
-      // allocation, and stored its reference. Purge the allocation that was
-      // just done and use the other one instead.
-      DCHECK_EQ(type_, allocator_->GetType(existing));
-      DCHECK_LE(size_, allocator_->GetAllocSize(existing));
-      allocator_->ChangeType(ref, 0, type_, /*clear=*/false);
-      ref = existing;
-    }
-  }
-
-  char* mem = allocator_->GetAsArray<char>(ref, type_, size_);
-  if (!mem) {
-    // This should never happen but be tolerant if it does as corruption from
-    // the outside is something to guard against.
-    NOTREACHED();
-    return nullptr;
-  }
-  return mem + offset_;
-}
-
-}  // namespace base
diff --git a/base/metrics/persistent_memory_allocator.h b/base/metrics/persistent_memory_allocator.h
deleted file mode 100644
index 978a362..0000000
--- a/base/metrics/persistent_memory_allocator.h
+++ /dev/null
@@ -1,872 +0,0 @@
-// Copyright (c) 2015 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_METRICS_PERSISTENT_MEMORY_ALLOCATOR_H_
-#define BASE_METRICS_PERSISTENT_MEMORY_ALLOCATOR_H_
-
-#include <stdint.h>
-
-#include <atomic>
-#include <memory>
-#include <type_traits>
-
-#include "base/atomicops.h"
-#include "base/base_export.h"
-#include "base/files/file_path.h"
-#include "base/gtest_prod_util.h"
-#include "base/macros.h"
-#include "base/strings/string_piece.h"
-
-namespace base {
-
-class HistogramBase;
-class MemoryMappedFile;
-class SharedMemory;
-
-// Simple allocator for pieces of a memory block that may be persistent
-// to some storage or shared across multiple processes. This class resides
-// under base/metrics because it was written for that purpose. It is,
-// however, fully general-purpose and can be freely moved to base/memory
-// if other uses are found.
-//
-// This class provides for thread-secure (i.e. safe against other threads
-// or processes that may be compromised and thus have malicious intent)
-// allocation of memory within a designated block and also a mechanism by
-// which other threads can learn of these allocations.
-//
-// There is (currently) no way to release an allocated block of data because
-// doing so would risk invalidating pointers held by other processes and
-// greatly complicate the allocation algorithm.
-//
-// Construction of this object can accept new, clean (i.e. zeroed) memory
-// or previously initialized memory. In the first case, construction must
-// be allowed to complete before letting other allocators attach to the same
-// segment. In other words, don't share the segment until at least one
-// allocator has been attached to it.
-//
-// Note that memory not in active use is not accessed so it is possible to
-// use virtual memory, including memory-mapped files, as backing storage with
-// the OS "pinning" new (zeroed) physical RAM pages only as they are needed.
-//
-// OBJECTS: Although the allocator can be used in a "malloc" sense, fetching
-// character arrays and manipulating that memory manually, the better way is
-// generally to use the "object" methods to create and manage allocations. In
-// this way the sizing, type-checking, and construction are all automatic. For
-// this to work, however, every type of stored object must define two public
-// "constexpr" values, kPersistentTypeId and kExpectedInstanceSize, as such:
-//
-// struct MyPersistentObjectType {
-//     // SHA1(MyPersistentObjectType): Increment this if structure changes!
-//     static constexpr uint32_t kPersistentTypeId = 0x3E15F6DE + 1;
-//
-//     // Expected size for 32/64-bit check. Update this if structure changes!
-//     static constexpr size_t kExpectedInstanceSize = 20;
-//
-//     ...
-// };
-//
-// kPersistentTypeId: This value is an arbitrary identifier that allows the
-//   identification of these objects in the allocator, including the ability
-//   to find them via iteration. The number is arbitrary but using the first
-//   four bytes of the SHA1 hash of the type name means that there shouldn't
-//   be any conflicts with other types that may also be stored in the memory.
-//   The fully qualified name (e.g. base::debug::MyPersistentObjectType) could
-//   be used to generate the hash if the type name seems common. Use a command
-//   like this to get the hash: echo -n "MyPersistentObjectType" | sha1sum
-//   If the structure layout changes, ALWAYS increment this number so that
-//   newer versions of the code don't try to interpret persistent data written
-//   by older versions with a different layout.
-//
-// kExpectedInstanceSize: This value is the hard-coded number that matches
-//   what sizeof(T) would return. By providing it explicitly, the allocator can
-//   verify that the structure is compatible between both 32-bit and 64-bit
-//   versions of the code.
-//
-// Using New manages the memory and then calls the default constructor for the
-// object. Given that objects are persistent, no destructor is ever called
-// automatically though a caller can explicitly call Delete to destruct it and
-// change the type to something indicating it is no longer in use.
-//
-// Though persistent memory segments are transferrable between programs built
-// for different natural word widths, they CANNOT be exchanged between CPUs
-// of different endianess. Attempts to do so will simply see the existing data
-// as corrupt and refuse to access any of it.
-class BASE_EXPORT PersistentMemoryAllocator {
- public:
-  typedef uint32_t Reference;
-
-  // These states are used to indicate the overall condition of the memory
-  // segment irrespective of what is stored within it. Because the data is
-  // often persistent and thus needs to be readable by different versions of
-  // a program, these values are fixed and can never change.
-  enum MemoryState : uint8_t {
-    // Persistent memory starts all zeros and so shows "uninitialized".
-    MEMORY_UNINITIALIZED = 0,
-
-    // The header has been written and the memory is ready for use.
-    MEMORY_INITIALIZED = 1,
-
-    // The data should be considered deleted. This would be set when the
-    // allocator is being cleaned up. If file-backed, the file is likely
-    // to be deleted but since deletion can fail for a variety of reasons,
-    // having this extra status means a future reader can realize what
-    // should have happened.
-    MEMORY_DELETED = 2,
-
-    // Outside code can create states starting with this number; these too
-    // must also never change between code versions.
-    MEMORY_USER_DEFINED = 100,
-  };
-
-  // Iterator for going through all iterable memory records in an allocator.
-  // Like the allocator itself, iterators are lock-free and thread-secure.
-  // That means that multiple threads can share an iterator and the same
-  // reference will not be returned twice.
-  //
-  // The order of the items returned by an iterator matches the order in which
-  // MakeIterable() was called on them. Once an allocation is made iterable,
-  // it is always such so the only possible difference between successive
-  // iterations is for more to be added to the end.
-  //
-  // Iteration, in general, is tolerant of corrupted memory. It will return
-  // what it can and stop only when corruption forces it to. Bad corruption
-  // could cause the same object to be returned many times but it will
-  // eventually quit.
-  class BASE_EXPORT Iterator {
-   public:
-    // Constructs an iterator on a given |allocator|, starting at the beginning.
-    // The allocator must live beyond the lifetime of the iterator. This class
-    // has read-only access to the allocator (hence "const") but the returned
-    // references can be used on a read/write version, too.
-    explicit Iterator(const PersistentMemoryAllocator* allocator);
-
-    // As above but resuming from the |starting_after| reference. The first call
-    // to GetNext() will return the next object found after that reference. The
-    // reference must be to an "iterable" object; references to non-iterable
-    // objects (those that never had MakeIterable() called for them) will cause
-    // a run-time error.
-    Iterator(const PersistentMemoryAllocator* allocator,
-             Reference starting_after);
-
-    // Resets the iterator back to the beginning.
-    void Reset();
-
-    // Resets the iterator, resuming from the |starting_after| reference.
-    void Reset(Reference starting_after);
-
-    // Returns the previously retrieved reference, or kReferenceNull if none.
-    // If constructor or reset with a starting_after location, this will return
-    // that value.
-    Reference GetLast();
-
-    // Gets the next iterable, storing that type in |type_return|. The actual
-    // return value is a reference to the allocation inside the allocator or
-    // zero if there are no more. GetNext() may still be called again at a
-    // later time to retrieve any new allocations that have been added.
-    Reference GetNext(uint32_t* type_return);
-
-    // Similar to above but gets the next iterable of a specific |type_match|.
-    // This should not be mixed with calls to GetNext() because any allocations
-    // skipped here due to a type mis-match will never be returned by later
-    // calls to GetNext() meaning it's possible to completely miss entries.
-    Reference GetNextOfType(uint32_t type_match);
-
-    // As above but works using object type.
-    template <typename T>
-    Reference GetNextOfType() {
-      return GetNextOfType(T::kPersistentTypeId);
-    }
-
-    // As above but works using objects and returns null if not found.
-    template <typename T>
-    const T* GetNextOfObject() {
-      return GetAsObject<T>(GetNextOfType<T>());
-    }
-
-    // Converts references to objects. This is a convenience method so that
-    // users of the iterator don't need to also have their own pointer to the
-    // allocator over which the iterator runs in order to retrieve objects.
-    // Because the iterator is not read/write, only "const" objects can be
-    // fetched. Non-const objects can be fetched using the reference on a
-    // non-const (external) pointer to the same allocator (or use const_cast
-    // to remove the qualifier).
-    template <typename T>
-    const T* GetAsObject(Reference ref) const {
-      return allocator_->GetAsObject<T>(ref);
-    }
-
-    // Similar to GetAsObject() but converts references to arrays of things.
-    template <typename T>
-    const T* GetAsArray(Reference ref, uint32_t type_id, size_t count) const {
-      return allocator_->GetAsArray<T>(ref, type_id, count);
-    }
-
-    // Convert a generic pointer back into a reference. A null reference will
-    // be returned if |memory| is not inside the persistent segment or does not
-    // point to an object of the specified |type_id|.
-    Reference GetAsReference(const void* memory, uint32_t type_id) const {
-      return allocator_->GetAsReference(memory, type_id);
-    }
-
-    // As above but convert an object back into a reference.
-    template <typename T>
-    Reference GetAsReference(const T* obj) const {
-      return allocator_->GetAsReference(obj);
-    }
-
-   private:
-    // Weak-pointer to memory allocator being iterated over.
-    const PersistentMemoryAllocator* allocator_;
-
-    // The last record that was returned.
-    std::atomic<Reference> last_record_;
-
-    // The number of records found; used for detecting loops.
-    std::atomic<uint32_t> record_count_;
-
-    DISALLOW_COPY_AND_ASSIGN(Iterator);
-  };
-
-  // Returned information about the internal state of the heap.
-  struct MemoryInfo {
-    size_t total;
-    size_t free;
-  };
-
-  enum : Reference {
-    // A common "null" reference value.
-    kReferenceNull = 0,
-  };
-
-  enum : uint32_t {
-    // A value that will match any type when doing lookups.
-    kTypeIdAny = 0x00000000,
-
-    // A value indicating that the type is in transition. Work is being done
-    // on the contents to prepare it for a new type to come.
-    kTypeIdTransitioning = 0xFFFFFFFF,
-  };
-
-  enum : size_t {
-    kSizeAny = 1  // Constant indicating that any array size is acceptable.
-  };
-
-  // This is the standard file extension (suitable for being passed to the
-  // AddExtension() method of base::FilePath) for dumps of persistent memory.
-  static const base::FilePath::CharType kFileExtension[];
-
-  // The allocator operates on any arbitrary block of memory. Creation and
-  // persisting or sharing of that block with another process is the
-  // responsibility of the caller. The allocator needs to know only the
-  // block's |base| address, the total |size| of the block, and any internal
-  // |page| size (zero if not paged) across which allocations should not span.
-  // The |id| is an arbitrary value the caller can use to identify a
-  // particular memory segment. It will only be loaded during the initial
-  // creation of the segment and can be checked by the caller for consistency.
-  // The |name|, if provided, is used to distinguish histograms for this
-  // allocator. Only the primary owner of the segment should define this value;
-  // other processes can learn it from the shared state. If the underlying
-  // memory is |readonly| then no changes will be made to it. The resulting
-  // object should be stored as a "const" pointer.
-  //
-  // PersistentMemoryAllocator does NOT take ownership of the memory block.
-  // The caller must manage it and ensure it stays available throughout the
-  // lifetime of this object.
-  //
-  // Memory segments for sharing must have had an allocator attached to them
-  // before actually being shared. If the memory segment was just created, it
-  // should be zeroed before being passed here. If it was an existing segment,
-  // the values here will be compared to copies stored in the shared segment
-  // as a guard against corruption.
-  //
-  // Make sure that the memory segment is acceptable (see IsMemoryAcceptable()
-  // method below) before construction if the definition of the segment can
-  // vary in any way at run-time. Invalid memory segments will cause a crash.
-  PersistentMemoryAllocator(void* base, size_t size, size_t page_size,
-                            uint64_t id, base::StringPiece name,
-                            bool readonly);
-  virtual ~PersistentMemoryAllocator();
-
-  // Check if memory segment is acceptable for creation of an Allocator. This
-  // doesn't do any analysis of the data and so doesn't guarantee that the
-  // contents are valid, just that the paramaters won't cause the program to
-  // abort. The IsCorrupt() method will report detection of data problems
-  // found during construction and general operation.
-  static bool IsMemoryAcceptable(const void* data, size_t size,
-                                 size_t page_size, bool readonly);
-
-  // Get the internal identifier for this persistent memory segment.
-  uint64_t Id() const;
-
-  // Get the internal name of this allocator (possibly an empty string).
-  const char* Name() const;
-
-  // Is this segment open only for read?
-  bool IsReadonly() const { return readonly_; }
-
-  // Manage the saved state of the memory.
-  void SetMemoryState(uint8_t memory_state);
-  uint8_t GetMemoryState() const;
-
-  // Create internal histograms for tracking memory use and allocation sizes
-  // for allocator of |name| (which can simply be the result of Name()). This
-  // is done seperately from construction for situations such as when the
-  // histograms will be backed by memory provided by this very allocator.
-  //
-  // IMPORTANT: Callers must update tools/metrics/histograms/histograms.xml
-  // with the following histograms:
-  //    UMA.PersistentAllocator.name.Errors
-  //    UMA.PersistentAllocator.name.UsedPct
-  void CreateTrackingHistograms(base::StringPiece name);
-
-  // Flushes the persistent memory to any backing store. This typically does
-  // nothing but is used by the FilePersistentMemoryAllocator to inform the
-  // OS that all the data should be sent to the disk immediately. This is
-  // useful in the rare case where something has just been stored that needs
-  // to survive a hard shutdown of the machine like from a power failure.
-  // The |sync| parameter indicates if this call should block until the flush
-  // is complete but is only advisory and may or may not have an effect
-  // depending on the capabilities of the OS. Synchronous flushes are allowed
-  // only from theads that are allowed to do I/O but since |sync| is only
-  // advisory, all flushes should be done on IO-capable threads.
-  void Flush(bool sync);
-
-  // Direct access to underlying memory segment. If the segment is shared
-  // across threads or processes, reading data through these values does
-  // not guarantee consistency. Use with care. Do not write.
-  const void* data() const { return const_cast<const char*>(mem_base_); }
-  size_t length() const { return mem_size_; }
-  size_t size() const { return mem_size_; }
-  size_t used() const;
-
-  // Get an object referenced by a |ref|. For safety reasons, the |type_id|
-  // code and size-of(|T|) are compared to ensure the reference is valid
-  // and cannot return an object outside of the memory segment. A |type_id| of
-  // kTypeIdAny (zero) will match any though the size is still checked. NULL is
-  // returned if any problem is detected, such as corrupted storage or incorrect
-  // parameters. Callers MUST check that the returned value is not-null EVERY
-  // TIME before accessing it or risk crashing! Once dereferenced, the pointer
-  // is safe to reuse forever.
-  //
-  // It is essential that the object be of a fixed size. All fields must be of
-  // a defined type that does not change based on the compiler or the CPU
-  // natural word size. Acceptable are char, float, double, and (u)intXX_t.
-  // Unacceptable are int, bool, and wchar_t which are implementation defined
-  // with regards to their size.
-  //
-  // Alignment must also be consistent. A uint64_t after a uint32_t will pad
-  // differently between 32 and 64 bit architectures. Either put the bigger
-  // elements first, group smaller elements into blocks the size of larger
-  // elements, or manually insert padding fields as appropriate for the
-  // largest architecture, including at the end.
-  //
-  // To protected against mistakes, all objects must have the attribute
-  // |kExpectedInstanceSize| (static constexpr size_t)  that is a hard-coded
-  // numerical value -- NNN, not sizeof(T) -- that can be tested. If the
-  // instance size is not fixed, at least one build will fail.
-  //
-  // If the size of a structure changes, the type-ID used to recognize it
-  // should also change so later versions of the code don't try to read
-  // incompatible structures from earlier versions.
-  //
-  // NOTE: Though this method will guarantee that an object of the specified
-  // type can be accessed without going outside the bounds of the memory
-  // segment, it makes no guarantees of the validity of the data within the
-  // object itself. If it is expected that the contents of the segment could
-  // be compromised with malicious intent, the object must be hardened as well.
-  //
-  // Though the persistent data may be "volatile" if it is shared with
-  // other processes, such is not necessarily the case. The internal
-  // "volatile" designation is discarded so as to not propagate the viral
-  // nature of that keyword to the caller. It can add it back, if necessary,
-  // based on knowledge of how the allocator is being used.
-  template <typename T>
-  T* GetAsObject(Reference ref) {
-    static_assert(std::is_standard_layout<T>::value, "only standard objects");
-    static_assert(!std::is_array<T>::value, "use GetAsArray<>()");
-    static_assert(T::kExpectedInstanceSize == sizeof(T), "inconsistent size");
-    return const_cast<T*>(reinterpret_cast<volatile T*>(
-        GetBlockData(ref, T::kPersistentTypeId, sizeof(T))));
-  }
-  template <typename T>
-  const T* GetAsObject(Reference ref) const {
-    static_assert(std::is_standard_layout<T>::value, "only standard objects");
-    static_assert(!std::is_array<T>::value, "use GetAsArray<>()");
-    static_assert(T::kExpectedInstanceSize == sizeof(T), "inconsistent size");
-    return const_cast<const T*>(reinterpret_cast<const volatile T*>(
-        GetBlockData(ref, T::kPersistentTypeId, sizeof(T))));
-  }
-
-  // Like GetAsObject but get an array of simple, fixed-size types.
-  //
-  // Use a |count| of the required number of array elements, or kSizeAny.
-  // GetAllocSize() can be used to calculate the upper bound but isn't reliable
-  // because padding can make space for extra elements that were not written.
-  //
-  // Remember that an array of char is a string but may not be NUL terminated.
-  //
-  // There are no compile-time or run-time checks to ensure 32/64-bit size
-  // compatibilty when using these accessors. Only use fixed-size types such
-  // as char, float, double, or (u)intXX_t.
-  template <typename T>
-  T* GetAsArray(Reference ref, uint32_t type_id, size_t count) {
-    static_assert(std::is_fundamental<T>::value, "use GetAsObject<>()");
-    return const_cast<T*>(reinterpret_cast<volatile T*>(
-        GetBlockData(ref, type_id, count * sizeof(T))));
-  }
-  template <typename T>
-  const T* GetAsArray(Reference ref, uint32_t type_id, size_t count) const {
-    static_assert(std::is_fundamental<T>::value, "use GetAsObject<>()");
-    return const_cast<const char*>(reinterpret_cast<const volatile T*>(
-        GetBlockData(ref, type_id, count * sizeof(T))));
-  }
-
-  // Get the corresponding reference for an object held in persistent memory.
-  // If the |memory| is not valid or the type does not match, a kReferenceNull
-  // result will be returned.
-  Reference GetAsReference(const void* memory, uint32_t type_id) const;
-
-  // Get the number of bytes allocated to a block. This is useful when storing
-  // arrays in order to validate the ending boundary. The returned value will
-  // include any padding added to achieve the required alignment and so could
-  // be larger than given in the original Allocate() request.
-  size_t GetAllocSize(Reference ref) const;
-
-  // Access the internal "type" of an object. This generally isn't necessary
-  // but can be used to "clear" the type and so effectively mark it as deleted
-  // even though the memory stays valid and allocated. Changing the type is
-  // an atomic compare/exchange and so requires knowing the existing value.
-  // It will return false if the existing type is not what is expected.
-  //
-  // Changing the type doesn't mean the data is compatible with the new type.
-  // Passing true for |clear| will zero the memory after the type has been
-  // changed away from |from_type_id| but before it becomes |to_type_id| meaning
-  // that it is done in a manner that is thread-safe. Memory is guaranteed to
-  // be zeroed atomically by machine-word in a monotonically increasing order.
-  //
-  // It will likely be necessary to reconstruct the type before it can be used.
-  // Changing the type WILL NOT invalidate existing pointers to the data, either
-  // in this process or others, so changing the data structure could have
-  // unpredicatable results. USE WITH CARE!
-  uint32_t GetType(Reference ref) const;
-  bool ChangeType(Reference ref,
-                  uint32_t to_type_id,
-                  uint32_t from_type_id,
-                  bool clear);
-
-  // Allocated objects can be added to an internal list that can then be
-  // iterated over by other processes. If an allocated object can be found
-  // another way, such as by having its reference within a different object
-  // that will be made iterable, then this call is not necessary. This always
-  // succeeds unless corruption is detected; check IsCorrupted() to find out.
-  // Once an object is made iterable, its position in iteration can never
-  // change; new iterable objects will always be added after it in the series.
-  // Changing the type does not alter its "iterable" status.
-  void MakeIterable(Reference ref);
-
-  // Get the information about the amount of free space in the allocator. The
-  // amount of free space should be treated as approximate due to extras from
-  // alignment and metadata. Concurrent allocations from other threads will
-  // also make the true amount less than what is reported.
-  void GetMemoryInfo(MemoryInfo* meminfo) const;
-
-  // If there is some indication that the memory has become corrupted,
-  // calling this will attempt to prevent further damage by indicating to
-  // all processes that something is not as expected.
-  void SetCorrupt() const;
-
-  // This can be called to determine if corruption has been detected in the
-  // segment, possibly my a malicious actor. Once detected, future allocations
-  // will fail and iteration may not locate all objects.
-  bool IsCorrupt() const;
-
-  // Flag set if an allocation has failed because the memory segment was full.
-  bool IsFull() const;
-
-  // Update those "tracking" histograms which do not get updates during regular
-  // operation, such as how much memory is currently used. This should be
-  // called before such information is to be displayed or uploaded.
-  void UpdateTrackingHistograms();
-
-  // While the above works much like malloc & free, these next methods provide
-  // an "object" interface similar to new and delete.
-
-  // Reserve space in the memory segment of the desired |size| and |type_id|.
-  // A return value of zero indicates the allocation failed, otherwise the
-  // returned reference can be used by any process to get a real pointer via
-  // the GetAsObject() or GetAsArray calls. The actual allocated size may be
-  // larger and will always be a multiple of 8 bytes (64 bits).
-  Reference Allocate(size_t size, uint32_t type_id);
-
-  // Allocate and construct an object in persistent memory. The type must have
-  // both (size_t) kExpectedInstanceSize and (uint32_t) kPersistentTypeId
-  // static constexpr fields that are used to ensure compatibility between
-  // software versions. An optional size parameter can be specified to force
-  // the allocation to be bigger than the size of the object; this is useful
-  // when the last field is actually variable length.
-  template <typename T>
-  T* New(size_t size) {
-    if (size < sizeof(T))
-      size = sizeof(T);
-    Reference ref = Allocate(size, T::kPersistentTypeId);
-    void* mem =
-        const_cast<void*>(GetBlockData(ref, T::kPersistentTypeId, size));
-    if (!mem)
-      return nullptr;
-    DCHECK_EQ(0U, reinterpret_cast<uintptr_t>(mem) & (alignof(T) - 1));
-    return new (mem) T();
-  }
-  template <typename T>
-  T* New() {
-    return New<T>(sizeof(T));
-  }
-
-  // Similar to New, above, but construct the object out of an existing memory
-  // block and of an expected type. If |clear| is true, memory will be zeroed
-  // before construction. Though this is not standard object behavior, it
-  // is present to match with new allocations that always come from zeroed
-  // memory. Anything previously present simply ceases to exist; no destructor
-  // is called for it so explicitly Delete() the old object first if need be.
-  // Calling this will not invalidate existing pointers to the object, either
-  // in this process or others, so changing the object could have unpredictable
-  // results. USE WITH CARE!
-  template <typename T>
-  T* New(Reference ref, uint32_t from_type_id, bool clear) {
-    DCHECK_LE(sizeof(T), GetAllocSize(ref)) << "alloc not big enough for obj";
-    // Make sure the memory is appropriate. This won't be used until after
-    // the type is changed but checking first avoids the possibility of having
-    // to change the type back.
-    void* mem = const_cast<void*>(GetBlockData(ref, 0, sizeof(T)));
-    if (!mem)
-      return nullptr;
-    // Ensure the allocator's internal alignment is sufficient for this object.
-    // This protects against coding errors in the allocator.
-    DCHECK_EQ(0U, reinterpret_cast<uintptr_t>(mem) & (alignof(T) - 1));
-    // Change the type, clearing the memory if so desired. The new type is
-    // "transitioning" so that there is no race condition with the construction
-    // of the object should another thread be simultaneously iterating over
-    // data. This will "acquire" the memory so no changes get reordered before
-    // it.
-    if (!ChangeType(ref, kTypeIdTransitioning, from_type_id, clear))
-      return nullptr;
-    // Construct an object of the desired type on this memory, just as if
-    // New() had been called to create it.
-    T* obj = new (mem) T();
-    // Finally change the type to the desired one. This will "release" all of
-    // the changes above and so provide a consistent view to other threads.
-    bool success =
-        ChangeType(ref, T::kPersistentTypeId, kTypeIdTransitioning, false);
-    DCHECK(success);
-    return obj;
-  }
-
-  // Deletes an object by destructing it and then changing the type to a
-  // different value (default 0).
-  template <typename T>
-  void Delete(T* obj, uint32_t new_type) {
-    // Get the reference for the object.
-    Reference ref = GetAsReference<T>(obj);
-    // First change the type to "transitioning" so there is no race condition
-    // where another thread could find the object through iteration while it
-    // is been destructed. This will "acquire" the memory so no changes get
-    // reordered before it. It will fail if |ref| is invalid.
-    if (!ChangeType(ref, kTypeIdTransitioning, T::kPersistentTypeId, false))
-      return;
-    // Destruct the object.
-    obj->~T();
-    // Finally change the type to the desired value. This will "release" all
-    // the changes above.
-    bool success = ChangeType(ref, new_type, kTypeIdTransitioning, false);
-    DCHECK(success);
-  }
-  template <typename T>
-  void Delete(T* obj) {
-    Delete<T>(obj, 0);
-  }
-
-  // As above but works with objects allocated from persistent memory.
-  template <typename T>
-  Reference GetAsReference(const T* obj) const {
-    return GetAsReference(obj, T::kPersistentTypeId);
-  }
-
-  // As above but works with an object allocated from persistent memory.
-  template <typename T>
-  void MakeIterable(const T* obj) {
-    MakeIterable(GetAsReference<T>(obj));
-  }
-
- protected:
-  enum MemoryType {
-    MEM_EXTERNAL,
-    MEM_MALLOC,
-    MEM_VIRTUAL,
-    MEM_SHARED,
-    MEM_FILE,
-  };
-
-  struct Memory {
-    Memory(void* b, MemoryType t) : base(b), type(t) {}
-
-    void* base;
-    MemoryType type;
-  };
-
-  // Constructs the allocator. Everything is the same as the public allocator
-  // except |memory| which is a structure with additional information besides
-  // the base address.
-  PersistentMemoryAllocator(Memory memory, size_t size, size_t page_size,
-                            uint64_t id, base::StringPiece name,
-                            bool readonly);
-
-  // Implementation of Flush that accepts how much to flush.
-  virtual void FlushPartial(size_t length, bool sync);
-
-  volatile char* const mem_base_;  // Memory base. (char so sizeof guaranteed 1)
-  const MemoryType mem_type_;      // Type of memory allocation.
-  const uint32_t mem_size_;        // Size of entire memory segment.
-  const uint32_t mem_page_;        // Page size allocations shouldn't cross.
-
- private:
-  struct SharedMetadata;
-  struct BlockHeader;
-  static const uint32_t kAllocAlignment;
-  static const Reference kReferenceQueue;
-
-  // The shared metadata is always located at the top of the memory segment.
-  // These convenience functions eliminate constant casting of the base
-  // pointer within the code.
-  const SharedMetadata* shared_meta() const {
-    return reinterpret_cast<const SharedMetadata*>(
-        const_cast<const char*>(mem_base_));
-  }
-  SharedMetadata* shared_meta() {
-    return reinterpret_cast<SharedMetadata*>(const_cast<char*>(mem_base_));
-  }
-
-  // Actual method for doing the allocation.
-  Reference AllocateImpl(size_t size, uint32_t type_id);
-
-  // Get the block header associated with a specific reference.
-  const volatile BlockHeader* GetBlock(Reference ref, uint32_t type_id,
-                                       uint32_t size, bool queue_ok,
-                                       bool free_ok) const;
-  volatile BlockHeader* GetBlock(Reference ref, uint32_t type_id, uint32_t size,
-                                 bool queue_ok, bool free_ok) {
-      return const_cast<volatile BlockHeader*>(
-          const_cast<const PersistentMemoryAllocator*>(this)->GetBlock(
-              ref, type_id, size, queue_ok, free_ok));
-  }
-
-  // Get the actual data within a block associated with a specific reference.
-  const volatile void* GetBlockData(Reference ref, uint32_t type_id,
-                                    uint32_t size) const;
-  volatile void* GetBlockData(Reference ref, uint32_t type_id,
-                              uint32_t size) {
-      return const_cast<volatile void*>(
-          const_cast<const PersistentMemoryAllocator*>(this)->GetBlockData(
-              ref, type_id, size));
-  }
-
-  // Record an error in the internal histogram.
-  void RecordError(int error) const;
-
-  const size_t vm_page_size_;          // The page size used by the OS.
-  const bool readonly_;                // Indicates access to read-only memory.
-  mutable std::atomic<bool> corrupt_;  // Local version of "corrupted" flag.
-
-  HistogramBase* allocs_histogram_;  // Histogram recording allocs.
-  HistogramBase* used_histogram_;    // Histogram recording used space.
-  HistogramBase* errors_histogram_;  // Histogram recording errors.
-
-  friend class PersistentMemoryAllocatorTest;
-  FRIEND_TEST_ALL_PREFIXES(PersistentMemoryAllocatorTest, AllocateAndIterate);
-  DISALLOW_COPY_AND_ASSIGN(PersistentMemoryAllocator);
-};
-
-
-// This allocator uses a local memory block it allocates from the general
-// heap. It is generally used when some kind of "death rattle" handler will
-// save the contents to persistent storage during process shutdown. It is
-// also useful for testing.
-class BASE_EXPORT LocalPersistentMemoryAllocator
-    : public PersistentMemoryAllocator {
- public:
-  LocalPersistentMemoryAllocator(size_t size, uint64_t id,
-                                 base::StringPiece name);
-  ~LocalPersistentMemoryAllocator() override;
-
- private:
-  // Allocates a block of local memory of the specified |size|, ensuring that
-  // the memory will not be physically allocated until accessed and will read
-  // as zero when that happens.
-  static Memory AllocateLocalMemory(size_t size);
-
-  // Deallocates a block of local |memory| of the specified |size|.
-  static void DeallocateLocalMemory(void* memory, size_t size, MemoryType type);
-
-  DISALLOW_COPY_AND_ASSIGN(LocalPersistentMemoryAllocator);
-};
-
-
-// This allocator takes a shared-memory object and performs allocation from
-// it. The memory must be previously mapped via Map() or MapAt(). The allocator
-// takes ownership of the memory object.
-class BASE_EXPORT SharedPersistentMemoryAllocator
-    : public PersistentMemoryAllocator {
- public:
-  SharedPersistentMemoryAllocator(std::unique_ptr<SharedMemory> memory,
-                                  uint64_t id,
-                                  base::StringPiece name,
-                                  bool read_only);
-  ~SharedPersistentMemoryAllocator() override;
-
-  SharedMemory* shared_memory() { return shared_memory_.get(); }
-
-  // Ensure that the memory isn't so invalid that it would crash when passing it
-  // to the allocator. This doesn't guarantee the data is valid, just that it
-  // won't cause the program to abort. The existing IsCorrupt() call will handle
-  // the rest.
-  static bool IsSharedMemoryAcceptable(const SharedMemory& memory);
-
- private:
-  std::unique_ptr<SharedMemory> shared_memory_;
-
-  DISALLOW_COPY_AND_ASSIGN(SharedPersistentMemoryAllocator);
-};
-
-
-#if !defined(OS_NACL)  // NACL doesn't support any kind of file access in build.
-// This allocator takes a memory-mapped file object and performs allocation
-// from it. The allocator takes ownership of the file object.
-class BASE_EXPORT FilePersistentMemoryAllocator
-    : public PersistentMemoryAllocator {
- public:
-  // A |max_size| of zero will use the length of the file as the maximum
-  // size. The |file| object must have been already created with sufficient
-  // permissions (read, read/write, or read/write/extend).
-  FilePersistentMemoryAllocator(std::unique_ptr<MemoryMappedFile> file,
-                                size_t max_size,
-                                uint64_t id,
-                                base::StringPiece name,
-                                bool read_only);
-  ~FilePersistentMemoryAllocator() override;
-
-  // Ensure that the file isn't so invalid that it would crash when passing it
-  // to the allocator. This doesn't guarantee the file is valid, just that it
-  // won't cause the program to abort. The existing IsCorrupt() call will handle
-  // the rest.
-  static bool IsFileAcceptable(const MemoryMappedFile& file, bool read_only);
-
- protected:
-  // PersistentMemoryAllocator:
-  void FlushPartial(size_t length, bool sync) override;
-
- private:
-  std::unique_ptr<MemoryMappedFile> mapped_file_;
-
-  DISALLOW_COPY_AND_ASSIGN(FilePersistentMemoryAllocator);
-};
-#endif  // !defined(OS_NACL)
-
-// An allocation that is defined but not executed until required at a later
-// time. This allows for potential users of an allocation to be decoupled
-// from the logic that defines it. In addition, there can be multiple users
-// of the same allocation or any region thereof that are guaranteed to always
-// use the same space. It's okay to copy/move these objects.
-//
-// This is a top-level class instead of an inner class of the PMA so that it
-// can be forward-declared in other header files without the need to include
-// the full contents of this file.
-class BASE_EXPORT DelayedPersistentAllocation {
- public:
-  using Reference = PersistentMemoryAllocator::Reference;
-
-  // Creates a delayed allocation using the specified |allocator|. When
-  // needed, the memory will be allocated using the specified |type| and
-  // |size|. If |offset| is given, the returned pointer will be at that
-  // offset into the segment; this allows combining allocations into a
-  // single persistent segment to reduce overhead and means an "all or
-  // nothing" request. Note that |size| is always the total memory size
-  // and |offset| is just indicating the start of a block within it.  If
-  // |make_iterable| was true, the allocation will made iterable when it
-  // is created; already existing allocations are not changed.
-  //
-  // Once allocated, a reference to the segment will be stored at |ref|.
-  // This shared location must be initialized to zero (0); it is checked
-  // with every Get() request to see if the allocation has already been
-  // done. If reading |ref| outside of this object, be sure to do an
-  // "acquire" load. Don't write to it -- leave that to this object.
-  //
-  // For convenience, methods taking both Atomic32 and std::atomic<Reference>
-  // are defined.
-  DelayedPersistentAllocation(PersistentMemoryAllocator* allocator,
-                              subtle::Atomic32* ref,
-                              uint32_t type,
-                              size_t size,
-                              bool make_iterable);
-  DelayedPersistentAllocation(PersistentMemoryAllocator* allocator,
-                              subtle::Atomic32* ref,
-                              uint32_t type,
-                              size_t size,
-                              size_t offset,
-                              bool make_iterable);
-  DelayedPersistentAllocation(PersistentMemoryAllocator* allocator,
-                              std::atomic<Reference>* ref,
-                              uint32_t type,
-                              size_t size,
-                              bool make_iterable);
-  DelayedPersistentAllocation(PersistentMemoryAllocator* allocator,
-                              std::atomic<Reference>* ref,
-                              uint32_t type,
-                              size_t size,
-                              size_t offset,
-                              bool make_iterable);
-  ~DelayedPersistentAllocation();
-
-  // Gets a pointer to the defined allocation. This will realize the request
-  // and update the reference provided during construction. The memory will
-  // be zeroed the first time it is returned, after that it is shared with
-  // all other Get() requests and so shows any changes made to it elsewhere.
-  //
-  // If the allocation fails for any reason, null will be returned. This works
-  // even on "const" objects because the allocation is already defined, just
-  // delayed.
-  void* Get() const;
-
-  // Gets the internal reference value. If this returns a non-zero value then
-  // a subsequent call to Get() will do nothing but convert that reference into
-  // a memory location -- useful for accessing an existing allocation without
-  // creating one unnecessarily.
-  Reference reference() const {
-    return reference_->load(std::memory_order_relaxed);
-  }
-
- private:
-  // The underlying object that does the actual allocation of memory. Its
-  // lifetime must exceed that of all DelayedPersistentAllocation objects
-  // that use it.
-  PersistentMemoryAllocator* const allocator_;
-
-  // The desired type and size of the allocated segment plus the offset
-  // within it for the defined request.
-  const uint32_t type_;
-  const uint32_t size_;
-  const uint32_t offset_;
-
-  // Flag indicating if allocation should be made iterable when done.
-  const bool make_iterable_;
-
-  // The location at which a reference to the allocated segment is to be
-  // stored once the allocation is complete. If multiple delayed allocations
-  // share the same pointer then an allocation on one will amount to an
-  // allocation for all.
-  volatile std::atomic<Reference>* const reference_;
-
-  // No DISALLOW_COPY_AND_ASSIGN as it's okay to copy/move these objects.
-};
-
-}  // namespace base
-
-#endif  // BASE_METRICS_PERSISTENT_MEMORY_ALLOCATOR_H_
diff --git a/base/metrics/persistent_sample_map.cc b/base/metrics/persistent_sample_map.cc
deleted file mode 100644
index f38b9d1..0000000
--- a/base/metrics/persistent_sample_map.cc
+++ /dev/null
@@ -1,305 +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/metrics/persistent_sample_map.h"
-
-#include "base/logging.h"
-#include "base/memory/ptr_util.h"
-#include "base/metrics/histogram_macros.h"
-#include "base/metrics/persistent_histogram_allocator.h"
-#include "base/numerics/safe_conversions.h"
-#include "base/stl_util.h"
-
-namespace base {
-
-typedef HistogramBase::Count Count;
-typedef HistogramBase::Sample Sample;
-
-namespace {
-
-// An iterator for going through a PersistentSampleMap. The logic here is
-// identical to that of SampleMapIterator but with different data structures.
-// Changes here likely need to be duplicated there.
-class PersistentSampleMapIterator : public SampleCountIterator {
- public:
-  typedef std::map<HistogramBase::Sample, HistogramBase::Count*>
-      SampleToCountMap;
-
-  explicit PersistentSampleMapIterator(const SampleToCountMap& sample_counts);
-  ~PersistentSampleMapIterator() override;
-
-  // SampleCountIterator:
-  bool Done() const override;
-  void Next() override;
-  void Get(HistogramBase::Sample* min,
-           int64_t* max,
-           HistogramBase::Count* count) const override;
-
- private:
-  void SkipEmptyBuckets();
-
-  SampleToCountMap::const_iterator iter_;
-  const SampleToCountMap::const_iterator end_;
-};
-
-PersistentSampleMapIterator::PersistentSampleMapIterator(
-    const SampleToCountMap& sample_counts)
-    : iter_(sample_counts.begin()),
-      end_(sample_counts.end()) {
-  SkipEmptyBuckets();
-}
-
-PersistentSampleMapIterator::~PersistentSampleMapIterator() = default;
-
-bool PersistentSampleMapIterator::Done() const {
-  return iter_ == end_;
-}
-
-void PersistentSampleMapIterator::Next() {
-  DCHECK(!Done());
-  ++iter_;
-  SkipEmptyBuckets();
-}
-
-void PersistentSampleMapIterator::Get(Sample* min,
-                                      int64_t* max,
-                                      Count* count) const {
-  DCHECK(!Done());
-  if (min)
-    *min = iter_->first;
-  if (max)
-    *max = strict_cast<int64_t>(iter_->first) + 1;
-  if (count)
-    *count = *iter_->second;
-}
-
-void PersistentSampleMapIterator::SkipEmptyBuckets() {
-  while (!Done() && *iter_->second == 0) {
-    ++iter_;
-  }
-}
-
-// This structure holds an entry for a PersistentSampleMap within a persistent
-// memory allocator. The "id" must be unique across all maps held by an
-// allocator or they will get attached to the wrong sample map.
-struct SampleRecord {
-  // SHA1(SampleRecord): Increment this if structure changes!
-  static constexpr uint32_t kPersistentTypeId = 0x8FE6A69F + 1;
-
-  // Expected size for 32/64-bit check.
-  static constexpr size_t kExpectedInstanceSize = 16;
-
-  uint64_t id;   // Unique identifier of owner.
-  Sample value;  // The value for which this record holds a count.
-  Count count;   // The count associated with the above value.
-};
-
-}  // namespace
-
-PersistentSampleMap::PersistentSampleMap(
-    uint64_t id,
-    PersistentHistogramAllocator* allocator,
-    Metadata* meta)
-    : HistogramSamples(id, meta), allocator_(allocator) {}
-
-PersistentSampleMap::~PersistentSampleMap() {
-  if (records_)
-    records_->Release(this);
-}
-
-void PersistentSampleMap::Accumulate(Sample value, Count count) {
-#if 0  // TODO(bcwhite) Re-enable efficient version after crbug.com/682680.
-  *GetOrCreateSampleCountStorage(value) += count;
-#else
-  Count* local_count_ptr = GetOrCreateSampleCountStorage(value);
-  if (count < 0) {
-    if (*local_count_ptr < -count)
-      RecordNegativeSample(SAMPLES_ACCUMULATE_WENT_NEGATIVE, -count);
-    else
-      RecordNegativeSample(SAMPLES_ACCUMULATE_NEGATIVE_COUNT, -count);
-    *local_count_ptr += count;
-  } else {
-    Sample old_value = *local_count_ptr;
-    Sample new_value = old_value + count;
-    *local_count_ptr = new_value;
-    if ((new_value >= 0) != (old_value >= 0))
-      RecordNegativeSample(SAMPLES_ACCUMULATE_OVERFLOW, count);
-  }
-#endif
-  IncreaseSumAndCount(strict_cast<int64_t>(count) * value, count);
-}
-
-Count PersistentSampleMap::GetCount(Sample value) const {
-  // Have to override "const" to make sure all samples have been loaded before
-  // being able to know what value to return.
-  Count* count_pointer =
-      const_cast<PersistentSampleMap*>(this)->GetSampleCountStorage(value);
-  return count_pointer ? *count_pointer : 0;
-}
-
-Count PersistentSampleMap::TotalCount() const {
-  // Have to override "const" in order to make sure all samples have been
-  // loaded before trying to iterate over the map.
-  const_cast<PersistentSampleMap*>(this)->ImportSamples(-1, true);
-
-  Count count = 0;
-  for (const auto& entry : sample_counts_) {
-    count += *entry.second;
-  }
-  return count;
-}
-
-std::unique_ptr<SampleCountIterator> PersistentSampleMap::Iterator() const {
-  // Have to override "const" in order to make sure all samples have been
-  // loaded before trying to iterate over the map.
-  const_cast<PersistentSampleMap*>(this)->ImportSamples(-1, true);
-  return WrapUnique(new PersistentSampleMapIterator(sample_counts_));
-}
-
-// static
-PersistentMemoryAllocator::Reference
-PersistentSampleMap::GetNextPersistentRecord(
-    PersistentMemoryAllocator::Iterator& iterator,
-    uint64_t* sample_map_id) {
-  const SampleRecord* record = iterator.GetNextOfObject<SampleRecord>();
-  if (!record)
-    return 0;
-
-  *sample_map_id = record->id;
-  return iterator.GetAsReference(record);
-}
-
-// static
-PersistentMemoryAllocator::Reference
-PersistentSampleMap::CreatePersistentRecord(
-    PersistentMemoryAllocator* allocator,
-    uint64_t sample_map_id,
-    Sample value) {
-  SampleRecord* record = allocator->New<SampleRecord>();
-  if (!record) {
-    NOTREACHED() << "full=" << allocator->IsFull()
-                 << ", corrupt=" << allocator->IsCorrupt();
-    return 0;
-  }
-
-  record->id = sample_map_id;
-  record->value = value;
-  record->count = 0;
-
-  PersistentMemoryAllocator::Reference ref = allocator->GetAsReference(record);
-  allocator->MakeIterable(ref);
-  return ref;
-}
-
-bool PersistentSampleMap::AddSubtractImpl(SampleCountIterator* iter,
-                                          Operator op) {
-  Sample min;
-  int64_t max;
-  Count count;
-  for (; !iter->Done(); iter->Next()) {
-    iter->Get(&min, &max, &count);
-    if (count == 0)
-      continue;
-    if (strict_cast<int64_t>(min) + 1 != max)
-      return false;  // SparseHistogram only supports bucket with size 1.
-    *GetOrCreateSampleCountStorage(min) +=
-        (op == HistogramSamples::ADD) ? count : -count;
-  }
-  return true;
-}
-
-Count* PersistentSampleMap::GetSampleCountStorage(Sample value) {
-  // If |value| is already in the map, just return that.
-  auto it = sample_counts_.find(value);
-  if (it != sample_counts_.end())
-    return it->second;
-
-  // Import any new samples from persistent memory looking for the value.
-  return ImportSamples(value, false);
-}
-
-Count* PersistentSampleMap::GetOrCreateSampleCountStorage(Sample value) {
-  // Get any existing count storage.
-  Count* count_pointer = GetSampleCountStorage(value);
-  if (count_pointer)
-    return count_pointer;
-
-  // Create a new record in persistent memory for the value. |records_| will
-  // have been initialized by the GetSampleCountStorage() call above.
-  DCHECK(records_);
-  PersistentMemoryAllocator::Reference ref = records_->CreateNew(value);
-  if (!ref) {
-    // If a new record could not be created then the underlying allocator is
-    // full or corrupt. Instead, allocate the counter from the heap. This
-    // sample will not be persistent, will not be shared, and will leak...
-    // but it's better than crashing.
-    count_pointer = new Count(0);
-    sample_counts_[value] = count_pointer;
-    return count_pointer;
-  }
-
-  // A race condition between two independent processes (i.e. two independent
-  // histogram objects sharing the same sample data) could cause two of the
-  // above records to be created. The allocator, however, forces a strict
-  // ordering on iterable objects so use the import method to actually add the
-  // just-created record. This ensures that all PersistentSampleMap objects
-  // will always use the same record, whichever was first made iterable.
-  // Thread-safety within a process where multiple threads use the same
-  // histogram object is delegated to the controlling histogram object which,
-  // for sparse histograms, is a lock object.
-  count_pointer = ImportSamples(value, false);
-  DCHECK(count_pointer);
-  return count_pointer;
-}
-
-PersistentSampleMapRecords* PersistentSampleMap::GetRecords() {
-  // The |records_| pointer is lazily fetched from the |allocator_| only on
-  // first use. Sometimes duplicate histograms are created by race conditions
-  // and if both were to grab the records object, there would be a conflict.
-  // Use of a histogram, and thus a call to this method, won't occur until
-  // after the histogram has been de-dup'd.
-  if (!records_)
-    records_ = allocator_->UseSampleMapRecords(id(), this);
-  return records_;
-}
-
-Count* PersistentSampleMap::ImportSamples(Sample until_value,
-                                          bool import_everything) {
-  Count* found_count = nullptr;
-  PersistentMemoryAllocator::Reference ref;
-  PersistentSampleMapRecords* records = GetRecords();
-  while ((ref = records->GetNext()) != 0) {
-    SampleRecord* record = records->GetAsObject<SampleRecord>(ref);
-    if (!record)
-      continue;
-
-    DCHECK_EQ(id(), record->id);
-
-    // Check if the record's value is already known.
-    if (!ContainsKey(sample_counts_, record->value)) {
-      // No: Add it to map of known values.
-      sample_counts_[record->value] = &record->count;
-    } else {
-      // Yes: Ignore it; it's a duplicate caused by a race condition -- see
-      // code & comment in GetOrCreateSampleCountStorage() for details.
-      // Check that nothing ever operated on the duplicate record.
-      DCHECK_EQ(0, record->count);
-    }
-
-    // Check if it's the value being searched for and, if so, keep a pointer
-    // to return later. Stop here unless everything is being imported.
-    // Because race conditions can cause multiple records for a single value,
-    // be sure to return the first one found.
-    if (record->value == until_value) {
-      if (!found_count)
-        found_count = &record->count;
-      if (!import_everything)
-        break;
-    }
-  }
-
-  return found_count;
-}
-
-}  // namespace base
diff --git a/base/metrics/persistent_sample_map.h b/base/metrics/persistent_sample_map.h
deleted file mode 100644
index 853f862..0000000
--- a/base/metrics/persistent_sample_map.h
+++ /dev/null
@@ -1,109 +0,0 @@
-// Copyright 2016 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-// PersistentSampleMap implements HistogramSamples interface. It is used
-// by the SparseHistogram class to store samples in persistent memory which
-// allows it to be shared between processes or live across restarts.
-
-#ifndef BASE_METRICS_PERSISTENT_SAMPLE_MAP_H_
-#define BASE_METRICS_PERSISTENT_SAMPLE_MAP_H_
-
-#include <stdint.h>
-
-#include <map>
-#include <memory>
-
-#include "base/compiler_specific.h"
-#include "base/macros.h"
-#include "base/metrics/histogram_base.h"
-#include "base/metrics/histogram_samples.h"
-#include "base/metrics/persistent_memory_allocator.h"
-
-namespace base {
-
-class PersistentHistogramAllocator;
-class PersistentSampleMapRecords;
-
-// The logic here is similar to that of SampleMap but with different data
-// structures. Changes here likely need to be duplicated there.
-class BASE_EXPORT PersistentSampleMap : public HistogramSamples {
- public:
-  // Constructs a persistent sample map using a PersistentHistogramAllocator
-  // as the data source for persistent records.
-  PersistentSampleMap(uint64_t id,
-                      PersistentHistogramAllocator* allocator,
-                      Metadata* meta);
-
-  ~PersistentSampleMap() override;
-
-  // HistogramSamples:
-  void Accumulate(HistogramBase::Sample value,
-                  HistogramBase::Count count) override;
-  HistogramBase::Count GetCount(HistogramBase::Sample value) const override;
-  HistogramBase::Count TotalCount() const override;
-  std::unique_ptr<SampleCountIterator> Iterator() const override;
-
-  // Uses a persistent-memory |iterator| to locate and return information about
-  // the next record holding information for a PersistentSampleMap. The record
-  // could be for any Map so return the |sample_map_id| as well.
-  static PersistentMemoryAllocator::Reference GetNextPersistentRecord(
-      PersistentMemoryAllocator::Iterator& iterator,
-      uint64_t* sample_map_id);
-
-  // Creates a new record in an |allocator| storing count information for a
-  // specific sample |value| of a histogram with the given |sample_map_id|.
-  static PersistentMemoryAllocator::Reference CreatePersistentRecord(
-      PersistentMemoryAllocator* allocator,
-      uint64_t sample_map_id,
-      HistogramBase::Sample value);
-
- protected:
-  // Performs arithemetic. |op| is ADD or SUBTRACT.
-  bool AddSubtractImpl(SampleCountIterator* iter, Operator op) override;
-
-  // Gets a pointer to a "count" corresponding to a given |value|. Returns NULL
-  // if sample does not exist.
-  HistogramBase::Count* GetSampleCountStorage(HistogramBase::Sample value);
-
-  // Gets a pointer to a "count" corresponding to a given |value|, creating
-  // the sample (initialized to zero) if it does not already exists.
-  HistogramBase::Count* GetOrCreateSampleCountStorage(
-      HistogramBase::Sample value);
-
- private:
-  // Gets the object that manages persistent records. This returns the
-  // |records_| member after first initializing it if necessary.
-  PersistentSampleMapRecords* GetRecords();
-
-  // Imports samples from persistent memory by iterating over all sample
-  // records found therein, adding them to the sample_counts_ map. If a
-  // count for the sample |until_value| is found, stop the import and return
-  // a pointer to that counter. If that value is not found, null will be
-  // returned after all currently available samples have been loaded. Pass
-  // true for |import_everything| to force the importing of all available
-  // samples even if a match is found.
-  HistogramBase::Count* ImportSamples(HistogramBase::Sample until_value,
-                                      bool import_everything);
-
-  // All created/loaded sample values and their associated counts. The storage
-  // for the actual Count numbers is owned by the |records_| object and its
-  // underlying allocator.
-  std::map<HistogramBase::Sample, HistogramBase::Count*> sample_counts_;
-
-  // The allocator that manages histograms inside persistent memory. This is
-  // owned externally and is expected to live beyond the life of this object.
-  PersistentHistogramAllocator* allocator_;
-
-  // The object that manages sample records inside persistent memory. This is
-  // owned by the |allocator_| object (above) and so, like it, is expected to
-  // live beyond the life of this object. This value is lazily-initialized on
-  // first use via the GetRecords() accessor method.
-  PersistentSampleMapRecords* records_ = nullptr;
-
-  DISALLOW_COPY_AND_ASSIGN(PersistentSampleMap);
-};
-
-}  // namespace base
-
-#endif  // BASE_METRICS_PERSISTENT_SAMPLE_MAP_H_
diff --git a/base/metrics/record_histogram_checker.h b/base/metrics/record_histogram_checker.h
deleted file mode 100644
index 75bc336..0000000
--- a/base/metrics/record_histogram_checker.h
+++ /dev/null
@@ -1,27 +0,0 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_METRICS_RECORD_HISTOGRAM_CHECKER_H_
-#define BASE_METRICS_RECORD_HISTOGRAM_CHECKER_H_
-
-#include <stdint.h>
-
-#include "base/base_export.h"
-
-namespace base {
-
-// RecordHistogramChecker provides an interface for checking whether
-// the given histogram should be recorded.
-class BASE_EXPORT RecordHistogramChecker {
- public:
-  virtual ~RecordHistogramChecker() = default;
-
-  // Returns true iff the given histogram should be recorded.
-  // This method may be called on any thread, so it should not mutate any state.
-  virtual bool ShouldRecord(uint64_t histogram_hash) const = 0;
-};
-
-}  // namespace base
-
-#endif  // BASE_METRICS_RECORD_HISTOGRAM_CHECKER_H_
diff --git a/base/metrics/sample_map.cc b/base/metrics/sample_map.cc
deleted file mode 100644
index c6dce29..0000000
--- a/base/metrics/sample_map.cc
+++ /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.
-
-#include "base/metrics/sample_map.h"
-
-#include "base/logging.h"
-#include "base/memory/ptr_util.h"
-#include "base/numerics/safe_conversions.h"
-#include "base/stl_util.h"
-
-namespace base {
-
-typedef HistogramBase::Count Count;
-typedef HistogramBase::Sample Sample;
-
-namespace {
-
-// An iterator for going through a SampleMap. The logic here is identical
-// to that of PersistentSampleMapIterator but with different data structures.
-// Changes here likely need to be duplicated there.
-class SampleMapIterator : public SampleCountIterator {
- public:
-  typedef std::map<HistogramBase::Sample, HistogramBase::Count>
-      SampleToCountMap;
-
-  explicit SampleMapIterator(const SampleToCountMap& sample_counts);
-  ~SampleMapIterator() override;
-
-  // SampleCountIterator:
-  bool Done() const override;
-  void Next() override;
-  void Get(HistogramBase::Sample* min,
-           int64_t* max,
-           HistogramBase::Count* count) const override;
-
- private:
-  void SkipEmptyBuckets();
-
-  SampleToCountMap::const_iterator iter_;
-  const SampleToCountMap::const_iterator end_;
-};
-
-SampleMapIterator::SampleMapIterator(const SampleToCountMap& sample_counts)
-    : iter_(sample_counts.begin()),
-      end_(sample_counts.end()) {
-  SkipEmptyBuckets();
-}
-
-SampleMapIterator::~SampleMapIterator() = default;
-
-bool SampleMapIterator::Done() const {
-  return iter_ == end_;
-}
-
-void SampleMapIterator::Next() {
-  DCHECK(!Done());
-  ++iter_;
-  SkipEmptyBuckets();
-}
-
-void SampleMapIterator::Get(Sample* min, int64_t* max, Count* count) const {
-  DCHECK(!Done());
-  if (min)
-    *min = iter_->first;
-  if (max)
-    *max = strict_cast<int64_t>(iter_->first) + 1;
-  if (count)
-    *count = iter_->second;
-}
-
-void SampleMapIterator::SkipEmptyBuckets() {
-  while (!Done() && iter_->second == 0) {
-    ++iter_;
-  }
-}
-
-}  // namespace
-
-SampleMap::SampleMap() : SampleMap(0) {}
-
-SampleMap::SampleMap(uint64_t id) : HistogramSamples(id, new LocalMetadata()) {}
-
-SampleMap::~SampleMap() {
-  delete static_cast<LocalMetadata*>(meta());
-}
-
-void SampleMap::Accumulate(Sample value, Count count) {
-  sample_counts_[value] += count;
-  IncreaseSumAndCount(strict_cast<int64_t>(count) * value, count);
-}
-
-Count SampleMap::GetCount(Sample value) const {
-  std::map<Sample, Count>::const_iterator it = sample_counts_.find(value);
-  if (it == sample_counts_.end())
-    return 0;
-  return it->second;
-}
-
-Count SampleMap::TotalCount() const {
-  Count count = 0;
-  for (const auto& entry : sample_counts_) {
-    count += entry.second;
-  }
-  return count;
-}
-
-std::unique_ptr<SampleCountIterator> SampleMap::Iterator() const {
-  return WrapUnique(new SampleMapIterator(sample_counts_));
-}
-
-bool SampleMap::AddSubtractImpl(SampleCountIterator* iter, Operator op) {
-  Sample min;
-  int64_t max;
-  Count count;
-  for (; !iter->Done(); iter->Next()) {
-    iter->Get(&min, &max, &count);
-    if (strict_cast<int64_t>(min) + 1 != max)
-      return false;  // SparseHistogram only supports bucket with size 1.
-
-    sample_counts_[min] += (op == HistogramSamples::ADD) ? count : -count;
-  }
-  return true;
-}
-
-}  // namespace base
diff --git a/base/metrics/sample_map.h b/base/metrics/sample_map.h
deleted file mode 100644
index 7458e05..0000000
--- a/base/metrics/sample_map.h
+++ /dev/null
@@ -1,50 +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.
-
-// SampleMap implements HistogramSamples interface. It is used by the
-// SparseHistogram class to store samples.
-
-#ifndef BASE_METRICS_SAMPLE_MAP_H_
-#define BASE_METRICS_SAMPLE_MAP_H_
-
-#include <stdint.h>
-
-#include <map>
-#include <memory>
-
-#include "base/compiler_specific.h"
-#include "base/macros.h"
-#include "base/metrics/histogram_base.h"
-#include "base/metrics/histogram_samples.h"
-
-namespace base {
-
-// The logic here is similar to that of PersistentSampleMap but with different
-// data structures. Changes here likely need to be duplicated there.
-class BASE_EXPORT SampleMap : public HistogramSamples {
- public:
-  SampleMap();
-  explicit SampleMap(uint64_t id);
-  ~SampleMap() override;
-
-  // HistogramSamples:
-  void Accumulate(HistogramBase::Sample value,
-                  HistogramBase::Count count) override;
-  HistogramBase::Count GetCount(HistogramBase::Sample value) const override;
-  HistogramBase::Count TotalCount() const override;
-  std::unique_ptr<SampleCountIterator> Iterator() const override;
-
- protected:
-  // Performs arithemetic. |op| is ADD or SUBTRACT.
-  bool AddSubtractImpl(SampleCountIterator* iter, Operator op) override;
-
- private:
-  std::map<HistogramBase::Sample, HistogramBase::Count> sample_counts_;
-
-  DISALLOW_COPY_AND_ASSIGN(SampleMap);
-};
-
-}  // namespace base
-
-#endif  // BASE_METRICS_SAMPLE_MAP_H_
diff --git a/base/metrics/sample_vector.cc b/base/metrics/sample_vector.cc
deleted file mode 100644
index cf8634e..0000000
--- a/base/metrics/sample_vector.cc
+++ /dev/null
@@ -1,429 +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/metrics/sample_vector.h"
-
-#include "base/lazy_instance.h"
-#include "base/logging.h"
-#include "base/memory/ptr_util.h"
-#include "base/metrics/persistent_memory_allocator.h"
-#include "base/numerics/safe_conversions.h"
-#include "base/synchronization/lock.h"
-#include "base/threading/platform_thread.h"
-
-// This SampleVector makes use of the single-sample embedded in the base
-// HistogramSamples class. If the count is non-zero then there is guaranteed
-// (within the bounds of "eventual consistency") to be no allocated external
-// storage. Once the full counts storage is allocated, the single-sample must
-// be extracted and disabled.
-
-namespace base {
-
-typedef HistogramBase::Count Count;
-typedef HistogramBase::Sample Sample;
-
-SampleVectorBase::SampleVectorBase(uint64_t id,
-                                   Metadata* meta,
-                                   const BucketRanges* bucket_ranges)
-    : HistogramSamples(id, meta), bucket_ranges_(bucket_ranges) {
-  CHECK_GE(bucket_ranges_->bucket_count(), 1u);
-}
-
-SampleVectorBase::~SampleVectorBase() = default;
-
-void SampleVectorBase::Accumulate(Sample value, Count count) {
-  const size_t bucket_index = GetBucketIndex(value);
-
-  // Handle the single-sample case.
-  if (!counts()) {
-    // Try to accumulate the parameters into the single-count entry.
-    if (AccumulateSingleSample(value, count, bucket_index)) {
-      // A race condition could lead to a new single-sample being accumulated
-      // above just after another thread executed the MountCountsStorage below.
-      // Since it is mounted, it could be mounted elsewhere and have values
-      // written to it. It's not allowed to have both a single-sample and
-      // entries in the counts array so move the single-sample.
-      if (counts())
-        MoveSingleSampleToCounts();
-      return;
-    }
-
-    // Need real storage to store both what was in the single-sample plus the
-    // parameter information.
-    MountCountsStorageAndMoveSingleSample();
-  }
-
-  // Handle the multi-sample case.
-  Count new_value =
-      subtle::NoBarrier_AtomicIncrement(&counts()[bucket_index], count);
-  IncreaseSumAndCount(strict_cast<int64_t>(count) * value, count);
-
-  // TODO(bcwhite) Remove after crbug.com/682680.
-  Count old_value = new_value - count;
-  if ((new_value >= 0) != (old_value >= 0) && count > 0)
-    RecordNegativeSample(SAMPLES_ACCUMULATE_OVERFLOW, count);
-}
-
-Count SampleVectorBase::GetCount(Sample value) const {
-  return GetCountAtIndex(GetBucketIndex(value));
-}
-
-Count SampleVectorBase::TotalCount() const {
-  // Handle the single-sample case.
-  SingleSample sample = single_sample().Load();
-  if (sample.count != 0)
-    return sample.count;
-
-  // Handle the multi-sample case.
-  if (counts() || MountExistingCountsStorage()) {
-    Count count = 0;
-    size_t size = counts_size();
-    const HistogramBase::AtomicCount* counts_array = counts();
-    for (size_t i = 0; i < size; ++i) {
-      count += subtle::NoBarrier_Load(&counts_array[i]);
-    }
-    return count;
-  }
-
-  // And the no-value case.
-  return 0;
-}
-
-Count SampleVectorBase::GetCountAtIndex(size_t bucket_index) const {
-  DCHECK(bucket_index < counts_size());
-
-  // Handle the single-sample case.
-  SingleSample sample = single_sample().Load();
-  if (sample.count != 0)
-    return sample.bucket == bucket_index ? sample.count : 0;
-
-  // Handle the multi-sample case.
-  if (counts() || MountExistingCountsStorage())
-    return subtle::NoBarrier_Load(&counts()[bucket_index]);
-
-  // And the no-value case.
-  return 0;
-}
-
-std::unique_ptr<SampleCountIterator> SampleVectorBase::Iterator() const {
-  // Handle the single-sample case.
-  SingleSample sample = single_sample().Load();
-  if (sample.count != 0) {
-    return std::make_unique<SingleSampleIterator>(
-        bucket_ranges_->range(sample.bucket),
-        bucket_ranges_->range(sample.bucket + 1), sample.count, sample.bucket);
-  }
-
-  // Handle the multi-sample case.
-  if (counts() || MountExistingCountsStorage()) {
-    return std::make_unique<SampleVectorIterator>(counts(), counts_size(),
-                                                  bucket_ranges_);
-  }
-
-  // And the no-value case.
-  return std::make_unique<SampleVectorIterator>(nullptr, 0, bucket_ranges_);
-}
-
-bool SampleVectorBase::AddSubtractImpl(SampleCountIterator* iter,
-                                       HistogramSamples::Operator op) {
-  // Stop now if there's nothing to do.
-  if (iter->Done())
-    return true;
-
-  // Get the first value and its index.
-  HistogramBase::Sample min;
-  int64_t max;
-  HistogramBase::Count count;
-  iter->Get(&min, &max, &count);
-  size_t dest_index = GetBucketIndex(min);
-
-  // The destination must be a superset of the source meaning that though the
-  // incoming ranges will find an exact match, the incoming bucket-index, if
-  // it exists, may be offset from the destination bucket-index. Calculate
-  // that offset of the passed iterator; there are are no overflow checks
-  // because 2's compliment math will work it out in the end.
-  //
-  // Because GetBucketIndex() always returns the same true or false result for
-  // a given iterator object, |index_offset| is either set here and used below,
-  // or never set and never used. The compiler doesn't know this, though, which
-  // is why it's necessary to initialize it to something.
-  size_t index_offset = 0;
-  size_t iter_index;
-  if (iter->GetBucketIndex(&iter_index))
-    index_offset = dest_index - iter_index;
-  if (dest_index >= counts_size())
-    return false;
-
-  // Post-increment. Information about the current sample is not available
-  // after this point.
-  iter->Next();
-
-  // Single-value storage is possible if there is no counts storage and the
-  // retrieved entry is the only one in the iterator.
-  if (!counts()) {
-    if (iter->Done()) {
-      // Don't call AccumulateSingleSample because that updates sum and count
-      // which was already done by the caller of this method.
-      if (single_sample().Accumulate(
-              dest_index, op == HistogramSamples::ADD ? count : -count)) {
-        // Handle race-condition that mounted counts storage between above and
-        // here.
-        if (counts())
-          MoveSingleSampleToCounts();
-        return true;
-      }
-    }
-
-    // The counts storage will be needed to hold the multiple incoming values.
-    MountCountsStorageAndMoveSingleSample();
-  }
-
-  // Go through the iterator and add the counts into correct bucket.
-  while (true) {
-    // Ensure that the sample's min/max match the ranges min/max.
-    if (min != bucket_ranges_->range(dest_index) ||
-        max != bucket_ranges_->range(dest_index + 1)) {
-      NOTREACHED() << "sample=" << min << "," << max
-                   << "; range=" << bucket_ranges_->range(dest_index) << ","
-                   << bucket_ranges_->range(dest_index + 1);
-      return false;
-    }
-
-    // Sample's bucket matches exactly. Adjust count.
-    subtle::NoBarrier_AtomicIncrement(
-        &counts()[dest_index], op == HistogramSamples::ADD ? count : -count);
-
-    // Advance to the next iterable sample. See comments above for how
-    // everything works.
-    if (iter->Done())
-      return true;
-    iter->Get(&min, &max, &count);
-    if (iter->GetBucketIndex(&iter_index)) {
-      // Destination bucket is a known offset from the source bucket.
-      dest_index = iter_index + index_offset;
-    } else {
-      // Destination bucket has to be determined anew each time.
-      dest_index = GetBucketIndex(min);
-    }
-    if (dest_index >= counts_size())
-      return false;
-    iter->Next();
-  }
-}
-
-// Use simple binary search.  This is very general, but there are better
-// approaches if we knew that the buckets were linearly distributed.
-size_t SampleVectorBase::GetBucketIndex(Sample value) const {
-  size_t bucket_count = bucket_ranges_->bucket_count();
-  CHECK_GE(bucket_count, 1u);
-  CHECK_GE(value, bucket_ranges_->range(0));
-  CHECK_LT(value, bucket_ranges_->range(bucket_count));
-
-  size_t under = 0;
-  size_t over = bucket_count;
-  size_t mid;
-  do {
-    DCHECK_GE(over, under);
-    mid = under + (over - under)/2;
-    if (mid == under)
-      break;
-    if (bucket_ranges_->range(mid) <= value)
-      under = mid;
-    else
-      over = mid;
-  } while (true);
-
-  DCHECK_LE(bucket_ranges_->range(mid), value);
-  CHECK_GT(bucket_ranges_->range(mid + 1), value);
-  return mid;
-}
-
-void SampleVectorBase::MoveSingleSampleToCounts() {
-  DCHECK(counts());
-
-  // Disable the single-sample since there is now counts storage for the data.
-  SingleSample sample = single_sample().Extract(/*disable=*/true);
-
-  // Stop here if there is no "count" as trying to find the bucket index of
-  // an invalid (including zero) "value" will crash.
-  if (sample.count == 0)
-    return;
-
-  // Move the value into storage. Sum and redundant-count already account
-  // for this entry so no need to call IncreaseSumAndCount().
-  subtle::NoBarrier_AtomicIncrement(&counts()[sample.bucket], sample.count);
-}
-
-void SampleVectorBase::MountCountsStorageAndMoveSingleSample() {
-  // There are many SampleVector objects and the lock is needed very
-  // infrequently (just when advancing from single-sample to multi-sample) so
-  // define a single, global lock that all can use. This lock only prevents
-  // concurrent entry into the code below; access and updates to |counts_|
-  // still requires atomic operations.
-  static LazyInstance<Lock>::Leaky counts_lock = LAZY_INSTANCE_INITIALIZER;
-  if (subtle::NoBarrier_Load(&counts_) == 0) {
-    AutoLock lock(counts_lock.Get());
-    if (subtle::NoBarrier_Load(&counts_) == 0) {
-      // Create the actual counts storage while the above lock is acquired.
-      HistogramBase::Count* counts = CreateCountsStorageWhileLocked();
-      DCHECK(counts);
-
-      // Point |counts_| to the newly created storage. This is done while
-      // locked to prevent possible concurrent calls to CreateCountsStorage
-      // but, between that call and here, other threads could notice the
-      // existence of the storage and race with this to set_counts(). That's
-      // okay because (a) it's atomic and (b) it always writes the same value.
-      set_counts(counts);
-    }
-  }
-
-  // Move any single-sample into the newly mounted storage.
-  MoveSingleSampleToCounts();
-}
-
-SampleVector::SampleVector(const BucketRanges* bucket_ranges)
-    : SampleVector(0, bucket_ranges) {}
-
-SampleVector::SampleVector(uint64_t id, const BucketRanges* bucket_ranges)
-    : SampleVectorBase(id, new LocalMetadata(), bucket_ranges) {}
-
-SampleVector::~SampleVector() {
-  delete static_cast<LocalMetadata*>(meta());
-}
-
-bool SampleVector::MountExistingCountsStorage() const {
-  // There is never any existing storage other than what is already in use.
-  return counts() != nullptr;
-}
-
-HistogramBase::AtomicCount* SampleVector::CreateCountsStorageWhileLocked() {
-  local_counts_.resize(counts_size());
-  return &local_counts_[0];
-}
-
-PersistentSampleVector::PersistentSampleVector(
-    uint64_t id,
-    const BucketRanges* bucket_ranges,
-    Metadata* meta,
-    const DelayedPersistentAllocation& counts)
-    : SampleVectorBase(id, meta, bucket_ranges), persistent_counts_(counts) {
-  // Only mount the full storage if the single-sample has been disabled.
-  // Otherwise, it is possible for this object instance to start using (empty)
-  // storage that was created incidentally while another instance continues to
-  // update to the single sample. This "incidental creation" can happen because
-  // the memory is a DelayedPersistentAllocation which allows multiple memory
-  // blocks within it and applies an all-or-nothing approach to the allocation.
-  // Thus, a request elsewhere for one of the _other_ blocks would make _this_
-  // block available even though nothing has explicitly requested it.
-  //
-  // Note that it's not possible for the ctor to mount existing storage and
-  // move any single-sample to it because sometimes the persistent memory is
-  // read-only. Only non-const methods (which assume that memory is read/write)
-  // can do that.
-  if (single_sample().IsDisabled()) {
-    bool success = MountExistingCountsStorage();
-    DCHECK(success);
-  }
-}
-
-PersistentSampleVector::~PersistentSampleVector() = default;
-
-bool PersistentSampleVector::MountExistingCountsStorage() const {
-  // There is no early exit if counts is not yet mounted because, given that
-  // this is a virtual function, it's more efficient to do that at the call-
-  // site. There is no danger, however, should this get called anyway (perhaps
-  // because of a race condition) because at worst the |counts_| value would
-  // be over-written (in an atomic manner) with the exact same address.
-
-  if (!persistent_counts_.reference())
-    return false;  // Nothing to mount.
-
-  // Mount the counts array in position.
-  set_counts(
-      static_cast<HistogramBase::AtomicCount*>(persistent_counts_.Get()));
-
-  // The above shouldn't fail but can if the data is corrupt or incomplete.
-  return counts() != nullptr;
-}
-
-HistogramBase::AtomicCount*
-PersistentSampleVector::CreateCountsStorageWhileLocked() {
-  void* mem = persistent_counts_.Get();
-  if (!mem) {
-    // The above shouldn't fail but can if Bad Things(tm) are occurring in the
-    // persistent allocator. Crashing isn't a good option so instead just
-    // allocate something from the heap and return that. There will be no
-    // sharing or persistence but worse things are already happening.
-    return new HistogramBase::AtomicCount[counts_size()];
-  }
-
-  return static_cast<HistogramBase::AtomicCount*>(mem);
-}
-
-SampleVectorIterator::SampleVectorIterator(
-    const std::vector<HistogramBase::AtomicCount>* counts,
-    const BucketRanges* bucket_ranges)
-    : counts_(&(*counts)[0]),
-      counts_size_(counts->size()),
-      bucket_ranges_(bucket_ranges),
-      index_(0) {
-  DCHECK_GE(bucket_ranges_->bucket_count(), counts_size_);
-  SkipEmptyBuckets();
-}
-
-SampleVectorIterator::SampleVectorIterator(
-    const HistogramBase::AtomicCount* counts,
-    size_t counts_size,
-    const BucketRanges* bucket_ranges)
-    : counts_(counts),
-      counts_size_(counts_size),
-      bucket_ranges_(bucket_ranges),
-      index_(0) {
-  DCHECK_GE(bucket_ranges_->bucket_count(), counts_size_);
-  SkipEmptyBuckets();
-}
-
-SampleVectorIterator::~SampleVectorIterator() = default;
-
-bool SampleVectorIterator::Done() const {
-  return index_ >= counts_size_;
-}
-
-void SampleVectorIterator::Next() {
-  DCHECK(!Done());
-  index_++;
-  SkipEmptyBuckets();
-}
-
-void SampleVectorIterator::Get(HistogramBase::Sample* min,
-                               int64_t* max,
-                               HistogramBase::Count* count) const {
-  DCHECK(!Done());
-  if (min != nullptr)
-    *min = bucket_ranges_->range(index_);
-  if (max != nullptr)
-    *max = strict_cast<int64_t>(bucket_ranges_->range(index_ + 1));
-  if (count != nullptr)
-    *count = subtle::NoBarrier_Load(&counts_[index_]);
-}
-
-bool SampleVectorIterator::GetBucketIndex(size_t* index) const {
-  DCHECK(!Done());
-  if (index != nullptr)
-    *index = index_;
-  return true;
-}
-
-void SampleVectorIterator::SkipEmptyBuckets() {
-  if (Done())
-    return;
-
-  while (index_ < counts_size_) {
-    if (subtle::NoBarrier_Load(&counts_[index_]) != 0)
-      return;
-    index_++;
-  }
-}
-
-}  // namespace base
diff --git a/base/metrics/sample_vector.h b/base/metrics/sample_vector.h
deleted file mode 100644
index 278272d..0000000
--- a/base/metrics/sample_vector.h
+++ /dev/null
@@ -1,185 +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.
-
-// SampleVector implements HistogramSamples interface. It is used by all
-// Histogram based classes to store samples.
-
-#ifndef BASE_METRICS_SAMPLE_VECTOR_H_
-#define BASE_METRICS_SAMPLE_VECTOR_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-#include <memory>
-#include <vector>
-
-#include "base/atomicops.h"
-#include "base/compiler_specific.h"
-#include "base/gtest_prod_util.h"
-#include "base/macros.h"
-#include "base/metrics/bucket_ranges.h"
-#include "base/metrics/histogram_base.h"
-#include "base/metrics/histogram_samples.h"
-#include "base/metrics/persistent_memory_allocator.h"
-
-namespace base {
-
-class BucketRanges;
-
-class BASE_EXPORT SampleVectorBase : public HistogramSamples {
- public:
-  SampleVectorBase(uint64_t id,
-                   Metadata* meta,
-                   const BucketRanges* bucket_ranges);
-  ~SampleVectorBase() override;
-
-  // HistogramSamples:
-  void Accumulate(HistogramBase::Sample value,
-                  HistogramBase::Count count) override;
-  HistogramBase::Count GetCount(HistogramBase::Sample value) const override;
-  HistogramBase::Count TotalCount() const override;
-  std::unique_ptr<SampleCountIterator> Iterator() const override;
-
-  // Get count of a specific bucket.
-  HistogramBase::Count GetCountAtIndex(size_t bucket_index) const;
-
-  // Access the bucket ranges held externally.
-  const BucketRanges* bucket_ranges() const { return bucket_ranges_; }
-
- protected:
-  bool AddSubtractImpl(
-      SampleCountIterator* iter,
-      HistogramSamples::Operator op) override;  // |op| is ADD or SUBTRACT.
-
-  virtual size_t GetBucketIndex(HistogramBase::Sample value) const;
-
-  // Moves the single-sample value to a mounted "counts" array.
-  void MoveSingleSampleToCounts();
-
-  // Mounts (creating if necessary) an array of "counts" for multi-value
-  // storage.
-  void MountCountsStorageAndMoveSingleSample();
-
-  // Mounts "counts" storage that already exists. This does not attempt to move
-  // any single-sample information to that storage as that would violate the
-  // "const" restriction that is often used to indicate read-only memory.
-  virtual bool MountExistingCountsStorage() const = 0;
-
-  // Creates "counts" storage and returns a pointer to it. Ownership of the
-  // array remains with the called method but will never change. This must be
-  // called while some sort of lock is held to prevent reentry.
-  virtual HistogramBase::Count* CreateCountsStorageWhileLocked() = 0;
-
-  HistogramBase::AtomicCount* counts() {
-    return reinterpret_cast<HistogramBase::AtomicCount*>(
-        subtle::Acquire_Load(&counts_));
-  }
-
-  const HistogramBase::AtomicCount* counts() const {
-    return reinterpret_cast<HistogramBase::AtomicCount*>(
-        subtle::Acquire_Load(&counts_));
-  }
-
-  void set_counts(const HistogramBase::AtomicCount* counts) const {
-    subtle::Release_Store(&counts_, reinterpret_cast<uintptr_t>(counts));
-  }
-
-  size_t counts_size() const { return bucket_ranges_->bucket_count(); }
-
- private:
-  friend class SampleVectorTest;
-  FRIEND_TEST_ALL_PREFIXES(HistogramTest, CorruptSampleCounts);
-  FRIEND_TEST_ALL_PREFIXES(SharedHistogramTest, CorruptSampleCounts);
-
-  // |counts_| is actually a pointer to a HistogramBase::AtomicCount array but
-  // is held as an AtomicWord for concurrency reasons. When combined with the
-  // single_sample held in the metadata, there are four possible states:
-  //   1) single_sample == zero, counts_ == null
-  //   2) single_sample != zero, counts_ == null
-  //   3) single_sample != zero, counts_ != null BUT IS EMPTY
-  //   4) single_sample == zero, counts_ != null and may have data
-  // Once |counts_| is set, it can never revert and any existing single-sample
-  // must be moved to this storage. It is mutable because changing it doesn't
-  // change the (const) data but must adapt if a non-const object causes the
-  // storage to be allocated and updated.
-  mutable subtle::AtomicWord counts_ = 0;
-
-  // Shares the same BucketRanges with Histogram object.
-  const BucketRanges* const bucket_ranges_;
-
-  DISALLOW_COPY_AND_ASSIGN(SampleVectorBase);
-};
-
-// A sample vector that uses local memory for the counts array.
-class BASE_EXPORT SampleVector : public SampleVectorBase {
- public:
-  explicit SampleVector(const BucketRanges* bucket_ranges);
-  SampleVector(uint64_t id, const BucketRanges* bucket_ranges);
-  ~SampleVector() override;
-
- private:
-  // SampleVectorBase:
-  bool MountExistingCountsStorage() const override;
-  HistogramBase::Count* CreateCountsStorageWhileLocked() override;
-
-  // Simple local storage for counts.
-  mutable std::vector<HistogramBase::AtomicCount> local_counts_;
-
-  DISALLOW_COPY_AND_ASSIGN(SampleVector);
-};
-
-// A sample vector that uses persistent memory for the counts array.
-class BASE_EXPORT PersistentSampleVector : public SampleVectorBase {
- public:
-  PersistentSampleVector(uint64_t id,
-                         const BucketRanges* bucket_ranges,
-                         Metadata* meta,
-                         const DelayedPersistentAllocation& counts);
-  ~PersistentSampleVector() override;
-
- private:
-  // SampleVectorBase:
-  bool MountExistingCountsStorage() const override;
-  HistogramBase::Count* CreateCountsStorageWhileLocked() override;
-
-  // Persistent storage for counts.
-  DelayedPersistentAllocation persistent_counts_;
-
-  DISALLOW_COPY_AND_ASSIGN(PersistentSampleVector);
-};
-
-// An iterator for sample vectors. This could be defined privately in the .cc
-// file but is here for easy testing.
-class BASE_EXPORT SampleVectorIterator : public SampleCountIterator {
- public:
-  SampleVectorIterator(const std::vector<HistogramBase::AtomicCount>* counts,
-                       const BucketRanges* bucket_ranges);
-  SampleVectorIterator(const HistogramBase::AtomicCount* counts,
-                       size_t counts_size,
-                       const BucketRanges* bucket_ranges);
-  ~SampleVectorIterator() override;
-
-  // SampleCountIterator implementation:
-  bool Done() const override;
-  void Next() override;
-  void Get(HistogramBase::Sample* min,
-           int64_t* max,
-           HistogramBase::Count* count) const override;
-
-  // SampleVector uses predefined buckets, so iterator can return bucket index.
-  bool GetBucketIndex(size_t* index) const override;
-
- private:
-  void SkipEmptyBuckets();
-
-  const HistogramBase::AtomicCount* counts_;
-  size_t counts_size_;
-  const BucketRanges* bucket_ranges_;
-
-  size_t index_;
-};
-
-}  // namespace base
-
-#endif  // BASE_METRICS_SAMPLE_VECTOR_H_
diff --git a/base/metrics/single_sample_metrics.cc b/base/metrics/single_sample_metrics.cc
deleted file mode 100644
index 57c1c8f..0000000
--- a/base/metrics/single_sample_metrics.cc
+++ /dev/null
@@ -1,77 +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/metrics/single_sample_metrics.h"
-
-#include "base/memory/ptr_util.h"
-#include "base/metrics/histogram.h"
-
-namespace base {
-
-static SingleSampleMetricsFactory* g_factory = nullptr;
-
-// static
-SingleSampleMetricsFactory* SingleSampleMetricsFactory::Get() {
-  if (!g_factory)
-    g_factory = new DefaultSingleSampleMetricsFactory();
-
-  return g_factory;
-}
-
-// static
-void SingleSampleMetricsFactory::SetFactory(
-    std::unique_ptr<SingleSampleMetricsFactory> factory) {
-  DCHECK(!g_factory);
-  g_factory = factory.release();
-}
-
-// static
-void SingleSampleMetricsFactory::DeleteFactoryForTesting() {
-  DCHECK(g_factory);
-  delete g_factory;
-  g_factory = nullptr;
-}
-
-std::unique_ptr<SingleSampleMetric>
-DefaultSingleSampleMetricsFactory::CreateCustomCountsMetric(
-    const std::string& histogram_name,
-    HistogramBase::Sample min,
-    HistogramBase::Sample max,
-    uint32_t bucket_count) {
-  return std::make_unique<DefaultSingleSampleMetric>(
-      histogram_name, min, max, bucket_count,
-      HistogramBase::kUmaTargetedHistogramFlag);
-}
-
-DefaultSingleSampleMetric::DefaultSingleSampleMetric(
-    const std::string& histogram_name,
-    HistogramBase::Sample min,
-    HistogramBase::Sample max,
-    uint32_t bucket_count,
-    int32_t flags)
-    : histogram_(Histogram::FactoryGet(histogram_name,
-                                       min,
-                                       max,
-                                       bucket_count,
-                                       flags)) {
-  // Bad construction parameters may lead to |histogram_| being null; DCHECK to
-  // find accidental errors in production. We must still handle the nullptr in
-  // destruction though since this construction may come from another untrusted
-  // process.
-  DCHECK(histogram_);
-}
-
-DefaultSingleSampleMetric::~DefaultSingleSampleMetric() {
-  // |histogram_| may be nullptr if bad construction parameters are given.
-  if (sample_ < 0 || !histogram_)
-    return;
-  histogram_->Add(sample_);
-}
-
-void DefaultSingleSampleMetric::SetSample(HistogramBase::Sample sample) {
-  DCHECK_GE(sample, 0);
-  sample_ = sample;
-}
-
-}  // namespace base
diff --git a/base/metrics/single_sample_metrics.h b/base/metrics/single_sample_metrics.h
deleted file mode 100644
index b966cb1..0000000
--- a/base/metrics/single_sample_metrics.h
+++ /dev/null
@@ -1,104 +0,0 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_METRICS_SINGLE_SAMPLE_METRICS_H_
-#define BASE_METRICS_SINGLE_SAMPLE_METRICS_H_
-
-#include <string>
-
-#include "base/base_export.h"
-#include "base/macros.h"
-#include "base/metrics/histogram_base.h"
-
-namespace base {
-
-// See base/metrics/histograms.h for parameter definitions. Must only be used
-// and destroyed from the same thread as construction.
-class BASE_EXPORT SingleSampleMetric {
- public:
-  virtual ~SingleSampleMetric() = default;
-
-  virtual void SetSample(HistogramBase::Sample sample) = 0;
-};
-
-// Factory for creating single sample metrics. A single sample metric only
-// reports its sample once at destruction time. The sample may be changed prior
-// to destruction using the SetSample() method as many times as desired.
-//
-// The metric creation methods are safe to call from any thread, however the
-// returned class must only be used and destroyed from the same thread as
-// construction.
-//
-// See base/metrics/histogram_macros.h for usage recommendations and
-// base/metrics/histogram.h for full parameter definitions.
-class BASE_EXPORT SingleSampleMetricsFactory {
- public:
-  virtual ~SingleSampleMetricsFactory() = default;
-
-  // Returns the factory provided by SetFactory(), or if no factory has been set
-  // a default factory will be provided (future calls to SetFactory() will fail
-  // if the default factory is ever vended).
-  static SingleSampleMetricsFactory* Get();
-  static void SetFactory(std::unique_ptr<SingleSampleMetricsFactory> factory);
-
-  // The factory normally persists until process shutdown, but in testing we
-  // should avoid leaking it since it sets a global.
-  static void DeleteFactoryForTesting();
-
-  // The methods below return a single sample metric for counts histograms; see
-  // method comments for the corresponding histogram macro.
-
-  // UMA_HISTOGRAM_CUSTOM_COUNTS()
-  virtual std::unique_ptr<SingleSampleMetric> CreateCustomCountsMetric(
-      const std::string& histogram_name,
-      HistogramBase::Sample min,
-      HistogramBase::Sample max,
-      uint32_t bucket_count) = 0;
-};
-
-// Default implementation for when no factory has been provided to the process.
-// Samples are only recorded within the current process in this case, so samples
-// will be lost in the event of sudden process termination.
-class BASE_EXPORT DefaultSingleSampleMetricsFactory
-    : public SingleSampleMetricsFactory {
- public:
-  DefaultSingleSampleMetricsFactory() = default;
-  ~DefaultSingleSampleMetricsFactory() override = default;
-
-  // SingleSampleMetricsFactory:
-  std::unique_ptr<SingleSampleMetric> CreateCustomCountsMetric(
-      const std::string& histogram_name,
-      HistogramBase::Sample min,
-      HistogramBase::Sample max,
-      uint32_t bucket_count) override;
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(DefaultSingleSampleMetricsFactory);
-};
-
-class BASE_EXPORT DefaultSingleSampleMetric : public SingleSampleMetric {
- public:
-  DefaultSingleSampleMetric(const std::string& histogram_name,
-                            HistogramBase::Sample min,
-                            HistogramBase::Sample max,
-                            uint32_t bucket_count,
-                            int32_t flags);
-  ~DefaultSingleSampleMetric() override;
-
-  // SingleSampleMetric:
-  void SetSample(HistogramBase::Sample sample) override;
-
- private:
-  HistogramBase* const histogram_;
-
-  // The last sample provided to SetSample(). We use -1 as a sentinel value to
-  // indicate no sample has been set.
-  HistogramBase::Sample sample_ = -1;
-
-  DISALLOW_COPY_AND_ASSIGN(DefaultSingleSampleMetric);
-};
-
-}  // namespace base
-
-#endif  // BASE_METRICS_SINGLE_SAMPLE_METRICS_H_
diff --git a/base/metrics/sparse_histogram.cc b/base/metrics/sparse_histogram.cc
deleted file mode 100644
index 30175a0..0000000
--- a/base/metrics/sparse_histogram.cc
+++ /dev/null
@@ -1,290 +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/metrics/sparse_histogram.h"
-
-#include <utility>
-
-#include "base/memory/ptr_util.h"
-#include "base/metrics/dummy_histogram.h"
-#include "base/metrics/metrics_hashes.h"
-#include "base/metrics/persistent_histogram_allocator.h"
-#include "base/metrics/persistent_sample_map.h"
-#include "base/metrics/sample_map.h"
-#include "base/metrics/statistics_recorder.h"
-#include "base/pickle.h"
-#include "base/strings/stringprintf.h"
-#include "base/synchronization/lock.h"
-
-namespace base {
-
-typedef HistogramBase::Count Count;
-typedef HistogramBase::Sample Sample;
-
-// static
-HistogramBase* SparseHistogram::FactoryGet(const std::string& name,
-                                           int32_t flags) {
-  HistogramBase* histogram = StatisticsRecorder::FindHistogram(name);
-  if (!histogram) {
-    // TODO(gayane): |HashMetricName| is called again in Histogram constructor.
-    // Refactor code to avoid the additional call.
-    bool should_record =
-        StatisticsRecorder::ShouldRecordHistogram(HashMetricName(name));
-    if (!should_record)
-      return DummyHistogram::GetInstance();
-    // Try to create the histogram using a "persistent" allocator. As of
-    // 2016-02-25, the availability of such is controlled by a base::Feature
-    // that is off by default. If the allocator doesn't exist or if
-    // allocating from it fails, code below will allocate the histogram from
-    // the process heap.
-    PersistentMemoryAllocator::Reference histogram_ref = 0;
-    std::unique_ptr<HistogramBase> tentative_histogram;
-    PersistentHistogramAllocator* allocator = GlobalHistogramAllocator::Get();
-    if (allocator) {
-      tentative_histogram = allocator->AllocateHistogram(
-          SPARSE_HISTOGRAM, name, 0, 0, nullptr, flags, &histogram_ref);
-    }
-
-    // Handle the case where no persistent allocator is present or the
-    // persistent allocation fails (perhaps because it is full).
-    if (!tentative_histogram) {
-      DCHECK(!histogram_ref);  // Should never have been set.
-      DCHECK(!allocator);      // Shouldn't have failed.
-      flags &= ~HistogramBase::kIsPersistent;
-      tentative_histogram.reset(new SparseHistogram(GetPermanentName(name)));
-      tentative_histogram->SetFlags(flags);
-    }
-
-    // Register this histogram with the StatisticsRecorder. Keep a copy of
-    // the pointer value to tell later whether the locally created histogram
-    // was registered or deleted. The type is "void" because it could point
-    // to released memory after the following line.
-    const void* tentative_histogram_ptr = tentative_histogram.get();
-    histogram = StatisticsRecorder::RegisterOrDeleteDuplicate(
-        tentative_histogram.release());
-
-    // Persistent histograms need some follow-up processing.
-    if (histogram_ref) {
-      allocator->FinalizeHistogram(histogram_ref,
-                                   histogram == tentative_histogram_ptr);
-    }
-  }
-
-  CHECK_EQ(SPARSE_HISTOGRAM, histogram->GetHistogramType());
-  return histogram;
-}
-
-// static
-std::unique_ptr<HistogramBase> SparseHistogram::PersistentCreate(
-    PersistentHistogramAllocator* allocator,
-    const char* name,
-    HistogramSamples::Metadata* meta,
-    HistogramSamples::Metadata* logged_meta) {
-  return WrapUnique(
-      new SparseHistogram(allocator, name, meta, logged_meta));
-}
-
-SparseHistogram::~SparseHistogram() = default;
-
-uint64_t SparseHistogram::name_hash() const {
-  return unlogged_samples_->id();
-}
-
-HistogramType SparseHistogram::GetHistogramType() const {
-  return SPARSE_HISTOGRAM;
-}
-
-bool SparseHistogram::HasConstructionArguments(
-    Sample expected_minimum,
-    Sample expected_maximum,
-    uint32_t expected_bucket_count) const {
-  // SparseHistogram never has min/max/bucket_count limit.
-  return false;
-}
-
-void SparseHistogram::Add(Sample value) {
-  AddCount(value, 1);
-}
-
-void SparseHistogram::AddCount(Sample value, int count) {
-  if (count <= 0) {
-    NOTREACHED();
-    return;
-  }
-  {
-    base::AutoLock auto_lock(lock_);
-    unlogged_samples_->Accumulate(value, count);
-  }
-
-  FindAndRunCallback(value);
-}
-
-std::unique_ptr<HistogramSamples> SparseHistogram::SnapshotSamples() const {
-  std::unique_ptr<SampleMap> snapshot(new SampleMap(name_hash()));
-
-  base::AutoLock auto_lock(lock_);
-  snapshot->Add(*unlogged_samples_);
-  snapshot->Add(*logged_samples_);
-  return std::move(snapshot);
-}
-
-std::unique_ptr<HistogramSamples> SparseHistogram::SnapshotDelta() {
-  DCHECK(!final_delta_created_);
-
-  std::unique_ptr<SampleMap> snapshot(new SampleMap(name_hash()));
-  base::AutoLock auto_lock(lock_);
-  snapshot->Add(*unlogged_samples_);
-
-  unlogged_samples_->Subtract(*snapshot);
-  logged_samples_->Add(*snapshot);
-  return std::move(snapshot);
-}
-
-std::unique_ptr<HistogramSamples> SparseHistogram::SnapshotFinalDelta() const {
-  DCHECK(!final_delta_created_);
-  final_delta_created_ = true;
-
-  std::unique_ptr<SampleMap> snapshot(new SampleMap(name_hash()));
-  base::AutoLock auto_lock(lock_);
-  snapshot->Add(*unlogged_samples_);
-
-  return std::move(snapshot);
-}
-
-void SparseHistogram::AddSamples(const HistogramSamples& samples) {
-  base::AutoLock auto_lock(lock_);
-  unlogged_samples_->Add(samples);
-}
-
-bool SparseHistogram::AddSamplesFromPickle(PickleIterator* iter) {
-  base::AutoLock auto_lock(lock_);
-  return unlogged_samples_->AddFromPickle(iter);
-}
-
-void SparseHistogram::WriteHTMLGraph(std::string* output) const {
-  output->append("<PRE>");
-  WriteAsciiImpl(true, "<br>", output);
-  output->append("</PRE>");
-}
-
-void SparseHistogram::WriteAscii(std::string* output) const {
-  WriteAsciiImpl(true, "\n", output);
-}
-
-void SparseHistogram::SerializeInfoImpl(Pickle* pickle) const {
-  pickle->WriteString(histogram_name());
-  pickle->WriteInt(flags());
-}
-
-SparseHistogram::SparseHistogram(const char* name)
-    : HistogramBase(name),
-      unlogged_samples_(new SampleMap(HashMetricName(name))),
-      logged_samples_(new SampleMap(unlogged_samples_->id())) {}
-
-SparseHistogram::SparseHistogram(PersistentHistogramAllocator* allocator,
-                                 const char* name,
-                                 HistogramSamples::Metadata* meta,
-                                 HistogramSamples::Metadata* logged_meta)
-    : HistogramBase(name),
-      // While other histogram types maintain a static vector of values with
-      // sufficient space for both "active" and "logged" samples, with each
-      // SampleVector being given the appropriate half, sparse histograms
-      // have no such initial allocation. Each sample has its own record
-      // attached to a single PersistentSampleMap by a common 64-bit identifier.
-      // Since a sparse histogram has two sample maps (active and logged),
-      // there must be two sets of sample records with diffent IDs. The
-      // "active" samples use, for convenience purposes, an ID matching
-      // that of the histogram while the "logged" samples use that number
-      // plus 1.
-      unlogged_samples_(
-          new PersistentSampleMap(HashMetricName(name), allocator, meta)),
-      logged_samples_(new PersistentSampleMap(unlogged_samples_->id() + 1,
-                                              allocator,
-                                              logged_meta)) {}
-
-HistogramBase* SparseHistogram::DeserializeInfoImpl(PickleIterator* iter) {
-  std::string histogram_name;
-  int flags;
-  if (!iter->ReadString(&histogram_name) || !iter->ReadInt(&flags)) {
-    DLOG(ERROR) << "Pickle error decoding Histogram: " << histogram_name;
-    return nullptr;
-  }
-
-  flags &= ~HistogramBase::kIPCSerializationSourceFlag;
-
-  return SparseHistogram::FactoryGet(histogram_name, flags);
-}
-
-void SparseHistogram::GetParameters(DictionaryValue* params) const {
-  // TODO(kaiwang): Implement. (See HistogramBase::WriteJSON.)
-}
-
-void SparseHistogram::GetCountAndBucketData(Count* count,
-                                            int64_t* sum,
-                                            ListValue* buckets) const {
-  // TODO(kaiwang): Implement. (See HistogramBase::WriteJSON.)
-}
-
-void SparseHistogram::WriteAsciiImpl(bool graph_it,
-                                     const std::string& newline,
-                                     std::string* output) const {
-  // Get a local copy of the data so we are consistent.
-  std::unique_ptr<HistogramSamples> snapshot = SnapshotSamples();
-  Count total_count = snapshot->TotalCount();
-  double scaled_total_count = total_count / 100.0;
-
-  WriteAsciiHeader(total_count, output);
-  output->append(newline);
-
-  // Determine how wide the largest bucket range is (how many digits to print),
-  // so that we'll be able to right-align starts for the graphical bars.
-  // Determine which bucket has the largest sample count so that we can
-  // normalize the graphical bar-width relative to that sample count.
-  Count largest_count = 0;
-  Sample largest_sample = 0;
-  std::unique_ptr<SampleCountIterator> it = snapshot->Iterator();
-  while (!it->Done()) {
-    Sample min;
-    int64_t max;
-    Count count;
-    it->Get(&min, &max, &count);
-    if (min > largest_sample)
-      largest_sample = min;
-    if (count > largest_count)
-      largest_count = count;
-    it->Next();
-  }
-  size_t print_width = GetSimpleAsciiBucketRange(largest_sample).size() + 1;
-
-  // iterate over each item and display them
-  it = snapshot->Iterator();
-  while (!it->Done()) {
-    Sample min;
-    int64_t max;
-    Count count;
-    it->Get(&min, &max, &count);
-
-    // value is min, so display it
-    std::string range = GetSimpleAsciiBucketRange(min);
-    output->append(range);
-    for (size_t j = 0; range.size() + j < print_width + 1; ++j)
-      output->push_back(' ');
-
-    if (graph_it)
-      WriteAsciiBucketGraph(count, largest_count, output);
-    WriteAsciiBucketValue(count, scaled_total_count, output);
-    output->append(newline);
-    it->Next();
-  }
-}
-
-void SparseHistogram::WriteAsciiHeader(const Count total_count,
-                                       std::string* output) const {
-  StringAppendF(output, "Histogram: %s recorded %d samples", histogram_name(),
-                total_count);
-  if (flags())
-    StringAppendF(output, " (flags = 0x%x)", flags());
-}
-
-}  // namespace base
diff --git a/base/metrics/sparse_histogram.h b/base/metrics/sparse_histogram.h
deleted file mode 100644
index 913762c..0000000
--- a/base/metrics/sparse_histogram.h
+++ /dev/null
@@ -1,108 +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_METRICS_SPARSE_HISTOGRAM_H_
-#define BASE_METRICS_SPARSE_HISTOGRAM_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-#include <map>
-#include <memory>
-#include <string>
-
-#include "base/base_export.h"
-#include "base/macros.h"
-#include "base/metrics/histogram_base.h"
-#include "base/metrics/histogram_samples.h"
-#include "base/synchronization/lock.h"
-
-namespace base {
-
-class HistogramSamples;
-class PersistentHistogramAllocator;
-class Pickle;
-class PickleIterator;
-
-class BASE_EXPORT SparseHistogram : public HistogramBase {
- public:
-  // If there's one with same name, return the existing one. If not, create a
-  // new one.
-  static HistogramBase* FactoryGet(const std::string& name, int32_t flags);
-
-  // Create a histogram using data in persistent storage. The allocator must
-  // live longer than the created sparse histogram.
-  static std::unique_ptr<HistogramBase> PersistentCreate(
-      PersistentHistogramAllocator* allocator,
-      const char* name,
-      HistogramSamples::Metadata* meta,
-      HistogramSamples::Metadata* logged_meta);
-
-  ~SparseHistogram() override;
-
-  // HistogramBase implementation:
-  uint64_t name_hash() const override;
-  HistogramType GetHistogramType() const override;
-  bool HasConstructionArguments(Sample expected_minimum,
-                                Sample expected_maximum,
-                                uint32_t expected_bucket_count) const override;
-  void Add(Sample value) override;
-  void AddCount(Sample value, int count) override;
-  void AddSamples(const HistogramSamples& samples) override;
-  bool AddSamplesFromPickle(base::PickleIterator* iter) override;
-  std::unique_ptr<HistogramSamples> SnapshotSamples() const override;
-  std::unique_ptr<HistogramSamples> SnapshotDelta() override;
-  std::unique_ptr<HistogramSamples> SnapshotFinalDelta() const override;
-  void WriteHTMLGraph(std::string* output) const override;
-  void WriteAscii(std::string* output) const override;
-
- protected:
-  // HistogramBase implementation:
-  void SerializeInfoImpl(base::Pickle* pickle) const override;
-
- private:
-  // Clients should always use FactoryGet to create SparseHistogram.
-  explicit SparseHistogram(const char* name);
-
-  SparseHistogram(PersistentHistogramAllocator* allocator,
-                  const char* name,
-                  HistogramSamples::Metadata* meta,
-                  HistogramSamples::Metadata* logged_meta);
-
-  friend BASE_EXPORT HistogramBase* DeserializeHistogramInfo(
-      base::PickleIterator* iter);
-  static HistogramBase* DeserializeInfoImpl(base::PickleIterator* iter);
-
-  void GetParameters(DictionaryValue* params) const override;
-  void GetCountAndBucketData(Count* count,
-                             int64_t* sum,
-                             ListValue* buckets) const override;
-
-  // Helpers for emitting Ascii graphic.  Each method appends data to output.
-  void WriteAsciiImpl(bool graph_it,
-                      const std::string& newline,
-                      std::string* output) const;
-
-  // Write a common header message describing this histogram.
-  void WriteAsciiHeader(const Count total_count,
-                        std::string* output) const;
-
-  // For constuctor calling.
-  friend class SparseHistogramTest;
-
-  // Protects access to |samples_|.
-  mutable base::Lock lock_;
-
-  // Flag to indicate if PrepareFinalDelta has been previously called.
-  mutable bool final_delta_created_ = false;
-
-  std::unique_ptr<HistogramSamples> unlogged_samples_;
-  std::unique_ptr<HistogramSamples> logged_samples_;
-
-  DISALLOW_COPY_AND_ASSIGN(SparseHistogram);
-};
-
-}  // namespace base
-
-#endif  // BASE_METRICS_SPARSE_HISTOGRAM_H_
diff --git a/base/metrics/statistics_recorder.cc b/base/metrics/statistics_recorder.cc
deleted file mode 100644
index 28773a1..0000000
--- a/base/metrics/statistics_recorder.cc
+++ /dev/null
@@ -1,416 +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/metrics/statistics_recorder.h"
-
-#include <memory>
-
-#include "base/at_exit.h"
-#include "base/debug/leak_annotations.h"
-#include "base/json/string_escape.h"
-#include "base/logging.h"
-#include "base/memory/ptr_util.h"
-#include "base/metrics/histogram.h"
-#include "base/metrics/histogram_snapshot_manager.h"
-#include "base/metrics/metrics_hashes.h"
-#include "base/metrics/persistent_histogram_allocator.h"
-#include "base/metrics/record_histogram_checker.h"
-#include "base/stl_util.h"
-#include "base/strings/stringprintf.h"
-#include "base/values.h"
-
-namespace base {
-namespace {
-
-bool HistogramNameLesser(const base::HistogramBase* a,
-                         const base::HistogramBase* b) {
-  return strcmp(a->histogram_name(), b->histogram_name()) < 0;
-}
-
-}  // namespace
-
-// static
-LazyInstance<Lock>::Leaky StatisticsRecorder::lock_;
-
-// static
-StatisticsRecorder* StatisticsRecorder::top_ = nullptr;
-
-// static
-bool StatisticsRecorder::is_vlog_initialized_ = false;
-
-size_t StatisticsRecorder::BucketRangesHash::operator()(
-    const BucketRanges* const a) const {
-  return a->checksum();
-}
-
-bool StatisticsRecorder::BucketRangesEqual::operator()(
-    const BucketRanges* const a,
-    const BucketRanges* const b) const {
-  return a->Equals(b);
-}
-
-StatisticsRecorder::~StatisticsRecorder() {
-  const AutoLock auto_lock(lock_.Get());
-  DCHECK_EQ(this, top_);
-  top_ = previous_;
-}
-
-// static
-void StatisticsRecorder::EnsureGlobalRecorderWhileLocked() {
-  lock_.Get().AssertAcquired();
-  if (top_)
-    return;
-
-  const StatisticsRecorder* const p = new StatisticsRecorder;
-  // The global recorder is never deleted.
-  ANNOTATE_LEAKING_OBJECT_PTR(p);
-  DCHECK_EQ(p, top_);
-}
-
-// static
-void StatisticsRecorder::RegisterHistogramProvider(
-    const WeakPtr<HistogramProvider>& provider) {
-  const AutoLock auto_lock(lock_.Get());
-  EnsureGlobalRecorderWhileLocked();
-  top_->providers_.push_back(provider);
-}
-
-// static
-HistogramBase* StatisticsRecorder::RegisterOrDeleteDuplicate(
-    HistogramBase* histogram) {
-  // Declared before |auto_lock| to ensure correct destruction order.
-  std::unique_ptr<HistogramBase> histogram_deleter;
-  const AutoLock auto_lock(lock_.Get());
-  EnsureGlobalRecorderWhileLocked();
-
-  const char* const name = histogram->histogram_name();
-  HistogramBase*& registered = top_->histograms_[name];
-
-  if (!registered) {
-    // |name| is guaranteed to never change or be deallocated so long
-    // as the histogram is alive (which is forever).
-    registered = histogram;
-    ANNOTATE_LEAKING_OBJECT_PTR(histogram);  // see crbug.com/79322
-    // If there are callbacks for this histogram, we set the kCallbackExists
-    // flag.
-    const auto callback_iterator = top_->callbacks_.find(name);
-    if (callback_iterator != top_->callbacks_.end()) {
-      if (!callback_iterator->second.is_null())
-        histogram->SetFlags(HistogramBase::kCallbackExists);
-      else
-        histogram->ClearFlags(HistogramBase::kCallbackExists);
-    }
-    return histogram;
-  }
-
-  if (histogram == registered) {
-    // The histogram was registered before.
-    return histogram;
-  }
-
-  // We already have one histogram with this name.
-  histogram_deleter.reset(histogram);
-  return registered;
-}
-
-// static
-const BucketRanges* StatisticsRecorder::RegisterOrDeleteDuplicateRanges(
-    const BucketRanges* ranges) {
-  DCHECK(ranges->HasValidChecksum());
-
-  // Declared before |auto_lock| to ensure correct destruction order.
-  std::unique_ptr<const BucketRanges> ranges_deleter;
-  const AutoLock auto_lock(lock_.Get());
-  EnsureGlobalRecorderWhileLocked();
-
-  const BucketRanges* const registered = *top_->ranges_.insert(ranges).first;
-  if (registered == ranges) {
-    ANNOTATE_LEAKING_OBJECT_PTR(ranges);
-  } else {
-    ranges_deleter.reset(ranges);
-  }
-
-  return registered;
-}
-
-// static
-void StatisticsRecorder::WriteHTMLGraph(const std::string& query,
-                                        std::string* output) {
-  for (const HistogramBase* const histogram :
-       Sort(WithName(GetHistograms(), query))) {
-    histogram->WriteHTMLGraph(output);
-    *output += "<br><hr><br>";
-  }
-}
-
-// static
-void StatisticsRecorder::WriteGraph(const std::string& query,
-                                    std::string* output) {
-  if (query.length())
-    StringAppendF(output, "Collections of histograms for %s\n", query.c_str());
-  else
-    output->append("Collections of all histograms\n");
-
-  for (const HistogramBase* const histogram :
-       Sort(WithName(GetHistograms(), query))) {
-    histogram->WriteAscii(output);
-    output->append("\n");
-  }
-}
-
-// static
-std::string StatisticsRecorder::ToJSON(JSONVerbosityLevel verbosity_level) {
-  std::string output = "{\"histograms\":[";
-  const char* sep = "";
-  for (const HistogramBase* const histogram : Sort(GetHistograms())) {
-    output += sep;
-    sep = ",";
-    std::string json;
-    histogram->WriteJSON(&json, verbosity_level);
-    output += json;
-  }
-  output += "]}";
-  return output;
-}
-
-// static
-std::vector<const BucketRanges*> StatisticsRecorder::GetBucketRanges() {
-  std::vector<const BucketRanges*> out;
-  const AutoLock auto_lock(lock_.Get());
-  EnsureGlobalRecorderWhileLocked();
-  out.reserve(top_->ranges_.size());
-  out.assign(top_->ranges_.begin(), top_->ranges_.end());
-  return out;
-}
-
-// static
-HistogramBase* StatisticsRecorder::FindHistogram(base::StringPiece name) {
-  // This must be called *before* the lock is acquired below because it will
-  // call back into this object to register histograms. Those called methods
-  // will acquire the lock at that time.
-  ImportGlobalPersistentHistograms();
-
-  const AutoLock auto_lock(lock_.Get());
-  EnsureGlobalRecorderWhileLocked();
-
-  const HistogramMap::const_iterator it = top_->histograms_.find(name);
-  return it != top_->histograms_.end() ? it->second : nullptr;
-}
-
-// static
-StatisticsRecorder::HistogramProviders
-StatisticsRecorder::GetHistogramProviders() {
-  const AutoLock auto_lock(lock_.Get());
-  EnsureGlobalRecorderWhileLocked();
-  return top_->providers_;
-}
-
-// static
-void StatisticsRecorder::ImportProvidedHistograms() {
-  // Merge histogram data from each provider in turn.
-  for (const WeakPtr<HistogramProvider>& provider : GetHistogramProviders()) {
-    // Weak-pointer may be invalid if the provider was destructed, though they
-    // generally never are.
-    if (provider)
-      provider->MergeHistogramDeltas();
-  }
-}
-
-// static
-void StatisticsRecorder::PrepareDeltas(
-    bool include_persistent,
-    HistogramBase::Flags flags_to_set,
-    HistogramBase::Flags required_flags,
-    HistogramSnapshotManager* snapshot_manager) {
-  Histograms histograms = GetHistograms();
-  if (!include_persistent)
-    histograms = NonPersistent(std::move(histograms));
-  snapshot_manager->PrepareDeltas(Sort(std::move(histograms)), flags_to_set,
-                                  required_flags);
-}
-
-// static
-void StatisticsRecorder::InitLogOnShutdown() {
-  const AutoLock auto_lock(lock_.Get());
-  InitLogOnShutdownWhileLocked();
-}
-
-// static
-bool StatisticsRecorder::SetCallback(
-    const std::string& name,
-    const StatisticsRecorder::OnSampleCallback& cb) {
-  DCHECK(!cb.is_null());
-  const AutoLock auto_lock(lock_.Get());
-  EnsureGlobalRecorderWhileLocked();
-
-  if (!top_->callbacks_.insert({name, cb}).second)
-    return false;
-
-  const HistogramMap::const_iterator it = top_->histograms_.find(name);
-  if (it != top_->histograms_.end())
-    it->second->SetFlags(HistogramBase::kCallbackExists);
-
-  return true;
-}
-
-// static
-void StatisticsRecorder::ClearCallback(const std::string& name) {
-  const AutoLock auto_lock(lock_.Get());
-  EnsureGlobalRecorderWhileLocked();
-
-  top_->callbacks_.erase(name);
-
-  // We also clear the flag from the histogram (if it exists).
-  const HistogramMap::const_iterator it = top_->histograms_.find(name);
-  if (it != top_->histograms_.end())
-    it->second->ClearFlags(HistogramBase::kCallbackExists);
-}
-
-// static
-StatisticsRecorder::OnSampleCallback StatisticsRecorder::FindCallback(
-    const std::string& name) {
-  const AutoLock auto_lock(lock_.Get());
-  EnsureGlobalRecorderWhileLocked();
-  const auto it = top_->callbacks_.find(name);
-  return it != top_->callbacks_.end() ? it->second : OnSampleCallback();
-}
-
-// static
-size_t StatisticsRecorder::GetHistogramCount() {
-  const AutoLock auto_lock(lock_.Get());
-  EnsureGlobalRecorderWhileLocked();
-  return top_->histograms_.size();
-}
-
-// static
-void StatisticsRecorder::ForgetHistogramForTesting(base::StringPiece name) {
-  const AutoLock auto_lock(lock_.Get());
-  EnsureGlobalRecorderWhileLocked();
-
-  const HistogramMap::iterator found = top_->histograms_.find(name);
-  if (found == top_->histograms_.end())
-    return;
-
-  HistogramBase* const base = found->second;
-  if (base->GetHistogramType() != SPARSE_HISTOGRAM) {
-    // When forgetting a histogram, it's likely that other information is
-    // also becoming invalid. Clear the persistent reference that may no
-    // longer be valid. There's no danger in this as, at worst, duplicates
-    // will be created in persistent memory.
-    static_cast<Histogram*>(base)->bucket_ranges()->set_persistent_reference(0);
-  }
-
-  top_->histograms_.erase(found);
-}
-
-// static
-std::unique_ptr<StatisticsRecorder>
-StatisticsRecorder::CreateTemporaryForTesting() {
-  const AutoLock auto_lock(lock_.Get());
-  return WrapUnique(new StatisticsRecorder());
-}
-
-// static
-void StatisticsRecorder::SetRecordChecker(
-    std::unique_ptr<RecordHistogramChecker> record_checker) {
-  const AutoLock auto_lock(lock_.Get());
-  EnsureGlobalRecorderWhileLocked();
-  top_->record_checker_ = std::move(record_checker);
-}
-
-// static
-bool StatisticsRecorder::ShouldRecordHistogram(uint64_t histogram_hash) {
-  const AutoLock auto_lock(lock_.Get());
-  EnsureGlobalRecorderWhileLocked();
-  return !top_->record_checker_ ||
-         top_->record_checker_->ShouldRecord(histogram_hash);
-}
-
-// static
-StatisticsRecorder::Histograms StatisticsRecorder::GetHistograms() {
-  // This must be called *before* the lock is acquired below because it will
-  // call back into this object to register histograms. Those called methods
-  // will acquire the lock at that time.
-  ImportGlobalPersistentHistograms();
-
-  Histograms out;
-
-  const AutoLock auto_lock(lock_.Get());
-  EnsureGlobalRecorderWhileLocked();
-
-  out.reserve(top_->histograms_.size());
-  for (const auto& entry : top_->histograms_)
-    out.push_back(entry.second);
-
-  return out;
-}
-
-// static
-StatisticsRecorder::Histograms StatisticsRecorder::Sort(Histograms histograms) {
-  std::sort(histograms.begin(), histograms.end(), &HistogramNameLesser);
-  return histograms;
-}
-
-// static
-StatisticsRecorder::Histograms StatisticsRecorder::WithName(
-    Histograms histograms,
-    const std::string& query) {
-  // Need a C-string query for comparisons against C-string histogram name.
-  const char* const query_string = query.c_str();
-  histograms.erase(std::remove_if(histograms.begin(), histograms.end(),
-                                  [query_string](const HistogramBase* const h) {
-                                    return !strstr(h->histogram_name(),
-                                                   query_string);
-                                  }),
-                   histograms.end());
-  return histograms;
-}
-
-// static
-StatisticsRecorder::Histograms StatisticsRecorder::NonPersistent(
-    Histograms histograms) {
-  histograms.erase(
-      std::remove_if(histograms.begin(), histograms.end(),
-                     [](const HistogramBase* const h) {
-                       return (h->flags() & HistogramBase::kIsPersistent) != 0;
-                     }),
-      histograms.end());
-  return histograms;
-}
-
-// static
-void StatisticsRecorder::ImportGlobalPersistentHistograms() {
-  // Import histograms from known persistent storage. Histograms could have been
-  // added by other processes and they must be fetched and recognized locally.
-  // If the persistent memory segment is not shared between processes, this call
-  // does nothing.
-  if (GlobalHistogramAllocator* allocator = GlobalHistogramAllocator::Get())
-    allocator->ImportHistogramsToStatisticsRecorder();
-}
-
-// This singleton instance should be started during the single threaded portion
-// of main(), and hence it is not thread safe. It initializes globals to provide
-// support for all future calls.
-StatisticsRecorder::StatisticsRecorder() {
-  lock_.Get().AssertAcquired();
-  previous_ = top_;
-  top_ = this;
-  InitLogOnShutdownWhileLocked();
-}
-
-// static
-void StatisticsRecorder::InitLogOnShutdownWhileLocked() {
-  lock_.Get().AssertAcquired();
-  if (!is_vlog_initialized_ && VLOG_IS_ON(1)) {
-    is_vlog_initialized_ = true;
-    const auto dump_to_vlog = [](void*) {
-      std::string output;
-      WriteGraph("", &output);
-      VLOG(1) << output;
-    };
-    AtExitManager::RegisterCallback(dump_to_vlog, nullptr);
-  }
-}
-
-}  // namespace base
diff --git a/base/metrics/statistics_recorder.h b/base/metrics/statistics_recorder.h
deleted file mode 100644
index 87a9311..0000000
--- a/base/metrics/statistics_recorder.h
+++ /dev/null
@@ -1,302 +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.
-
-// StatisticsRecorder holds all Histograms and BucketRanges that are used by
-// Histograms in the system. It provides a general place for
-// Histograms/BucketRanges to register, and supports a global API for accessing
-// (i.e., dumping, or graphing) the data.
-
-#ifndef BASE_METRICS_STATISTICS_RECORDER_H_
-#define BASE_METRICS_STATISTICS_RECORDER_H_
-
-#include <stdint.h>
-
-#include <memory>
-#include <string>
-#include <unordered_map>
-#include <unordered_set>
-#include <vector>
-
-#include "base/base_export.h"
-#include "base/callback.h"
-#include "base/gtest_prod_util.h"
-#include "base/lazy_instance.h"
-#include "base/macros.h"
-#include "base/memory/weak_ptr.h"
-#include "base/metrics/histogram_base.h"
-#include "base/metrics/record_histogram_checker.h"
-#include "base/strings/string_piece.h"
-#include "base/synchronization/lock.h"
-
-namespace base {
-
-class BucketRanges;
-class HistogramSnapshotManager;
-
-// In-memory recorder of usage statistics (aka metrics, aka histograms).
-//
-// All the public methods are static and act on a global recorder. This global
-// recorder is internally synchronized and all the static methods are thread
-// safe.
-//
-// StatisticsRecorder doesn't have any public constructor. For testing purpose,
-// you can create a temporary recorder using the factory method
-// CreateTemporaryForTesting(). This temporary recorder becomes the global one
-// until deleted. When this temporary recorder is deleted, it restores the
-// previous global one.
-class BASE_EXPORT StatisticsRecorder {
- public:
-  // An interface class that allows the StatisticsRecorder to forcibly merge
-  // histograms from providers when necessary.
-  class HistogramProvider {
-   public:
-    // Merges all histogram information into the global versions.
-    virtual void MergeHistogramDeltas() = 0;
-  };
-
-  typedef std::vector<HistogramBase*> Histograms;
-
-  // Restores the previous global recorder.
-  //
-  // When several temporary recorders are created using
-  // CreateTemporaryForTesting(), these recorders must be deleted in reverse
-  // order of creation.
-  //
-  // This method is thread safe.
-  //
-  // Precondition: The recorder being deleted is the current global recorder.
-  ~StatisticsRecorder();
-
-  // Registers a provider of histograms that can be called to merge those into
-  // the global recorder. Calls to ImportProvidedHistograms() will fetch from
-  // registered providers.
-  //
-  // This method is thread safe.
-  static void RegisterHistogramProvider(
-      const WeakPtr<HistogramProvider>& provider);
-
-  // Registers or adds a new histogram to the collection of statistics. If an
-  // identically named histogram is already registered, then the argument
-  // |histogram| will be deleted. The returned value is always the registered
-  // histogram (either the argument, or the pre-existing registered histogram).
-  //
-  // This method is thread safe.
-  static HistogramBase* RegisterOrDeleteDuplicate(HistogramBase* histogram);
-
-  // Registers or adds a new BucketRanges. If an equivalent BucketRanges is
-  // already registered, then the argument |ranges| will be deleted. The
-  // returned value is always the registered BucketRanges (either the argument,
-  // or the pre-existing one).
-  //
-  // This method is thread safe.
-  static const BucketRanges* RegisterOrDeleteDuplicateRanges(
-      const BucketRanges* ranges);
-
-  // Methods for appending histogram data to a string.  Only histograms which
-  // have |query| as a substring are written to |output| (an empty string will
-  // process all registered histograms).
-  //
-  // These methods are thread safe.
-  static void WriteHTMLGraph(const std::string& query, std::string* output);
-  static void WriteGraph(const std::string& query, std::string* output);
-
-  // Returns the histograms with |verbosity_level| as the serialization
-  // verbosity.
-  //
-  // This method is thread safe.
-  static std::string ToJSON(JSONVerbosityLevel verbosity_level);
-
-  // Gets existing histograms.
-  //
-  // The order of returned histograms is not guaranteed.
-  //
-  // Ownership of the individual histograms remains with the StatisticsRecorder.
-  //
-  // This method is thread safe.
-  static Histograms GetHistograms();
-
-  // Gets BucketRanges used by all histograms registered. The order of returned
-  // BucketRanges is not guaranteed.
-  //
-  // This method is thread safe.
-  static std::vector<const BucketRanges*> GetBucketRanges();
-
-  // Finds a histogram by name. Matches the exact name. Returns a null pointer
-  // if a matching histogram is not found.
-  //
-  // This method is thread safe.
-  static HistogramBase* FindHistogram(base::StringPiece name);
-
-  // Imports histograms from providers.
-  //
-  // This method must be called on the UI thread.
-  static void ImportProvidedHistograms();
-
-  // Snapshots all histograms via |snapshot_manager|. |flags_to_set| is used to
-  // set flags for each histogram. |required_flags| is used to select
-  // histograms to be recorded. Only histograms that have all the flags
-  // specified by the argument will be chosen. If all histograms should be
-  // recorded, set it to |Histogram::kNoFlags|.
-  static void PrepareDeltas(bool include_persistent,
-                            HistogramBase::Flags flags_to_set,
-                            HistogramBase::Flags required_flags,
-                            HistogramSnapshotManager* snapshot_manager);
-
-  typedef base::Callback<void(HistogramBase::Sample)> OnSampleCallback;
-
-  // Sets the callback to notify when a new sample is recorded on the histogram
-  // referred to by |histogram_name|. Can be called before or after the
-  // histogram is created. Returns whether the callback was successfully set.
-  //
-  // This method is thread safe.
-  static bool SetCallback(const std::string& histogram_name,
-                          const OnSampleCallback& callback);
-
-  // Clears any callback set on the histogram referred to by |histogram_name|.
-  //
-  // This method is thread safe.
-  static void ClearCallback(const std::string& histogram_name);
-
-  // Retrieves the callback for the histogram referred to by |histogram_name|,
-  // or a null callback if no callback exists for this histogram.
-  //
-  // This method is thread safe.
-  static OnSampleCallback FindCallback(const std::string& histogram_name);
-
-  // Returns the number of known histograms.
-  //
-  // This method is thread safe.
-  static size_t GetHistogramCount();
-
-  // Initializes logging histograms with --v=1. Safe to call multiple times.
-  // Is called from ctor but for browser it seems that it is more useful to
-  // start logging after statistics recorder, so we need to init log-on-shutdown
-  // later.
-  //
-  // This method is thread safe.
-  static void InitLogOnShutdown();
-
-  // Removes a histogram from the internal set of known ones. This can be
-  // necessary during testing persistent histograms where the underlying
-  // memory is being released.
-  //
-  // This method is thread safe.
-  static void ForgetHistogramForTesting(base::StringPiece name);
-
-  // Creates a temporary StatisticsRecorder object for testing purposes. All new
-  // histograms will be registered in it until it is destructed or pushed aside
-  // for the lifetime of yet another StatisticsRecorder object. The destruction
-  // of the returned object will re-activate the previous one.
-  // StatisticsRecorder objects must be deleted in the opposite order to which
-  // they're created.
-  //
-  // This method is thread safe.
-  static std::unique_ptr<StatisticsRecorder> CreateTemporaryForTesting()
-      WARN_UNUSED_RESULT;
-
-  // Sets the record checker for determining if a histogram should be recorded.
-  // Record checker doesn't affect any already recorded histograms, so this
-  // method must be called very early, before any threads have started.
-  // Record checker methods can be called on any thread, so they shouldn't
-  // mutate any state.
-  static void SetRecordChecker(
-      std::unique_ptr<RecordHistogramChecker> record_checker);
-
-  // Checks if the given histogram should be recorded based on the
-  // ShouldRecord() method of the record checker. If the record checker is not
-  // set, returns true.
-  //
-  // This method is thread safe.
-  static bool ShouldRecordHistogram(uint64_t histogram_hash);
-
-  // Sorts histograms by name.
-  static Histograms Sort(Histograms histograms);
-
-  // Filters histograms by name. Only histograms which have |query| as a
-  // substring in their name are kept. An empty query keeps all histograms.
-  static Histograms WithName(Histograms histograms, const std::string& query);
-
-  // Filters histograms by persistency. Only non-persistent histograms are kept.
-  static Histograms NonPersistent(Histograms histograms);
-
- private:
-  typedef std::vector<WeakPtr<HistogramProvider>> HistogramProviders;
-
-  typedef std::unordered_map<StringPiece, HistogramBase*, StringPieceHash>
-      HistogramMap;
-
-  // We keep a map of callbacks to histograms, so that as histograms are
-  // created, we can set the callback properly.
-  typedef std::unordered_map<std::string, OnSampleCallback> CallbackMap;
-
-  struct BucketRangesHash {
-    size_t operator()(const BucketRanges* a) const;
-  };
-
-  struct BucketRangesEqual {
-    bool operator()(const BucketRanges* a, const BucketRanges* b) const;
-  };
-
-  typedef std::
-      unordered_set<const BucketRanges*, BucketRangesHash, BucketRangesEqual>
-          RangesMap;
-
-  friend class StatisticsRecorderTest;
-  FRIEND_TEST_ALL_PREFIXES(StatisticsRecorderTest, IterationTest);
-
-  // Initializes the global recorder if it doesn't already exist. Safe to call
-  // multiple times.
-  //
-  // Precondition: The global lock is already acquired.
-  static void EnsureGlobalRecorderWhileLocked();
-
-  // Gets histogram providers.
-  //
-  // This method is thread safe.
-  static HistogramProviders GetHistogramProviders();
-
-  // Imports histograms from global persistent memory.
-  //
-  // Precondition: The global lock must not be held during this call.
-  static void ImportGlobalPersistentHistograms();
-
-  // Constructs a new StatisticsRecorder and sets it as the current global
-  // recorder.
-  //
-  // Precondition: The global lock is already acquired.
-  StatisticsRecorder();
-
-  // Initialize implementation but without lock. Caller should guard
-  // StatisticsRecorder by itself if needed (it isn't in unit tests).
-  //
-  // Precondition: The global lock is already acquired.
-  static void InitLogOnShutdownWhileLocked();
-
-  HistogramMap histograms_;
-  CallbackMap callbacks_;
-  RangesMap ranges_;
-  HistogramProviders providers_;
-  std::unique_ptr<RecordHistogramChecker> record_checker_;
-
-  // Previous global recorder that existed when this one was created.
-  StatisticsRecorder* previous_ = nullptr;
-
-  // Global lock for internal synchronization.
-  static LazyInstance<Lock>::Leaky lock_;
-
-  // Current global recorder. This recorder is used by static methods. When a
-  // new global recorder is created by CreateTemporaryForTesting(), then the
-  // previous global recorder is referenced by top_->previous_.
-  static StatisticsRecorder* top_;
-
-  // Tracks whether InitLogOnShutdownWhileLocked() has registered a logging
-  // function that will be called when the program finishes.
-  static bool is_vlog_initialized_;
-
-  DISALLOW_COPY_AND_ASSIGN(StatisticsRecorder);
-};
-
-}  // namespace base
-
-#endif  // BASE_METRICS_STATISTICS_RECORDER_H_
diff --git a/base/metrics/user_metrics.cc b/base/metrics/user_metrics.cc
deleted file mode 100644
index 9fcc9e8..0000000
--- a/base/metrics/user_metrics.cc
+++ /dev/null
@@ -1,74 +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/metrics/user_metrics.h"
-
-#include <stddef.h>
-
-#include <vector>
-
-#include "base/bind.h"
-#include "base/lazy_instance.h"
-#include "base/location.h"
-#include "base/macros.h"
-#include "base/threading/thread_checker.h"
-
-namespace base {
-namespace {
-
-LazyInstance<std::vector<ActionCallback>>::DestructorAtExit g_callbacks =
-    LAZY_INSTANCE_INITIALIZER;
-LazyInstance<scoped_refptr<SingleThreadTaskRunner>>::DestructorAtExit
-    g_task_runner = LAZY_INSTANCE_INITIALIZER;
-
-}  // namespace
-
-void RecordAction(const UserMetricsAction& action) {
-  RecordComputedAction(action.str_);
-}
-
-void RecordComputedAction(const std::string& action) {
-  if (!g_task_runner.Get()) {
-    DCHECK(g_callbacks.Get().empty());
-    return;
-  }
-
-  if (!g_task_runner.Get()->BelongsToCurrentThread()) {
-    g_task_runner.Get()->PostTask(FROM_HERE,
-                                  BindOnce(&RecordComputedAction, action));
-    return;
-  }
-
-  for (const ActionCallback& callback : g_callbacks.Get()) {
-    callback.Run(action);
-  }
-}
-
-void AddActionCallback(const ActionCallback& callback) {
-  // Only allow adding a callback if the task runner is set.
-  DCHECK(g_task_runner.Get());
-  DCHECK(g_task_runner.Get()->BelongsToCurrentThread());
-  g_callbacks.Get().push_back(callback);
-}
-
-void RemoveActionCallback(const ActionCallback& callback) {
-  DCHECK(g_task_runner.Get());
-  DCHECK(g_task_runner.Get()->BelongsToCurrentThread());
-  std::vector<ActionCallback>* callbacks = g_callbacks.Pointer();
-  for (size_t i = 0; i < callbacks->size(); ++i) {
-    if ((*callbacks)[i].Equals(callback)) {
-      callbacks->erase(callbacks->begin() + i);
-      return;
-    }
-  }
-}
-
-void SetRecordActionTaskRunner(
-    scoped_refptr<SingleThreadTaskRunner> task_runner) {
-  DCHECK(task_runner->BelongsToCurrentThread());
-  DCHECK(!g_task_runner.Get() || g_task_runner.Get()->BelongsToCurrentThread());
-  g_task_runner.Get() = task_runner;
-}
-
-}  // namespace base
diff --git a/base/metrics/user_metrics.h b/base/metrics/user_metrics.h
deleted file mode 100644
index 87fbd9c..0000000
--- a/base/metrics/user_metrics.h
+++ /dev/null
@@ -1,73 +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_METRICS_USER_METRICS_H_
-#define BASE_METRICS_USER_METRICS_H_
-
-#include <string>
-
-#include "base/base_export.h"
-#include "base/callback.h"
-#include "base/metrics/user_metrics_action.h"
-#include "base/single_thread_task_runner.h"
-
-namespace base {
-
-// This module provides some helper functions for logging actions tracked by
-// the user metrics system.
-
-// For best practices on deciding when to emit a user action, see
-// https://chromium.googlesource.com/chromium/src.git/+/HEAD/tools/metrics/actions/README.md
-
-// Record that the user performed an action.
-// This function must be called after the task runner has been set with
-// SetRecordActionTaskRunner().
-//
-// "Action" here means a user-generated event:
-//   good: "Reload", "CloseTab", and "IMEInvoked"
-//   not good: "SSLDialogShown", "PageLoaded", "DiskFull"
-// We use this to gather anonymized information about how users are
-// interacting with the browser.
-// WARNING: In calls to this function, UserMetricsAction should be followed by a
-// string literal parameter and not a variable e.g.
-//   RecordAction(UserMetricsAction("my action name"));
-// This ensures that our processing scripts can associate this action's hash
-// with its metric name. Therefore, it will be possible to retrieve the metric
-// name from the hash later on.
-//
-// Once a new recorded action is added, run
-//   tools/metrics/actions/extract_actions.py
-// to add the metric to actions.xml, then update the <owner>s and <description>
-// sections. Make sure to include the actions.xml file when you upload your code
-// for review!
-//
-// For more complicated situations (like when there are many different
-// possible actions), see RecordComputedAction().
-BASE_EXPORT void RecordAction(const UserMetricsAction& action);
-
-// This function has identical input and behavior to RecordAction(), but is
-// not automatically found by the action-processing scripts.  It can be used
-// when it's a pain to enumerate all possible actions, but if you use this
-// you need to also update the rules for extracting known actions in
-// tools/metrics/actions/extract_actions.py.
-// This function must be called after the task runner has been set with
-// SetRecordActionTaskRunner().
-BASE_EXPORT void RecordComputedAction(const std::string& action);
-
-// Called with the action string.
-typedef Callback<void(const std::string&)> ActionCallback;
-
-// Add/remove action callbacks (see above).
-// These functions must be called after the task runner has been set with
-// SetRecordActionTaskRunner().
-BASE_EXPORT void AddActionCallback(const ActionCallback& callback);
-BASE_EXPORT void RemoveActionCallback(const ActionCallback& callback);
-
-// Set the task runner on which to record actions.
-BASE_EXPORT void SetRecordActionTaskRunner(
-    scoped_refptr<SingleThreadTaskRunner> task_runner);
-
-}  // namespace base
-
-#endif  // BASE_METRICS_USER_METRICS_H_
diff --git a/base/metrics/user_metrics_action.h b/base/metrics/user_metrics_action.h
deleted file mode 100644
index 454ed83..0000000
--- a/base/metrics/user_metrics_action.h
+++ /dev/null
@@ -1,27 +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_METRICS_USER_METRICS_ACTION_H_
-#define BASE_METRICS_USER_METRICS_ACTION_H_
-
-namespace base {
-
-// UserMetricsAction exists purely to standardize on the parameters passed to
-// UserMetrics. That way, our toolset can scan the source code reliable for
-// constructors and extract the associated string constants.
-// WARNING: When using UserMetricsAction you should use a string literal
-// parameter e.g.
-//   RecordAction(UserMetricsAction("my action name"));
-// This ensures that our processing scripts can associate this action's hash
-// with its metric name. Therefore, it will be possible to retrieve the metric
-// name from the hash later on.
-// Please see tools/metrics/actions/extract_actions.py for details.
-struct UserMetricsAction {
-  const char* str_;
-  explicit constexpr UserMetricsAction(const char* str) noexcept : str_(str) {}
-};
-
-}  // namespace base
-
-#endif  // BASE_METRICS_USER_METRICS_ACTION_H_
diff --git a/base/process/kill_posix.cc b/base/process/kill_posix.cc
index 5159c19..7d75095 100644
--- a/base/process/kill_posix.cc
+++ b/base/process/kill_posix.cc
@@ -10,7 +10,6 @@
 #include <sys/wait.h>
 #include <unistd.h>
 
-#include "base/debug/activity_tracker.h"
 #include "base/files/file_util.h"
 #include "base/logging.h"
 #include "base/macros.h"
diff --git a/base/process/process.h b/base/process/process.h
index 479e24d..2826be3 100644
--- a/base/process/process.h
+++ b/base/process/process.h
@@ -20,16 +20,11 @@
 #endif
 
 #if defined(OS_MACOSX)
-#include "base/feature_list.h"
 #include "base/process/port_provider_mac.h"
 #endif
 
 namespace base {
 
-#if defined(OS_MACOSX)
-extern const Feature kMacAllowBackgroundingProcesses;
-#endif
-
 // Provides a move-only encapsulation of a process.
 //
 // This object is not tied to the lifetime of the underlying process: the
diff --git a/base/process/process_mac.cc b/base/process/process_mac.cc
index 70bc4c2..cd47c62 100644
--- a/base/process/process_mac.cc
+++ b/base/process/process_mac.cc
@@ -6,17 +6,12 @@
 
 #include <mach/mach.h>
 
-#include "base/feature_list.h"
 #include "base/mac/mach_logging.h"
 
 namespace base {
 
-// Enables backgrounding hidden renderers on Mac.
-const Feature kMacAllowBackgroundingProcesses{"MacAllowBackgroundingProcesses",
-                                              FEATURE_DISABLED_BY_DEFAULT};
-
 bool Process::CanBackgroundProcesses() {
-  return FeatureList::IsEnabled(kMacAllowBackgroundingProcesses);
+  return false;
 }
 
 bool Process::IsProcessBackgrounded(PortProvider* port_provider) const {
diff --git a/base/process/process_posix.cc b/base/process/process_posix.cc
index 51b57e1..6b758a2 100644
--- a/base/process/process_posix.cc
+++ b/base/process/process_posix.cc
@@ -10,7 +10,6 @@
 #include <sys/resource.h>
 #include <sys/wait.h>
 
-#include "base/debug/activity_tracker.h"
 #include "base/files/scoped_file.h"
 #include "base/logging.h"
 #include "base/posix/eintr_wrapper.h"
@@ -339,9 +338,6 @@
   if (!timeout.is_zero())
     internal::AssertBaseSyncPrimitivesAllowed();
 
-  // Record the event that this thread is blocking upon (for hang diagnosis).
-  base::debug::ScopedProcessWaitActivity process_activity(this);
-
   int local_exit_code;
   bool exited = WaitForExitWithTimeoutImpl(Handle(), &local_exit_code, timeout);
   if (exited) {
diff --git a/base/synchronization/lock_impl_posix.cc b/base/synchronization/lock_impl_posix.cc
index 1cfa88a..3812fe2 100644
--- a/base/synchronization/lock_impl_posix.cc
+++ b/base/synchronization/lock_impl_posix.cc
@@ -6,7 +6,6 @@
 
 #include <string>
 
-#include "base/debug/activity_tracker.h"
 #include "base/logging.h"
 #include "base/posix/safe_strerror.h"
 #include "base/strings/stringprintf.h"
@@ -86,18 +85,6 @@
 }
 
 void LockImpl::Lock() {
-  // The ScopedLockAcquireActivity below is relatively expensive and so its
-  // actions can become significant due to the very large number of locks
-  // that tend to be used throughout the build. To avoid this cost in the
-  // vast majority of the calls, simply "try" the lock first and only do the
-  // (tracked) blocking call if that fails. Since "try" itself is a system
-  // call, and thus also somewhat expensive, don't bother with it unless
-  // tracking is actually enabled.
-  if (base::debug::GlobalActivityTracker::IsEnabled())
-    if (Try())
-      return;
-
-  base::debug::ScopedLockAcquireActivity lock_activity(this);
   int rv = pthread_mutex_lock(&native_handle_);
   DCHECK_EQ(rv, 0) << ". " << SystemErrorCodeToString(rv);
 }
diff --git a/base/synchronization/waitable_event_mac.cc b/base/synchronization/waitable_event_mac.cc
index 56e6cb3..7979553 100644
--- a/base/synchronization/waitable_event_mac.cc
+++ b/base/synchronization/waitable_event_mac.cc
@@ -8,7 +8,7 @@
 #include <mach/mach.h>
 #include <sys/event.h>
 
-#include "base/debug/activity_tracker.h"
+#include "base/callback.h"
 #include "base/files/scoped_file.h"
 #include "base/mac/dispatch_source_mach.h"
 #include "base/mac/mac_util.h"
@@ -113,8 +113,6 @@
 bool WaitableEvent::TimedWaitUntil(const TimeTicks& end_time) {
   internal::AssertBaseSyncPrimitivesAllowed();
   ScopedBlockingCall scoped_blocking_call(BlockingType::MAY_BLOCK);
-  // Record the event that this thread is blocking upon (for hang diagnosis).
-  debug::ScopedEventWaitActivity event_activity(this);
 
   TimeDelta wait_time = end_time - TimeTicks::Now();
   if (wait_time < TimeDelta()) {
@@ -169,8 +167,6 @@
   internal::AssertBaseSyncPrimitivesAllowed();
   DCHECK(count) << "Cannot wait on no events";
   ScopedBlockingCall scoped_blocking_call(BlockingType::MAY_BLOCK);
-  // Record an event (the first) that this thread is blocking upon.
-  debug::ScopedEventWaitActivity event_activity(raw_waitables[0]);
 
   // On macOS 10.11+, using Mach port sets may cause system instability, per
   // https://crbug.com/756102. On macOS 10.12+, a kqueue can be used
diff --git a/base/synchronization/waitable_event_posix.cc b/base/synchronization/waitable_event_posix.cc
index 9799e7d..34d54c7 100644
--- a/base/synchronization/waitable_event_posix.cc
+++ b/base/synchronization/waitable_event_posix.cc
@@ -8,7 +8,6 @@
 #include <limits>
 #include <vector>
 
-#include "base/debug/activity_tracker.h"
 #include "base/logging.h"
 #include "base/synchronization/condition_variable.h"
 #include "base/synchronization/lock.h"
@@ -164,8 +163,6 @@
 bool WaitableEvent::TimedWaitUntil(const TimeTicks& end_time) {
   internal::AssertBaseSyncPrimitivesAllowed();
   ScopedBlockingCall scoped_blocking_call(BlockingType::MAY_BLOCK);
-  // Record the event that this thread is blocking upon (for hang diagnosis).
-  base::debug::ScopedEventWaitActivity event_activity(this);
 
   const bool finite_time = !end_time.is_max();
 
@@ -240,8 +237,6 @@
   internal::AssertBaseSyncPrimitivesAllowed();
   DCHECK(count) << "Cannot wait on no events";
   ScopedBlockingCall scoped_blocking_call(BlockingType::MAY_BLOCK);
-  // Record an event (the first) that this thread is blocking upon.
-  base::debug::ScopedEventWaitActivity event_activity(raw_waitables[0]);
 
   // We need to acquire the locks in a globally consistent order. Thus we sort
   // the array of waitables by address. We actually sort a pairs so that we can
diff --git a/base/task_scheduler/scheduler_worker_pool_impl.cc b/base/task_scheduler/scheduler_worker_pool_impl.cc
index 0e0c107..9e7e892 100644
--- a/base/task_scheduler/scheduler_worker_pool_impl.cc
+++ b/base/task_scheduler/scheduler_worker_pool_impl.cc
@@ -16,7 +16,6 @@
 #include "base/compiler_specific.h"
 #include "base/location.h"
 #include "base/memory/ptr_util.h"
-#include "base/metrics/histogram.h"
 #include "base/sequence_token.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
@@ -41,13 +40,6 @@
 
 namespace {
 
-constexpr char kPoolNameSuffix[] = "Pool";
-constexpr char kDetachDurationHistogramPrefix[] =
-    "TaskScheduler.DetachDuration.";
-constexpr char kNumTasksBeforeDetachHistogramPrefix[] =
-    "TaskScheduler.NumTasksBeforeDetach.";
-constexpr char kNumTasksBetweenWaitsHistogramPrefix[] =
-    "TaskScheduler.NumTasksBetweenWaits.";
 constexpr size_t kMaxNumberOfWorkers = 256;
 
 // Only used in DCHECKs.
@@ -168,38 +160,6 @@
       priority_hint_(priority_hint),
       lock_(shared_priority_queue_.container_lock()),
       idle_workers_stack_cv_for_testing_(lock_.CreateConditionVariable()),
-      // Mimics the UMA_HISTOGRAM_LONG_TIMES macro.
-      detach_duration_histogram_(Histogram::FactoryTimeGet(
-          JoinString({kDetachDurationHistogramPrefix, histogram_label,
-                      kPoolNameSuffix},
-                     ""),
-          TimeDelta::FromMilliseconds(1),
-          TimeDelta::FromHours(1),
-          50,
-          HistogramBase::kUmaTargetedHistogramFlag)),
-      // Mimics the UMA_HISTOGRAM_COUNTS_1000 macro. When a worker runs more
-      // than 1000 tasks before detaching, there is no need to know the exact
-      // number of tasks that ran.
-      num_tasks_before_detach_histogram_(Histogram::FactoryGet(
-          JoinString({kNumTasksBeforeDetachHistogramPrefix, histogram_label,
-                      kPoolNameSuffix},
-                     ""),
-          1,
-          1000,
-          50,
-          HistogramBase::kUmaTargetedHistogramFlag)),
-      // Mimics the UMA_HISTOGRAM_COUNTS_100 macro. A SchedulerWorker is
-      // expected to run between zero and a few tens of tasks between waits.
-      // When it runs more than 100 tasks, there is no need to know the exact
-      // number of tasks that ran.
-      num_tasks_between_waits_histogram_(Histogram::FactoryGet(
-          JoinString({kNumTasksBetweenWaitsHistogramPrefix, histogram_label,
-                      kPoolNameSuffix},
-                     ""),
-          1,
-          100,
-          50,
-          HistogramBase::kUmaTargetedHistogramFlag)),
       tracked_ref_factory_(this) {
   DCHECK(!histogram_label.empty());
   DCHECK(!pool_label_.empty());
@@ -271,12 +231,6 @@
   WakeUpOneWorker();
 }
 
-void SchedulerWorkerPoolImpl::GetHistograms(
-    std::vector<const HistogramBase*>* histograms) const {
-  histograms->push_back(detach_duration_histogram_);
-  histograms->push_back(num_tasks_between_waits_histogram_);
-}
-
 int SchedulerWorkerPoolImpl::GetMaxConcurrentNonBlockedTasksDeprecated() const {
 #if DCHECK_IS_ON()
   AutoSchedulerLock auto_lock(lock_);
@@ -521,7 +475,6 @@
   DCHECK_CALLED_ON_VALID_THREAD(worker_thread_checker_);
 
   outer_->lock_.AssertAcquired();
-  outer_->num_tasks_before_detach_histogram_->Add(num_tasks_since_last_detach_);
   outer_->cleanup_timestamps_.push(TimeTicks::Now());
   worker->Cleanup();
   outer_->RemoveFromIdleWorkersStackLockRequired(worker);
@@ -546,7 +499,6 @@
   // returns nullptr, the SchedulerWorker will perform a wait on its
   // WaitableEvent, so we record how many tasks were ran since the last wait
   // here.
-  outer_->num_tasks_between_waits_histogram_->Add(num_tasks_since_last_wait_);
   num_tasks_since_last_wait_ = 0;
   outer_->AddToIdleWorkersStackLockRequired(worker);
   SetIsOnIdleWorkersStackLockRequired(worker);
@@ -843,8 +795,6 @@
   DCHECK_LE(workers_.size(), worker_capacity_);
 
   if (!cleanup_timestamps_.empty()) {
-    detach_duration_histogram_->AddTime(TimeTicks::Now() -
-                                        cleanup_timestamps_.top());
     cleanup_timestamps_.pop();
   }
   return worker.get();
diff --git a/base/task_scheduler/scheduler_worker_pool_impl.h b/base/task_scheduler/scheduler_worker_pool_impl.h
index 997fcc9..d331d3c 100644
--- a/base/task_scheduler/scheduler_worker_pool_impl.h
+++ b/base/task_scheduler/scheduler_worker_pool_impl.h
@@ -34,7 +34,6 @@
 
 namespace base {
 
-class HistogramBase;
 class SchedulerWorkerObserver;
 class SchedulerWorkerPoolParams;
 
@@ -95,16 +94,6 @@
   // SchedulerWorkerPool:
   void JoinForTesting() override;
 
-  const HistogramBase* num_tasks_before_detach_histogram() const {
-    return num_tasks_before_detach_histogram_;
-  }
-
-  const HistogramBase* num_tasks_between_waits_histogram() const {
-    return num_tasks_between_waits_histogram_;
-  }
-
-  void GetHistograms(std::vector<const HistogramBase*>* histograms) const;
-
   // Returns the maximum number of non-blocked tasks that can run concurrently
   // in this pool.
   //
@@ -306,18 +295,6 @@
   AtomicFlag join_for_testing_started_;
 #endif
 
-  // TaskScheduler.DetachDuration.[worker pool name] histogram. Intentionally
-  // leaked.
-  HistogramBase* const detach_duration_histogram_;
-
-  // TaskScheduler.NumTasksBeforeDetach.[worker pool name] histogram.
-  // Intentionally leaked.
-  HistogramBase* const num_tasks_before_detach_histogram_;
-
-  // TaskScheduler.NumTasksBetweenWaits.[worker pool name] histogram.
-  // Intentionally leaked.
-  HistogramBase* const num_tasks_between_waits_histogram_;
-
   scoped_refptr<TaskRunner> service_thread_task_runner_;
 
   // Optional observer notified when a worker enters and exits its main
diff --git a/base/task_scheduler/service_thread.cc b/base/task_scheduler/service_thread.cc
index 40f217f..ce8bf4d 100644
--- a/base/task_scheduler/service_thread.cc
+++ b/base/task_scheduler/service_thread.cc
@@ -13,17 +13,9 @@
 namespace base {
 namespace internal {
 
-ServiceThread::ServiceThread(const TaskTracker* task_tracker)
-    : Thread("TaskSchedulerServiceThread"), task_tracker_(task_tracker) {}
+ServiceThread::ServiceThread() : Thread("TaskSchedulerServiceThread") {}
 
-void ServiceThread::Init() {
-  if (task_tracker_) {
-    heartbeat_latency_timer_.Start(
-        FROM_HERE, TimeDelta::FromSeconds(5),
-        BindRepeating(&ServiceThread::PerformHeartbeatLatencyReport,
-                      Unretained(this)));
-  }
-}
+void ServiceThread::Init() {}
 
 NOINLINE void ServiceThread::Run(RunLoop* run_loop) {
   const int line_number = __LINE__;
@@ -31,23 +23,5 @@
   base::debug::Alias(&line_number);
 }
 
-void ServiceThread::PerformHeartbeatLatencyReport() const {
-  static constexpr TaskTraits kReportedTraits[] = {
-      {TaskPriority::BACKGROUND},    {TaskPriority::BACKGROUND, MayBlock()},
-      {TaskPriority::USER_VISIBLE},  {TaskPriority::USER_VISIBLE, MayBlock()},
-      {TaskPriority::USER_BLOCKING}, {TaskPriority::USER_BLOCKING, MayBlock()}};
-
-  for (auto& traits : kReportedTraits) {
-    // Post through the static API to time the full stack. Use a new Now() for
-    // every set of traits in case PostTaskWithTraits() itself is slow.
-    base::PostTaskWithTraits(
-        FROM_HERE, traits,
-        BindOnce(&TaskTracker::RecordLatencyHistogram,
-                 Unretained(task_tracker_),
-                 TaskTracker::LatencyHistogramType::HEARTBEAT_LATENCY, traits,
-                 TimeTicks::Now()));
-  }
-}
-
 }  // namespace internal
 }  // namespace base
diff --git a/base/task_scheduler/service_thread.h b/base/task_scheduler/service_thread.h
index f9b23fa..14ccd76 100644
--- a/base/task_scheduler/service_thread.h
+++ b/base/task_scheduler/service_thread.h
@@ -27,24 +27,13 @@
   // |task_tracker| if non-null. In that case, this ServiceThread will assume a
   // registered TaskScheduler instance and that |task_tracker| will outlive this
   // ServiceThread.
-  explicit ServiceThread(const TaskTracker* task_tracker);
+  ServiceThread();
 
  private:
   // Thread:
   void Init() override;
   void Run(RunLoop* run_loop) override;
 
-  // Kicks off async tasks which will record a histogram on the latency of
-  // various traits.
-  void PerformHeartbeatLatencyReport() const;
-
-  const TaskTracker* const task_tracker_;
-
-  // Fires a recurring heartbeat task to record latency histograms which are
-  // independent from any execution sequence. This is done on the service thread
-  // to avoid all external dependencies (even main thread).
-  base::RepeatingTimer heartbeat_latency_timer_;
-
   DISALLOW_COPY_AND_ASSIGN(ServiceThread);
 };
 
diff --git a/base/task_scheduler/task_scheduler.h b/base/task_scheduler/task_scheduler.h
index 8881028..3135f8c 100644
--- a/base/task_scheduler/task_scheduler.h
+++ b/base/task_scheduler/task_scheduler.h
@@ -136,9 +136,6 @@
       SingleThreadTaskRunnerThreadMode thread_mode) = 0;
 #endif  // defined(OS_WIN)
 
-  // Returns a vector of all histograms available in this task scheduler.
-  virtual std::vector<const HistogramBase*> GetHistograms() const = 0;
-
   // Synchronously shuts down the scheduler. Once this is called, only tasks
   // posted with the BLOCK_SHUTDOWN behavior will be run. When this returns:
   // - All SKIP_ON_SHUTDOWN tasks that were already running have completed their
diff --git a/base/task_scheduler/task_scheduler_impl.cc b/base/task_scheduler/task_scheduler_impl.cc
index a5ab06c..88250c2 100644
--- a/base/task_scheduler/task_scheduler_impl.cc
+++ b/base/task_scheduler/task_scheduler_impl.cc
@@ -9,7 +9,6 @@
 
 #include "base/compiler_specific.h"
 #include "base/message_loop/message_loop.h"
-#include "base/metrics/field_trial_params.h"
 #include "base/strings/string_util.h"
 #include "base/task_scheduler/delayed_task_manager.h"
 #include "base/task_scheduler/environment_config.h"
@@ -32,7 +31,7 @@
     StringPiece histogram_label,
     std::unique_ptr<TaskTrackerImpl> task_tracker)
     : task_tracker_(std::move(task_tracker)),
-      service_thread_(std::make_unique<ServiceThread>(task_tracker_.get())),
+      service_thread_(std::make_unique<ServiceThread>()),
       single_thread_task_runner_manager_(task_tracker_->GetTrackedRef(),
                                          &delayed_task_manager_) {
   DCHECK(!histogram_label.empty());
@@ -64,13 +63,6 @@
 void TaskSchedulerImpl::Start(
     const TaskScheduler::InitParams& init_params,
     SchedulerWorkerObserver* scheduler_worker_observer) {
-  // This is set in Start() and not in the constructor because variation params
-  // are usually not ready when TaskSchedulerImpl is instantiated in a process.
-  if (base::GetFieldTrialParamValue("BrowserScheduler",
-                                    "AllTasksUserBlocking") == "true") {
-    all_tasks_user_blocking_.Set();
-  }
-
   // Start the service thread. On platforms that support it (POSIX except NaCL
   // SFI), the service thread runs a MessageLoopForIO which is used to support
   // FileDescriptorWatcher in the scope in which tasks run.
@@ -174,14 +166,6 @@
 }
 #endif  // defined(OS_WIN)
 
-std::vector<const HistogramBase*> TaskSchedulerImpl::GetHistograms() const {
-  std::vector<const HistogramBase*> histograms;
-  for (const auto& worker_pool : worker_pools_)
-    worker_pool->GetHistograms(&histograms);
-
-  return histograms;
-}
-
 int TaskSchedulerImpl::GetMaxConcurrentNonBlockedTasksWithTraitsDeprecated(
     const TaskTraits& traits) const {
   return GetWorkerPoolForTraits(traits)
@@ -225,9 +209,7 @@
 
 TaskTraits TaskSchedulerImpl::SetUserBlockingPriorityIfNeeded(
     const TaskTraits& traits) const {
-  return all_tasks_user_blocking_.IsSet()
-             ? TaskTraits::Override(traits, {TaskPriority::USER_BLOCKING})
-             : traits;
+  return traits;
 }
 
 }  // namespace internal
diff --git a/base/task_scheduler/task_scheduler_impl.h b/base/task_scheduler/task_scheduler_impl.h
index 4ad7fc2..f409dc5 100644
--- a/base/task_scheduler/task_scheduler_impl.h
+++ b/base/task_scheduler/task_scheduler_impl.h
@@ -79,7 +79,6 @@
       const TaskTraits& traits,
       SingleThreadTaskRunnerThreadMode thread_mode) override;
 #endif  // defined(OS_WIN)
-  std::vector<const HistogramBase*> GetHistograms() const override;
   int GetMaxConcurrentNonBlockedTasksWithTraitsDeprecated(
       const TaskTraits& traits) const override;
   void Shutdown() override;
@@ -101,14 +100,6 @@
   DelayedTaskManager delayed_task_manager_;
   SchedulerSingleThreadTaskRunnerManager single_thread_task_runner_manager_;
 
-  // Indicates that all tasks are handled as if they had been posted with
-  // TaskPriority::USER_BLOCKING. Since this is set in Start(), it doesn't apply
-  // to tasks posted before Start() or to tasks posted to TaskRunners created
-  // before Start().
-  //
-  // TODO(fdoray): Remove after experiment. https://crbug.com/757022
-  AtomicFlag all_tasks_user_blocking_;
-
   // There are 4 SchedulerWorkerPoolImpl in this array to match the 4
   // SchedulerWorkerPoolParams in TaskScheduler::InitParams.
   std::unique_ptr<SchedulerWorkerPoolImpl> worker_pools_[4];
diff --git a/base/task_scheduler/task_tracker.cc b/base/task_scheduler/task_tracker.cc
index 4fd2356..33424bb 100644
--- a/base/task_scheduler/task_tracker.cc
+++ b/base/task_scheduler/task_tracker.cc
@@ -13,7 +13,6 @@
 #include "base/command_line.h"
 #include "base/json/json_writer.h"
 #include "base/memory/ptr_util.h"
-#include "base/metrics/histogram_macros.h"
 #include "base/sequence_token.h"
 #include "base/strings/string_util.h"
 #include "base/synchronization/condition_variable.h"
@@ -52,45 +51,6 @@
   DISALLOW_COPY_AND_ASSIGN(TaskTracingInfo);
 };
 
-// These name conveys that a Task is posted to/run by the task scheduler without
-// revealing its implementation details.
-constexpr char kQueueFunctionName[] = "TaskScheduler PostTask";
-constexpr char kRunFunctionName[] = "TaskScheduler RunTask";
-
-// Constructs a histogram to track latency which is logging to
-// "TaskScheduler.{histogram_name}.{histogram_label}.{task_type_suffix}".
-HistogramBase* GetLatencyHistogram(StringPiece histogram_name,
-                                   StringPiece histogram_label,
-                                   StringPiece task_type_suffix) {
-  DCHECK(!histogram_name.empty());
-  DCHECK(!histogram_label.empty());
-  DCHECK(!task_type_suffix.empty());
-  // Mimics the UMA_HISTOGRAM_HIGH_RESOLUTION_CUSTOM_TIMES macro. The minimums
-  // and maximums were chosen to place the 1ms mark at around the 70% range
-  // coverage for buckets giving us good info for tasks that have a latency
-  // below 1ms (most of them) and enough info to assess how bad the latency is
-  // for tasks that exceed this threshold.
-  const std::string histogram = JoinString(
-      {"TaskScheduler", histogram_name, histogram_label, task_type_suffix},
-      ".");
-  return Histogram::FactoryMicrosecondsTimeGet(
-      histogram, TimeDelta::FromMicroseconds(1),
-      TimeDelta::FromMilliseconds(20), 50,
-      HistogramBase::kUmaTargetedHistogramFlag);
-}
-
-// Upper bound for the
-// TaskScheduler.BlockShutdownTasksPostedDuringShutdown histogram.
-constexpr HistogramBase::Sample kMaxBlockShutdownTasksPostedDuringShutdown =
-    1000;
-
-void RecordNumBlockShutdownTasksPostedDuringShutdown(
-    HistogramBase::Sample value) {
-  UMA_HISTOGRAM_CUSTOM_COUNTS(
-      "TaskScheduler.BlockShutdownTasksPostedDuringShutdown", value, 1,
-      kMaxBlockShutdownTasksPostedDuringShutdown, 50);
-}
-
 // Returns the maximum number of TaskPriority::BACKGROUND sequences that can be
 // scheduled concurrently based on command line flags.
 int GetMaxNumScheduledBackgroundSequences() {
@@ -235,49 +195,7 @@
       shutdown_lock_(&flush_lock_),
       max_num_scheduled_background_sequences_(
           max_num_scheduled_background_sequences),
-      task_latency_histograms_{
-          {GetLatencyHistogram("TaskLatencyMicroseconds",
-                               histogram_label,
-                               "BackgroundTaskPriority"),
-           GetLatencyHistogram("TaskLatencyMicroseconds",
-                               histogram_label,
-                               "BackgroundTaskPriority_MayBlock")},
-          {GetLatencyHistogram("TaskLatencyMicroseconds",
-                               histogram_label,
-                               "UserVisibleTaskPriority"),
-           GetLatencyHistogram("TaskLatencyMicroseconds",
-                               histogram_label,
-                               "UserVisibleTaskPriority_MayBlock")},
-          {GetLatencyHistogram("TaskLatencyMicroseconds",
-                               histogram_label,
-                               "UserBlockingTaskPriority"),
-           GetLatencyHistogram("TaskLatencyMicroseconds",
-                               histogram_label,
-                               "UserBlockingTaskPriority_MayBlock")}},
-      heartbeat_latency_histograms_{
-          {GetLatencyHistogram("HeartbeatLatencyMicroseconds",
-                               histogram_label,
-                               "BackgroundTaskPriority"),
-           GetLatencyHistogram("HeartbeatLatencyMicroseconds",
-                               histogram_label,
-                               "BackgroundTaskPriority_MayBlock")},
-          {GetLatencyHistogram("HeartbeatLatencyMicroseconds",
-                               histogram_label,
-                               "UserVisibleTaskPriority"),
-           GetLatencyHistogram("HeartbeatLatencyMicroseconds",
-                               histogram_label,
-                               "UserVisibleTaskPriority_MayBlock")},
-          {GetLatencyHistogram("HeartbeatLatencyMicroseconds",
-                               histogram_label,
-                               "UserBlockingTaskPriority"),
-           GetLatencyHistogram("HeartbeatLatencyMicroseconds",
-                               histogram_label,
-                               "UserBlockingTaskPriority_MayBlock")}},
       tracked_ref_factory_(this) {
-  // Confirm that all |task_latency_histograms_| have been initialized above.
-  DCHECK(*(&task_latency_histograms_[static_cast<int>(TaskPriority::HIGHEST) +
-                                     1][0] -
-           1));
 }
 
 TaskTracker::~TaskTracker() = default;
@@ -419,22 +337,9 @@
   state_->StartShutdown();
 }
 
-void TaskTracker::RecordLatencyHistogram(
-    LatencyHistogramType latency_histogram_type,
-    TaskTraits task_traits,
-    TimeTicks posted_time) const {
-  const TimeDelta task_latency = TimeTicks::Now() - posted_time;
-
-  DCHECK(latency_histogram_type == LatencyHistogramType::TASK_LATENCY ||
-         latency_histogram_type == LatencyHistogramType::HEARTBEAT_LATENCY);
-}
-
 void TaskTracker::RunOrSkipTask(Task task,
                                 Sequence* sequence,
                                 bool can_run_task) {
-  RecordLatencyHistogram(LatencyHistogramType::TASK_LATENCY, task.traits,
-                         task.sequenced_time);
-
   const bool previous_singleton_allowed =
       ThreadRestrictions::SetSingletonAllowed(
           task.traits.shutdown_behavior() !=
@@ -488,7 +393,6 @@
 
     // This method can only be called once.
     DCHECK(!shutdown_event_);
-    DCHECK(!num_block_shutdown_tasks_posted_during_shutdown_);
     DCHECK(!state_->HasShutdownStarted());
 
     shutdown_event_.reset(
@@ -523,20 +427,6 @@
     base::ThreadRestrictions::ScopedAllowWait allow_wait;
     shutdown_event_->Wait();
   }
-
-  {
-    AutoSchedulerLock auto_lock(shutdown_lock_);
-
-    // Record TaskScheduler.BlockShutdownTasksPostedDuringShutdown if less than
-    // |kMaxBlockShutdownTasksPostedDuringShutdown| BLOCK_SHUTDOWN tasks were
-    // posted during shutdown. Otherwise, the histogram has already been
-    // recorded in BeforePostTask().
-    if (num_block_shutdown_tasks_posted_during_shutdown_ <
-        kMaxBlockShutdownTasksPostedDuringShutdown) {
-      RecordNumBlockShutdownTasksPostedDuringShutdown(
-          num_block_shutdown_tasks_posted_during_shutdown_);
-    }
-  }
 }
 
 void TaskTracker::SetMaxNumScheduledBackgroundSequences(
@@ -626,18 +516,6 @@
         state_->DecrementNumTasksBlockingShutdown();
         return false;
       }
-
-      ++num_block_shutdown_tasks_posted_during_shutdown_;
-
-      if (num_block_shutdown_tasks_posted_during_shutdown_ ==
-          kMaxBlockShutdownTasksPostedDuringShutdown) {
-        // Record the TaskScheduler.BlockShutdownTasksPostedDuringShutdown
-        // histogram as soon as its upper bound is hit. That way, a value will
-        // be recorded even if an infinite number of BLOCK_SHUTDOWN tasks are
-        // posted, preventing shutdown to complete.
-        RecordNumBlockShutdownTasksPostedDuringShutdown(
-            num_block_shutdown_tasks_posted_during_shutdown_);
-      }
     }
 
     return true;
diff --git a/base/task_scheduler/task_tracker.h b/base/task_scheduler/task_tracker.h
index 760a8f7..ae484ce 100644
--- a/base/task_scheduler/task_tracker.h
+++ b/base/task_scheduler/task_tracker.h
@@ -15,7 +15,6 @@
 #include "base/debug/task_annotator.h"
 #include "base/logging.h"
 #include "base/macros.h"
-#include "base/metrics/histogram_base.h"
 #include "base/strings/string_piece.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/task_scheduler/can_schedule_sequence_observer.h"
@@ -28,7 +27,6 @@
 namespace base {
 
 class ConditionVariable;
-class HistogramBase;
 
 namespace internal {
 
@@ -160,27 +158,11 @@
   // Returns true if shutdown has completed (Shutdown() has returned).
   bool IsShutdownComplete() const;
 
-  enum class LatencyHistogramType {
-    // Records the latency of each individual task posted through TaskTracker.
-    TASK_LATENCY,
-    // Records the latency of heartbeat tasks which are independent of current
-    // workload. These avoid a bias towards TASK_LATENCY reporting that high-
-    // priority tasks are "slower" than regular tasks because high-priority
-    // tasks tend to be correlated with heavy workloads.
-    HEARTBEAT_LATENCY,
-  };
-
   // Causes HasShutdownStarted() to return true. Unlike when Shutdown() returns,
   // IsShutdownComplete() won't return true after this returns. Shutdown()
   // cannot be called after this.
   void SetHasShutdownStartedForTesting();
 
-  // Records |Now() - posted_time| to the appropriate |latency_histogram_type|
-  // based on |task_traits|.
-  void RecordLatencyHistogram(LatencyHistogramType latency_histogram_type,
-                              TaskTraits task_traits,
-                              TimeTicks posted_time) const;
-
   TrackedRef<TaskTracker> GetTrackedRef() {
     return tracked_ref_factory_.GetTrackedRef();
   }
@@ -331,20 +313,6 @@
   // Number of currently scheduled background sequences.
   int num_scheduled_background_sequences_ = 0;
 
-  // TaskScheduler.TaskLatencyMicroseconds.* and
-  // TaskScheduler.HeartbeatLatencyMicroseconds.* histograms. The first index is
-  // a TaskPriority. The second index is 0 for non-blocking tasks, 1 for
-  // blocking tasks. Intentionally leaked.
-  // TODO(scheduler-dev): Consider using STATIC_HISTOGRAM_POINTER_GROUP for
-  // these.
-  static constexpr int kNumTaskPriorities =
-      static_cast<int>(TaskPriority::HIGHEST) + 1;
-  HistogramBase* const task_latency_histograms_[kNumTaskPriorities][2];
-  HistogramBase* const heartbeat_latency_histograms_[kNumTaskPriorities][2];
-
-  // Number of BLOCK_SHUTDOWN tasks posted during shutdown.
-  HistogramBase::Sample num_block_shutdown_tasks_posted_during_shutdown_ = 0;
-
   // Ensures all state (e.g. dangling cleaned up workers) is coalesced before
   // destroying the TaskTracker (e.g. in test environments).
   // Ref. https://crbug.com/827615.
diff --git a/base/test/histogram_tester.cc b/base/test/histogram_tester.cc
deleted file mode 100644
index 2a63b8c..0000000
--- a/base/test/histogram_tester.cc
+++ /dev/null
@@ -1,200 +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/test/histogram_tester.h"
-
-#include <stddef.h>
-
-#include "base/metrics/histogram.h"
-#include "base/metrics/histogram_samples.h"
-#include "base/metrics/metrics_hashes.h"
-#include "base/metrics/sample_map.h"
-#include "base/metrics/statistics_recorder.h"
-#include "base/strings/string_util.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-
-HistogramTester::HistogramTester() {
-  // Record any histogram data that exists when the object is created so it can
-  // be subtracted later.
-  for (const auto* const histogram : StatisticsRecorder::GetHistograms()) {
-    histograms_snapshot_[histogram->histogram_name()] =
-        histogram->SnapshotSamples();
-  }
-}
-
-HistogramTester::~HistogramTester() = default;
-
-void HistogramTester::ExpectUniqueSample(
-    const std::string& name,
-    HistogramBase::Sample sample,
-    HistogramBase::Count expected_count) const {
-  HistogramBase* histogram = StatisticsRecorder::FindHistogram(name);
-  EXPECT_NE(nullptr, histogram) << "Histogram \"" << name
-                                << "\" does not exist.";
-
-  if (histogram) {
-    std::unique_ptr<HistogramSamples> samples = histogram->SnapshotSamples();
-    CheckBucketCount(name, sample, expected_count, *samples);
-    CheckTotalCount(name, expected_count, *samples);
-  }
-}
-
-void HistogramTester::ExpectBucketCount(
-    const std::string& name,
-    HistogramBase::Sample sample,
-    HistogramBase::Count expected_count) const {
-  HistogramBase* histogram = StatisticsRecorder::FindHistogram(name);
-  EXPECT_NE(nullptr, histogram) << "Histogram \"" << name
-                                << "\" does not exist.";
-
-  if (histogram) {
-    std::unique_ptr<HistogramSamples> samples = histogram->SnapshotSamples();
-    CheckBucketCount(name, sample, expected_count, *samples);
-  }
-}
-
-void HistogramTester::ExpectTotalCount(const std::string& name,
-                                       HistogramBase::Count count) const {
-  HistogramBase* histogram = StatisticsRecorder::FindHistogram(name);
-  if (histogram) {
-    std::unique_ptr<HistogramSamples> samples = histogram->SnapshotSamples();
-    CheckTotalCount(name, count, *samples);
-  } else {
-    // No histogram means there were zero samples.
-    EXPECT_EQ(count, 0) << "Histogram \"" << name << "\" does not exist.";
-  }
-}
-
-void HistogramTester::ExpectTimeBucketCount(const std::string& name,
-                                            TimeDelta sample,
-                                            HistogramBase::Count count) const {
-  ExpectBucketCount(name, sample.InMilliseconds(), count);
-}
-
-std::vector<Bucket> HistogramTester::GetAllSamples(
-    const std::string& name) const {
-  std::vector<Bucket> samples;
-  std::unique_ptr<HistogramSamples> snapshot =
-      GetHistogramSamplesSinceCreation(name);
-  if (snapshot) {
-    for (auto it = snapshot->Iterator(); !it->Done(); it->Next()) {
-      HistogramBase::Sample sample;
-      HistogramBase::Count count;
-      it->Get(&sample, nullptr, &count);
-      samples.push_back(Bucket(sample, count));
-    }
-  }
-  return samples;
-}
-
-HistogramBase::Count HistogramTester::GetBucketCount(
-    const std::string& name,
-    HistogramBase::Sample sample) const {
-  HistogramBase* histogram = StatisticsRecorder::FindHistogram(name);
-  EXPECT_NE(nullptr, histogram)
-      << "Histogram \"" << name << "\" does not exist.";
-  HistogramBase::Count count = 0;
-  if (histogram) {
-    std::unique_ptr<HistogramSamples> samples = histogram->SnapshotSamples();
-    GetBucketCountForSamples(name, sample, *samples, &count);
-  }
-  return count;
-}
-
-void HistogramTester::GetBucketCountForSamples(
-    const std::string& name,
-    HistogramBase::Sample sample,
-    const HistogramSamples& samples,
-    HistogramBase::Count* count) const {
-  *count = samples.GetCount(sample);
-  auto histogram_data = histograms_snapshot_.find(name);
-  if (histogram_data != histograms_snapshot_.end())
-    *count -= histogram_data->second->GetCount(sample);
-}
-
-HistogramTester::CountsMap HistogramTester::GetTotalCountsForPrefix(
-    const std::string& prefix) const {
-  EXPECT_TRUE(prefix.find('.') != std::string::npos)
-      << "|prefix| ought to contain at least one period, to avoid matching too"
-      << " many histograms.";
-
-  CountsMap result;
-
-  // Find candidate matches by using the logic built into GetSnapshot().
-  for (const HistogramBase* histogram : StatisticsRecorder::GetHistograms()) {
-    if (!StartsWith(histogram->histogram_name(), prefix,
-                    CompareCase::SENSITIVE)) {
-      continue;
-    }
-    std::unique_ptr<HistogramSamples> new_samples =
-        GetHistogramSamplesSinceCreation(histogram->histogram_name());
-    // Omit unchanged histograms from the result.
-    if (new_samples->TotalCount()) {
-      result[histogram->histogram_name()] = new_samples->TotalCount();
-    }
-  }
-  return result;
-}
-
-std::unique_ptr<HistogramSamples>
-HistogramTester::GetHistogramSamplesSinceCreation(
-    const std::string& histogram_name) const {
-  HistogramBase* histogram = StatisticsRecorder::FindHistogram(histogram_name);
-  // Whether the histogram exists or not may not depend on the current test
-  // calling this method, but rather on which tests ran before and possibly
-  // generated a histogram or not (see http://crbug.com/473689). To provide a
-  // response which is independent of the previously run tests, this method
-  // creates empty samples in the absence of the histogram, rather than
-  // returning null.
-  if (!histogram) {
-    return std::unique_ptr<HistogramSamples>(
-        new SampleMap(HashMetricName(histogram_name)));
-  }
-  std::unique_ptr<HistogramSamples> named_samples =
-      histogram->SnapshotSamples();
-  auto original_samples_it = histograms_snapshot_.find(histogram_name);
-  if (original_samples_it != histograms_snapshot_.end())
-    named_samples->Subtract(*original_samples_it->second.get());
-  return named_samples;
-}
-
-void HistogramTester::CheckBucketCount(const std::string& name,
-                                       HistogramBase::Sample sample,
-                                       HistogramBase::Count expected_count,
-                                       const HistogramSamples& samples) const {
-  int actual_count;
-  GetBucketCountForSamples(name, sample, samples, &actual_count);
-
-  EXPECT_EQ(expected_count, actual_count)
-      << "Histogram \"" << name
-      << "\" does not have the right number of samples (" << expected_count
-      << ") in the expected bucket (" << sample << "). It has (" << actual_count
-      << ").";
-}
-
-void HistogramTester::CheckTotalCount(const std::string& name,
-                                      HistogramBase::Count expected_count,
-                                      const HistogramSamples& samples) const {
-  int actual_count = samples.TotalCount();
-  auto histogram_data = histograms_snapshot_.find(name);
-  if (histogram_data != histograms_snapshot_.end())
-    actual_count -= histogram_data->second->TotalCount();
-
-  EXPECT_EQ(expected_count, actual_count)
-      << "Histogram \"" << name
-      << "\" does not have the right total number of samples ("
-      << expected_count << "). It has (" << actual_count << ").";
-}
-
-bool Bucket::operator==(const Bucket& other) const {
-  return min == other.min && count == other.count;
-}
-
-void PrintTo(const Bucket& bucket, std::ostream* os) {
-  *os << "Bucket " << bucket.min << ": " << bucket.count;
-}
-
-}  // namespace base
diff --git a/base/test/histogram_tester.h b/base/test/histogram_tester.h
deleted file mode 100644
index 8019931..0000000
--- a/base/test/histogram_tester.h
+++ /dev/null
@@ -1,174 +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_TEST_HISTOGRAM_TESTER_H_
-#define BASE_TEST_HISTOGRAM_TESTER_H_
-
-#include <map>
-#include <memory>
-#include <ostream>
-#include <string>
-#include <utility>
-#include <vector>
-
-#include "base/macros.h"
-#include "base/metrics/histogram.h"
-#include "base/metrics/histogram_base.h"
-#include "base/time/time.h"
-
-namespace base {
-
-struct Bucket;
-class HistogramSamples;
-
-// HistogramTester provides a simple interface for examining histograms, UMA
-// or otherwise. Tests can use this interface to verify that histogram data is
-// getting logged as intended.
-//
-// Note: When using this class from a browser test, one might have to call
-// SubprocessMetricsProvider::MergeHistogramDeltasForTesting() to sync the
-// histogram data between the renderer and browser processes. If it is in a
-// content browser test, then content::FetchHistogramsFromChildProcesses()
-// should be used to achieve that.
-class HistogramTester {
- public:
-  using CountsMap = std::map<std::string, HistogramBase::Count>;
-
-  // Takes a snapshot of all current histograms counts.
-  HistogramTester();
-  ~HistogramTester();
-
-  // We know the exact number of samples in a bucket, and that no other bucket
-  // should have samples. Measures the diff from the snapshot taken when this
-  // object was constructed.
-  void ExpectUniqueSample(const std::string& name,
-                          HistogramBase::Sample sample,
-                          HistogramBase::Count expected_count) const;
-  template <typename T>
-  void ExpectUniqueSample(const std::string& name,
-                          T sample,
-                          HistogramBase::Count expected_count) const {
-    ExpectUniqueSample(name, static_cast<HistogramBase::Sample>(sample),
-                       expected_count);
-  }
-
-  // We know the exact number of samples in a bucket, but other buckets may
-  // have samples as well. Measures the diff from the snapshot taken when this
-  // object was constructed.
-  void ExpectBucketCount(const std::string& name,
-                         HistogramBase::Sample sample,
-                         HistogramBase::Count expected_count) const;
-  template <typename T>
-  void ExpectBucketCount(const std::string& name,
-                         T sample,
-                         HistogramBase::Count expected_count) const {
-    ExpectBucketCount(name, static_cast<HistogramBase::Sample>(sample),
-                      expected_count);
-  }
-
-  // We don't know the values of the samples, but we know how many there are.
-  // This measures the diff from the snapshot taken when this object was
-  // constructed.
-  void ExpectTotalCount(const std::string& name,
-                        HistogramBase::Count count) const;
-
-  // We know exact number of samples for buckets corresponding to a time
-  // interval. Other intervals may have samples too.
-  void ExpectTimeBucketCount(const std::string& name,
-                             TimeDelta sample,
-                             HistogramBase::Count count) const;
-
-  // Returns a list of all of the buckets recorded since creation of this
-  // object, as vector<Bucket>, where the Bucket represents the min boundary of
-  // the bucket and the count of samples recorded to that bucket since creation.
-  //
-  // Example usage, using gMock:
-  //   EXPECT_THAT(histogram_tester.GetAllSamples("HistogramName"),
-  //               ElementsAre(Bucket(1, 5), Bucket(2, 10), Bucket(3, 5)));
-  //
-  // If you build the expected list programmatically, you can use ContainerEq:
-  //   EXPECT_THAT(histogram_tester.GetAllSamples("HistogramName"),
-  //               ContainerEq(expected_buckets));
-  //
-  // or EXPECT_EQ if you prefer not to depend on gMock, at the expense of a
-  // slightly less helpful failure message:
-  //   EXPECT_EQ(expected_buckets,
-  //             histogram_tester.GetAllSamples("HistogramName"));
-  std::vector<Bucket> GetAllSamples(const std::string& name) const;
-
-  // Returns the value of the |sample| bucket for ths histogram |name|.
-  HistogramBase::Count GetBucketCount(const std::string& name,
-                                      HistogramBase::Sample sample) const;
-
-  // Finds histograms whose names start with |prefix|, and returns them along
-  // with the counts of any samples added since the creation of this object.
-  // Histograms that are unchanged are omitted from the result. The return value
-  // is a map whose keys are the histogram name, and whose values are the sample
-  // count.
-  //
-  // This is useful for cases where the code under test is choosing among a
-  // family of related histograms and incrementing one of them. Typically you
-  // should pass the result of this function directly to EXPECT_THAT.
-  //
-  // Example usage, using gmock (which produces better failure messages):
-  //   #include "testing/gmock/include/gmock/gmock.h"
-  // ...
-  //   base::HistogramTester::CountsMap expected_counts;
-  //   expected_counts["MyMetric.A"] = 1;
-  //   expected_counts["MyMetric.B"] = 1;
-  //   EXPECT_THAT(histogram_tester.GetTotalCountsForPrefix("MyMetric."),
-  //               testing::ContainerEq(expected_counts));
-  CountsMap GetTotalCountsForPrefix(const std::string& prefix) const;
-
-  // Access a modified HistogramSamples containing only what has been logged
-  // to the histogram since the creation of this object.
-  std::unique_ptr<HistogramSamples> GetHistogramSamplesSinceCreation(
-      const std::string& histogram_name) const;
-
- private:
-  // Verifies and asserts that value in the |sample| bucket matches the
-  // |expected_count|. The bucket's current value is determined from |samples|
-  // and is modified based on the snapshot stored for histogram |name|.
-  void CheckBucketCount(const std::string& name,
-                        HistogramBase::Sample sample,
-                        Histogram::Count expected_count,
-                        const HistogramSamples& samples) const;
-
-  // Verifies that the total number of values recorded for the histogram |name|
-  // is |expected_count|. This is checked against |samples| minus the snapshot
-  // that was taken for |name|.
-  void CheckTotalCount(const std::string& name,
-                       Histogram::Count expected_count,
-                       const HistogramSamples& samples) const;
-
-  // Sets the value for |count| to be the value in the |sample| bucket. The
-  // bucket's current value is determined from |samples| and is modified based
-  // on the snapshot stored for histogram |name|.
-  void GetBucketCountForSamples(const std::string& name,
-                                HistogramBase::Sample sample,
-                                const HistogramSamples& samples,
-                                HistogramBase::Count* count) const;
-
-  // Used to determine the histogram changes made during this instance's
-  // lifecycle.
-  std::map<std::string, std::unique_ptr<HistogramSamples>> histograms_snapshot_;
-
-  DISALLOW_COPY_AND_ASSIGN(HistogramTester);
-};
-
-struct Bucket {
-  Bucket(HistogramBase::Sample min, HistogramBase::Count count)
-      : min(min), count(count) {}
-
-  bool operator==(const Bucket& other) const;
-
-  HistogramBase::Sample min;
-  HistogramBase::Count count;
-};
-
-void PrintTo(const Bucket& value, std::ostream* os);
-
-}  // namespace base
-
-#endif  // BASE_TEST_HISTOGRAM_TESTER_H_
diff --git a/base/threading/platform_thread_posix.cc b/base/threading/platform_thread_posix.cc
index a5ddb2e..c3a071b 100644
--- a/base/threading/platform_thread_posix.cc
+++ b/base/threading/platform_thread_posix.cc
@@ -15,7 +15,6 @@
 
 #include <memory>
 
-#include "base/debug/activity_tracker.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/threading/platform_thread_internal_posix.h"
@@ -220,9 +219,6 @@
 
 // static
 void PlatformThread::Join(PlatformThreadHandle thread_handle) {
-  // Record the event that this thread is blocking upon (for hang diagnosis).
-  base::debug::ScopedThreadJoinActivity thread_activity(&thread_handle);
-
   // Joining another thread may block the current thread for a long time, since
   // the thread referred to by |thread_handle| may still be running long-lived /
   // blocking tasks.
diff --git a/build/gen.py b/build/gen.py
index 988cc58..37592d4 100755
--- a/build/gen.py
+++ b/build/gen.py
@@ -237,7 +237,6 @@
         'base/callback_helpers.cc',
         'base/callback_internal.cc',
         'base/command_line.cc',
-        'base/debug/activity_tracker.cc',
         'base/debug/alias.cc',
         'base/debug/crash_logging.cc',
         'base/debug/dump_without_crashing.cc',
@@ -245,14 +244,12 @@
         'base/debug/task_annotator.cc',
         'base/debug/thread_heap_usage_tracker.cc',
         'base/environment.cc',
-        'base/feature_list.cc',
         'base/files/file.cc',
         'base/files/file_enumerator.cc',
         'base/files/file_path.cc',
         'base/files/file_path_constants.cc',
         'base/files/file_tracing.cc',
         'base/files/file_util.cc',
-        'base/files/important_file_writer.cc',
         'base/files/memory_mapped_file.cc',
         'base/files/scoped_file.cc',
         'base/files/scoped_temp_dir.cc',
@@ -281,24 +278,6 @@
         'base/message_loop/message_pump.cc',
         'base/message_loop/message_pump_default.cc',
         'base/message_loop/watchable_io_message_pump_posix.cc',
-        'base/metrics/bucket_ranges.cc',
-        'base/metrics/dummy_histogram.cc',
-        'base/metrics/field_trial.cc',
-        'base/metrics/field_trial_param_associator.cc',
-        'base/metrics/field_trial_params.cc',
-        'base/metrics/histogram.cc',
-        'base/metrics/histogram_base.cc',
-        'base/metrics/histogram_functions.cc',
-        'base/metrics/histogram_samples.cc',
-        'base/metrics/histogram_snapshot_manager.cc',
-        'base/metrics/metrics_hashes.cc',
-        'base/metrics/persistent_histogram_allocator.cc',
-        'base/metrics/persistent_memory_allocator.cc',
-        'base/metrics/persistent_sample_map.cc',
-        'base/metrics/sample_map.cc',
-        'base/metrics/sample_vector.cc',
-        'base/metrics/sparse_histogram.cc',
-        'base/metrics/statistics_recorder.cc',
         'base/observer_list_threadsafe.cc',
         'base/path_service.cc',
         'base/pending_task.cc',