diff --git a/base/memory/OWNERS b/base/memory/OWNERS
deleted file mode 100644
index 9b7cbb1..0000000
--- a/base/memory/OWNERS
+++ /dev/null
@@ -1,4 +0,0 @@
-per-file *chromeos*=skuhne@chromium.org
-per-file *chromeos*=oshima@chromium.org
-per-file *shared_memory*=set noparent
-per-file *shared_memory*=file://ipc/SECURITY_OWNERS
diff --git a/base/memory/aligned_memory.cc b/base/memory/aligned_memory.cc
deleted file mode 100644
index 861ea50..0000000
--- a/base/memory/aligned_memory.cc
+++ /dev/null
@@ -1,47 +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/memory/aligned_memory.h"
-
-#include "base/logging.h"
-#include "build_config.h"
-
-#if defined(OS_ANDROID)
-#include <malloc.h>
-#endif
-
-namespace base {
-
-void* AlignedAlloc(size_t size, size_t alignment) {
-  DCHECK_GT(size, 0U);
-  DCHECK_EQ(alignment & (alignment - 1), 0U);
-  DCHECK_EQ(alignment % sizeof(void*), 0U);
-  void* ptr = nullptr;
-#if defined(COMPILER_MSVC)
-  ptr = _aligned_malloc(size, alignment);
-// Android technically supports posix_memalign(), but does not expose it in
-// the current version of the library headers used by Chrome.  Luckily,
-// memalign() on Android returns pointers which can safely be used with
-// free(), so we can use it instead.  Issue filed to document this:
-// http://code.google.com/p/android/issues/detail?id=35391
-#elif defined(OS_ANDROID)
-  ptr = memalign(alignment, size);
-#else
-  if (posix_memalign(&ptr, alignment, size))
-    ptr = nullptr;
-#endif
-  // Since aligned allocations may fail for non-memory related reasons, force a
-  // crash if we encounter a failed allocation; maintaining consistent behavior
-  // with a normal allocation failure in Chrome.
-  if (!ptr) {
-    DLOG(ERROR) << "If you crashed here, your aligned allocation is incorrect: "
-                << "size=" << size << ", alignment=" << alignment;
-    CHECK(false);
-  }
-  // Sanity check alignment just to be safe.
-  DCHECK_EQ(reinterpret_cast<uintptr_t>(ptr) & (alignment - 1), 0U);
-  return ptr;
-}
-
-}  // namespace base
diff --git a/base/memory/aligned_memory.h b/base/memory/aligned_memory.h
deleted file mode 100644
index e0dd7f5..0000000
--- a/base/memory/aligned_memory.h
+++ /dev/null
@@ -1,58 +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_MEMORY_ALIGNED_MEMORY_H_
-#define BASE_MEMORY_ALIGNED_MEMORY_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-#include <type_traits>
-
-#include "base/base_export.h"
-#include "base/compiler_specific.h"
-#include "build_config.h"
-
-#if defined(COMPILER_MSVC)
-#include <malloc.h>
-#else
-#include <stdlib.h>
-#endif
-
-// A runtime sized aligned allocation can be created:
-//
-//   float* my_array = static_cast<float*>(AlignedAlloc(size, alignment));
-//
-//   // ... later, to release the memory:
-//   AlignedFree(my_array);
-//
-// Or using unique_ptr:
-//
-//   std::unique_ptr<float, AlignedFreeDeleter> my_array(
-//       static_cast<float*>(AlignedAlloc(size, alignment)));
-
-namespace base {
-
-// This can be replaced with std::aligned_malloc when we have C++17.
-BASE_EXPORT void* AlignedAlloc(size_t size, size_t alignment);
-
-inline void AlignedFree(void* ptr) {
-#if defined(COMPILER_MSVC)
-  _aligned_free(ptr);
-#else
-  free(ptr);
-#endif
-}
-
-// Deleter for use with unique_ptr. E.g., use as
-//   std::unique_ptr<Foo, base::AlignedFreeDeleter> foo;
-struct AlignedFreeDeleter {
-  inline void operator()(void* ptr) const {
-    AlignedFree(ptr);
-  }
-};
-
-}  // namespace base
-
-#endif  // BASE_MEMORY_ALIGNED_MEMORY_H_
diff --git a/base/memory/discardable_memory.cc b/base/memory/discardable_memory.cc
deleted file mode 100644
index f0730aa..0000000
--- a/base/memory/discardable_memory.cc
+++ /dev/null
@@ -1,13 +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/memory/discardable_memory.h"
-
-namespace base {
-
-DiscardableMemory::DiscardableMemory() = default;
-
-DiscardableMemory::~DiscardableMemory() = default;
-
-}  // namespace base
diff --git a/base/memory/discardable_memory.h b/base/memory/discardable_memory.h
deleted file mode 100644
index 5c632d1..0000000
--- a/base/memory/discardable_memory.h
+++ /dev/null
@@ -1,78 +0,0 @@
-// Copyright (c) 2013 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_MEMORY_DISCARDABLE_MEMORY_H_
-#define BASE_MEMORY_DISCARDABLE_MEMORY_H_
-
-#include "base/base_export.h"
-#include "base/compiler_specific.h"
-
-namespace base {
-
-namespace trace_event {
-class MemoryAllocatorDump;
-class ProcessMemoryDump;
-}
-
-// Discardable memory is used to cache large objects without worrying about
-// blowing out memory, both on mobile devices where there is no swap, and
-// desktop devices where unused free memory should be used to help the user
-// experience. This is preferable to releasing memory in response to an OOM
-// signal because it is simpler and provides system-wide management of
-// purgable memory, though it has less flexibility as to which objects get
-// discarded.
-//
-// Discardable memory has two states: locked and unlocked. While the memory is
-// locked, it will not be discarded. Unlocking the memory allows the
-// discardable memory system and the OS to reclaim it if needed. Locks do not
-// nest.
-//
-// Notes:
-//   - The paging behavior of memory while it is locked is not specified. While
-//     mobile platforms will not swap it out, it may qualify for swapping
-//     on desktop platforms. It is not expected that this will matter, as the
-//     preferred pattern of usage for DiscardableMemory is to lock down the
-//     memory, use it as quickly as possible, and then unlock it.
-//   - Because of memory alignment, the amount of memory allocated can be
-//     larger than the requested memory size. It is not very efficient for
-//     small allocations.
-//   - A discardable memory instance is not thread safe. It is the
-//     responsibility of users of discardable memory to ensure there are no
-//     races.
-//
-class BASE_EXPORT DiscardableMemory {
- public:
-  DiscardableMemory();
-  virtual ~DiscardableMemory();
-
-  // Locks the memory so that it will not be purged by the system. Returns
-  // true on success. If the return value is false then this object should be
-  // discarded and a new one should be created.
-  virtual bool Lock() WARN_UNUSED_RESULT = 0;
-
-  // Unlocks the memory so that it can be purged by the system. Must be called
-  // after every successful lock call.
-  virtual void Unlock() = 0;
-
-  // Returns the memory address held by this object. The object must be locked
-  // before calling this.
-  virtual void* data() const = 0;
-
-  // Handy method to simplify calling data() with a reinterpret_cast.
-  template<typename T> T* data_as() const {
-    return reinterpret_cast<T*>(data());
-  }
-
-  // Used for dumping the statistics of discardable memory allocated in tracing.
-  // Returns a new MemoryAllocatorDump in the |pmd| with the size of the
-  // discardable memory. The MemoryAllocatorDump created is owned by |pmd|. See
-  // ProcessMemoryDump::CreateAllocatorDump.
-  virtual trace_event::MemoryAllocatorDump* CreateMemoryAllocatorDump(
-      const char* name,
-      trace_event::ProcessMemoryDump* pmd) const = 0;
-};
-
-}  // namespace base
-
-#endif  // BASE_MEMORY_DISCARDABLE_MEMORY_H_
diff --git a/base/memory/discardable_memory_allocator.cc b/base/memory/discardable_memory_allocator.cc
deleted file mode 100644
index 3dbb276..0000000
--- a/base/memory/discardable_memory_allocator.cc
+++ /dev/null
@@ -1,29 +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/memory/discardable_memory_allocator.h"
-
-#include "base/logging.h"
-
-namespace base {
-namespace {
-
-DiscardableMemoryAllocator* g_discardable_allocator = nullptr;
-
-}  // namespace
-
-// static
-void DiscardableMemoryAllocator::SetInstance(
-    DiscardableMemoryAllocator* allocator) {
-  DCHECK(!allocator || !g_discardable_allocator);
-  g_discardable_allocator = allocator;
-}
-
-// static
-DiscardableMemoryAllocator* DiscardableMemoryAllocator::GetInstance() {
-  DCHECK(g_discardable_allocator);
-  return g_discardable_allocator;
-}
-
-}  // namespace base
diff --git a/base/memory/discardable_memory_allocator.h b/base/memory/discardable_memory_allocator.h
deleted file mode 100644
index 8d74b16..0000000
--- a/base/memory/discardable_memory_allocator.h
+++ /dev/null
@@ -1,38 +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_MEMORY_DISCARDABLE_MEMORY_ALLOCATOR_H_
-#define BASE_MEMORY_DISCARDABLE_MEMORY_ALLOCATOR_H_
-
-#include <stddef.h>
-
-#include <memory>
-
-#include "base/base_export.h"
-
-namespace base {
-class DiscardableMemory;
-
-class BASE_EXPORT DiscardableMemoryAllocator {
- public:
-  // Returns the allocator instance.
-  static DiscardableMemoryAllocator* GetInstance();
-
-  // Sets the allocator instance. Can only be called once, e.g. on startup.
-  // Ownership of |instance| remains with the caller.
-  static void SetInstance(DiscardableMemoryAllocator* allocator);
-
-  // Giant WARNING: Discardable[Shared]Memory is only implemented on Android. On
-  // non-Android platforms, it behaves exactly the same as SharedMemory.
-  // See LockPages() in discardable_shared_memory.cc.
-  virtual std::unique_ptr<DiscardableMemory> AllocateLockedDiscardableMemory(
-      size_t size) = 0;
-
- protected:
-  virtual ~DiscardableMemoryAllocator() = default;
-};
-
-}  // namespace base
-
-#endif  // BASE_MEMORY_DISCARDABLE_MEMORY_ALLOCATOR_H_
diff --git a/base/memory/discardable_shared_memory.cc b/base/memory/discardable_shared_memory.cc
deleted file mode 100644
index 8601e21..0000000
--- a/base/memory/discardable_shared_memory.cc
+++ /dev/null
@@ -1,514 +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/memory/discardable_shared_memory.h"
-
-#include <stdint.h>
-
-#include <algorithm>
-
-#include "base/atomicops.h"
-#include "base/bits.h"
-#include "base/logging.h"
-#include "base/memory/shared_memory_tracker.h"
-#include "base/numerics/safe_math.h"
-#include "base/process/process_metrics.h"
-#include "base/trace_event/memory_allocator_dump.h"
-#include "base/trace_event/process_memory_dump.h"
-#include "build_config.h"
-
-#if defined(OS_POSIX) && !defined(OS_NACL)
-// For madvise() which is available on all POSIX compatible systems.
-#include <sys/mman.h>
-#endif
-
-#if defined(OS_ANDROID)
-#include "third_party/ashmem/ashmem.h"
-#endif
-
-#if defined(OS_WIN)
-#include <windows.h>
-#include "base/win/windows_version.h"
-#endif
-
-namespace base {
-namespace {
-
-// Use a machine-sized pointer as atomic type. It will use the Atomic32 or
-// Atomic64 routines, depending on the architecture.
-typedef intptr_t AtomicType;
-typedef uintptr_t UAtomicType;
-
-// Template specialization for timestamp serialization/deserialization. This
-// is used to serialize timestamps using Unix time on systems where AtomicType
-// does not have enough precision to contain a timestamp in the standard
-// serialized format.
-template <int>
-Time TimeFromWireFormat(int64_t value);
-template <int>
-int64_t TimeToWireFormat(Time time);
-
-// Serialize to Unix time when using 4-byte wire format.
-// Note: 19 January 2038, this will cease to work.
-template <>
-Time ALLOW_UNUSED_TYPE TimeFromWireFormat<4>(int64_t value) {
-  return value ? Time::UnixEpoch() + TimeDelta::FromSeconds(value) : Time();
-}
-template <>
-int64_t ALLOW_UNUSED_TYPE TimeToWireFormat<4>(Time time) {
-  return time > Time::UnixEpoch() ? (time - Time::UnixEpoch()).InSeconds() : 0;
-}
-
-// Standard serialization format when using 8-byte wire format.
-template <>
-Time ALLOW_UNUSED_TYPE TimeFromWireFormat<8>(int64_t value) {
-  return Time::FromInternalValue(value);
-}
-template <>
-int64_t ALLOW_UNUSED_TYPE TimeToWireFormat<8>(Time time) {
-  return time.ToInternalValue();
-}
-
-struct SharedState {
-  enum LockState { UNLOCKED = 0, LOCKED = 1 };
-
-  explicit SharedState(AtomicType ivalue) { value.i = ivalue; }
-  SharedState(LockState lock_state, Time timestamp) {
-    int64_t wire_timestamp = TimeToWireFormat<sizeof(AtomicType)>(timestamp);
-    DCHECK_GE(wire_timestamp, 0);
-    DCHECK_EQ(lock_state & ~1, 0);
-    value.u = (static_cast<UAtomicType>(wire_timestamp) << 1) | lock_state;
-  }
-
-  LockState GetLockState() const { return static_cast<LockState>(value.u & 1); }
-
-  Time GetTimestamp() const {
-    return TimeFromWireFormat<sizeof(AtomicType)>(value.u >> 1);
-  }
-
-  // Bit 1: Lock state. Bit is set when locked.
-  // Bit 2..sizeof(AtomicType)*8: Usage timestamp. NULL time when locked or
-  // purged.
-  union {
-    AtomicType i;
-    UAtomicType u;
-  } value;
-};
-
-// Shared state is stored at offset 0 in shared memory segments.
-SharedState* SharedStateFromSharedMemory(
-    const WritableSharedMemoryMapping& shared_memory) {
-  DCHECK(shared_memory.IsValid());
-  return static_cast<SharedState*>(shared_memory.memory());
-}
-
-// Round up |size| to a multiple of page size.
-size_t AlignToPageSize(size_t size) {
-  return bits::Align(size, base::GetPageSize());
-}
-
-}  // namespace
-
-DiscardableSharedMemory::DiscardableSharedMemory()
-    : mapped_size_(0), locked_page_count_(0) {
-}
-
-DiscardableSharedMemory::DiscardableSharedMemory(
-    UnsafeSharedMemoryRegion shared_memory_region)
-    : shared_memory_region_(std::move(shared_memory_region)),
-      mapped_size_(0),
-      locked_page_count_(0) {}
-
-DiscardableSharedMemory::~DiscardableSharedMemory() = default;
-
-bool DiscardableSharedMemory::CreateAndMap(size_t size) {
-  CheckedNumeric<size_t> checked_size = size;
-  checked_size += AlignToPageSize(sizeof(SharedState));
-  if (!checked_size.IsValid())
-    return false;
-
-  shared_memory_region_ =
-      UnsafeSharedMemoryRegion::Create(checked_size.ValueOrDie());
-
-  if (!shared_memory_region_.IsValid())
-    return false;
-
-  shared_memory_mapping_ = shared_memory_region_.Map();
-  if (!shared_memory_mapping_.IsValid())
-    return false;
-
-  mapped_size_ = shared_memory_mapping_.mapped_size() -
-                 AlignToPageSize(sizeof(SharedState));
-
-  locked_page_count_ = AlignToPageSize(mapped_size_) / base::GetPageSize();
-#if DCHECK_IS_ON()
-  for (size_t page = 0; page < locked_page_count_; ++page)
-    locked_pages_.insert(page);
-#endif
-
-  DCHECK(last_known_usage_.is_null());
-  SharedState new_state(SharedState::LOCKED, Time());
-  subtle::Release_Store(
-      &SharedStateFromSharedMemory(shared_memory_mapping_)->value.i,
-      new_state.value.i);
-  return true;
-}
-
-bool DiscardableSharedMemory::Map(size_t size) {
-  DCHECK(!shared_memory_mapping_.IsValid());
-  if (shared_memory_mapping_.IsValid())
-    return false;
-
-  shared_memory_mapping_ = shared_memory_region_.MapAt(
-      0, AlignToPageSize(sizeof(SharedState)) + size);
-  if (!shared_memory_mapping_.IsValid())
-    return false;
-
-  mapped_size_ = shared_memory_mapping_.mapped_size() -
-                 AlignToPageSize(sizeof(SharedState));
-
-  locked_page_count_ = AlignToPageSize(mapped_size_) / base::GetPageSize();
-#if DCHECK_IS_ON()
-  for (size_t page = 0; page < locked_page_count_; ++page)
-    locked_pages_.insert(page);
-#endif
-
-  return true;
-}
-
-bool DiscardableSharedMemory::Unmap() {
-  if (!shared_memory_mapping_.IsValid())
-    return false;
-
-  shared_memory_mapping_ = WritableSharedMemoryMapping();
-  locked_page_count_ = 0;
-#if DCHECK_IS_ON()
-  locked_pages_.clear();
-#endif
-  mapped_size_ = 0;
-  return true;
-}
-
-DiscardableSharedMemory::LockResult DiscardableSharedMemory::Lock(
-    size_t offset, size_t length) {
-  DCHECK_EQ(AlignToPageSize(offset), offset);
-  DCHECK_EQ(AlignToPageSize(length), length);
-
-  // Calls to this function must be synchronized properly.
-  DFAKE_SCOPED_LOCK(thread_collision_warner_);
-
-  DCHECK(shared_memory_mapping_.IsValid());
-
-  // We need to successfully acquire the platform independent lock before
-  // individual pages can be locked.
-  if (!locked_page_count_) {
-    // Return false when instance has been purged or not initialized properly
-    // by checking if |last_known_usage_| is NULL.
-    if (last_known_usage_.is_null())
-      return FAILED;
-
-    SharedState old_state(SharedState::UNLOCKED, last_known_usage_);
-    SharedState new_state(SharedState::LOCKED, Time());
-    SharedState result(subtle::Acquire_CompareAndSwap(
-        &SharedStateFromSharedMemory(shared_memory_mapping_)->value.i,
-        old_state.value.i, new_state.value.i));
-    if (result.value.u != old_state.value.u) {
-      // Update |last_known_usage_| in case the above CAS failed because of
-      // an incorrect timestamp.
-      last_known_usage_ = result.GetTimestamp();
-      return FAILED;
-    }
-  }
-
-  // Zero for length means "everything onward".
-  if (!length)
-    length = AlignToPageSize(mapped_size_) - offset;
-
-  size_t start = offset / base::GetPageSize();
-  size_t end = start + length / base::GetPageSize();
-  DCHECK_LE(start, end);
-  DCHECK_LE(end, AlignToPageSize(mapped_size_) / base::GetPageSize());
-
-  // Add pages to |locked_page_count_|.
-  // Note: Locking a page that is already locked is an error.
-  locked_page_count_ += end - start;
-#if DCHECK_IS_ON()
-  // Detect incorrect usage by keeping track of exactly what pages are locked.
-  for (auto page = start; page < end; ++page) {
-    auto result = locked_pages_.insert(page);
-    DCHECK(result.second);
-  }
-  DCHECK_EQ(locked_pages_.size(), locked_page_count_);
-#endif
-
-  // Always behave as if memory was purged when trying to lock a 0 byte segment.
-  if (!length)
-      return PURGED;
-
-#if defined(OS_ANDROID)
-  // Ensure that the platform won't discard the required pages.
-  return LockPages(shared_memory_region_,
-                   AlignToPageSize(sizeof(SharedState)) + offset, length);
-#elif defined(OS_MACOSX)
-  // On macOS, there is no mechanism to lock pages. However, we do need to call
-  // madvise(MADV_FREE_REUSE) in order to correctly update accounting for memory
-  // footprint via task_info().
-  //
-  // Note that calling madvise(MADV_FREE_REUSE) on regions that haven't had
-  // madvise(MADV_FREE_REUSABLE) called on them has no effect.
-  //
-  // Note that the corresponding call to MADV_FREE_REUSABLE is in Purge(), since
-  // that's where the memory is actually released, rather than Unlock(), which
-  // is a no-op on macOS.
-  //
-  // For more information, see
-  // https://bugs.chromium.org/p/chromium/issues/detail?id=823915.
-  if (madvise(reinterpret_cast<char*>(shared_memory_mapping_.memory()) +
-                  AlignToPageSize(sizeof(SharedState)),
-              AlignToPageSize(mapped_size_), MADV_FREE_REUSE))
-    ;
-  return DiscardableSharedMemory::SUCCESS;
-#else
-  return DiscardableSharedMemory::SUCCESS;
-#endif
-}
-
-void DiscardableSharedMemory::Unlock(size_t offset, size_t length) {
-  DCHECK_EQ(AlignToPageSize(offset), offset);
-  DCHECK_EQ(AlignToPageSize(length), length);
-
-  // Calls to this function must be synchronized properly.
-  DFAKE_SCOPED_LOCK(thread_collision_warner_);
-
-  // Passing zero for |length| means "everything onward". Note that |length| may
-  // still be zero after this calculation, e.g. if |mapped_size_| is zero.
-  if (!length)
-    length = AlignToPageSize(mapped_size_) - offset;
-
-  DCHECK(shared_memory_mapping_.IsValid());
-
-  // Allow the pages to be discarded by the platform, if supported.
-  UnlockPages(shared_memory_region_,
-              AlignToPageSize(sizeof(SharedState)) + offset, length);
-
-  size_t start = offset / base::GetPageSize();
-  size_t end = start + length / base::GetPageSize();
-  DCHECK_LE(start, end);
-  DCHECK_LE(end, AlignToPageSize(mapped_size_) / base::GetPageSize());
-
-  // Remove pages from |locked_page_count_|.
-  // Note: Unlocking a page that is not locked is an error.
-  DCHECK_GE(locked_page_count_, end - start);
-  locked_page_count_ -= end - start;
-#if DCHECK_IS_ON()
-  // Detect incorrect usage by keeping track of exactly what pages are locked.
-  for (auto page = start; page < end; ++page) {
-    auto erased_count = locked_pages_.erase(page);
-    DCHECK_EQ(1u, erased_count);
-  }
-  DCHECK_EQ(locked_pages_.size(), locked_page_count_);
-#endif
-
-  // Early out and avoid releasing the platform independent lock if some pages
-  // are still locked.
-  if (locked_page_count_)
-    return;
-
-  Time current_time = Now();
-  DCHECK(!current_time.is_null());
-
-  SharedState old_state(SharedState::LOCKED, Time());
-  SharedState new_state(SharedState::UNLOCKED, current_time);
-  // Note: timestamp cannot be NULL as that is a unique value used when
-  // locked or purged.
-  DCHECK(!new_state.GetTimestamp().is_null());
-  // Timestamp precision should at least be accurate to the second.
-  DCHECK_EQ((new_state.GetTimestamp() - Time::UnixEpoch()).InSeconds(),
-            (current_time - Time::UnixEpoch()).InSeconds());
-  SharedState result(subtle::Release_CompareAndSwap(
-      &SharedStateFromSharedMemory(shared_memory_mapping_)->value.i,
-      old_state.value.i, new_state.value.i));
-
-  DCHECK_EQ(old_state.value.u, result.value.u);
-
-  last_known_usage_ = current_time;
-}
-
-void* DiscardableSharedMemory::memory() const {
-  return reinterpret_cast<uint8_t*>(shared_memory_mapping_.memory()) +
-         AlignToPageSize(sizeof(SharedState));
-}
-
-bool DiscardableSharedMemory::Purge(Time current_time) {
-  // Calls to this function must be synchronized properly.
-  DFAKE_SCOPED_LOCK(thread_collision_warner_);
-  DCHECK(shared_memory_mapping_.IsValid());
-
-  SharedState old_state(SharedState::UNLOCKED, last_known_usage_);
-  SharedState new_state(SharedState::UNLOCKED, Time());
-  SharedState result(subtle::Acquire_CompareAndSwap(
-      &SharedStateFromSharedMemory(shared_memory_mapping_)->value.i,
-      old_state.value.i, new_state.value.i));
-
-  // Update |last_known_usage_| to |current_time| if the memory is locked. This
-  // allows the caller to determine if purging failed because last known usage
-  // was incorrect or memory was locked. In the second case, the caller should
-  // most likely wait for some amount of time before attempting to purge the
-  // the memory again.
-  if (result.value.u != old_state.value.u) {
-    last_known_usage_ = result.GetLockState() == SharedState::LOCKED
-                            ? current_time
-                            : result.GetTimestamp();
-    return false;
-  }
-
-// The next section will release as much resource as can be done
-// from the purging process, until the client process notices the
-// purge and releases its own references.
-// Note: this memory will not be accessed again.  The segment will be
-// freed asynchronously at a later time, so just do the best
-// immediately.
-#if defined(OS_POSIX) && !defined(OS_NACL)
-// Linux and Android provide MADV_REMOVE which is preferred as it has a
-// behavior that can be verified in tests. Other POSIX flavors (MacOSX, BSDs),
-// provide MADV_FREE which has the same result but memory is purged lazily.
-#if defined(OS_LINUX) || defined(OS_ANDROID)
-#define MADV_PURGE_ARGUMENT MADV_REMOVE
-#elif defined(OS_MACOSX)
-// MADV_FREE_REUSABLE is similar to MADV_FREE, but also marks the pages with the
-// reusable bit, which allows both Activity Monitor and memory-infra to
-// correctly track the pages.
-#define MADV_PURGE_ARGUMENT MADV_FREE_REUSABLE
-#else
-#define MADV_PURGE_ARGUMENT MADV_FREE
-#endif
-  // Advise the kernel to remove resources associated with purged pages.
-  // Subsequent accesses of memory pages will succeed, but might result in
-  // zero-fill-on-demand pages.
-  if (madvise(reinterpret_cast<char*>(shared_memory_mapping_.memory()) +
-                  AlignToPageSize(sizeof(SharedState)),
-              AlignToPageSize(mapped_size_), MADV_PURGE_ARGUMENT)) {
-    DPLOG(ERROR) << "madvise() failed";
-  }
-#elif defined(OS_WIN)
-  if (base::win::GetVersion() >= base::win::VERSION_WIN8_1) {
-    // Discard the purged pages, which releases the physical storage (resident
-    // memory, compressed or swapped), but leaves them reserved & committed.
-    // This does not free commit for use by other applications, but allows the
-    // system to avoid compressing/swapping these pages to free physical memory.
-    static const auto discard_virtual_memory =
-        reinterpret_cast<decltype(&::DiscardVirtualMemory)>(GetProcAddress(
-            GetModuleHandle(L"kernel32.dll"), "DiscardVirtualMemory"));
-    if (discard_virtual_memory) {
-      DWORD discard_result = discard_virtual_memory(
-          reinterpret_cast<char*>(shared_memory_mapping_.memory()) +
-              AlignToPageSize(sizeof(SharedState)),
-          AlignToPageSize(mapped_size_));
-      if (discard_result != ERROR_SUCCESS) {
-        DLOG(DCHECK) << "DiscardVirtualMemory() failed in Purge(): "
-                     << logging::SystemErrorCodeToString(discard_result);
-      }
-    }
-  }
-#endif
-
-  last_known_usage_ = Time();
-  return true;
-}
-
-bool DiscardableSharedMemory::IsMemoryResident() const {
-  DCHECK(shared_memory_mapping_.IsValid());
-
-  SharedState result(subtle::NoBarrier_Load(
-      &SharedStateFromSharedMemory(shared_memory_mapping_)->value.i));
-
-  return result.GetLockState() == SharedState::LOCKED ||
-         !result.GetTimestamp().is_null();
-}
-
-bool DiscardableSharedMemory::IsMemoryLocked() const {
-  DCHECK(shared_memory_mapping_.IsValid());
-
-  SharedState result(subtle::NoBarrier_Load(
-      &SharedStateFromSharedMemory(shared_memory_mapping_)->value.i));
-
-  return result.GetLockState() == SharedState::LOCKED;
-}
-
-void DiscardableSharedMemory::Close() {
-  shared_memory_region_ = UnsafeSharedMemoryRegion();
-}
-
-void DiscardableSharedMemory::CreateSharedMemoryOwnershipEdge(
-    trace_event::MemoryAllocatorDump* local_segment_dump,
-    trace_event::ProcessMemoryDump* pmd,
-    bool is_owned) const {
-  auto* shared_memory_dump = SharedMemoryTracker::GetOrCreateSharedMemoryDump(
-      shared_memory_mapping_, pmd);
-  // TODO(ssid): Clean this by a new api to inherit size of parent dump once the
-  // we send the full PMD and calculate sizes inside chrome, crbug.com/704203.
-  size_t resident_size = shared_memory_dump->GetSizeInternal();
-  local_segment_dump->AddScalar(trace_event::MemoryAllocatorDump::kNameSize,
-                                trace_event::MemoryAllocatorDump::kUnitsBytes,
-                                resident_size);
-
-  // By creating an edge with a higher |importance| (w.r.t non-owned dumps)
-  // the tracing UI will account the effective size of the segment to the
-  // client instead of manager.
-  // TODO(ssid): Define better constants in MemoryAllocatorDump for importance
-  // values, crbug.com/754793.
-  const int kImportance = is_owned ? 2 : 0;
-  auto shared_memory_guid = shared_memory_mapping_.guid();
-  local_segment_dump->AddString("id", "hash", shared_memory_guid.ToString());
-
-  // Owned discardable segments which are allocated by client process, could
-  // have been cleared by the discardable manager. So, the segment need not
-  // exist in memory and weak dumps are created to indicate the UI that the dump
-  // should exist only if the manager also created the global dump edge.
-  if (is_owned) {
-    pmd->CreateWeakSharedMemoryOwnershipEdge(local_segment_dump->guid(),
-                                             shared_memory_guid, kImportance);
-  } else {
-    pmd->CreateSharedMemoryOwnershipEdge(local_segment_dump->guid(),
-                                         shared_memory_guid, kImportance);
-  }
-}
-
-// static
-DiscardableSharedMemory::LockResult DiscardableSharedMemory::LockPages(
-    const UnsafeSharedMemoryRegion& region,
-    size_t offset,
-    size_t length) {
-#if defined(OS_ANDROID)
-  if (region.IsValid()) {
-    int pin_result =
-        ashmem_pin_region(region.GetPlatformHandle(), offset, length);
-    if (pin_result == ASHMEM_WAS_PURGED)
-      return PURGED;
-    if (pin_result < 0)
-      return FAILED;
-  }
-#endif
-  return SUCCESS;
-}
-
-// static
-void DiscardableSharedMemory::UnlockPages(
-    const UnsafeSharedMemoryRegion& region,
-    size_t offset,
-    size_t length) {
-#if defined(OS_ANDROID)
-  if (region.IsValid()) {
-    int unpin_result =
-        ashmem_unpin_region(region.GetPlatformHandle(), offset, length);
-    DCHECK_EQ(0, unpin_result);
-  }
-#endif
-}
-
-Time DiscardableSharedMemory::Now() const {
-  return Time::Now();
-}
-
-}  // namespace base
diff --git a/base/memory/discardable_shared_memory.h b/base/memory/discardable_shared_memory.h
deleted file mode 100644
index 55e99d9..0000000
--- a/base/memory/discardable_shared_memory.h
+++ /dev/null
@@ -1,187 +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_MEMORY_DISCARDABLE_SHARED_MEMORY_H_
-#define BASE_MEMORY_DISCARDABLE_SHARED_MEMORY_H_
-
-#include <stddef.h>
-
-#include "base/base_export.h"
-#include "base/logging.h"
-#include "base/macros.h"
-#include "base/memory/shared_memory_mapping.h"
-#include "base/memory/unsafe_shared_memory_region.h"
-#include "base/threading/thread_collision_warner.h"
-#include "base/time/time.h"
-#include "build_config.h"
-
-#if DCHECK_IS_ON()
-#include <set>
-#endif
-
-// Linux (including Android) support the MADV_REMOVE argument with madvise()
-// which has the behavior of reliably causing zero-fill-on-demand pages to
-// be returned after a call. Here we define
-// DISCARDABLE_SHARED_MEMORY_ZERO_FILL_ON_DEMAND_PAGES_AFTER_PURGE on Linux
-// and Android to indicate that this type of behavior can be expected on
-// those platforms. Note that madvise() will still be used on other POSIX
-// platforms but doesn't provide the zero-fill-on-demand pages guarantee.
-#if defined(OS_LINUX) || defined(OS_ANDROID)
-#define DISCARDABLE_SHARED_MEMORY_ZERO_FILL_ON_DEMAND_PAGES_AFTER_PURGE
-#endif
-
-namespace base {
-
-namespace trace_event {
-class MemoryAllocatorDump;
-class ProcessMemoryDump;
-}  // namespace trace_event
-
-// Platform abstraction for discardable shared memory.
-//
-// This class is not thread-safe. Clients are responsible for synchronizing
-// access to an instance of this class.
-class BASE_EXPORT DiscardableSharedMemory {
- public:
-  enum LockResult { SUCCESS, PURGED, FAILED };
-
-  DiscardableSharedMemory();
-
-  // Create a new DiscardableSharedMemory object from an existing, open shared
-  // memory file. Memory must be locked.
-  explicit DiscardableSharedMemory(UnsafeSharedMemoryRegion region);
-
-  // Closes any open files.
-  virtual ~DiscardableSharedMemory();
-
-  // Creates and maps a locked DiscardableSharedMemory object with |size|.
-  // Returns true on success and false on failure.
-  bool CreateAndMap(size_t size);
-
-  // Maps the locked discardable memory into the caller's address space.
-  // Returns true on success, false otherwise.
-  bool Map(size_t size);
-
-  // Unmaps the discardable shared memory from the caller's address space.
-  // Unmapping won't unlock previously locked range.
-  // Returns true if successful; returns false on error or if the memory is
-  // not mapped.
-  bool Unmap();
-
-  // The actual size of the mapped memory (may be larger than requested).
-  size_t mapped_size() const { return mapped_size_; }
-
-  // Returns a duplicated shared memory region for this DiscardableSharedMemory
-  // object.
-  UnsafeSharedMemoryRegion DuplicateRegion() const {
-    return shared_memory_region_.Duplicate();
-  }
-
-  // Returns an ID for the shared memory region. This is ID of the mapped region
-  // consistent across all processes and is valid as long as the region is not
-  // unmapped.
-  const UnguessableToken& mapped_id() const {
-    return shared_memory_mapping_.guid();
-  }
-
-  // Locks a range of memory so that it will not be purged by the system.
-  // The range of memory must be unlocked. The result of trying to lock an
-  // already locked range is undefined. |offset| and |length| must both be
-  // a multiple of the page size as returned by GetPageSize().
-  // Passing 0 for |length| means "everything onward".
-  // Returns SUCCESS if range was successfully locked and the memory is still
-  // resident, PURGED if range was successfully locked but has been purged
-  // since last time it was locked and FAILED if range could not be locked.
-  // Locking can fail for two reasons; object might have been purged, our
-  // last known usage timestamp might be out of date. Last known usage time
-  // is updated to the actual last usage timestamp if memory is still resident
-  // or 0 if not.
-  LockResult Lock(size_t offset, size_t length);
-
-  // Unlock a previously successfully locked range of memory. The range of
-  // memory must be locked. The result of trying to unlock a not
-  // previously locked range is undefined.
-  // |offset| and |length| must both be a multiple of the page size as returned
-  // by GetPageSize().
-  // Passing 0 for |length| means "everything onward".
-  void Unlock(size_t offset, size_t length);
-
-  // Gets a pointer to the opened discardable memory space. Discardable memory
-  // must have been mapped via Map().
-  void* memory() const;
-
-  // Returns the last known usage time for DiscardableSharedMemory object. This
-  // may be earlier than the "true" usage time when memory has been used by a
-  // different process. Returns NULL time if purged.
-  Time last_known_usage() const { return last_known_usage_; }
-
-  // This returns true and sets |last_known_usage_| to 0 if
-  // DiscardableSharedMemory object was successfully purged. Purging can fail
-  // for two reasons; object might be locked or our last known usage timestamp
-  // might be out of date. Last known usage time is updated to |current_time|
-  // if locked or the actual last usage timestamp if unlocked. It is often
-  // necessary to call this function twice for the object to successfully be
-  // purged. First call, updates |last_known_usage_|. Second call, successfully
-  // purges the object using the updated |last_known_usage_|.
-  // Note: there is no guarantee that multiple calls to this function will
-  // successfully purge object. DiscardableSharedMemory object might be locked
-  // or another thread/process might be able to lock and unlock it in between
-  // each call.
-  bool Purge(Time current_time);
-
-  // Returns true if memory is still resident.
-  bool IsMemoryResident() const;
-
-  // Returns true if memory is locked.
-  bool IsMemoryLocked() const;
-
-  // Closes the open discardable memory segment.
-  // It is safe to call Close repeatedly.
-  void Close();
-
-  // For tracing: Creates ownership edge to the underlying shared memory dump
-  // which is cross process in the given |pmd|. |local_segment_dump| is the dump
-  // associated with the local discardable shared memory segment and |is_owned|
-  // is true when the current process owns the segment and the effective memory
-  // is assigned to the current process.
-  void CreateSharedMemoryOwnershipEdge(
-      trace_event::MemoryAllocatorDump* local_segment_dump,
-      trace_event::ProcessMemoryDump* pmd,
-      bool is_owned) const;
-
- private:
-  // LockPages/UnlockPages are platform-native discardable page management
-  // helper functions. Both expect |offset| to be specified relative to the
-  // base address at which |memory| is mapped, and that |offset| and |length|
-  // are page-aligned by the caller.
-  // Returns SUCCESS on platforms which do not support discardable pages.
-  static LockResult LockPages(const UnsafeSharedMemoryRegion& region,
-                              size_t offset,
-                              size_t length);
-  // UnlockPages() is a no-op on platforms not supporting discardable pages.
-  static void UnlockPages(const UnsafeSharedMemoryRegion& region,
-                          size_t offset,
-                          size_t length);
-
-  // Virtual for tests.
-  virtual Time Now() const;
-
-  UnsafeSharedMemoryRegion shared_memory_region_;
-  WritableSharedMemoryMapping shared_memory_mapping_;
-  size_t mapped_size_;
-  size_t locked_page_count_;
-#if DCHECK_IS_ON()
-  std::set<size_t> locked_pages_;
-#endif
-  // Implementation is not thread-safe but still usable if clients are
-  // synchronized somehow. Use a collision warner to detect incorrect usage.
-  DFAKE_MUTEX(thread_collision_warner_);
-  Time last_known_usage_;
-
-  DISALLOW_COPY_AND_ASSIGN(DiscardableSharedMemory);
-};
-
-}  // namespace base
-
-#endif  // BASE_MEMORY_DISCARDABLE_SHARED_MEMORY_H_
diff --git a/base/memory/linked_ptr.h b/base/memory/linked_ptr.h
deleted file mode 100644
index 6851286..0000000
--- a/base/memory/linked_ptr.h
+++ /dev/null
@@ -1,179 +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.
-//
-// A "smart" pointer type with reference tracking.  Every pointer to a
-// particular object is kept on a circular linked list.  When the last pointer
-// to an object is destroyed or reassigned, the object is deleted.
-//
-// Used properly, this deletes the object when the last reference goes away.
-// There are several caveats:
-// - Like all reference counting schemes, cycles lead to leaks.
-// - Each smart pointer is actually two pointers (8 bytes instead of 4).
-// - Every time a pointer is released, the entire list of pointers to that
-//   object is traversed.  This class is therefore NOT SUITABLE when there
-//   will often be more than two or three pointers to a particular object.
-// - References are only tracked as long as linked_ptr<> objects are copied.
-//   If a linked_ptr<> is converted to a raw pointer and back, BAD THINGS
-//   will happen (double deletion).
-//
-// Note: If you use an incomplete type with linked_ptr<>, the class
-// *containing* linked_ptr<> must have a constructor and destructor (even
-// if they do nothing!).
-//
-// Thread Safety:
-//   A linked_ptr is NOT thread safe. Copying a linked_ptr object is
-//   effectively a read-write operation.
-//
-// Alternative: to linked_ptr is shared_ptr, which
-//  - is also two pointers in size (8 bytes for 32 bit addresses)
-//  - is thread safe for copying and deletion
-//  - supports weak_ptrs
-
-#ifndef BASE_MEMORY_LINKED_PTR_H_
-#define BASE_MEMORY_LINKED_PTR_H_
-
-#include "base/logging.h"  // for CHECK macros
-
-// This is used internally by all instances of linked_ptr<>.  It needs to be
-// a non-template class because different types of linked_ptr<> can refer to
-// the same object (linked_ptr<Superclass>(obj) vs linked_ptr<Subclass>(obj)).
-// So, it needs to be possible for different types of linked_ptr to participate
-// in the same circular linked list, so we need a single class type here.
-//
-// DO NOT USE THIS CLASS DIRECTLY YOURSELF.  Use linked_ptr<T>.
-class linked_ptr_internal {
- public:
-  // Create a new circle that includes only this instance.
-  void join_new() {
-    next_ = this;
-  }
-
-  // Join an existing circle.
-  void join(linked_ptr_internal const* ptr) {
-    next_ = ptr->next_;
-    ptr->next_ = this;
-  }
-
-  // Leave whatever circle we're part of.  Returns true iff we were the
-  // last member of the circle.  Once this is done, you can join() another.
-  bool depart() {
-    if (next_ == this) return true;
-    linked_ptr_internal const* p = next_;
-    while (p->next_ != this) p = p->next_;
-    p->next_ = next_;
-    return false;
-  }
-
- private:
-  mutable linked_ptr_internal const* next_;
-};
-
-// TODO(http://crbug.com/556939): DEPRECATED: Use unique_ptr instead (now that
-// we have support for moveable types inside STL containers).
-template <typename T>
-class linked_ptr {
- public:
-  typedef T element_type;
-
-  // Take over ownership of a raw pointer.  This should happen as soon as
-  // possible after the object is created.
-  explicit linked_ptr(T* ptr = NULL) { capture(ptr); }
-  ~linked_ptr() { depart(); }
-
-  // Copy an existing linked_ptr<>, adding ourselves to the list of references.
-  template <typename U> linked_ptr(linked_ptr<U> const& ptr) { copy(&ptr); }
-
-  linked_ptr(linked_ptr const& ptr) {
-    DCHECK_NE(&ptr, this);
-    copy(&ptr);
-  }
-
-  // Assignment releases the old value and acquires the new.
-  template <typename U> linked_ptr& operator=(linked_ptr<U> const& ptr) {
-    depart();
-    copy(&ptr);
-    return *this;
-  }
-
-  linked_ptr& operator=(linked_ptr const& ptr) {
-    if (&ptr != this) {
-      depart();
-      copy(&ptr);
-    }
-    return *this;
-  }
-
-  // Smart pointer members.
-  void reset(T* ptr = NULL) {
-    depart();
-    capture(ptr);
-  }
-  T* get() const { return value_; }
-  T* operator->() const { return value_; }
-  T& operator*() const { return *value_; }
-  // Release ownership of the pointed object and returns it.
-  // Sole ownership by this linked_ptr object is required.
-  T* release() {
-    bool last = link_.depart();
-    CHECK(last);
-    T* v = value_;
-    value_ = NULL;
-    return v;
-  }
-
-  bool operator==(const T* p) const { return value_ == p; }
-  bool operator!=(const T* p) const { return value_ != p; }
-  template <typename U>
-  bool operator==(linked_ptr<U> const& ptr) const {
-    return value_ == ptr.get();
-  }
-  template <typename U>
-  bool operator!=(linked_ptr<U> const& ptr) const {
-    return value_ != ptr.get();
-  }
-
- private:
-  template <typename U>
-  friend class linked_ptr;
-
-  T* value_;
-  linked_ptr_internal link_;
-
-  void depart() {
-    if (link_.depart()) delete value_;
-  }
-
-  void capture(T* ptr) {
-    value_ = ptr;
-    link_.join_new();
-  }
-
-  template <typename U> void copy(linked_ptr<U> const* ptr) {
-    value_ = ptr->get();
-    if (value_)
-      link_.join(&ptr->link_);
-    else
-      link_.join_new();
-  }
-};
-
-template<typename T> inline
-bool operator==(T* ptr, const linked_ptr<T>& x) {
-  return ptr == x.get();
-}
-
-template<typename T> inline
-bool operator!=(T* ptr, const linked_ptr<T>& x) {
-  return ptr != x.get();
-}
-
-// A function to convert T* into linked_ptr<T>
-// Doing e.g. make_linked_ptr(new FooBarBaz<type>(arg)) is a shorter notation
-// for linked_ptr<FooBarBaz<type> >(new FooBarBaz<type>(arg))
-template <typename T>
-linked_ptr<T> make_linked_ptr(T* ptr) {
-  return linked_ptr<T>(ptr);
-}
-
-#endif  // BASE_MEMORY_LINKED_PTR_H_
diff --git a/base/memory/memory_coordinator_client.cc b/base/memory/memory_coordinator_client.cc
deleted file mode 100644
index 7fa6232..0000000
--- a/base/memory/memory_coordinator_client.cc
+++ /dev/null
@@ -1,27 +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/memory/memory_coordinator_client.h"
-
-#include "base/logging.h"
-
-namespace base {
-
-const char* MemoryStateToString(MemoryState state) {
-  switch (state) {
-    case MemoryState::UNKNOWN:
-      return "unknown";
-    case MemoryState::NORMAL:
-      return "normal";
-    case MemoryState::THROTTLED:
-      return "throttled";
-    case MemoryState::SUSPENDED:
-      return "suspended";
-    default:
-      NOTREACHED();
-  }
-  return "";
-}
-
-}  // namespace base
diff --git a/base/memory/memory_coordinator_client.h b/base/memory/memory_coordinator_client.h
deleted file mode 100644
index 804f0a6..0000000
--- a/base/memory/memory_coordinator_client.h
+++ /dev/null
@@ -1,79 +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_MEMORY_MEMORY_COORDINATOR_CLIENT_H_
-#define BASE_MEMORY_MEMORY_COORDINATOR_CLIENT_H_
-
-#include "base/base_export.h"
-
-namespace base {
-
-// OVERVIEW:
-//
-// MemoryCoordinatorClient is an interface which a component can implement to
-// adjust "future allocation" and "existing allocation". For "future allocation"
-// it provides a callback to observe memory state changes, and for "existing
-// allocation" it provides a callback to purge memory.
-//
-// Unlike MemoryPressureListener, memory state changes are stateful. State
-// transitions are throttled to avoid thrashing; the exact throttling period is
-// platform dependent, but will be at least 5-10 seconds. When a state change
-// notification is dispatched, clients are expected to update their allocation
-// policies (e.g. setting cache limit) that persist for the duration of the
-// memory state. Note that clients aren't expected to free up memory on memory
-// state changes. Clients should wait for a separate purge request to free up
-// memory. Purging requests will be throttled as well.
-
-// MemoryState is an indicator that processes can use to guide their memory
-// allocation policies. For example, a process that receives the throttled
-// state can use that as as signal to decrease memory cache limits.
-// NOTE: This enum is used to back an UMA histogram, and therefore should be
-// treated as append-only.
-enum class MemoryState : int {
-  // The state is unknown.
-  UNKNOWN = -1,
-  // No memory constraints.
-  NORMAL = 0,
-  // Running and interactive but memory allocation should be throttled.
-  // Clients should set lower budget for any memory that is used as an
-  // optimization but that is not necessary for the process to run.
-  // (e.g. caches)
-  THROTTLED = 1,
-  // Still resident in memory but core processing logic has been suspended.
-  // In most cases, OnPurgeMemory() will be called before entering this state.
-  SUSPENDED = 2,
-};
-
-const int kMemoryStateMax = static_cast<int>(MemoryState::SUSPENDED) + 1;
-
-// Returns a string representation of MemoryState.
-BASE_EXPORT const char* MemoryStateToString(MemoryState state);
-
-// This is an interface for components which can respond to memory status
-// changes. An initial state is NORMAL. See MemoryCoordinatorClientRegistry for
-// threading guarantees and ownership management.
-class BASE_EXPORT MemoryCoordinatorClient {
- public:
-  // Called when memory state has changed. Any transition can occur except for
-  // UNKNOWN. General guidelines are:
-  //  * NORMAL:    Restore the default settings for memory allocation/usage if
-  //               it has changed.
-  //  * THROTTLED: Use smaller limits for future memory allocations. You don't
-  //               need to take any action on existing allocations.
-  //  * SUSPENDED: Use much smaller limits for future memory allocations. You
-  //               don't need to take any action on existing allocations.
-  virtual void OnMemoryStateChange(MemoryState state) {}
-
-  // Called to purge memory.
-  // This callback should free up any memory that is used as an optimization, or
-  // any memory whose contents can be reproduced.
-  virtual void OnPurgeMemory() {}
-
- protected:
-  virtual ~MemoryCoordinatorClient() = default;
-};
-
-}  // namespace base
-
-#endif  // BASE_MEMORY_MEMORY_COORDINATOR_CLIENT_H_
diff --git a/base/memory/memory_coordinator_client_registry.cc b/base/memory/memory_coordinator_client_registry.cc
deleted file mode 100644
index 45b4a7f..0000000
--- a/base/memory/memory_coordinator_client_registry.cc
+++ /dev/null
@@ -1,41 +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/memory/memory_coordinator_client_registry.h"
-
-namespace base {
-
-// static
-MemoryCoordinatorClientRegistry*
-MemoryCoordinatorClientRegistry::GetInstance() {
-  return Singleton<
-      MemoryCoordinatorClientRegistry,
-      LeakySingletonTraits<MemoryCoordinatorClientRegistry>>::get();
-}
-
-MemoryCoordinatorClientRegistry::MemoryCoordinatorClientRegistry()
-    : clients_(new ClientList) {}
-
-MemoryCoordinatorClientRegistry::~MemoryCoordinatorClientRegistry() = default;
-
-void MemoryCoordinatorClientRegistry::Register(
-    MemoryCoordinatorClient* client) {
-  clients_->AddObserver(client);
-}
-
-void MemoryCoordinatorClientRegistry::Unregister(
-    MemoryCoordinatorClient* client) {
-  clients_->RemoveObserver(client);
-}
-
-void MemoryCoordinatorClientRegistry::Notify(MemoryState state) {
-  clients_->Notify(FROM_HERE,
-                   &base::MemoryCoordinatorClient::OnMemoryStateChange, state);
-}
-
-void MemoryCoordinatorClientRegistry::PurgeMemory() {
-  clients_->Notify(FROM_HERE, &base::MemoryCoordinatorClient::OnPurgeMemory);
-}
-
-}  // namespace base
diff --git a/base/memory/memory_coordinator_client_registry.h b/base/memory/memory_coordinator_client_registry.h
deleted file mode 100644
index e2c81b7..0000000
--- a/base/memory/memory_coordinator_client_registry.h
+++ /dev/null
@@ -1,56 +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_MEMORY_MEMORY_CLIENT_REGISTRY_H_
-#define BASE_MEMORY_MEMORY_CLIENT_REGISTRY_H_
-
-#include "base/base_export.h"
-#include "base/memory/memory_coordinator_client.h"
-#include "base/memory/singleton.h"
-#include "base/observer_list_threadsafe.h"
-
-namespace base {
-
-// MemoryCoordinatorClientRegistry is the registry of MemoryCoordinatorClients.
-// This class manages clients and provides a way to notify memory state changes
-// to clients, but this isn't responsible to determine how/when to change
-// memory states.
-//
-// Threading guarantees:
-// This class uses ObserverListThreadsafe internally, which means that
-//  * Registering/unregistering callbacks are thread-safe.
-//  * Callbacks are invoked on the same thread on which they are registered.
-// See base/observer_list_threadsafe.h for reference.
-//
-// Ownership management:
-// This class doesn't take the ownership of clients. Clients must be
-// unregistered before they are destroyed.
-class BASE_EXPORT MemoryCoordinatorClientRegistry {
- public:
-  static MemoryCoordinatorClientRegistry* GetInstance();
-
-  ~MemoryCoordinatorClientRegistry();
-
-  // Registers/unregisters a client. Does not take ownership of client.
-  void Register(MemoryCoordinatorClient* client);
-  void Unregister(MemoryCoordinatorClient* client);
-
-  // Notify clients of a memory state change.
-  void Notify(MemoryState state);
-
-  // Requests purging memory.
-  void PurgeMemory();
-
- private:
-  friend struct DefaultSingletonTraits<MemoryCoordinatorClientRegistry>;
-
-  MemoryCoordinatorClientRegistry();
-
-  using ClientList = ObserverListThreadSafe<MemoryCoordinatorClient>;
-  scoped_refptr<ClientList> clients_;
-};
-
-}  // namespace base
-
-#endif  // BASE_MEMORY_MEMORY_CLIENT_REGISTRY_H_
diff --git a/base/memory/memory_coordinator_proxy.cc b/base/memory/memory_coordinator_proxy.cc
deleted file mode 100644
index 4e22fe0..0000000
--- a/base/memory/memory_coordinator_proxy.cc
+++ /dev/null
@@ -1,37 +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/memory/memory_coordinator_proxy.h"
-
-namespace base {
-
-namespace {
-
-MemoryCoordinator* g_memory_coordinator = nullptr;
-
-}  // namespace
-
-MemoryCoordinatorProxy::MemoryCoordinatorProxy() = default;
-
-MemoryCoordinatorProxy::~MemoryCoordinatorProxy() = default;
-
-// static
-MemoryCoordinatorProxy* MemoryCoordinatorProxy::GetInstance() {
-  return Singleton<base::MemoryCoordinatorProxy>::get();
-}
-
-// static
-void MemoryCoordinatorProxy::SetMemoryCoordinator(
-    MemoryCoordinator* coordinator) {
-  DCHECK(!g_memory_coordinator || !coordinator);
-  g_memory_coordinator = coordinator;
-}
-
-MemoryState MemoryCoordinatorProxy::GetCurrentMemoryState() const {
-  if (!g_memory_coordinator)
-    return MemoryState::NORMAL;
-  return g_memory_coordinator->GetCurrentMemoryState();
-}
-
-}  // namespace base
diff --git a/base/memory/memory_coordinator_proxy.h b/base/memory/memory_coordinator_proxy.h
deleted file mode 100644
index b6e7b3f..0000000
--- a/base/memory/memory_coordinator_proxy.h
+++ /dev/null
@@ -1,49 +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_MEMORY_MEMORY_COORDINATOR_PROXY_H_
-#define BASE_MEMORY_MEMORY_COORDINATOR_PROXY_H_
-
-#include "base/base_export.h"
-#include "base/callback.h"
-#include "base/memory/memory_coordinator_client.h"
-#include "base/memory/singleton.h"
-
-namespace base {
-
-// The MemoryCoordinator interface. See comments in MemoryCoordinatorProxy for
-// method descriptions.
-class BASE_EXPORT MemoryCoordinator {
- public:
-  virtual ~MemoryCoordinator() = default;
-
-  virtual MemoryState GetCurrentMemoryState() const = 0;
-};
-
-// The proxy of MemoryCoordinator to be accessed from components that are not
-// in content/browser e.g. net.
-class BASE_EXPORT MemoryCoordinatorProxy {
- public:
-  static MemoryCoordinatorProxy* GetInstance();
-
-  // Sets an implementation of MemoryCoordinator. MemoryCoordinatorProxy doesn't
-  // take the ownership of |coordinator|. It must outlive this proxy.
-  // This should be called before any components starts using this proxy.
-  static void SetMemoryCoordinator(MemoryCoordinator* coordinator);
-
-  // Returns the current memory state.
-  MemoryState GetCurrentMemoryState() const;
-
- private:
-  friend struct base::DefaultSingletonTraits<MemoryCoordinatorProxy>;
-
-  MemoryCoordinatorProxy();
-  virtual ~MemoryCoordinatorProxy();
-
-  DISALLOW_COPY_AND_ASSIGN(MemoryCoordinatorProxy);
-};
-
-}  // namespace base
-
-#endif  // BASE_MEMORY_MEMORY_COORDINATOR_PROXY_H_
diff --git a/base/memory/memory_pressure_listener.cc b/base/memory/memory_pressure_listener.cc
deleted file mode 100644
index 3768283..0000000
--- a/base/memory/memory_pressure_listener.cc
+++ /dev/null
@@ -1,128 +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/memory/memory_pressure_listener.h"
-
-#include "base/observer_list_threadsafe.h"
-
-namespace base {
-
-namespace {
-
-// This class is thread safe and internally synchronized.
-class MemoryPressureObserver {
- public:
-  // There is at most one MemoryPressureObserver and it is never deleted.
-  ~MemoryPressureObserver() = delete;
-
-  void AddObserver(MemoryPressureListener* listener, bool sync) {
-    async_observers_->AddObserver(listener);
-    if (sync) {
-      AutoLock lock(sync_observers_lock_);
-      sync_observers_.AddObserver(listener);
-    }
-  }
-
-  void RemoveObserver(MemoryPressureListener* listener) {
-    async_observers_->RemoveObserver(listener);
-    AutoLock lock(sync_observers_lock_);
-    sync_observers_.RemoveObserver(listener);
-  }
-
-  void Notify(
-      MemoryPressureListener::MemoryPressureLevel memory_pressure_level) {
-    async_observers_->Notify(FROM_HERE, &MemoryPressureListener::Notify,
-                             memory_pressure_level);
-    AutoLock lock(sync_observers_lock_);
-    for (auto& observer : sync_observers_)
-      observer.SyncNotify(memory_pressure_level);
-  }
-
- private:
-  const scoped_refptr<ObserverListThreadSafe<MemoryPressureListener>>
-      async_observers_ = base::MakeRefCounted<
-          ObserverListThreadSafe<MemoryPressureListener>>();
-  ObserverList<MemoryPressureListener> sync_observers_;
-  Lock sync_observers_lock_;
-};
-
-// Gets the shared MemoryPressureObserver singleton instance.
-MemoryPressureObserver* GetMemoryPressureObserver() {
-  static auto* const observer = new MemoryPressureObserver();
-  return observer;
-}
-
-subtle::Atomic32 g_notifications_suppressed = 0;
-
-}  // namespace
-
-MemoryPressureListener::MemoryPressureListener(
-    const MemoryPressureListener::MemoryPressureCallback& callback)
-    : callback_(callback) {
-  GetMemoryPressureObserver()->AddObserver(this, false);
-}
-
-MemoryPressureListener::MemoryPressureListener(
-    const MemoryPressureListener::MemoryPressureCallback& callback,
-    const MemoryPressureListener::SyncMemoryPressureCallback&
-        sync_memory_pressure_callback)
-    : callback_(callback),
-      sync_memory_pressure_callback_(sync_memory_pressure_callback) {
-  GetMemoryPressureObserver()->AddObserver(this, true);
-}
-
-MemoryPressureListener::~MemoryPressureListener() {
-  GetMemoryPressureObserver()->RemoveObserver(this);
-}
-
-void MemoryPressureListener::Notify(MemoryPressureLevel memory_pressure_level) {
-  callback_.Run(memory_pressure_level);
-}
-
-void MemoryPressureListener::SyncNotify(
-    MemoryPressureLevel memory_pressure_level) {
-  if (!sync_memory_pressure_callback_.is_null()) {
-    sync_memory_pressure_callback_.Run(memory_pressure_level);
-  }
-}
-
-// static
-void MemoryPressureListener::NotifyMemoryPressure(
-    MemoryPressureLevel memory_pressure_level) {
-  DCHECK_NE(memory_pressure_level, MEMORY_PRESSURE_LEVEL_NONE);
-  TRACE_EVENT_INSTANT1(TRACE_DISABLED_BY_DEFAULT("memory-infra"),
-                       "MemoryPressureListener::NotifyMemoryPressure",
-                       TRACE_EVENT_SCOPE_THREAD, "level",
-                       memory_pressure_level);
-  if (AreNotificationsSuppressed())
-    return;
-  DoNotifyMemoryPressure(memory_pressure_level);
-}
-
-// static
-bool MemoryPressureListener::AreNotificationsSuppressed() {
-  return subtle::Acquire_Load(&g_notifications_suppressed) == 1;
-}
-
-// static
-void MemoryPressureListener::SetNotificationsSuppressed(bool suppress) {
-  subtle::Release_Store(&g_notifications_suppressed, suppress ? 1 : 0);
-}
-
-// static
-void MemoryPressureListener::SimulatePressureNotification(
-    MemoryPressureLevel memory_pressure_level) {
-  // Notify all listeners even if regular pressure notifications are suppressed.
-  DoNotifyMemoryPressure(memory_pressure_level);
-}
-
-// static
-void MemoryPressureListener::DoNotifyMemoryPressure(
-    MemoryPressureLevel memory_pressure_level) {
-  DCHECK_NE(memory_pressure_level, MEMORY_PRESSURE_LEVEL_NONE);
-
-  GetMemoryPressureObserver()->Notify(memory_pressure_level);
-}
-
-}  // namespace base
diff --git a/base/memory/memory_pressure_listener.h b/base/memory/memory_pressure_listener.h
deleted file mode 100644
index 7e97010..0000000
--- a/base/memory/memory_pressure_listener.h
+++ /dev/null
@@ -1,102 +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.
-
-// MemoryPressure provides static APIs for handling memory pressure on
-// platforms that have such signals, such as Android and ChromeOS.
-// The app will try to discard buffers that aren't deemed essential (individual
-// modules will implement their own policy).
-
-#ifndef BASE_MEMORY_MEMORY_PRESSURE_LISTENER_H_
-#define BASE_MEMORY_MEMORY_PRESSURE_LISTENER_H_
-
-#include "base/base_export.h"
-#include "base/callback.h"
-#include "base/macros.h"
-
-namespace base {
-
-// To start listening, create a new instance, passing a callback to a
-// function that takes a MemoryPressureLevel parameter. To stop listening,
-// simply delete the listener object. The implementation guarantees
-// that the callback will always be called on the thread that created
-// the listener.
-// Note that even on the same thread, the callback is not guaranteed to be
-// called synchronously within the system memory pressure broadcast.
-// Please see notes in MemoryPressureLevel enum below: some levels are
-// absolutely critical, and if not enough memory is returned to the system,
-// it'll potentially kill the app, and then later the app will have to be
-// cold-started.
-//
-// Example:
-//
-//    void OnMemoryPressure(MemoryPressureLevel memory_pressure_level) {
-//       ...
-//    }
-//
-//    // Start listening.
-//    MemoryPressureListener* my_listener =
-//        new MemoryPressureListener(base::Bind(&OnMemoryPressure));
-//
-//    ...
-//
-//    // Stop listening.
-//    delete my_listener;
-//
-class BASE_EXPORT MemoryPressureListener {
- public:
-  // A Java counterpart will be generated for this enum.
-  // GENERATED_JAVA_ENUM_PACKAGE: org.chromium.base
-  enum MemoryPressureLevel {
-    // No problems, there is enough memory to use. This event is not sent via
-    // callback, but the enum is used in other places to find out the current
-    // state of the system.
-    MEMORY_PRESSURE_LEVEL_NONE,
-
-    // Modules are advised to free buffers that are cheap to re-allocate and not
-    // immediately needed.
-    MEMORY_PRESSURE_LEVEL_MODERATE,
-
-    // At this level, modules are advised to free all possible memory.  The
-    // alternative is to be killed by the system, which means all memory will
-    // have to be re-created, plus the cost of a cold start.
-    MEMORY_PRESSURE_LEVEL_CRITICAL,
-  };
-
-  typedef Callback<void(MemoryPressureLevel)> MemoryPressureCallback;
-  typedef Callback<void(MemoryPressureLevel)> SyncMemoryPressureCallback;
-
-  explicit MemoryPressureListener(
-      const MemoryPressureCallback& memory_pressure_callback);
-  MemoryPressureListener(
-      const MemoryPressureCallback& memory_pressure_callback,
-      const SyncMemoryPressureCallback& sync_memory_pressure_callback);
-
-  ~MemoryPressureListener();
-
-  // Intended for use by the platform specific implementation.
-  static void NotifyMemoryPressure(MemoryPressureLevel memory_pressure_level);
-
-  // These methods should not be used anywhere else but in memory measurement
-  // code, where they are intended to maintain stable conditions across
-  // measurements.
-  static bool AreNotificationsSuppressed();
-  static void SetNotificationsSuppressed(bool suppressed);
-  static void SimulatePressureNotification(
-      MemoryPressureLevel memory_pressure_level);
-
-  void Notify(MemoryPressureLevel memory_pressure_level);
-  void SyncNotify(MemoryPressureLevel memory_pressure_level);
-
- private:
-  static void DoNotifyMemoryPressure(MemoryPressureLevel memory_pressure_level);
-
-  MemoryPressureCallback callback_;
-  SyncMemoryPressureCallback sync_memory_pressure_callback_;
-
-  DISALLOW_COPY_AND_ASSIGN(MemoryPressureListener);
-};
-
-}  // namespace base
-
-#endif  // BASE_MEMORY_MEMORY_PRESSURE_LISTENER_H_
diff --git a/base/memory/memory_pressure_monitor.cc b/base/memory/memory_pressure_monitor.cc
deleted file mode 100644
index ed350b8..0000000
--- a/base/memory/memory_pressure_monitor.cc
+++ /dev/null
@@ -1,71 +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/memory/memory_pressure_monitor.h"
-
-#include "base/logging.h"
-#include "base/metrics/histogram_macros.h"
-
-namespace base {
-namespace {
-
-MemoryPressureMonitor* g_monitor = nullptr;
-
-// Enumeration of UMA memory pressure levels. This needs to be kept in sync with
-// histograms.xml and the memory pressure levels defined in
-// MemoryPressureListener.
-enum MemoryPressureLevelUMA {
-  UMA_MEMORY_PRESSURE_LEVEL_NONE = 0,
-  UMA_MEMORY_PRESSURE_LEVEL_MODERATE = 1,
-  UMA_MEMORY_PRESSURE_LEVEL_CRITICAL = 2,
-  // This must be the last value in the enum.
-  UMA_MEMORY_PRESSURE_LEVEL_COUNT,
-};
-
-// Converts a memory pressure level to an UMA enumeration value.
-MemoryPressureLevelUMA MemoryPressureLevelToUmaEnumValue(
-    base::MemoryPressureListener::MemoryPressureLevel level) {
-  switch (level) {
-    case MemoryPressureListener::MEMORY_PRESSURE_LEVEL_NONE:
-      return UMA_MEMORY_PRESSURE_LEVEL_NONE;
-    case MemoryPressureListener::MEMORY_PRESSURE_LEVEL_MODERATE:
-      return UMA_MEMORY_PRESSURE_LEVEL_MODERATE;
-    case MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL:
-      return UMA_MEMORY_PRESSURE_LEVEL_CRITICAL;
-  }
-  NOTREACHED();
-  return UMA_MEMORY_PRESSURE_LEVEL_NONE;
-}
-
-}  // namespace
-
-MemoryPressureMonitor::MemoryPressureMonitor() {
-  DCHECK(!g_monitor);
-  g_monitor = this;
-}
-
-MemoryPressureMonitor::~MemoryPressureMonitor() {
-  DCHECK(g_monitor);
-  g_monitor = nullptr;
-}
-
-// static
-MemoryPressureMonitor* MemoryPressureMonitor::Get() {
-  return g_monitor;
-}
-void MemoryPressureMonitor::RecordMemoryPressure(
-    base::MemoryPressureListener::MemoryPressureLevel level,
-    int ticks) {
-  // Use the more primitive STATIC_HISTOGRAM_POINTER_BLOCK macro because the
-  // simple UMA_HISTOGRAM macros don't expose 'AddCount' functionality.
-  STATIC_HISTOGRAM_POINTER_BLOCK(
-      "Memory.PressureLevel",
-      AddCount(MemoryPressureLevelToUmaEnumValue(level), ticks),
-      base::LinearHistogram::FactoryGet(
-          "Memory.PressureLevel", 1, UMA_MEMORY_PRESSURE_LEVEL_COUNT,
-          UMA_MEMORY_PRESSURE_LEVEL_COUNT + 1,
-          base::HistogramBase::kUmaTargetedHistogramFlag));
-}
-
-}  // namespace base
diff --git a/base/memory/memory_pressure_monitor.h b/base/memory/memory_pressure_monitor.h
deleted file mode 100644
index e48244b..0000000
--- a/base/memory/memory_pressure_monitor.h
+++ /dev/null
@@ -1,53 +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_MEMORY_MEMORY_PRESSURE_MONITOR_H_
-#define BASE_MEMORY_MEMORY_PRESSURE_MONITOR_H_
-
-#include "base/base_export.h"
-#include "base/callback.h"
-#include "base/macros.h"
-#include "base/memory/memory_pressure_listener.h"
-
-namespace base {
-
-// TODO(chrisha): Make this a concrete class with per-OS implementations rather
-// than an abstract base class.
-
-// Declares the interface for a MemoryPressureMonitor. There are multiple
-// OS specific implementations of this class. An instance of the memory
-// pressure observer is created at the process level, tracks memory usage, and
-// pushes memory state change notifications to the static function
-// base::MemoryPressureListener::NotifyMemoryPressure. This is turn notifies
-// all MemoryPressureListener instances via a callback.
-class BASE_EXPORT MemoryPressureMonitor {
- public:
-  using MemoryPressureLevel = base::MemoryPressureListener::MemoryPressureLevel;
-  using DispatchCallback = base::Callback<void(MemoryPressureLevel level)>;
-
-  virtual ~MemoryPressureMonitor();
-
-  // Return the singleton MemoryPressureMonitor.
-  static MemoryPressureMonitor* Get();
-
-  // Record memory pressure UMA statistic. A tick is 5 seconds.
-  static void RecordMemoryPressure(MemoryPressureLevel level, int ticks);
-
-  // Returns the currently observed memory pressure.
-  virtual MemoryPressureLevel GetCurrentPressureLevel() = 0;
-
-  // Sets a notification callback. The default callback invokes
-  // base::MemoryPressureListener::NotifyMemoryPressure.
-  virtual void SetDispatchCallback(const DispatchCallback& callback) = 0;
-
- protected:
-  MemoryPressureMonitor();
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(MemoryPressureMonitor);
-};
-
-}  // namespace base
-
-#endif  // BASE_MEMORY_MEMORY_PRESSURE_MONITOR_H_
diff --git a/base/memory/memory_pressure_monitor_chromeos.cc b/base/memory/memory_pressure_monitor_chromeos.cc
deleted file mode 100644
index b4e4b94..0000000
--- a/base/memory/memory_pressure_monitor_chromeos.cc
+++ /dev/null
@@ -1,288 +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/memory/memory_pressure_monitor_chromeos.h"
-
-#include <fcntl.h>
-#include <sys/select.h>
-
-#include "base/metrics/histogram_macros.h"
-#include "base/posix/eintr_wrapper.h"
-#include "base/process/process_metrics.h"
-#include "base/single_thread_task_runner.h"
-#include "base/sys_info.h"
-#include "base/threading/thread_task_runner_handle.h"
-#include "base/time/time.h"
-
-namespace base {
-namespace chromeos {
-
-namespace {
-
-// The time between memory pressure checks. While under critical pressure, this
-// is also the timer to repeat cleanup attempts.
-const int kMemoryPressureIntervalMs = 1000;
-
-// The time which should pass between two moderate memory pressure calls.
-const int kModerateMemoryPressureCooldownMs = 10000;
-
-// Number of event polls before the next moderate pressure event can be sent.
-const int kModerateMemoryPressureCooldown =
-    kModerateMemoryPressureCooldownMs / kMemoryPressureIntervalMs;
-
-// Threshold constants to emit pressure events.
-const int kNormalMemoryPressureModerateThresholdPercent = 60;
-const int kNormalMemoryPressureCriticalThresholdPercent = 95;
-const int kAggressiveMemoryPressureModerateThresholdPercent = 35;
-const int kAggressiveMemoryPressureCriticalThresholdPercent = 70;
-
-// The possible state for memory pressure level. The values should be in line
-// with values in MemoryPressureListener::MemoryPressureLevel and should be
-// updated if more memory pressure levels are introduced.
-enum MemoryPressureLevelUMA {
-  MEMORY_PRESSURE_LEVEL_NONE = 0,
-  MEMORY_PRESSURE_LEVEL_MODERATE,
-  MEMORY_PRESSURE_LEVEL_CRITICAL,
-  NUM_MEMORY_PRESSURE_LEVELS
-};
-
-// This is the file that will exist if low memory notification is available
-// on the device.  Whenever it becomes readable, it signals a low memory
-// condition.
-const char kLowMemFile[] = "/dev/chromeos-low-mem";
-
-// Converts a |MemoryPressureThreshold| value into a used memory percentage for
-// the moderate pressure event.
-int GetModerateMemoryThresholdInPercent(
-    MemoryPressureMonitor::MemoryPressureThresholds thresholds) {
-  return thresholds == MemoryPressureMonitor::
-                           THRESHOLD_AGGRESSIVE_CACHE_DISCARD ||
-         thresholds == MemoryPressureMonitor::THRESHOLD_AGGRESSIVE
-             ? kAggressiveMemoryPressureModerateThresholdPercent
-             : kNormalMemoryPressureModerateThresholdPercent;
-}
-
-// Converts a |MemoryPressureThreshold| value into a used memory percentage for
-// the critical pressure event.
-int GetCriticalMemoryThresholdInPercent(
-    MemoryPressureMonitor::MemoryPressureThresholds thresholds) {
-  return thresholds == MemoryPressureMonitor::
-                           THRESHOLD_AGGRESSIVE_TAB_DISCARD ||
-         thresholds == MemoryPressureMonitor::THRESHOLD_AGGRESSIVE
-             ? kAggressiveMemoryPressureCriticalThresholdPercent
-             : kNormalMemoryPressureCriticalThresholdPercent;
-}
-
-// Converts free percent of memory into a memory pressure value.
-MemoryPressureListener::MemoryPressureLevel GetMemoryPressureLevelFromFillLevel(
-    int actual_fill_level,
-    int moderate_threshold,
-    int critical_threshold) {
-  if (actual_fill_level < moderate_threshold)
-    return MemoryPressureListener::MEMORY_PRESSURE_LEVEL_NONE;
-  return actual_fill_level < critical_threshold
-             ? MemoryPressureListener::MEMORY_PRESSURE_LEVEL_MODERATE
-             : MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL;
-}
-
-// This function will be called less than once a second. It will check if
-// the kernel has detected a low memory situation.
-bool IsLowMemoryCondition(int file_descriptor) {
-  fd_set fds;
-  struct timeval tv;
-
-  FD_ZERO(&fds);
-  FD_SET(file_descriptor, &fds);
-
-  tv.tv_sec = 0;
-  tv.tv_usec = 0;
-
-  return HANDLE_EINTR(select(file_descriptor + 1, &fds, NULL, NULL, &tv)) > 0;
-}
-
-}  // namespace
-
-MemoryPressureMonitor::MemoryPressureMonitor(
-    MemoryPressureThresholds thresholds)
-    : current_memory_pressure_level_(
-          MemoryPressureListener::MEMORY_PRESSURE_LEVEL_NONE),
-      moderate_pressure_repeat_count_(0),
-      seconds_since_reporting_(0),
-      moderate_pressure_threshold_percent_(
-          GetModerateMemoryThresholdInPercent(thresholds)),
-      critical_pressure_threshold_percent_(
-          GetCriticalMemoryThresholdInPercent(thresholds)),
-      low_mem_file_(HANDLE_EINTR(::open(kLowMemFile, O_RDONLY))),
-      dispatch_callback_(
-          base::Bind(&MemoryPressureListener::NotifyMemoryPressure)),
-      weak_ptr_factory_(this) {
-  StartObserving();
-  LOG_IF(ERROR,
-         base::SysInfo::IsRunningOnChromeOS() && !low_mem_file_.is_valid())
-      << "Cannot open kernel listener";
-}
-
-MemoryPressureMonitor::~MemoryPressureMonitor() {
-  StopObserving();
-}
-
-void MemoryPressureMonitor::ScheduleEarlyCheck() {
-  ThreadTaskRunnerHandle::Get()->PostTask(
-      FROM_HERE, BindOnce(&MemoryPressureMonitor::CheckMemoryPressure,
-                          weak_ptr_factory_.GetWeakPtr()));
-}
-
-MemoryPressureListener::MemoryPressureLevel
-MemoryPressureMonitor::GetCurrentPressureLevel() {
-  return current_memory_pressure_level_;
-}
-
-// static
-MemoryPressureMonitor* MemoryPressureMonitor::Get() {
-  return static_cast<MemoryPressureMonitor*>(
-      base::MemoryPressureMonitor::Get());
-}
-
-void MemoryPressureMonitor::StartObserving() {
-  timer_.Start(FROM_HERE,
-               TimeDelta::FromMilliseconds(kMemoryPressureIntervalMs),
-               Bind(&MemoryPressureMonitor::
-                        CheckMemoryPressureAndRecordStatistics,
-                    weak_ptr_factory_.GetWeakPtr()));
-}
-
-void MemoryPressureMonitor::StopObserving() {
-  // If StartObserving failed, StopObserving will still get called.
-  timer_.Stop();
-}
-
-void MemoryPressureMonitor::CheckMemoryPressureAndRecordStatistics() {
-  CheckMemoryPressure();
-  if (seconds_since_reporting_++ == 5) {
-    seconds_since_reporting_ = 0;
-    RecordMemoryPressure(current_memory_pressure_level_, 1);
-  }
-  // Record UMA histogram statistics for the current memory pressure level.
-  // TODO(lgrey): Remove this once there's a usable history for the
-  // "Memory.PressureLevel" statistic
-  MemoryPressureLevelUMA memory_pressure_level_uma(MEMORY_PRESSURE_LEVEL_NONE);
-  switch (current_memory_pressure_level_) {
-    case MemoryPressureListener::MEMORY_PRESSURE_LEVEL_NONE:
-      memory_pressure_level_uma = MEMORY_PRESSURE_LEVEL_NONE;
-      break;
-    case MemoryPressureListener::MEMORY_PRESSURE_LEVEL_MODERATE:
-      memory_pressure_level_uma = MEMORY_PRESSURE_LEVEL_MODERATE;
-      break;
-    case MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL:
-      memory_pressure_level_uma = MEMORY_PRESSURE_LEVEL_CRITICAL;
-      break;
-  }
-
-  UMA_HISTOGRAM_ENUMERATION("ChromeOS.MemoryPressureLevel",
-                            memory_pressure_level_uma,
-                            NUM_MEMORY_PRESSURE_LEVELS);
-}
-
-void MemoryPressureMonitor::CheckMemoryPressure() {
-  MemoryPressureListener::MemoryPressureLevel old_pressure =
-      current_memory_pressure_level_;
-
-  // If we have the kernel low memory observer, we use it's flag instead of our
-  // own computation (for now). Note that in "simulation mode" it can be null.
-  // TODO(skuhne): We need to add code which makes sure that the kernel and this
-  // computation come to similar results and then remove this override again.
-  // TODO(skuhne): Add some testing framework here to see how close the kernel
-  // and the internal functions are.
-  if (low_mem_file_.is_valid() && IsLowMemoryCondition(low_mem_file_.get())) {
-    current_memory_pressure_level_ =
-        MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL;
-  } else {
-    current_memory_pressure_level_ = GetMemoryPressureLevelFromFillLevel(
-        GetUsedMemoryInPercent(),
-        moderate_pressure_threshold_percent_,
-        critical_pressure_threshold_percent_);
-
-    // When listening to the kernel, we ignore the reported memory pressure
-    // level from our own computation and reduce critical to moderate.
-    if (low_mem_file_.is_valid() &&
-        current_memory_pressure_level_ ==
-        MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL) {
-      current_memory_pressure_level_ =
-          MemoryPressureListener::MEMORY_PRESSURE_LEVEL_MODERATE;
-    }
-  }
-
-  // In case there is no memory pressure we do not notify.
-  if (current_memory_pressure_level_ ==
-      MemoryPressureListener::MEMORY_PRESSURE_LEVEL_NONE) {
-    return;
-  }
-  if (old_pressure == current_memory_pressure_level_) {
-    // If the memory pressure is still at the same level, we notify again for a
-    // critical level. In case of a moderate level repeat however, we only send
-    // a notification after a certain time has passed.
-    if (current_memory_pressure_level_ ==
-        MemoryPressureListener::MEMORY_PRESSURE_LEVEL_MODERATE &&
-          ++moderate_pressure_repeat_count_ <
-              kModerateMemoryPressureCooldown) {
-      return;
-    }
-  } else if (current_memory_pressure_level_ ==
-               MemoryPressureListener::MEMORY_PRESSURE_LEVEL_MODERATE &&
-             old_pressure ==
-               MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL) {
-    // When we reducing the pressure level from critical to moderate, we
-    // restart the timeout and do not send another notification.
-    moderate_pressure_repeat_count_ = 0;
-    return;
-  }
-  moderate_pressure_repeat_count_ = 0;
-  dispatch_callback_.Run(current_memory_pressure_level_);
-}
-
-// Gets the used ChromeOS memory in percent.
-int MemoryPressureMonitor::GetUsedMemoryInPercent() {
-  base::SystemMemoryInfoKB info;
-  if (!base::GetSystemMemoryInfo(&info)) {
-    VLOG(1) << "Cannot determine the free memory of the system.";
-    return 0;
-  }
-  // TODO(skuhne): Instead of adding the kernel memory pressure calculation
-  // logic here, we should have a kernel mechanism similar to the low memory
-  // notifier in ChromeOS which offers multiple pressure states.
-  // To track this, we have crbug.com/381196.
-
-  // The available memory consists of "real" and virtual (z)ram memory.
-  // Since swappable memory uses a non pre-deterministic compression and
-  // the compression creates its own "dynamic" in the system, it gets
-  // de-emphasized by the |kSwapWeight| factor.
-  const int kSwapWeight = 4;
-
-  // The total memory we have is the "real memory" plus the virtual (z)ram.
-  int total_memory = info.total + info.swap_total / kSwapWeight;
-
-  // The kernel internally uses 50MB.
-  const int kMinFileMemory = 50 * 1024;
-
-  // Most file memory can be easily reclaimed.
-  int file_memory = info.active_file + info.inactive_file;
-  // unless it is dirty or it's a minimal portion which is required.
-  file_memory -= info.dirty + kMinFileMemory;
-
-  // Available memory is the sum of free, swap and easy reclaimable memory.
-  int available_memory =
-      info.free + info.swap_free / kSwapWeight + file_memory;
-
-  DCHECK(available_memory < total_memory);
-  int percentage = ((total_memory - available_memory) * 100) / total_memory;
-  return percentage;
-}
-
-void MemoryPressureMonitor::SetDispatchCallback(
-    const DispatchCallback& callback) {
-  dispatch_callback_ = callback;
-}
-
-}  // namespace chromeos
-}  // namespace base
diff --git a/base/memory/memory_pressure_monitor_chromeos.h b/base/memory/memory_pressure_monitor_chromeos.h
deleted file mode 100644
index 563ba85..0000000
--- a/base/memory/memory_pressure_monitor_chromeos.h
+++ /dev/null
@@ -1,128 +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_MEMORY_MEMORY_PRESSURE_MONITOR_CHROMEOS_H_
-#define BASE_MEMORY_MEMORY_PRESSURE_MONITOR_CHROMEOS_H_
-
-#include "base/base_export.h"
-#include "base/files/scoped_file.h"
-#include "base/macros.h"
-#include "base/memory/memory_pressure_listener.h"
-#include "base/memory/memory_pressure_monitor.h"
-#include "base/memory/weak_ptr.h"
-#include "base/timer/timer.h"
-
-namespace base {
-namespace chromeos {
-
-class TestMemoryPressureMonitor;
-
-////////////////////////////////////////////////////////////////////////////////
-// MemoryPressureMonitor
-//
-// A class to handle the observation of our free memory. It notifies the
-// MemoryPressureListener of memory fill level changes, so that it can take
-// action to reduce memory resources accordingly.
-//
-class BASE_EXPORT MemoryPressureMonitor : public base::MemoryPressureMonitor {
- public:
-  using GetUsedMemoryInPercentCallback = int (*)();
-
-  // There are two memory pressure events:
-  // MODERATE - which will mainly release caches.
-  // CRITICAL - which will discard tabs.
-  // The |MemoryPressureThresholds| enum selects the strategy of firing these
-  // events: A conservative strategy will keep as much content in memory as
-  // possible (causing the system to swap to zram) and an aggressive strategy
-  // will release memory earlier to avoid swapping.
-  enum MemoryPressureThresholds {
-    // Use the system default.
-    THRESHOLD_DEFAULT = 0,
-    // Try to keep as much content in memory as possible.
-    THRESHOLD_CONSERVATIVE = 1,
-    // Discard caches earlier, allowing to keep more tabs in memory.
-    THRESHOLD_AGGRESSIVE_CACHE_DISCARD = 2,
-    // Discard tabs earlier, allowing the system to get faster.
-    THRESHOLD_AGGRESSIVE_TAB_DISCARD = 3,
-    // Discard caches and tabs earlier to allow the system to be faster.
-    THRESHOLD_AGGRESSIVE = 4
-  };
-
-  explicit MemoryPressureMonitor(MemoryPressureThresholds thresholds);
-  ~MemoryPressureMonitor() override;
-
-  // Redo the memory pressure calculation soon and call again if a critical
-  // memory pressure prevails. Note that this call will trigger an asynchronous
-  // action which gives the system time to release memory back into the pool.
-  void ScheduleEarlyCheck();
-
-  // Get the current memory pressure level.
-  MemoryPressureListener::MemoryPressureLevel GetCurrentPressureLevel()
-      override;
-  void SetDispatchCallback(const DispatchCallback& callback) override;
-
-  // Returns a type-casted version of the current memory pressure monitor. A
-  // simple wrapper to base::MemoryPressureMonitor::Get.
-  static MemoryPressureMonitor* Get();
-
- private:
-  friend TestMemoryPressureMonitor;
-  // Starts observing the memory fill level.
-  // Calls to StartObserving should always be matched with calls to
-  // StopObserving.
-  void StartObserving();
-
-  // Stop observing the memory fill level.
-  // May be safely called if StartObserving has not been called.
-  void StopObserving();
-
-  // The function which gets periodically called to check any changes in the
-  // memory pressure. It will report pressure changes as well as continuous
-  // critical pressure levels.
-  void CheckMemoryPressure();
-
-  // The function periodically checks the memory pressure changes and records
-  // the UMA histogram statistics for the current memory pressure level.
-  void CheckMemoryPressureAndRecordStatistics();
-
-  // Get the memory pressure in percent (virtual for testing).
-  virtual int GetUsedMemoryInPercent();
-
-  // The current memory pressure.
-  base::MemoryPressureListener::MemoryPressureLevel
-      current_memory_pressure_level_;
-
-  // A periodic timer to check for resource pressure changes. This will get
-  // replaced by a kernel triggered event system (see crbug.com/381196).
-  base::RepeatingTimer timer_;
-
-  // To slow down the amount of moderate pressure event calls, this counter
-  // gets used to count the number of events since the last event occured.
-  int moderate_pressure_repeat_count_;
-
-  // The "Memory.PressureLevel" statistic is recorded every
-  // 5 seconds, but the timer to report "ChromeOS.MemoryPressureLevel"
-  // fires every second. This counter is used to allow reporting
-  // "Memory.PressureLevel" correctly without adding another
-  // timer.
-  int seconds_since_reporting_;
-
-  // The thresholds for moderate and critical pressure.
-  const int moderate_pressure_threshold_percent_;
-  const int critical_pressure_threshold_percent_;
-
-  // File descriptor used to detect low memory condition.
-  ScopedFD low_mem_file_;
-
-  DispatchCallback dispatch_callback_;
-
-  base::WeakPtrFactory<MemoryPressureMonitor> weak_ptr_factory_;
-
-  DISALLOW_COPY_AND_ASSIGN(MemoryPressureMonitor);
-};
-
-}  // namespace chromeos
-}  // namespace base
-
-#endif  // BASE_MEMORY_MEMORY_PRESSURE_MONITOR_CHROMEOS_H_
diff --git a/base/memory/memory_pressure_monitor_mac.cc b/base/memory/memory_pressure_monitor_mac.cc
deleted file mode 100644
index 678c276..0000000
--- a/base/memory/memory_pressure_monitor_mac.cc
+++ /dev/null
@@ -1,190 +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/memory/memory_pressure_monitor_mac.h"
-
-#include <CoreFoundation/CoreFoundation.h>
-
-#include <dlfcn.h>
-#include <stddef.h>
-#include <sys/sysctl.h>
-
-#include <cmath>
-
-#include "base/bind.h"
-#include "base/logging.h"
-#include "base/mac/mac_util.h"
-
-// Redeclare for partial 10.9 availability.
-DISPATCH_EXPORT const struct dispatch_source_type_s
-    _dispatch_source_type_memorypressure;
-
-namespace {
-static const int kUMATickSize = 5;
-}  // namespace
-
-namespace base {
-namespace mac {
-
-MemoryPressureListener::MemoryPressureLevel
-MemoryPressureMonitor::MemoryPressureLevelForMacMemoryPressureLevel(
-    int mac_memory_pressure_level) {
-  switch (mac_memory_pressure_level) {
-    case DISPATCH_MEMORYPRESSURE_NORMAL:
-      return MemoryPressureListener::MEMORY_PRESSURE_LEVEL_NONE;
-    case DISPATCH_MEMORYPRESSURE_WARN:
-      return MemoryPressureListener::MEMORY_PRESSURE_LEVEL_MODERATE;
-    case DISPATCH_MEMORYPRESSURE_CRITICAL:
-      return MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL;
-  }
-  return MemoryPressureListener::MEMORY_PRESSURE_LEVEL_NONE;
-}
-
-void MemoryPressureMonitor::OnRunLoopExit(CFRunLoopObserverRef observer,
-                                          CFRunLoopActivity activity,
-                                          void* info) {
-  MemoryPressureMonitor* self = static_cast<MemoryPressureMonitor*>(info);
-  self->UpdatePressureLevelOnRunLoopExit();
-}
-
-MemoryPressureMonitor::MemoryPressureMonitor()
-    : memory_level_event_source_(dispatch_source_create(
-          DISPATCH_SOURCE_TYPE_MEMORYPRESSURE,
-          0,
-          DISPATCH_MEMORYPRESSURE_WARN | DISPATCH_MEMORYPRESSURE_CRITICAL |
-              DISPATCH_MEMORYPRESSURE_NORMAL,
-          dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0))),
-      dispatch_callback_(
-          base::Bind(&MemoryPressureListener::NotifyMemoryPressure)),
-      last_statistic_report_time_(CFAbsoluteTimeGetCurrent()),
-      last_pressure_level_(MemoryPressureListener::MEMORY_PRESSURE_LEVEL_NONE),
-      subtick_seconds_(0) {
-  // Attach an event handler to the memory pressure event source.
-  if (memory_level_event_source_.get()) {
-    dispatch_source_set_event_handler(memory_level_event_source_, ^{
-      OnMemoryPressureChanged(memory_level_event_source_.get(),
-                              dispatch_callback_);
-    });
-
-    // Start monitoring the event source.
-    dispatch_resume(memory_level_event_source_);
-  }
-
-  // Create a CFRunLoopObserver to check the memory pressure at the end of
-  // every pass through the event loop (modulo kUMATickSize).
-  CFRunLoopObserverContext observer_context = {0, this, NULL, NULL, NULL};
-
-  exit_observer_.reset(
-      CFRunLoopObserverCreate(kCFAllocatorDefault, kCFRunLoopExit, true, 0,
-                              OnRunLoopExit, &observer_context));
-
-  CFRunLoopRef run_loop = CFRunLoopGetCurrent();
-  CFRunLoopAddObserver(run_loop, exit_observer_, kCFRunLoopCommonModes);
-  CFRunLoopAddObserver(run_loop, exit_observer_,
-                       kMessageLoopExclusiveRunLoopMode);
-}
-
-MemoryPressureMonitor::~MemoryPressureMonitor() {
-  // Detach from the run loop.
-  CFRunLoopRef run_loop = CFRunLoopGetCurrent();
-  CFRunLoopRemoveObserver(run_loop, exit_observer_, kCFRunLoopCommonModes);
-  CFRunLoopRemoveObserver(run_loop, exit_observer_,
-                          kMessageLoopExclusiveRunLoopMode);
-
-  // Remove the memory pressure event source.
-  if (memory_level_event_source_.get()) {
-    dispatch_source_cancel(memory_level_event_source_);
-  }
-}
-
-int MemoryPressureMonitor::GetMacMemoryPressureLevel() {
-  // Get the raw memory pressure level from macOS.
-  int mac_memory_pressure_level;
-  size_t length = sizeof(int);
-  sysctlbyname("kern.memorystatus_vm_pressure_level",
-               &mac_memory_pressure_level, &length, nullptr, 0);
-
-  return mac_memory_pressure_level;
-}
-
-void MemoryPressureMonitor::UpdatePressureLevel() {
-  // Get the current macOS pressure level and convert to the corresponding
-  // Chrome pressure level.
-  int mac_memory_pressure_level = GetMacMemoryPressureLevel();
-  MemoryPressureListener::MemoryPressureLevel new_pressure_level =
-      MemoryPressureLevelForMacMemoryPressureLevel(mac_memory_pressure_level);
-
-  // Compute the number of "ticks" spent at |last_pressure_level_| (since the
-  // last report sent to UMA).
-  CFTimeInterval now = CFAbsoluteTimeGetCurrent();
-  CFTimeInterval time_since_last_report = now - last_statistic_report_time_;
-  last_statistic_report_time_ = now;
-
-  double accumulated_time = time_since_last_report + subtick_seconds_;
-  int ticks_to_report = static_cast<int>(accumulated_time / kUMATickSize);
-  // Save for later the seconds that didn't make it into a full tick.
-  subtick_seconds_ = std::fmod(accumulated_time, kUMATickSize);
-
-  // Round the tick count up on a pressure level change to ensure we capture it.
-  bool pressure_level_changed = (new_pressure_level != last_pressure_level_);
-  if (pressure_level_changed && ticks_to_report < 1) {
-    ticks_to_report = 1;
-    subtick_seconds_ = 0;
-  }
-
-  // Send elapsed ticks to UMA.
-  if (ticks_to_report >= 1) {
-    RecordMemoryPressure(last_pressure_level_, ticks_to_report);
-  }
-
-  // Save the now-current memory pressure level.
-  last_pressure_level_ = new_pressure_level;
-}
-
-void MemoryPressureMonitor::UpdatePressureLevelOnRunLoopExit() {
-  // Wait until it's time to check the pressure level.
-  CFTimeInterval now = CFAbsoluteTimeGetCurrent();
-  if (now >= next_run_loop_update_time_) {
-    UpdatePressureLevel();
-
-    // Update again in kUMATickSize seconds. We can update at any frequency,
-    // but because we're only checking memory pressure levels for UMA there's
-    // no need to update more frequently than we're keeping statistics on.
-    next_run_loop_update_time_ = now + kUMATickSize - subtick_seconds_;
-  }
-}
-
-// Static.
-int MemoryPressureMonitor::GetSecondsPerUMATick() {
-  return kUMATickSize;
-}
-
-MemoryPressureListener::MemoryPressureLevel
-MemoryPressureMonitor::GetCurrentPressureLevel() {
-  return last_pressure_level_;
-}
-
-void MemoryPressureMonitor::OnMemoryPressureChanged(
-    dispatch_source_s* event_source,
-    const MemoryPressureMonitor::DispatchCallback& dispatch_callback) {
-  // The OS has sent a notification that the memory pressure level has changed.
-  // Go through the normal memory pressure level checking mechanism so that
-  // last_pressure_level_ and UMA get updated to the current value.
-  UpdatePressureLevel();
-
-  // Run the callback that's waiting on memory pressure change notifications.
-  // The convention is to not send notifiations on memory pressure returning to
-  // normal.
-  if (last_pressure_level_ !=
-      MemoryPressureListener::MEMORY_PRESSURE_LEVEL_NONE)
-    dispatch_callback.Run(last_pressure_level_);
-}
-
-void MemoryPressureMonitor::SetDispatchCallback(
-    const DispatchCallback& callback) {
-  dispatch_callback_ = callback;
-}
-
-}  // namespace mac
-}  // namespace base
diff --git a/base/memory/memory_pressure_monitor_mac.h b/base/memory/memory_pressure_monitor_mac.h
deleted file mode 100644
index b85b6c9..0000000
--- a/base/memory/memory_pressure_monitor_mac.h
+++ /dev/null
@@ -1,91 +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_MEMORY_MEMORY_PRESSURE_MONITOR_MAC_H_
-#define BASE_MEMORY_MEMORY_PRESSURE_MONITOR_MAC_H_
-
-#include <CoreFoundation/CFDate.h>
-#include <dispatch/dispatch.h>
-
-#include "base/base_export.h"
-#include "base/mac/scoped_cftyperef.h"
-#include "base/mac/scoped_dispatch_object.h"
-#include "base/macros.h"
-#include "base/memory/memory_pressure_listener.h"
-#include "base/memory/memory_pressure_monitor.h"
-#include "base/message_loop/message_pump_mac.h"
-
-namespace base {
-namespace mac {
-
-class TestMemoryPressureMonitor;
-
-// Declares the interface for the Mac MemoryPressureMonitor, which reports
-// memory pressure events and status.
-class BASE_EXPORT MemoryPressureMonitor : public base::MemoryPressureMonitor {
- public:
-  MemoryPressureMonitor();
-  ~MemoryPressureMonitor() override;
-
-  // Returns the currently-observed memory pressure.
-  MemoryPressureLevel GetCurrentPressureLevel() override;
-
-  void SetDispatchCallback(const DispatchCallback& callback) override;
-
- private:
-  friend TestMemoryPressureMonitor;
-
-  static MemoryPressureLevel MemoryPressureLevelForMacMemoryPressureLevel(
-      int mac_memory_pressure_level);
-  static void OnRunLoopExit(CFRunLoopObserverRef observer,
-                            CFRunLoopActivity activity,
-                            void* info);
-  // Returns the raw memory pressure level from the macOS. Exposed for
-  // unit testing.
-  virtual int GetMacMemoryPressureLevel();
-
-  // Updates |last_pressure_level_| with the current memory pressure level.
-  void UpdatePressureLevel();
-
-  // Updates |last_pressure_level_| at the end of every run loop pass (modulo
-  // some number of seconds).
-  void UpdatePressureLevelOnRunLoopExit();
-
-  // Run |dispatch_callback| on memory pressure notifications from the OS.
-  void OnMemoryPressureChanged(dispatch_source_s* event_source,
-                               const DispatchCallback& dispatch_callback);
-
-  // Returns the number of seconds per UMA tick (for statistics recording).
-  // Exposed for testing.
-  static int GetSecondsPerUMATick();
-
-  // The dispatch source that generates memory pressure change notifications.
-  ScopedDispatchObject<dispatch_source_t> memory_level_event_source_;
-
-  // The callback to call upon receiving a memory pressure change notification.
-  DispatchCallback dispatch_callback_;
-
-  // Last UMA report time.
-  CFTimeInterval last_statistic_report_time_;
-
-  // Most-recent memory pressure level.
-  MemoryPressureLevel last_pressure_level_;
-
-  // Observer that tracks exits from the main run loop.
-  ScopedCFTypeRef<CFRunLoopObserverRef> exit_observer_;
-
-  // Next time to update the memory pressure level when exiting the run loop.
-  CFTimeInterval next_run_loop_update_time_;
-
-  // Seconds left over from the last UMA tick calculation (to be added to the
-  // next calculation).
-  CFTimeInterval subtick_seconds_;
-
-  DISALLOW_COPY_AND_ASSIGN(MemoryPressureMonitor);
-};
-
-}  // namespace mac
-}  // namespace base
-
-#endif  // BASE_MEMORY_MEMORY_PRESSURE_MONITOR_MAC_H_
diff --git a/base/memory/memory_pressure_monitor_win.cc b/base/memory/memory_pressure_monitor_win.cc
deleted file mode 100644
index 3effe2c..0000000
--- a/base/memory/memory_pressure_monitor_win.cc
+++ /dev/null
@@ -1,233 +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/memory/memory_pressure_monitor_win.h"
-
-#include <windows.h>
-
-#include "base/single_thread_task_runner.h"
-#include "base/threading/thread_task_runner_handle.h"
-#include "base/time/time.h"
-
-namespace base {
-namespace win {
-
-namespace {
-
-static const DWORDLONG kMBBytes = 1024 * 1024;
-
-}  // namespace
-
-// The following constants have been lifted from similar values in the ChromeOS
-// memory pressure monitor. The values were determined experimentally to ensure
-// sufficient responsiveness of the memory pressure subsystem, and minimal
-// overhead.
-const int MemoryPressureMonitor::kPollingIntervalMs = 5000;
-const int MemoryPressureMonitor::kModeratePressureCooldownMs = 10000;
-const int MemoryPressureMonitor::kModeratePressureCooldownCycles =
-    kModeratePressureCooldownMs / kPollingIntervalMs;
-
-// TODO(chrisha): Explore the following constants further with an experiment.
-
-// A system is considered 'high memory' if it has more than 1.5GB of system
-// memory available for use by the memory manager (not reserved for hardware
-// and drivers). This is a fuzzy version of the ~2GB discussed below.
-const int MemoryPressureMonitor::kLargeMemoryThresholdMb = 1536;
-
-// These are the default thresholds used for systems with < ~2GB of physical
-// memory. Such systems have been observed to always maintain ~100MB of
-// available memory, paging until that is the case. To try to avoid paging a
-// threshold slightly above this is chosen. The moderate threshold is slightly
-// less grounded in reality and chosen as 2.5x critical.
-const int MemoryPressureMonitor::kSmallMemoryDefaultModerateThresholdMb = 500;
-const int MemoryPressureMonitor::kSmallMemoryDefaultCriticalThresholdMb = 200;
-
-// These are the default thresholds used for systems with >= ~2GB of physical
-// memory. Such systems have been observed to always maintain ~300MB of
-// available memory, paging until that is the case.
-const int MemoryPressureMonitor::kLargeMemoryDefaultModerateThresholdMb = 1000;
-const int MemoryPressureMonitor::kLargeMemoryDefaultCriticalThresholdMb = 400;
-
-MemoryPressureMonitor::MemoryPressureMonitor()
-    : moderate_threshold_mb_(0),
-      critical_threshold_mb_(0),
-      current_memory_pressure_level_(
-          MemoryPressureListener::MEMORY_PRESSURE_LEVEL_NONE),
-      moderate_pressure_repeat_count_(0),
-      dispatch_callback_(
-          base::Bind(&MemoryPressureListener::NotifyMemoryPressure)),
-      weak_ptr_factory_(this) {
-  InferThresholds();
-  StartObserving();
-}
-
-MemoryPressureMonitor::MemoryPressureMonitor(int moderate_threshold_mb,
-                                             int critical_threshold_mb)
-    : moderate_threshold_mb_(moderate_threshold_mb),
-      critical_threshold_mb_(critical_threshold_mb),
-      current_memory_pressure_level_(
-          MemoryPressureListener::MEMORY_PRESSURE_LEVEL_NONE),
-      moderate_pressure_repeat_count_(0),
-      dispatch_callback_(
-          base::Bind(&MemoryPressureListener::NotifyMemoryPressure)),
-      weak_ptr_factory_(this) {
-  DCHECK_GE(moderate_threshold_mb_, critical_threshold_mb_);
-  DCHECK_LE(0, critical_threshold_mb_);
-  StartObserving();
-}
-
-MemoryPressureMonitor::~MemoryPressureMonitor() {
-  StopObserving();
-}
-
-void MemoryPressureMonitor::CheckMemoryPressureSoon() {
-  DCHECK(thread_checker_.CalledOnValidThread());
-
-  ThreadTaskRunnerHandle::Get()->PostTask(
-      FROM_HERE, Bind(&MemoryPressureMonitor::CheckMemoryPressure,
-                      weak_ptr_factory_.GetWeakPtr()));
-}
-
-MemoryPressureListener::MemoryPressureLevel
-MemoryPressureMonitor::GetCurrentPressureLevel() {
-  return current_memory_pressure_level_;
-}
-
-void MemoryPressureMonitor::InferThresholds() {
-  // Default to a 'high' memory situation, which uses more conservative
-  // thresholds.
-  bool high_memory = true;
-  MEMORYSTATUSEX mem_status = {};
-  if (GetSystemMemoryStatus(&mem_status)) {
-    static const DWORDLONG kLargeMemoryThresholdBytes =
-        static_cast<DWORDLONG>(kLargeMemoryThresholdMb) * kMBBytes;
-    high_memory = mem_status.ullTotalPhys >= kLargeMemoryThresholdBytes;
-  }
-
-  if (high_memory) {
-    moderate_threshold_mb_ = kLargeMemoryDefaultModerateThresholdMb;
-    critical_threshold_mb_ = kLargeMemoryDefaultCriticalThresholdMb;
-  } else {
-    moderate_threshold_mb_ = kSmallMemoryDefaultModerateThresholdMb;
-    critical_threshold_mb_ = kSmallMemoryDefaultCriticalThresholdMb;
-  }
-}
-
-void MemoryPressureMonitor::StartObserving() {
-  DCHECK(thread_checker_.CalledOnValidThread());
-
-  timer_.Start(FROM_HERE,
-               TimeDelta::FromMilliseconds(kPollingIntervalMs),
-               Bind(&MemoryPressureMonitor::
-                        CheckMemoryPressureAndRecordStatistics,
-                    weak_ptr_factory_.GetWeakPtr()));
-}
-
-void MemoryPressureMonitor::StopObserving() {
-  DCHECK(thread_checker_.CalledOnValidThread());
-
-  // If StartObserving failed, StopObserving will still get called.
-  timer_.Stop();
-  weak_ptr_factory_.InvalidateWeakPtrs();
-}
-
-void MemoryPressureMonitor::CheckMemoryPressure() {
-  DCHECK(thread_checker_.CalledOnValidThread());
-
-  // Get the previous pressure level and update the current one.
-  MemoryPressureLevel old_pressure = current_memory_pressure_level_;
-  current_memory_pressure_level_ = CalculateCurrentPressureLevel();
-
-  // |notify| will be set to true if MemoryPressureListeners need to be
-  // notified of a memory pressure level state change.
-  bool notify = false;
-  switch (current_memory_pressure_level_) {
-    case MemoryPressureListener::MEMORY_PRESSURE_LEVEL_NONE:
-      break;
-
-    case MemoryPressureListener::MEMORY_PRESSURE_LEVEL_MODERATE:
-      if (old_pressure != current_memory_pressure_level_) {
-        // This is a new transition to moderate pressure so notify.
-        moderate_pressure_repeat_count_ = 0;
-        notify = true;
-      } else {
-        // Already in moderate pressure, only notify if sustained over the
-        // cooldown period.
-        if (++moderate_pressure_repeat_count_ ==
-                kModeratePressureCooldownCycles) {
-          moderate_pressure_repeat_count_ = 0;
-          notify = true;
-        }
-      }
-      break;
-
-    case MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL:
-      // Always notify of critical pressure levels.
-      notify = true;
-      break;
-  }
-
-  if (!notify)
-    return;
-
-  // Emit a notification of the current memory pressure level. This can only
-  // happen for moderate and critical pressure levels.
-  DCHECK_NE(MemoryPressureListener::MEMORY_PRESSURE_LEVEL_NONE,
-            current_memory_pressure_level_);
-  dispatch_callback_.Run(current_memory_pressure_level_);
-}
-
-void MemoryPressureMonitor::CheckMemoryPressureAndRecordStatistics() {
-  DCHECK(thread_checker_.CalledOnValidThread());
-
-  CheckMemoryPressure();
-
-  RecordMemoryPressure(current_memory_pressure_level_, 1);
-}
-
-MemoryPressureListener::MemoryPressureLevel
-MemoryPressureMonitor::CalculateCurrentPressureLevel() {
-  MEMORYSTATUSEX mem_status = {};
-  if (!GetSystemMemoryStatus(&mem_status))
-    return MemoryPressureListener::MEMORY_PRESSURE_LEVEL_NONE;
-
-  // How much system memory is actively available for use right now, in MBs.
-  int phys_free = static_cast<int>(mem_status.ullAvailPhys / kMBBytes);
-
-  // TODO(chrisha): This should eventually care about address space pressure,
-  // but the browser process (where this is running) effectively never runs out
-  // of address space. Renderers occasionally do, but it does them no good to
-  // have the browser process monitor address space pressure. Long term,
-  // renderers should run their own address space pressure monitors and act
-  // accordingly, with the browser making cross-process decisions based on
-  // system memory pressure.
-
-  // Determine if the physical memory is under critical memory pressure.
-  if (phys_free <= critical_threshold_mb_)
-    return MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL;
-
-  // Determine if the physical memory is under moderate memory pressure.
-  if (phys_free <= moderate_threshold_mb_)
-    return MemoryPressureListener::MEMORY_PRESSURE_LEVEL_MODERATE;
-
-  // No memory pressure was detected.
-  return MemoryPressureListener::MEMORY_PRESSURE_LEVEL_NONE;
-}
-
-bool MemoryPressureMonitor::GetSystemMemoryStatus(
-    MEMORYSTATUSEX* mem_status) {
-  DCHECK(mem_status != nullptr);
-  mem_status->dwLength = sizeof(*mem_status);
-  if (!::GlobalMemoryStatusEx(mem_status))
-    return false;
-  return true;
-}
-
-void MemoryPressureMonitor::SetDispatchCallback(
-    const DispatchCallback& callback) {
-  dispatch_callback_ = callback;
-}
-
-}  // namespace win
-}  // namespace base
diff --git a/base/memory/memory_pressure_monitor_win.h b/base/memory/memory_pressure_monitor_win.h
deleted file mode 100644
index a65c191..0000000
--- a/base/memory/memory_pressure_monitor_win.h
+++ /dev/null
@@ -1,148 +0,0 @@
-// Copyright 2015 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_MEMORY_MEMORY_PRESSURE_MONITOR_WIN_H_
-#define BASE_MEMORY_MEMORY_PRESSURE_MONITOR_WIN_H_
-
-#include "base/base_export.h"
-#include "base/macros.h"
-#include "base/memory/memory_pressure_listener.h"
-#include "base/memory/memory_pressure_monitor.h"
-#include "base/memory/weak_ptr.h"
-#include "base/threading/thread_checker.h"
-#include "base/timer/timer.h"
-
-// To not pull in windows.h.
-typedef struct _MEMORYSTATUSEX MEMORYSTATUSEX;
-
-namespace base {
-namespace win {
-
-// Windows memory pressure monitor. Because there is no OS provided signal this
-// polls at a low frequency (once per second), and applies internal hysteresis.
-class BASE_EXPORT MemoryPressureMonitor : public base::MemoryPressureMonitor {
- public:
-  // Constants governing the polling and hysteresis behaviour of the observer.
-
-  // The polling interval, in milliseconds. While under critical pressure, this
-  // is also the timer to repeat cleanup attempts.
-  static const int kPollingIntervalMs;
-  // The time which should pass between 2 successive moderate memory pressure
-  // signals, in milliseconds.
-  static const int kModeratePressureCooldownMs;
-  // The number of cycles that should pass between 2 successive moderate memory
-  // pressure signals.
-  static const int kModeratePressureCooldownCycles;
-
-  // Constants governing the memory pressure level detection.
-
-  // The amount of total system memory beyond which a system is considered to be
-  // a large-memory system.
-  static const int kLargeMemoryThresholdMb;
-  // Default minimum free memory thresholds for small-memory systems, in MB.
-  static const int kSmallMemoryDefaultModerateThresholdMb;
-  static const int kSmallMemoryDefaultCriticalThresholdMb;
-  // Default minimum free memory thresholds for large-memory systems, in MB.
-  static const int kLargeMemoryDefaultModerateThresholdMb;
-  static const int kLargeMemoryDefaultCriticalThresholdMb;
-
-  // Default constructor. Will choose thresholds automatically basd on the
-  // actual amount of system memory.
-  MemoryPressureMonitor();
-
-  // Constructor with explicit memory thresholds. These represent the amount of
-  // free memory below which the applicable memory pressure state engages.
-  MemoryPressureMonitor(int moderate_threshold_mb, int critical_threshold_mb);
-
-  ~MemoryPressureMonitor() override;
-
-  // Schedules a memory pressure check to run soon. This must be called on the
-  // same thread where the monitor was instantiated.
-  void CheckMemoryPressureSoon();
-
-  // Get the current memory pressure level. This can be called from any thread.
-  MemoryPressureLevel GetCurrentPressureLevel() override;
-  void SetDispatchCallback(const DispatchCallback& callback) override;
-
-  // Returns the moderate pressure level free memory threshold, in MB.
-  int moderate_threshold_mb() const { return moderate_threshold_mb_; }
-
-  // Returns the critical pressure level free memory threshold, in MB.
-  int critical_threshold_mb() const { return critical_threshold_mb_; }
-
- protected:
-  // Internals are exposed for unittests.
-
-  // Automatically infers threshold values based on system memory. This invokes
-  // GetMemoryStatus so it can be mocked in unittests.
-  void InferThresholds();
-
-  // Starts observing the memory fill level. Calls to StartObserving should
-  // always be matched with calls to StopObserving.
-  void StartObserving();
-
-  // Stop observing the memory fill level. May be safely called if
-  // StartObserving has not been called. Must be called from the same thread on
-  // which the monitor was instantiated.
-  void StopObserving();
-
-  // Checks memory pressure, storing the current level, applying any hysteresis
-  // and emitting memory pressure level change signals as necessary. This
-  // function is called periodically while the monitor is observing memory
-  // pressure. This is split out from CheckMemoryPressureAndRecordStatistics so
-  // that it may be called by CheckMemoryPressureSoon and not invoke UMA
-  // logging. Must be called from the same thread on which the monitor was
-  // instantiated.
-  void CheckMemoryPressure();
-
-  // Wrapper to CheckMemoryPressure that also records the observed memory
-  // pressure level via an UMA enumeration. This is the function that is called
-  // periodically by the timer. Must be called from the same thread on which the
-  // monitor was instantiated.
-  void CheckMemoryPressureAndRecordStatistics();
-
-  // Calculates the current instantaneous memory pressure level. This does not
-  // use any hysteresis and simply returns the result at the current moment. Can
-  // be called on any thread.
-  MemoryPressureLevel CalculateCurrentPressureLevel();
-
-  // Gets system memory status. This is virtual as a unittesting hook. Returns
-  // true if the system call succeeds, false otherwise. Can be called on any
-  // thread.
-  virtual bool GetSystemMemoryStatus(MEMORYSTATUSEX* mem_status);
-
- private:
-  // Threshold amounts of available memory that trigger pressure levels. See
-  // memory_pressure_monitor.cc for a discussion of reasonable values for these.
-  int moderate_threshold_mb_;
-  int critical_threshold_mb_;
-
-  // A periodic timer to check for memory pressure changes.
-  base::RepeatingTimer timer_;
-
-  // The current memory pressure.
-  MemoryPressureLevel current_memory_pressure_level_;
-
-  // To slow down the amount of moderate pressure event calls, this gets used to
-  // count the number of events since the last event occured. This is used by
-  // |CheckMemoryPressure| to apply hysteresis on the raw results of
-  // |CalculateCurrentPressureLevel|.
-  int moderate_pressure_repeat_count_;
-
-  // Ensures that this object is used from a single thread.
-  base::ThreadChecker thread_checker_;
-
-  DispatchCallback dispatch_callback_;
-
-  // Weak pointer factory to ourself used for scheduling calls to
-  // CheckMemoryPressure/CheckMemoryPressureAndRecordStatistics via |timer_|.
-  base::WeakPtrFactory<MemoryPressureMonitor> weak_ptr_factory_;
-
-  DISALLOW_COPY_AND_ASSIGN(MemoryPressureMonitor);
-};
-
-}  // namespace win
-}  // namespace base
-
-#endif  // BASE_MEMORY_MEMORY_PRESSURE_MONITOR_WIN_H_
diff --git a/base/memory/platform_shared_memory_region.cc b/base/memory/platform_shared_memory_region.cc
deleted file mode 100644
index c145336..0000000
--- a/base/memory/platform_shared_memory_region.cc
+++ /dev/null
@@ -1,37 +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/memory/platform_shared_memory_region.h"
-
-#include "base/memory/shared_memory_mapping.h"
-
-namespace base {
-namespace subtle {
-
-// static
-PlatformSharedMemoryRegion PlatformSharedMemoryRegion::CreateWritable(
-    size_t size) {
-  return Create(Mode::kWritable, size);
-}
-
-// static
-PlatformSharedMemoryRegion PlatformSharedMemoryRegion::CreateUnsafe(
-    size_t size) {
-  return Create(Mode::kUnsafe, size);
-}
-
-PlatformSharedMemoryRegion::PlatformSharedMemoryRegion() = default;
-PlatformSharedMemoryRegion::PlatformSharedMemoryRegion(
-    PlatformSharedMemoryRegion&& other) = default;
-PlatformSharedMemoryRegion& PlatformSharedMemoryRegion::operator=(
-    PlatformSharedMemoryRegion&& other) = default;
-PlatformSharedMemoryRegion::~PlatformSharedMemoryRegion() = default;
-
-PlatformSharedMemoryRegion::ScopedPlatformHandle
-PlatformSharedMemoryRegion::PassPlatformHandle() {
-  return std::move(handle_);
-}
-
-}  // namespace subtle
-}  // namespace base
diff --git a/base/memory/platform_shared_memory_region.h b/base/memory/platform_shared_memory_region.h
deleted file mode 100644
index df4cc4d..0000000
--- a/base/memory/platform_shared_memory_region.h
+++ /dev/null
@@ -1,223 +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_MEMORY_PLATFORM_SHARED_MEMORY_REGION_H_
-#define BASE_MEMORY_PLATFORM_SHARED_MEMORY_REGION_H_
-
-#include <utility>
-
-#include "base/compiler_specific.h"
-#include "base/gtest_prod_util.h"
-#include "base/macros.h"
-#include "base/unguessable_token.h"
-#include "build_config.h"
-
-#if defined(OS_MACOSX) && !defined(OS_IOS)
-#include <mach/mach.h>
-#include "base/mac/scoped_mach_port.h"
-#elif defined(OS_FUCHSIA)
-#include "base/fuchsia/scoped_zx_handle.h"
-#elif defined(OS_WIN)
-#include "base/win/scoped_handle.h"
-#include "base/win/windows_types.h"
-#elif defined(OS_POSIX)
-#include <sys/types.h>
-#include "base/file_descriptor_posix.h"
-#include "base/files/scoped_file.h"
-#endif
-
-namespace base {
-namespace subtle {
-
-#if defined(OS_POSIX) && (!defined(OS_MACOSX) || defined(OS_IOS)) && \
-    !defined(OS_FUCHSIA) && !defined(OS_ANDROID)
-// Helper structs to keep two descriptors on POSIX. It's needed to support
-// ConvertToReadOnly().
-struct BASE_EXPORT FDPair {
-  int fd;
-  int readonly_fd;
-};
-
-struct BASE_EXPORT ScopedFDPair {
-  ScopedFDPair();
-  ScopedFDPair(ScopedFD in_fd, ScopedFD in_readonly_fd);
-  ScopedFDPair(ScopedFDPair&&);
-  ScopedFDPair& operator=(ScopedFDPair&&);
-  ~ScopedFDPair();
-
-  FDPair get() const;
-
-  ScopedFD fd;
-  ScopedFD readonly_fd;
-};
-#endif
-
-// Implementation class for shared memory regions.
-//
-// This class does the following:
-//
-// - Wraps and owns a shared memory region platform handle.
-// - Provides a way to allocate a new region of platform shared memory of given
-//   size.
-// - Provides a way to create mapping of the region in the current process'
-//   address space, under special access-control constraints (see Mode).
-// - Provides methods to help transferring the handle across process boundaries.
-// - Holds a 128-bit unique identifier used to uniquely identify the same
-//   kernel region resource across processes (used for memory tracking).
-// - Has a method to retrieve the region's size in bytes.
-//
-// IMPORTANT NOTE: Users should never use this directly, but
-// ReadOnlySharedMemoryRegion, WritableSharedMemoryRegion or
-// UnsafeSharedMemoryRegion since this is an implementation class.
-class BASE_EXPORT PlatformSharedMemoryRegion {
- public:
-  // Permission mode of the platform handle. Each mode corresponds to one of the
-  // typed shared memory classes:
-  //
-  // * ReadOnlySharedMemoryRegion: A region that can only create read-only
-  // mappings.
-  //
-  // * WritableSharedMemoryRegion: A region that can only create writable
-  // mappings. The region can be demoted to ReadOnlySharedMemoryRegion without
-  // the possibility of promoting back to writable.
-  //
-  // * UnsafeSharedMemoryRegion: A region that can only create writable
-  // mappings. The region cannot be demoted to ReadOnlySharedMemoryRegion.
-  enum class Mode {
-    kReadOnly,  // ReadOnlySharedMemoryRegion
-    kWritable,  // WritableSharedMemoryRegion
-    kUnsafe,    // UnsafeSharedMemoryRegion
-    kMaxValue = kUnsafe
-  };
-
-// Platform-specific shared memory type used by this class.
-#if defined(OS_MACOSX) && !defined(OS_IOS)
-  using PlatformHandle = mach_port_t;
-  using ScopedPlatformHandle = mac::ScopedMachSendRight;
-#elif defined(OS_FUCHSIA)
-  using PlatformHandle = zx_handle_t;
-  using ScopedPlatformHandle = ScopedZxHandle;
-#elif defined(OS_WIN)
-  using PlatformHandle = HANDLE;
-  using ScopedPlatformHandle = win::ScopedHandle;
-#elif defined(OS_ANDROID)
-  using PlatformHandle = int;
-  using ScopedPlatformHandle = ScopedFD;
-#else
-  using PlatformHandle = FDPair;
-  using ScopedPlatformHandle = ScopedFDPair;
-#endif
-
-  // The minimum alignment in bytes that any mapped address produced by Map()
-  // and MapAt() is guaranteed to have.
-  enum { kMapMinimumAlignment = 32 };
-
-  // Creates a new PlatformSharedMemoryRegion with corresponding mode and size.
-  // Creating in kReadOnly mode isn't supported because then there will be no
-  // way to modify memory content.
-  static PlatformSharedMemoryRegion CreateWritable(size_t size);
-  static PlatformSharedMemoryRegion CreateUnsafe(size_t size);
-
-  // Returns a new PlatformSharedMemoryRegion that takes ownership of the
-  // |handle|. All parameters must be taken from another valid
-  // PlatformSharedMemoryRegion instance, e.g. |size| must be equal to the
-  // actual region size as allocated by the kernel.
-  // Closes the |handle| and returns an invalid instance if passed parameters
-  // are invalid.
-  static PlatformSharedMemoryRegion Take(ScopedPlatformHandle handle,
-                                         Mode mode,
-                                         size_t size,
-                                         const UnguessableToken& guid);
-
-  // Default constructor initializes an invalid instance, i.e. an instance that
-  // doesn't wrap any valid platform handle.
-  PlatformSharedMemoryRegion();
-
-  // Move operations are allowed.
-  PlatformSharedMemoryRegion(PlatformSharedMemoryRegion&&);
-  PlatformSharedMemoryRegion& operator=(PlatformSharedMemoryRegion&&);
-
-  // Destructor closes the platform handle. Does nothing if the handle is
-  // invalid.
-  ~PlatformSharedMemoryRegion();
-
-  // Passes ownership of the platform handle to the caller. The current instance
-  // becomes invalid. It's the responsibility of the caller to close the handle.
-  ScopedPlatformHandle PassPlatformHandle() WARN_UNUSED_RESULT;
-
-  // Returns the platform handle. The current instance keeps ownership of this
-  // handle.
-  PlatformHandle GetPlatformHandle() const;
-
-  // Whether the platform handle is valid.
-  bool IsValid() const;
-
-  // Duplicates the platform handle and creates a new PlatformSharedMemoryRegion
-  // with the same |mode_|, |size_| and |guid_| that owns this handle. Returns
-  // invalid region on failure, the current instance remains valid.
-  // Can be called only in kReadOnly and kUnsafe modes, CHECK-fails if is
-  // called in kWritable mode.
-  PlatformSharedMemoryRegion Duplicate() const;
-
-  // Converts the region to read-only. Returns whether the operation succeeded.
-  // Makes the current instance invalid on failure. Can be called only in
-  // kWritable mode, all other modes will CHECK-fail. The object will have
-  // kReadOnly mode after this call on success.
-  bool ConvertToReadOnly();
-#if defined(OS_MACOSX) && !defined(OS_IOS)
-  // Same as above, but |mapped_addr| is used as a hint to avoid additional
-  // mapping of the memory object.
-  // |mapped_addr| must be mapped location of |memory_object_|. If the location
-  // is unknown, |mapped_addr| should be |nullptr|.
-  bool ConvertToReadOnly(void* mapped_addr);
-#endif  // defined(OS_MACOSX) && !defined(OS_IOS)
-
-  // Maps |size| bytes of the shared memory region starting with the given
-  // |offset| into the caller's address space. |offset| must be aligned to value
-  // of |SysInfo::VMAllocationGranularity()|. Fails if requested bytes are out
-  // of the region limits.
-  // Returns true and sets |memory| and |mapped_size| on success, returns false
-  // and leaves output parameters in unspecified state otherwise. The mapped
-  // address is guaranteed to have an alignment of at least
-  // |kMapMinimumAlignment|.
-  bool MapAt(off_t offset,
-             size_t size,
-             void** memory,
-             size_t* mapped_size) const;
-
-  const UnguessableToken& GetGUID() const { return guid_; }
-
-  size_t GetSize() const { return size_; }
-
-  Mode GetMode() const { return mode_; }
-
- private:
-  FRIEND_TEST_ALL_PREFIXES(PlatformSharedMemoryRegionTest,
-                           CreateReadOnlyRegionDeathTest);
-  FRIEND_TEST_ALL_PREFIXES(PlatformSharedMemoryRegionTest,
-                           CheckPlatformHandlePermissionsCorrespondToMode);
-  static PlatformSharedMemoryRegion Create(Mode mode, size_t size);
-
-  static bool CheckPlatformHandlePermissionsCorrespondToMode(
-      PlatformHandle handle,
-      Mode mode,
-      size_t size);
-
-  PlatformSharedMemoryRegion(ScopedPlatformHandle handle,
-                             Mode mode,
-                             size_t size,
-                             const UnguessableToken& guid);
-
-  ScopedPlatformHandle handle_;
-  Mode mode_ = Mode::kReadOnly;
-  size_t size_ = 0;
-  UnguessableToken guid_;
-
-  DISALLOW_COPY_AND_ASSIGN(PlatformSharedMemoryRegion);
-};
-
-}  // namespace subtle
-}  // namespace base
-
-#endif  // BASE_MEMORY_PLATFORM_SHARED_MEMORY_REGION_H_
diff --git a/base/memory/platform_shared_memory_region_fuchsia.cc b/base/memory/platform_shared_memory_region_fuchsia.cc
deleted file mode 100644
index 5a75845..0000000
--- a/base/memory/platform_shared_memory_region_fuchsia.cc
+++ /dev/null
@@ -1,190 +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/memory/platform_shared_memory_region.h"
-
-#include <zircon/process.h>
-#include <zircon/rights.h>
-#include <zircon/syscalls.h>
-
-#include "base/bits.h"
-#include "base/fuchsia/fuchsia_logging.h"
-#include "base/numerics/checked_math.h"
-#include "base/process/process_metrics.h"
-
-namespace base {
-namespace subtle {
-
-static constexpr int kNoWriteOrExec =
-    ZX_DEFAULT_VMO_RIGHTS &
-    ~(ZX_RIGHT_WRITE | ZX_RIGHT_EXECUTE | ZX_RIGHT_SET_PROPERTY);
-
-// static
-PlatformSharedMemoryRegion PlatformSharedMemoryRegion::Take(
-    ScopedZxHandle handle,
-    Mode mode,
-    size_t size,
-    const UnguessableToken& guid) {
-  if (!handle.is_valid())
-    return {};
-
-  if (size == 0)
-    return {};
-
-  if (size > static_cast<size_t>(std::numeric_limits<int>::max()))
-    return {};
-
-  CHECK(
-      CheckPlatformHandlePermissionsCorrespondToMode(handle.get(), mode, size));
-
-  return PlatformSharedMemoryRegion(std::move(handle), mode, size, guid);
-}
-
-zx_handle_t PlatformSharedMemoryRegion::GetPlatformHandle() const {
-  return handle_.get();
-}
-
-bool PlatformSharedMemoryRegion::IsValid() const {
-  return handle_.is_valid();
-}
-
-PlatformSharedMemoryRegion PlatformSharedMemoryRegion::Duplicate() const {
-  if (!IsValid())
-    return {};
-
-  CHECK_NE(mode_, Mode::kWritable)
-      << "Duplicating a writable shared memory region is prohibited";
-
-  ScopedZxHandle duped_handle;
-  zx_status_t status = zx_handle_duplicate(handle_.get(), ZX_RIGHT_SAME_RIGHTS,
-                                           duped_handle.receive());
-  if (status != ZX_OK) {
-    ZX_DLOG(ERROR, status) << "zx_handle_duplicate";
-    return {};
-  }
-
-  return PlatformSharedMemoryRegion(std::move(duped_handle), mode_, size_,
-                                    guid_);
-}
-
-bool PlatformSharedMemoryRegion::ConvertToReadOnly() {
-  if (!IsValid())
-    return false;
-
-  CHECK_EQ(mode_, Mode::kWritable)
-      << "Only writable shared memory region can be converted to read-only";
-
-  ScopedZxHandle old_handle(handle_.release());
-  ScopedZxHandle new_handle;
-  zx_status_t status =
-      zx_handle_replace(old_handle.get(), kNoWriteOrExec, new_handle.receive());
-  if (status != ZX_OK) {
-    ZX_DLOG(ERROR, status) << "zx_handle_replace";
-    return false;
-  }
-  ignore_result(old_handle.release());
-
-  handle_ = std::move(new_handle);
-  mode_ = Mode::kReadOnly;
-  return true;
-}
-
-bool PlatformSharedMemoryRegion::MapAt(off_t offset,
-                                       size_t size,
-                                       void** memory,
-                                       size_t* mapped_size) const {
-  if (!IsValid())
-    return false;
-
-  size_t end_byte;
-  if (!CheckAdd(offset, size).AssignIfValid(&end_byte) || end_byte > size_) {
-    return false;
-  }
-
-  bool write_allowed = mode_ != Mode::kReadOnly;
-  uintptr_t addr;
-  zx_status_t status = zx_vmar_map(
-      zx_vmar_root_self(), 0, handle_.get(), offset, size,
-      ZX_VM_FLAG_PERM_READ | (write_allowed ? ZX_VM_FLAG_PERM_WRITE : 0),
-      &addr);
-  if (status != ZX_OK) {
-    ZX_DLOG(ERROR, status) << "zx_vmar_map";
-    return false;
-  }
-
-  *memory = reinterpret_cast<void*>(addr);
-  *mapped_size = size;
-  DCHECK_EQ(0U,
-            reinterpret_cast<uintptr_t>(*memory) & (kMapMinimumAlignment - 1));
-  return true;
-}
-
-// static
-PlatformSharedMemoryRegion PlatformSharedMemoryRegion::Create(Mode mode,
-                                                              size_t size) {
-  if (size == 0)
-    return {};
-
-  size_t rounded_size = bits::Align(size, GetPageSize());
-  if (rounded_size > static_cast<size_t>(std::numeric_limits<int>::max()))
-    return {};
-
-  CHECK_NE(mode, Mode::kReadOnly) << "Creating a region in read-only mode will "
-                                     "lead to this region being non-modifiable";
-
-  ScopedZxHandle vmo;
-  zx_status_t status = zx_vmo_create(rounded_size, 0, vmo.receive());
-  if (status != ZX_OK) {
-    ZX_DLOG(ERROR, status) << "zx_vmo_create";
-    return {};
-  }
-
-  const int kNoExecFlags = ZX_DEFAULT_VMO_RIGHTS & ~ZX_RIGHT_EXECUTE;
-  ScopedZxHandle old_vmo(std::move(vmo));
-  status = zx_handle_replace(old_vmo.get(), kNoExecFlags, vmo.receive());
-  if (status != ZX_OK) {
-    ZX_DLOG(ERROR, status) << "zx_handle_replace";
-    return {};
-  }
-  ignore_result(old_vmo.release());
-
-  return PlatformSharedMemoryRegion(std::move(vmo), mode, size,
-                                    UnguessableToken::Create());
-}
-
-// static
-bool PlatformSharedMemoryRegion::CheckPlatformHandlePermissionsCorrespondToMode(
-    PlatformHandle handle,
-    Mode mode,
-    size_t size) {
-  zx_info_handle_basic_t basic = {};
-  zx_status_t status = zx_object_get_info(handle, ZX_INFO_HANDLE_BASIC, &basic,
-                                          sizeof(basic), nullptr, nullptr);
-  if (status != ZX_OK) {
-    ZX_DLOG(ERROR, status) << "zx_object_get_info";
-    return false;
-  }
-
-  bool is_read_only = (basic.rights & kNoWriteOrExec) == basic.rights;
-  bool expected_read_only = mode == Mode::kReadOnly;
-
-  if (is_read_only != expected_read_only) {
-    DLOG(ERROR) << "VMO object has wrong access rights: it is"
-                << (is_read_only ? " " : " not ") << "read-only but it should"
-                << (expected_read_only ? " " : " not ") << "be";
-    return false;
-  }
-
-  return true;
-}
-
-PlatformSharedMemoryRegion::PlatformSharedMemoryRegion(
-    ScopedZxHandle handle,
-    Mode mode,
-    size_t size,
-    const UnguessableToken& guid)
-    : handle_(std::move(handle)), mode_(mode), size_(size), guid_(guid) {}
-
-}  // namespace subtle
-}  // namespace base
diff --git a/base/memory/platform_shared_memory_region_mac.cc b/base/memory/platform_shared_memory_region_mac.cc
deleted file mode 100644
index 9cbe92e..0000000
--- a/base/memory/platform_shared_memory_region_mac.cc
+++ /dev/null
@@ -1,222 +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/memory/platform_shared_memory_region.h"
-
-#include <mach/mach_vm.h>
-
-#include "base/mac/mach_logging.h"
-#include "base/mac/scoped_mach_vm.h"
-#include "base/numerics/checked_math.h"
-#include "build_config.h"
-
-#if defined(OS_IOS)
-#error "MacOS only - iOS uses platform_shared_memory_region_posix.cc"
-#endif
-
-namespace base {
-namespace subtle {
-
-// static
-PlatformSharedMemoryRegion PlatformSharedMemoryRegion::Take(
-    mac::ScopedMachSendRight handle,
-    Mode mode,
-    size_t size,
-    const UnguessableToken& guid) {
-  if (!handle.is_valid())
-    return {};
-
-  if (size == 0)
-    return {};
-
-  if (size > static_cast<size_t>(std::numeric_limits<int>::max()))
-    return {};
-
-  CHECK(
-      CheckPlatformHandlePermissionsCorrespondToMode(handle.get(), mode, size));
-
-  return PlatformSharedMemoryRegion(std::move(handle), mode, size, guid);
-}
-
-mach_port_t PlatformSharedMemoryRegion::GetPlatformHandle() const {
-  return handle_.get();
-}
-
-bool PlatformSharedMemoryRegion::IsValid() const {
-  return handle_.is_valid();
-}
-
-PlatformSharedMemoryRegion PlatformSharedMemoryRegion::Duplicate() const {
-  if (!IsValid())
-    return {};
-
-  CHECK_NE(mode_, Mode::kWritable)
-      << "Duplicating a writable shared memory region is prohibited";
-
-  // Increment the ref count.
-  kern_return_t kr = mach_port_mod_refs(mach_task_self(), handle_.get(),
-                                        MACH_PORT_RIGHT_SEND, 1);
-  if (kr != KERN_SUCCESS) {
-    MACH_DLOG(ERROR, kr) << "mach_port_mod_refs";
-    return {};
-  }
-
-  return PlatformSharedMemoryRegion(mac::ScopedMachSendRight(handle_.get()),
-                                    mode_, size_, guid_);
-}
-
-bool PlatformSharedMemoryRegion::ConvertToReadOnly() {
-  return ConvertToReadOnly(nullptr);
-}
-
-bool PlatformSharedMemoryRegion::ConvertToReadOnly(void* mapped_addr) {
-  if (!IsValid())
-    return false;
-
-  CHECK_EQ(mode_, Mode::kWritable)
-      << "Only writable shared memory region can be converted to read-only";
-
-  mac::ScopedMachSendRight handle_copy(handle_.release());
-
-  void* temp_addr = mapped_addr;
-  mac::ScopedMachVM scoped_memory;
-  if (!temp_addr) {
-    // Intentionally lower current prot and max prot to |VM_PROT_READ|.
-    kern_return_t kr = mach_vm_map(
-        mach_task_self(), reinterpret_cast<mach_vm_address_t*>(&temp_addr),
-        size_, 0, VM_FLAGS_ANYWHERE, handle_copy.get(), 0, FALSE, VM_PROT_READ,
-        VM_PROT_READ, VM_INHERIT_NONE);
-    if (kr != KERN_SUCCESS) {
-      MACH_DLOG(ERROR, kr) << "mach_vm_map";
-      return false;
-    }
-    scoped_memory.reset(reinterpret_cast<vm_address_t>(temp_addr),
-                        mach_vm_round_page(size_));
-  }
-
-  // Make new memory object.
-  memory_object_size_t allocation_size = size_;
-  mac::ScopedMachSendRight named_right;
-  kern_return_t kr = mach_make_memory_entry_64(
-      mach_task_self(), &allocation_size,
-      reinterpret_cast<memory_object_offset_t>(temp_addr), VM_PROT_READ,
-      named_right.receive(), MACH_PORT_NULL);
-  if (kr != KERN_SUCCESS) {
-    MACH_DLOG(ERROR, kr) << "mach_make_memory_entry_64";
-    return false;
-  }
-  DCHECK_GE(allocation_size, size_);
-
-  handle_ = std::move(named_right);
-  mode_ = Mode::kReadOnly;
-  return true;
-}
-
-bool PlatformSharedMemoryRegion::MapAt(off_t offset,
-                                       size_t size,
-                                       void** memory,
-                                       size_t* mapped_size) const {
-  if (!IsValid())
-    return false;
-
-  size_t end_byte;
-  if (!CheckAdd(offset, size).AssignIfValid(&end_byte) || end_byte > size_) {
-    return false;
-  }
-
-  bool write_allowed = mode_ != Mode::kReadOnly;
-  vm_prot_t vm_prot_write = write_allowed ? VM_PROT_WRITE : 0;
-  kern_return_t kr = mach_vm_map(
-      mach_task_self(),
-      reinterpret_cast<mach_vm_address_t*>(memory),  // Output parameter
-      size,
-      0,  // Alignment mask
-      VM_FLAGS_ANYWHERE, handle_.get(), offset,
-      FALSE,                         // Copy
-      VM_PROT_READ | vm_prot_write,  // Current protection
-      VM_PROT_READ | vm_prot_write,  // Maximum protection
-      VM_INHERIT_NONE);
-  if (kr != KERN_SUCCESS) {
-    MACH_DLOG(ERROR, kr) << "mach_vm_map";
-    return false;
-  }
-
-  *mapped_size = size;
-  DCHECK_EQ(0U,
-            reinterpret_cast<uintptr_t>(*memory) & (kMapMinimumAlignment - 1));
-  return true;
-}
-
-// static
-PlatformSharedMemoryRegion PlatformSharedMemoryRegion::Create(Mode mode,
-                                                              size_t size) {
-  if (size == 0)
-    return {};
-
-  if (size > static_cast<size_t>(std::numeric_limits<int>::max()))
-    return {};
-
-  CHECK_NE(mode, Mode::kReadOnly) << "Creating a region in read-only mode will "
-                                     "lead to this region being non-modifiable";
-
-  mach_vm_size_t vm_size = size;
-  mac::ScopedMachSendRight named_right;
-  kern_return_t kr = mach_make_memory_entry_64(
-      mach_task_self(), &vm_size,
-      0,  // Address.
-      MAP_MEM_NAMED_CREATE | VM_PROT_READ | VM_PROT_WRITE,
-      named_right.receive(),
-      MACH_PORT_NULL);  // Parent handle.
-  if (kr != KERN_SUCCESS) {
-    MACH_DLOG(ERROR, kr) << "mach_make_memory_entry_64";
-    return {};
-  }
-  DCHECK_GE(vm_size, size);
-
-  return PlatformSharedMemoryRegion(std::move(named_right), mode, size,
-                                    UnguessableToken::Create());
-}
-
-// static
-bool PlatformSharedMemoryRegion::CheckPlatformHandlePermissionsCorrespondToMode(
-    PlatformHandle handle,
-    Mode mode,
-    size_t size) {
-  mach_vm_address_t temp_addr = 0;
-  kern_return_t kr =
-      mach_vm_map(mach_task_self(), &temp_addr, size, 0, VM_FLAGS_ANYWHERE,
-                  handle, 0, FALSE, VM_PROT_READ | VM_PROT_WRITE,
-                  VM_PROT_READ | VM_PROT_WRITE, VM_INHERIT_NONE);
-  if (kr == KERN_SUCCESS) {
-    kern_return_t kr_deallocate =
-        mach_vm_deallocate(mach_task_self(), temp_addr, size);
-    MACH_DLOG_IF(ERROR, kr_deallocate != KERN_SUCCESS, kr_deallocate)
-        << "mach_vm_deallocate";
-  } else if (kr != KERN_INVALID_RIGHT) {
-    MACH_DLOG(ERROR, kr) << "mach_vm_map";
-    return false;
-  }
-
-  bool is_read_only = kr == KERN_INVALID_RIGHT;
-  bool expected_read_only = mode == Mode::kReadOnly;
-
-  if (is_read_only != expected_read_only) {
-    DLOG(ERROR) << "VM region has a wrong protection mask: it is"
-                << (is_read_only ? " " : " not ") << "read-only but it should"
-                << (expected_read_only ? " " : " not ") << "be";
-    return false;
-  }
-
-  return true;
-}
-
-PlatformSharedMemoryRegion::PlatformSharedMemoryRegion(
-    mac::ScopedMachSendRight handle,
-    Mode mode,
-    size_t size,
-    const UnguessableToken& guid)
-    : handle_(std::move(handle)), mode_(mode), size_(size), guid_(guid) {}
-
-}  // namespace subtle
-}  // namespace base
diff --git a/base/memory/platform_shared_memory_region_posix.cc b/base/memory/platform_shared_memory_region_posix.cc
deleted file mode 100644
index 422cec5..0000000
--- a/base/memory/platform_shared_memory_region_posix.cc
+++ /dev/null
@@ -1,291 +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/memory/platform_shared_memory_region.h"
-
-#include <fcntl.h>
-#include <sys/mman.h>
-#include <sys/stat.h>
-
-#include "base/files/file_util.h"
-#include "base/numerics/checked_math.h"
-#include "base/threading/thread_restrictions.h"
-#include "build_config.h"
-
-namespace base {
-namespace subtle {
-
-namespace {
-
-struct ScopedPathUnlinkerTraits {
-  static const FilePath* InvalidValue() { return nullptr; }
-
-  static void Free(const FilePath* path) {
-    if (unlink(path->value().c_str()))
-      PLOG(WARNING) << "unlink";
-  }
-};
-
-// Unlinks the FilePath when the object is destroyed.
-using ScopedPathUnlinker =
-    ScopedGeneric<const FilePath*, ScopedPathUnlinkerTraits>;
-
-bool CheckFDAccessMode(int fd, int expected_mode) {
-  int fd_status = fcntl(fd, F_GETFL);
-  if (fd_status == -1) {
-    DPLOG(ERROR) << "fcntl(" << fd << ", F_GETFL) failed";
-    return false;
-  }
-
-  int mode = fd_status & O_ACCMODE;
-  if (mode != expected_mode) {
-    DLOG(ERROR) << "Descriptor access mode (" << mode
-                << ") differs from expected (" << expected_mode << ")";
-    return false;
-  }
-
-  return true;
-}
-
-}  // namespace
-
-ScopedFDPair::ScopedFDPair() = default;
-
-ScopedFDPair::ScopedFDPair(ScopedFDPair&&) = default;
-
-ScopedFDPair& ScopedFDPair::operator=(ScopedFDPair&&) = default;
-
-ScopedFDPair::~ScopedFDPair() = default;
-
-ScopedFDPair::ScopedFDPair(ScopedFD in_fd, ScopedFD in_readonly_fd)
-    : fd(std::move(in_fd)), readonly_fd(std::move(in_readonly_fd)) {}
-
-FDPair ScopedFDPair::get() const {
-  return {fd.get(), readonly_fd.get()};
-}
-
-// static
-PlatformSharedMemoryRegion PlatformSharedMemoryRegion::Take(
-    ScopedFDPair handle,
-    Mode mode,
-    size_t size,
-    const UnguessableToken& guid) {
-  if (!handle.fd.is_valid())
-    return {};
-
-  if (size == 0)
-    return {};
-
-  if (size > static_cast<size_t>(std::numeric_limits<int>::max()))
-    return {};
-
-  CHECK(
-      CheckPlatformHandlePermissionsCorrespondToMode(handle.get(), mode, size));
-
-  switch (mode) {
-    case Mode::kReadOnly:
-    case Mode::kUnsafe:
-      if (handle.readonly_fd.is_valid()) {
-        handle.readonly_fd.reset();
-        DLOG(WARNING) << "Readonly handle shouldn't be valid for a "
-                         "non-writable memory region; closing";
-      }
-      break;
-    case Mode::kWritable:
-      if (!handle.readonly_fd.is_valid()) {
-        DLOG(ERROR)
-            << "Readonly handle must be valid for writable memory region";
-        return {};
-      }
-      break;
-    default:
-      DLOG(ERROR) << "Invalid permission mode: " << static_cast<int>(mode);
-      return {};
-  }
-
-  return PlatformSharedMemoryRegion(std::move(handle), mode, size, guid);
-}
-
-FDPair PlatformSharedMemoryRegion::GetPlatformHandle() const {
-  return handle_.get();
-}
-
-bool PlatformSharedMemoryRegion::IsValid() const {
-  return handle_.fd.is_valid() &&
-         (mode_ == Mode::kWritable ? handle_.readonly_fd.is_valid() : true);
-}
-
-PlatformSharedMemoryRegion PlatformSharedMemoryRegion::Duplicate() const {
-  if (!IsValid())
-    return {};
-
-  CHECK_NE(mode_, Mode::kWritable)
-      << "Duplicating a writable shared memory region is prohibited";
-
-  ScopedFD duped_fd(HANDLE_EINTR(dup(handle_.fd.get())));
-  if (!duped_fd.is_valid()) {
-    DPLOG(ERROR) << "dup(" << handle_.fd.get() << ") failed";
-    return {};
-  }
-
-  return PlatformSharedMemoryRegion({std::move(duped_fd), ScopedFD()}, mode_,
-                                    size_, guid_);
-}
-
-bool PlatformSharedMemoryRegion::ConvertToReadOnly() {
-  if (!IsValid())
-    return false;
-
-  CHECK_EQ(mode_, Mode::kWritable)
-      << "Only writable shared memory region can be converted to read-only";
-
-  handle_.fd.reset(handle_.readonly_fd.release());
-  mode_ = Mode::kReadOnly;
-  return true;
-}
-
-bool PlatformSharedMemoryRegion::MapAt(off_t offset,
-                                       size_t size,
-                                       void** memory,
-                                       size_t* mapped_size) const {
-  if (!IsValid())
-    return false;
-
-  size_t end_byte;
-  if (!CheckAdd(offset, size).AssignIfValid(&end_byte) || end_byte > size_) {
-    return false;
-  }
-
-  bool write_allowed = mode_ != Mode::kReadOnly;
-  *memory = mmap(nullptr, size, PROT_READ | (write_allowed ? PROT_WRITE : 0),
-                 MAP_SHARED, handle_.fd.get(), offset);
-
-  bool mmap_succeeded = *memory && *memory != reinterpret_cast<void*>(-1);
-  if (!mmap_succeeded) {
-    DPLOG(ERROR) << "mmap " << handle_.fd.get() << " failed";
-    return false;
-  }
-
-  *mapped_size = size;
-  DCHECK_EQ(0U,
-            reinterpret_cast<uintptr_t>(*memory) & (kMapMinimumAlignment - 1));
-  return true;
-}
-
-// static
-PlatformSharedMemoryRegion PlatformSharedMemoryRegion::Create(Mode mode,
-                                                              size_t size) {
-#if defined(OS_NACL)
-  // Untrusted code can't create descriptors or handles.
-  return {};
-#else
-  if (size == 0)
-    return {};
-
-  if (size > static_cast<size_t>(std::numeric_limits<int>::max()))
-    return {};
-
-  CHECK_NE(mode, Mode::kReadOnly) << "Creating a region in read-only mode will "
-                                     "lead to this region being non-modifiable";
-
-  // This function theoretically can block on the disk, but realistically
-  // the temporary files we create will just go into the buffer cache
-  // and be deleted before they ever make it out to disk.
-  ThreadRestrictions::ScopedAllowIO allow_io;
-
-  // We don't use shm_open() API in order to support the --disable-dev-shm-usage
-  // flag.
-  FilePath directory;
-  if (!GetShmemTempDir(false /* executable */, &directory))
-    return {};
-
-  ScopedFD fd;
-  FilePath path;
-  fd.reset(CreateAndOpenFdForTemporaryFileInDir(directory, &path));
-
-  if (!fd.is_valid()) {
-    PLOG(ERROR) << "Creating shared memory in " << path.value() << " failed";
-    FilePath dir = path.DirName();
-    if (access(dir.value().c_str(), W_OK | X_OK) < 0) {
-      PLOG(ERROR) << "Unable to access(W_OK|X_OK) " << dir.value();
-      if (dir.value() == "/dev/shm") {
-        LOG(FATAL) << "This is frequently caused by incorrect permissions on "
-                   << "/dev/shm.  Try 'sudo chmod 1777 /dev/shm' to fix.";
-      }
-    }
-    return {};
-  }
-
-  // Deleting the file prevents anyone else from mapping it in (making it
-  // private), and prevents the need for cleanup (once the last fd is
-  // closed, it is truly freed).
-  ScopedPathUnlinker path_unlinker(&path);
-
-  ScopedFD readonly_fd;
-  if (mode == Mode::kWritable) {
-    // Also open as readonly so that we can ConvertToReadOnly().
-    readonly_fd.reset(HANDLE_EINTR(open(path.value().c_str(), O_RDONLY)));
-    if (!readonly_fd.is_valid()) {
-      DPLOG(ERROR) << "open(\"" << path.value() << "\", O_RDONLY) failed";
-      return {};
-    }
-  }
-
-  // Get current size.
-  struct stat stat = {};
-  if (fstat(fd.get(), &stat) != 0)
-    return {};
-  const size_t current_size = stat.st_size;
-  if (current_size != size) {
-    if (HANDLE_EINTR(ftruncate(fd.get(), size)) != 0)
-      return {};
-  }
-
-  if (readonly_fd.is_valid()) {
-    struct stat readonly_stat = {};
-    if (fstat(readonly_fd.get(), &readonly_stat))
-      NOTREACHED();
-
-    if (stat.st_dev != readonly_stat.st_dev ||
-        stat.st_ino != readonly_stat.st_ino) {
-      LOG(ERROR) << "Writable and read-only inodes don't match; bailing";
-      return {};
-    }
-  }
-
-  return PlatformSharedMemoryRegion({std::move(fd), std::move(readonly_fd)},
-                                    mode, size, UnguessableToken::Create());
-#endif  // !defined(OS_NACL)
-}
-
-bool PlatformSharedMemoryRegion::CheckPlatformHandlePermissionsCorrespondToMode(
-    PlatformHandle handle,
-    Mode mode,
-    size_t size) {
-  if (!CheckFDAccessMode(handle.fd,
-                         mode == Mode::kReadOnly ? O_RDONLY : O_RDWR)) {
-    return false;
-  }
-
-  if (mode == Mode::kWritable)
-    return CheckFDAccessMode(handle.readonly_fd, O_RDONLY);
-
-  // The second descriptor must be invalid in kReadOnly and kUnsafe modes.
-  if (handle.readonly_fd != -1) {
-    DLOG(ERROR) << "The second descriptor must be invalid";
-    return false;
-  }
-
-  return true;
-}
-
-PlatformSharedMemoryRegion::PlatformSharedMemoryRegion(
-    ScopedFDPair handle,
-    Mode mode,
-    size_t size,
-    const UnguessableToken& guid)
-    : handle_(std::move(handle)), mode_(mode), size_(size), guid_(guid) {}
-
-}  // namespace subtle
-}  // namespace base
diff --git a/base/memory/platform_shared_memory_region_win.cc b/base/memory/platform_shared_memory_region_win.cc
deleted file mode 100644
index b6608da..0000000
--- a/base/memory/platform_shared_memory_region_win.cc
+++ /dev/null
@@ -1,345 +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/memory/platform_shared_memory_region.h"
-
-#include <aclapi.h>
-#include <stddef.h>
-#include <stdint.h>
-
-#include "base/allocator/partition_allocator/page_allocator.h"
-#include "base/bits.h"
-#include "base/metrics/histogram_functions.h"
-#include "base/metrics/histogram_macros.h"
-#include "base/numerics/checked_math.h"
-#include "base/process/process_handle.h"
-#include "base/rand_util.h"
-#include "base/strings/stringprintf.h"
-
-namespace base {
-namespace subtle {
-
-namespace {
-
-// Errors that can occur during Shared Memory construction.
-// These match tools/metrics/histograms/histograms.xml.
-// This enum is append-only.
-enum CreateError {
-  SUCCESS = 0,
-  SIZE_ZERO = 1,
-  SIZE_TOO_LARGE = 2,
-  INITIALIZE_ACL_FAILURE = 3,
-  INITIALIZE_SECURITY_DESC_FAILURE = 4,
-  SET_SECURITY_DESC_FAILURE = 5,
-  CREATE_FILE_MAPPING_FAILURE = 6,
-  REDUCE_PERMISSIONS_FAILURE = 7,
-  ALREADY_EXISTS = 8,
-  CREATE_ERROR_LAST = ALREADY_EXISTS
-};
-
-// Emits UMA metrics about encountered errors. Pass zero (0) for |winerror|
-// if there is no associated Windows error.
-void LogError(CreateError error, DWORD winerror) {
-  UMA_HISTOGRAM_ENUMERATION("SharedMemory.CreateError", error,
-                            CREATE_ERROR_LAST + 1);
-  static_assert(ERROR_SUCCESS == 0, "Windows error code changed!");
-  if (winerror != ERROR_SUCCESS)
-    UmaHistogramSparse("SharedMemory.CreateWinError", winerror);
-}
-
-typedef enum _SECTION_INFORMATION_CLASS {
-  SectionBasicInformation,
-} SECTION_INFORMATION_CLASS;
-
-typedef struct _SECTION_BASIC_INFORMATION {
-  PVOID BaseAddress;
-  ULONG Attributes;
-  LARGE_INTEGER Size;
-} SECTION_BASIC_INFORMATION, *PSECTION_BASIC_INFORMATION;
-
-typedef ULONG(__stdcall* NtQuerySectionType)(
-    HANDLE SectionHandle,
-    SECTION_INFORMATION_CLASS SectionInformationClass,
-    PVOID SectionInformation,
-    ULONG SectionInformationLength,
-    PULONG ResultLength);
-
-// Returns the length of the memory section starting at the supplied address.
-size_t GetMemorySectionSize(void* address) {
-  MEMORY_BASIC_INFORMATION memory_info;
-  if (!::VirtualQuery(address, &memory_info, sizeof(memory_info)))
-    return 0;
-  return memory_info.RegionSize -
-         (static_cast<char*>(address) -
-          static_cast<char*>(memory_info.AllocationBase));
-}
-
-// Checks if the section object is safe to map. At the moment this just means
-// it's not an image section.
-bool IsSectionSafeToMap(HANDLE handle) {
-  static NtQuerySectionType nt_query_section_func =
-      reinterpret_cast<NtQuerySectionType>(
-          ::GetProcAddress(::GetModuleHandle(L"ntdll.dll"), "NtQuerySection"));
-  DCHECK(nt_query_section_func);
-
-  // The handle must have SECTION_QUERY access for this to succeed.
-  SECTION_BASIC_INFORMATION basic_information = {};
-  ULONG status =
-      nt_query_section_func(handle, SectionBasicInformation, &basic_information,
-                            sizeof(basic_information), nullptr);
-  if (status)
-    return false;
-  return (basic_information.Attributes & SEC_IMAGE) != SEC_IMAGE;
-}
-
-// Returns a HANDLE on success and |nullptr| on failure.
-// This function is similar to CreateFileMapping, but removes the permissions
-// WRITE_DAC, WRITE_OWNER, READ_CONTROL, and DELETE.
-//
-// A newly created file mapping has two sets of permissions. It has access
-// control permissions (WRITE_DAC, WRITE_OWNER, READ_CONTROL, and DELETE) and
-// file permissions (FILE_MAP_READ, FILE_MAP_WRITE, etc.). The Chrome sandbox
-// prevents HANDLEs with the WRITE_DAC permission from being duplicated into
-// unprivileged processes.
-//
-// In order to remove the access control permissions, after being created the
-// handle is duplicated with only the file access permissions.
-HANDLE CreateFileMappingWithReducedPermissions(SECURITY_ATTRIBUTES* sa,
-                                               size_t rounded_size,
-                                               LPCWSTR name) {
-  HANDLE h = CreateFileMapping(INVALID_HANDLE_VALUE, sa, PAGE_READWRITE, 0,
-                               static_cast<DWORD>(rounded_size), name);
-  if (!h) {
-    LogError(CREATE_FILE_MAPPING_FAILURE, GetLastError());
-    return nullptr;
-  }
-
-  HANDLE h2;
-  ProcessHandle process = GetCurrentProcess();
-  BOOL success = ::DuplicateHandle(
-      process, h, process, &h2, FILE_MAP_READ | FILE_MAP_WRITE | SECTION_QUERY,
-      FALSE, 0);
-  BOOL rv = ::CloseHandle(h);
-  DCHECK(rv);
-
-  if (!success) {
-    LogError(REDUCE_PERMISSIONS_FAILURE, GetLastError());
-    return nullptr;
-  }
-
-  return h2;
-}
-
-}  // namespace
-
-// static
-PlatformSharedMemoryRegion PlatformSharedMemoryRegion::Take(
-    win::ScopedHandle handle,
-    Mode mode,
-    size_t size,
-    const UnguessableToken& guid) {
-  if (!handle.IsValid())
-    return {};
-
-  if (size == 0)
-    return {};
-
-  if (size > static_cast<size_t>(std::numeric_limits<int>::max()))
-    return {};
-
-  if (!IsSectionSafeToMap(handle.Get()))
-    return {};
-
-  CHECK(
-      CheckPlatformHandlePermissionsCorrespondToMode(handle.Get(), mode, size));
-
-  return PlatformSharedMemoryRegion(std::move(handle), mode, size, guid);
-}
-
-HANDLE PlatformSharedMemoryRegion::GetPlatformHandle() const {
-  return handle_.Get();
-}
-
-bool PlatformSharedMemoryRegion::IsValid() const {
-  return handle_.IsValid();
-}
-
-PlatformSharedMemoryRegion PlatformSharedMemoryRegion::Duplicate() const {
-  if (!IsValid())
-    return {};
-
-  CHECK_NE(mode_, Mode::kWritable)
-      << "Duplicating a writable shared memory region is prohibited";
-
-  HANDLE duped_handle;
-  ProcessHandle process = GetCurrentProcess();
-  BOOL success =
-      ::DuplicateHandle(process, handle_.Get(), process, &duped_handle, 0,
-                        FALSE, DUPLICATE_SAME_ACCESS);
-  if (!success)
-    return {};
-
-  return PlatformSharedMemoryRegion(win::ScopedHandle(duped_handle), mode_,
-                                    size_, guid_);
-}
-
-bool PlatformSharedMemoryRegion::ConvertToReadOnly() {
-  if (!IsValid())
-    return false;
-
-  CHECK_EQ(mode_, Mode::kWritable)
-      << "Only writable shared memory region can be converted to read-only";
-
-  win::ScopedHandle handle_copy(handle_.Take());
-
-  HANDLE duped_handle;
-  ProcessHandle process = GetCurrentProcess();
-  BOOL success =
-      ::DuplicateHandle(process, handle_copy.Get(), process, &duped_handle,
-                        FILE_MAP_READ | SECTION_QUERY, FALSE, 0);
-  if (!success)
-    return false;
-
-  handle_.Set(duped_handle);
-  mode_ = Mode::kReadOnly;
-  return true;
-}
-
-bool PlatformSharedMemoryRegion::MapAt(off_t offset,
-                                       size_t size,
-                                       void** memory,
-                                       size_t* mapped_size) const {
-  if (!IsValid())
-    return false;
-
-  size_t end_byte;
-  if (!CheckAdd(offset, size).AssignIfValid(&end_byte) || end_byte > size_) {
-    return false;
-  }
-
-  bool write_allowed = mode_ != Mode::kReadOnly;
-  // Try to map the shared memory. On the first failure, release any reserved
-  // address space for a single entry.
-  for (int i = 0; i < 2; ++i) {
-    *memory = MapViewOfFile(
-        handle_.Get(), FILE_MAP_READ | (write_allowed ? FILE_MAP_WRITE : 0),
-        static_cast<uint64_t>(offset) >> 32, static_cast<DWORD>(offset), size);
-    if (*memory)
-      break;
-    ReleaseReservation();
-  }
-  if (!*memory) {
-    DPLOG(ERROR) << "Failed executing MapViewOfFile";
-    return false;
-  }
-
-  *mapped_size = GetMemorySectionSize(*memory);
-  DCHECK_EQ(0U,
-            reinterpret_cast<uintptr_t>(*memory) & (kMapMinimumAlignment - 1));
-  return true;
-}
-
-// static
-PlatformSharedMemoryRegion PlatformSharedMemoryRegion::Create(Mode mode,
-                                                              size_t size) {
-  // TODO(crbug.com/210609): NaCl forces us to round up 64k here, wasting 32k
-  // per mapping on average.
-  static const size_t kSectionSize = 65536;
-  if (size == 0) {
-    LogError(SIZE_ZERO, 0);
-    return {};
-  }
-
-  size_t rounded_size = bits::Align(size, kSectionSize);
-  if (rounded_size > static_cast<size_t>(std::numeric_limits<int>::max())) {
-    LogError(SIZE_TOO_LARGE, 0);
-    return {};
-  }
-
-  CHECK_NE(mode, Mode::kReadOnly) << "Creating a region in read-only mode will "
-                                     "lead to this region being non-modifiable";
-
-  // Add an empty DACL to enforce anonymous read-only sections.
-  ACL dacl;
-  SECURITY_DESCRIPTOR sd;
-  if (!InitializeAcl(&dacl, sizeof(dacl), ACL_REVISION)) {
-    LogError(INITIALIZE_ACL_FAILURE, GetLastError());
-    return {};
-  }
-  if (!InitializeSecurityDescriptor(&sd, SECURITY_DESCRIPTOR_REVISION)) {
-    LogError(INITIALIZE_SECURITY_DESC_FAILURE, GetLastError());
-    return {};
-  }
-  if (!SetSecurityDescriptorDacl(&sd, TRUE, &dacl, FALSE)) {
-    LogError(SET_SECURITY_DESC_FAILURE, GetLastError());
-    return {};
-  }
-
-  // Windows ignores DACLs on unnamed shared section. Generate a random name in
-  // order to be able to enforce read-only.
-  uint64_t rand_values[4];
-  RandBytes(&rand_values, sizeof(rand_values));
-  string16 name =
-      StringPrintf(L"CrSharedMem_%016llx%016llx%016llx%016llx", rand_values[0],
-                   rand_values[1], rand_values[2], rand_values[3]);
-
-  SECURITY_ATTRIBUTES sa = {sizeof(sa), &sd, FALSE};
-  // Ask for the file mapping with reduced permisions to avoid passing the
-  // access control permissions granted by default into unpriviledged process.
-  HANDLE h =
-      CreateFileMappingWithReducedPermissions(&sa, rounded_size, name.c_str());
-  if (h == nullptr) {
-    // The error is logged within CreateFileMappingWithReducedPermissions().
-    return {};
-  }
-
-  win::ScopedHandle scoped_h(h);
-  // Check if the shared memory pre-exists.
-  if (GetLastError() == ERROR_ALREADY_EXISTS) {
-    LogError(ALREADY_EXISTS, ERROR_ALREADY_EXISTS);
-    return {};
-  }
-
-  return PlatformSharedMemoryRegion(std::move(scoped_h), mode, size,
-                                    UnguessableToken::Create());
-}
-
-// static
-bool PlatformSharedMemoryRegion::CheckPlatformHandlePermissionsCorrespondToMode(
-    PlatformHandle handle,
-    Mode mode,
-    size_t size) {
-  // Call ::DuplicateHandle() with FILE_MAP_WRITE as a desired access to check
-  // if the |handle| has a write access.
-  ProcessHandle process = GetCurrentProcess();
-  HANDLE duped_handle;
-  BOOL success = ::DuplicateHandle(process, handle, process, &duped_handle,
-                                   FILE_MAP_WRITE, FALSE, 0);
-  if (success) {
-    BOOL rv = ::CloseHandle(duped_handle);
-    DCHECK(rv);
-  }
-
-  bool is_read_only = !success;
-  bool expected_read_only = mode == Mode::kReadOnly;
-
-  if (is_read_only != expected_read_only) {
-    DLOG(ERROR) << "File mapping handle has wrong access rights: it is"
-                << (is_read_only ? " " : " not ") << "read-only but it should"
-                << (expected_read_only ? " " : " not ") << "be";
-    return false;
-  }
-
-  return true;
-}
-
-PlatformSharedMemoryRegion::PlatformSharedMemoryRegion(
-    win::ScopedHandle handle,
-    Mode mode,
-    size_t size,
-    const UnguessableToken& guid)
-    : handle_(std::move(handle)), mode_(mode), size_(size), guid_(guid) {}
-
-}  // namespace subtle
-}  // namespace base
diff --git a/base/memory/protected_memory.cc b/base/memory/protected_memory.cc
deleted file mode 100644
index 157a677..0000000
--- a/base/memory/protected_memory.cc
+++ /dev/null
@@ -1,17 +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/memory/protected_memory.h"
-#include "base/synchronization/lock.h"
-
-namespace base {
-
-#if !defined(COMPONENT_BUILD)
-PROTECTED_MEMORY_SECTION int AutoWritableMemory::writers = 0;
-#endif  // !defined(COMPONENT_BUILD)
-
-base::LazyInstance<Lock>::Leaky AutoWritableMemory::writers_lock =
-    LAZY_INSTANCE_INITIALIZER;
-
-}  // namespace base
diff --git a/base/memory/protected_memory.h b/base/memory/protected_memory.h
deleted file mode 100644
index 9f372ca..0000000
--- a/base/memory/protected_memory.h
+++ /dev/null
@@ -1,261 +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.
-
-// Protected memory is memory holding security-sensitive data intended to be
-// left read-only for the majority of its lifetime to avoid being overwritten
-// by attackers. ProtectedMemory is a simple wrapper around platform-specific
-// APIs to set memory read-write and read-only when required. Protected memory
-// should be set read-write for the minimum amount of time required.
-
-// Normally mutable variables are held in read-write memory and constant data
-// is held in read-only memory to ensure it is not accidentally overwritten.
-// In some cases we want to hold mutable variables in read-only memory, except
-// when they are being written to, to ensure that they are not tampered with.
-//
-// ProtectedMemory is a container class intended to hold a single variable in
-// read-only memory, except when explicitly set read-write. The variable can be
-// set read-write by creating a scoped AutoWritableMemory object by calling
-// AutoWritableMemory::Create(), the memory stays writable until the returned
-// object goes out of scope and is destructed. The wrapped variable can be
-// accessed using operator* and operator->.
-//
-// Instances of ProtectedMemory must be declared in the PROTECTED_MEMORY_SECTION
-// and as global variables. Because protected memory variables are globals, the
-// the same rules apply disallowing non-trivial constructors and destructors.
-// Global definitions are required to avoid the linker placing statics in
-// inlinable functions into a comdat section and setting the protected memory
-// section read-write when they are merged.
-//
-// EXAMPLE:
-//
-//  struct Items { void* item1; };
-//  static PROTECTED_MEMORY_SECTION base::ProtectedMemory<Items> items;
-//  void InitializeItems() {
-//    // Explicitly set items read-write before writing to it.
-//    auto writer = base::AutoWritableMemory::Create(items);
-//    items->item1 = /* ... */;
-//    assert(items->item1 != nullptr);
-//    // items is set back to read-only on the destruction of writer
-//  }
-//
-//  using FnPtr = void (*)(void);
-//  PROTECTED_MEMORY_SECTION base::ProtectedMemory<FnPtr> fnPtr;
-//  FnPtr ResolveFnPtr(void) {
-//    // The Initializer nested class is a helper class for creating a static
-//    // initializer for a ProtectedMemory variable. It implicitly sets the
-//    // variable read-write during initialization.
-//    static base::ProtectedMemory<FnPtr>::Initializer I(&fnPtr,
-//      reinterpret_cast<FnPtr>(dlsym(/* ... */)));
-//    return *fnPtr;
-//  }
-
-#ifndef BASE_MEMORY_PROTECTED_MEMORY_H_
-#define BASE_MEMORY_PROTECTED_MEMORY_H_
-
-#include "base/lazy_instance.h"
-#include "base/logging.h"
-#include "base/macros.h"
-#include "base/synchronization/lock.h"
-#include "build_config.h"
-
-#define PROTECTED_MEMORY_ENABLED 1
-
-#if defined(OS_MACOSX) && !defined(OS_IOS)
-// The segment the section is in is defined read-only with a linker flag in
-// build/config/mac/BUILD.gn
-#define PROTECTED_MEMORY_SECTION \
-  __attribute__((section("PROTECTED_MEMORY, protected_memory")))
-extern char __start_protected_memory __asm(
-    "section$start$PROTECTED_MEMORY$protected_memory");
-extern char __stop_protected_memory __asm(
-    "section$end$PROTECTED_MEMORY$protected_memory");
-
-#elif defined(OS_WIN)
-// Define a read-write prot section. The $a, $mem, and $z 'sub-sections' are
-// merged alphabetically so $a and $z are used to define the start and end of
-// the protected memory section, and $mem holds protected variables.
-// (Note: Sections in Portable Executables are equivalent to segments in other
-// executable formats, so this section is mapped into its own pages.)
-#pragma section("prot$a", read, write)
-#pragma section("prot$mem", read, write)
-#pragma section("prot$z", read, write)
-
-// We want the protected memory section to be read-only, not read-write so we
-// instruct the linker to set the section read-only at link time. We do this
-// at link time instead of compile time, because defining the prot section
-// read-only would cause mis-compiles due to optimizations assuming that the
-// section contents are constant.
-#pragma comment(linker, "/SECTION:prot,R")
-
-__declspec(allocate("prot$a")) __declspec(selectany)
-char __start_protected_memory;
-__declspec(allocate("prot$z")) __declspec(selectany)
-char __stop_protected_memory;
-
-#define PROTECTED_MEMORY_SECTION __declspec(allocate("prot$mem"))
-
-#else
-#undef PROTECTED_MEMORY_ENABLED
-#define PROTECTED_MEMORY_ENABLED 0
-#define PROTECTED_MEMORY_SECTION
-#endif
-
-namespace base {
-
-template <typename T>
-class ProtectedMemory {
- public:
-  ProtectedMemory() = default;
-
-  // Expose direct access to the encapsulated variable
-  T& operator*() { return data; }
-  const T& operator*() const { return data; }
-  T* operator->() { return &data; }
-  const T* operator->() const { return &data; }
-
-  // Helper class for creating simple ProtectedMemory static initializers.
-  class Initializer {
-   public:
-    // Defined out-of-line below to break circular definition dependency between
-    // ProtectedMemory and AutoWritableMemory.
-    Initializer(ProtectedMemory<T>* PM, const T& Init);
-
-    DISALLOW_IMPLICIT_CONSTRUCTORS(Initializer);
-  };
-
- private:
-  T data;
-
-  DISALLOW_COPY_AND_ASSIGN(ProtectedMemory);
-};
-
-// DCHECK that the byte at |ptr| is read-only.
-BASE_EXPORT void AssertMemoryIsReadOnly(const void* ptr);
-
-// Abstract out platform-specific methods to get the beginning and end of the
-// PROTECTED_MEMORY_SECTION. ProtectedMemoryEnd returns a pointer to the byte
-// past the end of the PROTECTED_MEMORY_SECTION.
-#if PROTECTED_MEMORY_ENABLED
-constexpr void* ProtectedMemoryStart = &__start_protected_memory;
-constexpr void* ProtectedMemoryEnd = &__stop_protected_memory;
-#endif
-
-#if defined(COMPONENT_BUILD)
-namespace internal {
-
-// For component builds we want to define a separate global writers variable
-// (explained below) in every DSO that includes this header. To do that we use
-// this template to define a global without duplicate symbol errors.
-template <typename T>
-struct DsoSpecific {
-  static T value;
-};
-template <typename T>
-T DsoSpecific<T>::value = 0;
-
-}  // namespace internal
-#endif  // defined(COMPONENT_BUILD)
-
-// A class that sets a given ProtectedMemory variable writable while the
-// AutoWritableMemory is in scope. This class implements the logic for setting
-// the protected memory region read-only/read-write in a thread-safe manner.
-class AutoWritableMemory {
- private:
-  // 'writers' is a global holding the number of ProtectedMemory instances set
-  // writable, used to avoid races setting protected memory readable/writable.
-  // When this reaches zero the protected memory region is set read only.
-  // Access is controlled by writers_lock.
-#if defined(COMPONENT_BUILD)
-  // For component builds writers is a reference to an int defined separately in
-  // every DSO.
-  static constexpr int& writers = internal::DsoSpecific<int>::value;
-#else
-  // Otherwise, we declare writers in the protected memory section to avoid the
-  // scenario where an attacker could overwrite it with a large value and invoke
-  // code that constructs and destructs an AutoWritableMemory. After such a call
-  // protected memory would still be set writable because writers > 0.
-  static int writers;
-#endif  // defined(COMPONENT_BUILD)
-
-  // Synchronizes access to the writers variable and the simultaneous actions
-  // that need to happen alongside writers changes, e.g. setting the protected
-  // memory region readable when writers is decremented to 0.
-  static BASE_EXPORT base::LazyInstance<Lock>::Leaky writers_lock;
-
-  // Abstract out platform-specific memory APIs. |end| points to the byte past
-  // the end of the region of memory having its memory protections changed.
-  BASE_EXPORT bool SetMemoryReadWrite(void* start, void* end);
-  BASE_EXPORT bool SetMemoryReadOnly(void* start, void* end);
-
-  // If this is the first writer (e.g. writers == 0) set the writers variable
-  // read-write. Next, increment writers and set the requested memory writable.
-  AutoWritableMemory(void* ptr, void* ptr_end) {
-#if PROTECTED_MEMORY_ENABLED
-    DCHECK(ptr >= ProtectedMemoryStart && ptr_end <= ProtectedMemoryEnd);
-
-    {
-      base::AutoLock auto_lock(writers_lock.Get());
-      if (writers == 0) {
-        AssertMemoryIsReadOnly(ptr);
-#if !defined(COMPONENT_BUILD)
-        AssertMemoryIsReadOnly(&writers);
-        CHECK(SetMemoryReadWrite(&writers, &writers + 1));
-#endif  // !defined(COMPONENT_BUILD)
-      }
-
-      writers++;
-    }
-
-    CHECK(SetMemoryReadWrite(ptr, ptr_end));
-#endif  // PROTECTED_MEMORY_ENABLED
-  }
-
- public:
-  // Wrap the private constructor to create an easy-to-use interface to
-  // construct AutoWritableMemory objects.
-  template <typename T>
-  static AutoWritableMemory Create(ProtectedMemory<T>& PM) {
-    T* ptr = &*PM;
-    return AutoWritableMemory(ptr, ptr + 1);
-  }
-
-  // Move constructor just increments writers
-  AutoWritableMemory(AutoWritableMemory&& original) {
-#if PROTECTED_MEMORY_ENABLED
-    base::AutoLock auto_lock(writers_lock.Get());
-    CHECK_GT(writers, 0);
-    writers++;
-#endif  // PROTECTED_MEMORY_ENABLED
-  }
-
-  // On destruction decrement writers, and if no other writers exist, set the
-  // entire protected memory region read-only.
-  ~AutoWritableMemory() {
-#if PROTECTED_MEMORY_ENABLED
-    base::AutoLock auto_lock(writers_lock.Get());
-    CHECK_GT(writers, 0);
-    writers--;
-
-    if (writers == 0) {
-      CHECK(SetMemoryReadOnly(ProtectedMemoryStart, ProtectedMemoryEnd));
-#if !defined(COMPONENT_BUILD)
-      AssertMemoryIsReadOnly(&writers);
-#endif  // !defined(COMPONENT_BUILD)
-    }
-#endif  // PROTECTED_MEMORY_ENABLED
-  }
-
-  DISALLOW_IMPLICIT_CONSTRUCTORS(AutoWritableMemory);
-};
-
-template <typename T>
-ProtectedMemory<T>::Initializer::Initializer(ProtectedMemory<T>* PM,
-                                             const T& Init) {
-  AutoWritableMemory writer = AutoWritableMemory::Create(*PM);
-  **PM = Init;
-}
-
-}  // namespace base
-
-#endif  // BASE_MEMORY_PROTECTED_MEMORY_H_
diff --git a/base/memory/protected_memory_cfi.h b/base/memory/protected_memory_cfi.h
deleted file mode 100644
index f5b0121..0000000
--- a/base/memory/protected_memory_cfi.h
+++ /dev/null
@@ -1,81 +0,0 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-// Helper routines to call function pointers stored in protected memory with
-// Control Flow Integrity indirect call checking disabled. Some indirect calls,
-// e.g. dynamically resolved symbols in another DSO, can not be accounted for by
-// CFI-icall. These routines allow those symbols to be called without CFI-icall
-// checking safely by ensuring that they are placed in protected memory.
-
-#ifndef BASE_MEMORY_PROTECTED_MEMORY_CFI_H_
-#define BASE_MEMORY_PROTECTED_MEMORY_CFI_H_
-
-#include <utility>
-
-#include "base/compiler_specific.h"
-#include "base/macros.h"
-#include "base/memory/protected_memory.h"
-#include "build_config.h"
-
-namespace base {
-namespace internal {
-
-// This class is used to exempt calls to function pointers stored in
-// ProtectedMemory from cfi-icall checking. It's not secure to use directly, it
-// should only be used by the UnsanitizedCfiCall() functions below. Given an
-// UnsanitizedCfiCall object, you can use operator() to call the encapsulated
-// function pointer without cfi-icall checking.
-template <typename FunctionType>
-class UnsanitizedCfiCall {
- public:
-  explicit UnsanitizedCfiCall(FunctionType function) : function_(function) {}
-  UnsanitizedCfiCall(UnsanitizedCfiCall&&) = default;
-
-  template <typename... Args>
-  NO_SANITIZE("cfi-icall")
-  auto operator()(Args&&... args) {
-    return function_(std::forward<Args>(args)...);
-  }
-
- private:
-  FunctionType function_;
-
-  DISALLOW_IMPLICIT_CONSTRUCTORS(UnsanitizedCfiCall);
-};
-
-}  // namespace internal
-
-// These functions can be used to call function pointers in ProtectedMemory
-// without cfi-icall checking. They are intended to be used to create an
-// UnsanitizedCfiCall object and immediately call it. UnsanitizedCfiCall objects
-// should not initialized directly or stored because they hold a function
-// pointer that will be called without CFI-icall checking in mutable memory. The
-// functions can be used as shown below:
-
-// ProtectedMemory<void (*)(int)> p;
-// UnsanitizedCfiCall(p)(5); /* In place of (*p)(5); */
-
-template <typename T>
-auto UnsanitizedCfiCall(const ProtectedMemory<T>& PM) {
-#if PROTECTED_MEMORY_ENABLED
-  DCHECK(&PM >= ProtectedMemoryStart && &PM < ProtectedMemoryEnd);
-#endif  // PROTECTED_MEMORY_ENABLED
-  return internal::UnsanitizedCfiCall<T>(*PM);
-}
-
-// struct S { void (*fp)(int); } s;
-// ProtectedMemory<S> p;
-// UnsanitizedCfiCall(p, &S::fp)(5); /* In place of p->fp(5); */
-
-template <typename T, typename Member>
-auto UnsanitizedCfiCall(const ProtectedMemory<T>& PM, Member member) {
-#if PROTECTED_MEMORY_ENABLED
-  DCHECK(&PM >= ProtectedMemoryStart && &PM < ProtectedMemoryEnd);
-#endif  // PROTECTED_MEMORY_ENABLED
-  return internal::UnsanitizedCfiCall<decltype(*PM.*member)>(*PM.*member);
-}
-
-}  // namespace base
-
-#endif  // BASE_MEMORY_PROTECTED_MEMORY_CFI_H_
diff --git a/base/memory/protected_memory_posix.cc b/base/memory/protected_memory_posix.cc
deleted file mode 100644
index 1839e3e..0000000
--- a/base/memory/protected_memory_posix.cc
+++ /dev/null
@@ -1,79 +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/memory/protected_memory.h"
-
-#include <stdint.h>
-#include <sys/mman.h>
-#include <unistd.h>
-
-#if defined(OS_LINUX)
-#include <sys/resource.h>
-#endif  // defined(OS_LINUX)
-
-#if defined(OS_MACOSX) && !defined(OS_IOS)
-#include <mach/mach.h>
-#include <mach/mach_vm.h>
-#endif  // defined(OS_MACOSX) && !defined(OS_IOS)
-
-#include "base/posix/eintr_wrapper.h"
-#include "base/process/process_metrics.h"
-#include "base/synchronization/lock.h"
-#include "build_config.h"
-
-namespace base {
-
-namespace {
-
-bool SetMemory(void* start, void* end, int prot) {
-  DCHECK(end > start);
-  const uintptr_t page_mask = ~(base::GetPageSize() - 1);
-  const uintptr_t page_start = reinterpret_cast<uintptr_t>(start) & page_mask;
-  return mprotect(reinterpret_cast<void*>(page_start),
-                  reinterpret_cast<uintptr_t>(end) - page_start, prot) == 0;
-}
-
-}  // namespace
-
-bool AutoWritableMemory::SetMemoryReadWrite(void* start, void* end) {
-  return SetMemory(start, end, PROT_READ | PROT_WRITE);
-}
-
-bool AutoWritableMemory::SetMemoryReadOnly(void* start, void* end) {
-  return SetMemory(start, end, PROT_READ);
-}
-
-#if defined(OS_LINUX)
-void AssertMemoryIsReadOnly(const void* ptr) {
-#if DCHECK_IS_ON()
-  const uintptr_t page_mask = ~(base::GetPageSize() - 1);
-  const uintptr_t page_start = reinterpret_cast<uintptr_t>(ptr) & page_mask;
-
-  // Note: We've casted away const here, which should not be meaningful since
-  // if the memory is written to we will abort immediately.
-  int result =
-      getrlimit(RLIMIT_NPROC, reinterpret_cast<struct rlimit*>(page_start));
-  DCHECK_EQ(result, -1);
-  DCHECK_EQ(errno, EFAULT);
-#endif  // DCHECK_IS_ON()
-}
-#elif defined(OS_MACOSX) && !defined(OS_IOS)
-void AssertMemoryIsReadOnly(const void* ptr) {
-#if DCHECK_IS_ON()
-  mach_port_t object_name;
-  vm_region_basic_info_64 region_info;
-  mach_vm_size_t size = 1;
-  mach_msg_type_number_t count = VM_REGION_BASIC_INFO_COUNT_64;
-
-  kern_return_t kr = mach_vm_region(
-      mach_task_self(), reinterpret_cast<mach_vm_address_t*>(&ptr), &size,
-      VM_REGION_BASIC_INFO_64, reinterpret_cast<vm_region_info_t>(&region_info),
-      &count, &object_name);
-  DCHECK_EQ(kr, KERN_SUCCESS);
-  DCHECK_EQ(region_info.protection, VM_PROT_READ);
-#endif  // DCHECK_IS_ON()
-}
-#endif  // defined(OS_LINUX) || (defined(OS_MACOSX) && !defined(OS_IOS))
-
-}  // namespace base
diff --git a/base/memory/protected_memory_win.cc b/base/memory/protected_memory_win.cc
deleted file mode 100644
index 43ad8ba..0000000
--- a/base/memory/protected_memory_win.cc
+++ /dev/null
@@ -1,52 +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/memory/protected_memory.h"
-
-#include <windows.h>
-
-#include <stdint.h>
-
-#include "base/process/process_metrics.h"
-#include "base/synchronization/lock.h"
-#include "build_config.h"
-
-namespace base {
-
-namespace {
-
-bool SetMemory(void* start, void* end, DWORD prot) {
-  DCHECK(end > start);
-  const uintptr_t page_mask = ~(base::GetPageSize() - 1);
-  const uintptr_t page_start = reinterpret_cast<uintptr_t>(start) & page_mask;
-  DWORD old_prot;
-  return VirtualProtect(reinterpret_cast<void*>(page_start),
-                        reinterpret_cast<uintptr_t>(end) - page_start, prot,
-                        &old_prot) != 0;
-}
-
-}  // namespace
-
-bool AutoWritableMemory::SetMemoryReadWrite(void* start, void* end) {
-  return SetMemory(start, end, PAGE_READWRITE);
-}
-
-bool AutoWritableMemory::SetMemoryReadOnly(void* start, void* end) {
-  return SetMemory(start, end, PAGE_READONLY);
-}
-
-void AssertMemoryIsReadOnly(const void* ptr) {
-#if DCHECK_IS_ON()
-  const uintptr_t page_mask = ~(base::GetPageSize() - 1);
-  const uintptr_t page_start = reinterpret_cast<uintptr_t>(ptr) & page_mask;
-
-  MEMORY_BASIC_INFORMATION info;
-  SIZE_T result =
-      VirtualQuery(reinterpret_cast<LPCVOID>(page_start), &info, sizeof(info));
-  DCHECK_GT(result, 0U);
-  DCHECK(info.Protect == PAGE_READONLY);
-#endif  // DCHECK_IS_ON()
-}
-
-}  // namespace base
diff --git a/base/memory/read_only_shared_memory_region.cc b/base/memory/read_only_shared_memory_region.cc
deleted file mode 100644
index 0a5f900..0000000
--- a/base/memory/read_only_shared_memory_region.cc
+++ /dev/null
@@ -1,97 +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/memory/read_only_shared_memory_region.h"
-
-#include <utility>
-
-#include "base/memory/shared_memory.h"
-#include "build_config.h"
-
-namespace base {
-
-// static
-MappedReadOnlyRegion ReadOnlySharedMemoryRegion::Create(size_t size) {
-  subtle::PlatformSharedMemoryRegion handle =
-      subtle::PlatformSharedMemoryRegion::CreateWritable(size);
-  if (!handle.IsValid())
-    return {};
-
-  void* memory_ptr = nullptr;
-  size_t mapped_size = 0;
-  if (!handle.MapAt(0, handle.GetSize(), &memory_ptr, &mapped_size))
-    return {};
-
-  WritableSharedMemoryMapping mapping(memory_ptr, size, mapped_size,
-                                      handle.GetGUID());
-#if defined(OS_MACOSX) && !defined(OS_IOS)
-  handle.ConvertToReadOnly(memory_ptr);
-#else
-  handle.ConvertToReadOnly();
-#endif  // defined(OS_MACOSX) && !defined(OS_IOS)
-  ReadOnlySharedMemoryRegion region(std::move(handle));
-
-  if (!region.IsValid() || !mapping.IsValid())
-    return {};
-
-  return {std::move(region), std::move(mapping)};
-}
-
-// static
-ReadOnlySharedMemoryRegion ReadOnlySharedMemoryRegion::Deserialize(
-    subtle::PlatformSharedMemoryRegion handle) {
-  return ReadOnlySharedMemoryRegion(std::move(handle));
-}
-
-// static
-subtle::PlatformSharedMemoryRegion
-ReadOnlySharedMemoryRegion::TakeHandleForSerialization(
-    ReadOnlySharedMemoryRegion region) {
-  return std::move(region.handle_);
-}
-
-ReadOnlySharedMemoryRegion::ReadOnlySharedMemoryRegion() = default;
-ReadOnlySharedMemoryRegion::ReadOnlySharedMemoryRegion(
-    ReadOnlySharedMemoryRegion&& region) = default;
-ReadOnlySharedMemoryRegion& ReadOnlySharedMemoryRegion::operator=(
-    ReadOnlySharedMemoryRegion&& region) = default;
-ReadOnlySharedMemoryRegion::~ReadOnlySharedMemoryRegion() = default;
-
-ReadOnlySharedMemoryRegion ReadOnlySharedMemoryRegion::Duplicate() const {
-  return ReadOnlySharedMemoryRegion(handle_.Duplicate());
-}
-
-ReadOnlySharedMemoryMapping ReadOnlySharedMemoryRegion::Map() const {
-  return MapAt(0, handle_.GetSize());
-}
-
-ReadOnlySharedMemoryMapping ReadOnlySharedMemoryRegion::MapAt(
-    off_t offset,
-    size_t size) const {
-  if (!IsValid())
-    return {};
-
-  void* memory = nullptr;
-  size_t mapped_size = 0;
-  if (!handle_.MapAt(offset, size, &memory, &mapped_size))
-    return {};
-
-  return ReadOnlySharedMemoryMapping(memory, size, mapped_size,
-                                     handle_.GetGUID());
-}
-
-bool ReadOnlySharedMemoryRegion::IsValid() const {
-  return handle_.IsValid();
-}
-
-ReadOnlySharedMemoryRegion::ReadOnlySharedMemoryRegion(
-    subtle::PlatformSharedMemoryRegion handle)
-    : handle_(std::move(handle)) {
-  if (handle_.IsValid()) {
-    CHECK_EQ(handle_.GetMode(),
-             subtle::PlatformSharedMemoryRegion::Mode::kReadOnly);
-  }
-}
-
-}  // namespace base
diff --git a/base/memory/read_only_shared_memory_region.h b/base/memory/read_only_shared_memory_region.h
deleted file mode 100644
index 54e73ed..0000000
--- a/base/memory/read_only_shared_memory_region.h
+++ /dev/null
@@ -1,116 +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_MEMORY_READ_ONLY_SHARED_MEMORY_REGION_H_
-#define BASE_MEMORY_READ_ONLY_SHARED_MEMORY_REGION_H_
-
-#include <utility>
-
-#include "base/macros.h"
-#include "base/memory/platform_shared_memory_region.h"
-#include "base/memory/shared_memory_mapping.h"
-
-namespace base {
-
-struct MappedReadOnlyRegion;
-
-// Scoped move-only handle to a region of platform shared memory. The instance
-// owns the platform handle it wraps. Mappings created by this region are
-// read-only. These mappings remain valid even after the region handle is moved
-// or destroyed.
-class BASE_EXPORT ReadOnlySharedMemoryRegion {
- public:
-  using MappingType = ReadOnlySharedMemoryMapping;
-  // Creates a new ReadOnlySharedMemoryRegion instance of a given size along
-  // with the WritableSharedMemoryMapping which provides the only way to modify
-  // the content of the newly created region. The returned region and mapping
-  // are guaranteed to either be both valid or both invalid. Use
-  // |MappedReadOnlyRegion::IsValid()| as a shortcut for checking creation
-  // success.
-  //
-  // This means that the caller's process is the only process that can modify
-  // the region content. If you need to pass write access to another process,
-  // consider using WritableSharedMemoryRegion or UnsafeSharedMemoryRegion.
-  static MappedReadOnlyRegion Create(size_t size);
-
-  // Returns a ReadOnlySharedMemoryRegion built from a platform-specific handle
-  // that was taken from another ReadOnlySharedMemoryRegion instance. Returns an
-  // invalid region iff the |handle| is invalid. CHECK-fails if the |handle|
-  // isn't read-only.
-  // This should be used only by the code passing handles across process
-  // boundaries.
-  static ReadOnlySharedMemoryRegion Deserialize(
-      subtle::PlatformSharedMemoryRegion handle);
-
-  // Extracts a platform handle from the region. Ownership is transferred to the
-  // returned region object.
-  // This should be used only for sending the handle from the current process to
-  // another.
-  static subtle::PlatformSharedMemoryRegion TakeHandleForSerialization(
-      ReadOnlySharedMemoryRegion region);
-
-  // Default constructor initializes an invalid instance.
-  ReadOnlySharedMemoryRegion();
-
-  // Move operations are allowed.
-  ReadOnlySharedMemoryRegion(ReadOnlySharedMemoryRegion&&);
-  ReadOnlySharedMemoryRegion& operator=(ReadOnlySharedMemoryRegion&&);
-
-  // Destructor closes shared memory region if valid.
-  // All created mappings will remain valid.
-  ~ReadOnlySharedMemoryRegion();
-
-  // Duplicates the underlying platform handle and creates a new
-  // ReadOnlySharedMemoryRegion instance that owns this handle. Returns a valid
-  // ReadOnlySharedMemoryRegion on success, invalid otherwise. The current
-  // region instance remains valid in any case.
-  ReadOnlySharedMemoryRegion Duplicate() const;
-
-  // Maps the shared memory region into the caller's address space with
-  // read-only access. The mapped address is guaranteed to have an alignment of
-  // at least |subtle::PlatformSharedMemoryRegion::kMapMinimumAlignment|.
-  // Returns a valid ReadOnlySharedMemoryMapping instance on success, invalid
-  // otherwise.
-  ReadOnlySharedMemoryMapping Map() const;
-
-  // Same as above, but maps only |size| bytes of the shared memory region
-  // starting with the given |offset|. |offset| must be aligned to value of
-  // |SysInfo::VMAllocationGranularity()|. Returns an invalid mapping if
-  // requested bytes are out of the region limits.
-  ReadOnlySharedMemoryMapping MapAt(off_t offset, size_t size) const;
-
-  // Whether the underlying platform handle is valid.
-  bool IsValid() const;
-
-  // Returns the maximum mapping size that can be created from this region.
-  size_t GetSize() const {
-    DCHECK(IsValid());
-    return handle_.GetSize();
-  }
-
- private:
-  explicit ReadOnlySharedMemoryRegion(
-      subtle::PlatformSharedMemoryRegion handle);
-
-  subtle::PlatformSharedMemoryRegion handle_;
-
-  DISALLOW_COPY_AND_ASSIGN(ReadOnlySharedMemoryRegion);
-};
-
-// Helper struct for return value of ReadOnlySharedMemoryRegion::Create().
-struct MappedReadOnlyRegion {
-  ReadOnlySharedMemoryRegion region;
-  WritableSharedMemoryMapping mapping;
-  // Helper function to check return value of
-  // ReadOnlySharedMemoryRegion::Create(). |region| and |mapping| either both
-  // valid or invalid.
-  bool IsValid() {
-    DCHECK_EQ(region.IsValid(), mapping.IsValid());
-    return region.IsValid() && mapping.IsValid();
-  }
-};
-
-}  // namespace base
-
-#endif  // BASE_MEMORY_READ_ONLY_SHARED_MEMORY_REGION_H_
diff --git a/base/memory/ref_counted_delete_on_sequence.h b/base/memory/ref_counted_delete_on_sequence.h
deleted file mode 100644
index dd30106..0000000
--- a/base/memory/ref_counted_delete_on_sequence.h
+++ /dev/null
@@ -1,82 +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_MEMORY_REF_COUNTED_DELETE_ON_SEQUENCE_H_
-#define BASE_MEMORY_REF_COUNTED_DELETE_ON_SEQUENCE_H_
-
-#include <utility>
-
-#include "base/location.h"
-#include "base/logging.h"
-#include "base/macros.h"
-#include "base/memory/ref_counted.h"
-#include "base/sequenced_task_runner.h"
-
-namespace base {
-
-// RefCountedDeleteOnSequence is similar to RefCountedThreadSafe, and ensures
-// that the object will be deleted on a specified sequence.
-//
-// Sample usage:
-// class Foo : public RefCountedDeleteOnSequence<Foo> {
-//
-//   Foo(scoped_refptr<SequencedTaskRunner> task_runner)
-//       : RefCountedDeleteOnSequence<Foo>(std::move(task_runner)) {}
-//   ...
-//  private:
-//   friend class RefCountedDeleteOnSequence<Foo>;
-//   friend class DeleteHelper<Foo>;
-//
-//   ~Foo();
-// };
-template <class T>
-class RefCountedDeleteOnSequence : public subtle::RefCountedThreadSafeBase {
- public:
-  static constexpr subtle::StartRefCountFromZeroTag kRefCountPreference =
-      subtle::kStartRefCountFromZeroTag;
-
-  // A SequencedTaskRunner for the current sequence can be acquired by calling
-  // SequencedTaskRunnerHandle::Get().
-  RefCountedDeleteOnSequence(
-      scoped_refptr<SequencedTaskRunner> owning_task_runner)
-      : subtle::RefCountedThreadSafeBase(T::kRefCountPreference),
-        owning_task_runner_(std::move(owning_task_runner)) {
-    DCHECK(owning_task_runner_);
-  }
-
-  void AddRef() const { subtle::RefCountedThreadSafeBase::AddRef(); }
-
-  void Release() const {
-    if (subtle::RefCountedThreadSafeBase::Release())
-      DestructOnSequence();
-  }
-
- protected:
-  friend class DeleteHelper<RefCountedDeleteOnSequence>;
-  ~RefCountedDeleteOnSequence() = default;
-
-  SequencedTaskRunner* owning_task_runner() {
-    return owning_task_runner_.get();
-  }
-  const SequencedTaskRunner* owning_task_runner() const {
-    return owning_task_runner_.get();
-  }
-
- private:
-  void DestructOnSequence() const {
-    const T* t = static_cast<const T*>(this);
-    if (owning_task_runner_->RunsTasksInCurrentSequence())
-      delete t;
-    else
-      owning_task_runner_->DeleteSoon(FROM_HERE, t);
-  }
-
-  const scoped_refptr<SequencedTaskRunner> owning_task_runner_;
-
-  DISALLOW_COPY_AND_ASSIGN(RefCountedDeleteOnSequence);
-};
-
-}  // namespace base
-
-#endif  // BASE_MEMORY_REF_COUNTED_DELETE_ON_SEQUENCE_H_
diff --git a/base/memory/ref_counted_memory.cc b/base/memory/ref_counted_memory.cc
deleted file mode 100644
index 23a5ffc..0000000
--- a/base/memory/ref_counted_memory.cc
+++ /dev/null
@@ -1,132 +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/memory/ref_counted_memory.h"
-
-#include <utility>
-
-#include "base/logging.h"
-#include "base/memory/read_only_shared_memory_region.h"
-
-namespace base {
-
-bool RefCountedMemory::Equals(
-    const scoped_refptr<RefCountedMemory>& other) const {
-  return other.get() &&
-         size() == other->size() &&
-         (memcmp(front(), other->front(), size()) == 0);
-}
-
-RefCountedMemory::RefCountedMemory() = default;
-
-RefCountedMemory::~RefCountedMemory() = default;
-
-const unsigned char* RefCountedStaticMemory::front() const {
-  return data_;
-}
-
-size_t RefCountedStaticMemory::size() const {
-  return length_;
-}
-
-RefCountedStaticMemory::~RefCountedStaticMemory() = default;
-
-RefCountedBytes::RefCountedBytes() = default;
-
-RefCountedBytes::RefCountedBytes(const std::vector<unsigned char>& initializer)
-    : data_(initializer) {
-}
-
-RefCountedBytes::RefCountedBytes(const unsigned char* p, size_t size)
-    : data_(p, p + size) {}
-
-RefCountedBytes::RefCountedBytes(size_t size) : data_(size, 0) {}
-
-scoped_refptr<RefCountedBytes> RefCountedBytes::TakeVector(
-    std::vector<unsigned char>* to_destroy) {
-  auto bytes = MakeRefCounted<RefCountedBytes>();
-  bytes->data_.swap(*to_destroy);
-  return bytes;
-}
-
-const unsigned char* RefCountedBytes::front() const {
-  // STL will assert if we do front() on an empty vector, but calling code
-  // expects a NULL.
-  return size() ? &data_.front() : nullptr;
-}
-
-size_t RefCountedBytes::size() const {
-  return data_.size();
-}
-
-RefCountedBytes::~RefCountedBytes() = default;
-
-RefCountedString::RefCountedString() = default;
-
-RefCountedString::~RefCountedString() = default;
-
-// static
-scoped_refptr<RefCountedString> RefCountedString::TakeString(
-    std::string* to_destroy) {
-  auto self = MakeRefCounted<RefCountedString>();
-  to_destroy->swap(self->data_);
-  return self;
-}
-
-const unsigned char* RefCountedString::front() const {
-  return data_.empty() ? nullptr
-                       : reinterpret_cast<const unsigned char*>(data_.data());
-}
-
-size_t RefCountedString::size() const {
-  return data_.size();
-}
-
-RefCountedSharedMemory::RefCountedSharedMemory(
-    std::unique_ptr<SharedMemory> shm,
-    size_t size)
-    : shm_(std::move(shm)), size_(size) {
-  DCHECK(shm_);
-  DCHECK(shm_->memory());
-  DCHECK_GT(size_, 0U);
-  DCHECK_LE(size_, shm_->mapped_size());
-}
-
-RefCountedSharedMemory::~RefCountedSharedMemory() = default;
-
-const unsigned char* RefCountedSharedMemory::front() const {
-  return static_cast<const unsigned char*>(shm_->memory());
-}
-
-size_t RefCountedSharedMemory::size() const {
-  return size_;
-}
-
-RefCountedSharedMemoryMapping::RefCountedSharedMemoryMapping(
-    ReadOnlySharedMemoryMapping mapping)
-    : mapping_(std::move(mapping)), size_(mapping_.size()) {
-  DCHECK_GT(size_, 0U);
-}
-
-RefCountedSharedMemoryMapping::~RefCountedSharedMemoryMapping() = default;
-
-const unsigned char* RefCountedSharedMemoryMapping::front() const {
-  return static_cast<const unsigned char*>(mapping_.memory());
-}
-
-size_t RefCountedSharedMemoryMapping::size() const {
-  return size_;
-}
-
-// static
-scoped_refptr<RefCountedSharedMemoryMapping>
-RefCountedSharedMemoryMapping::CreateFromWholeRegion(
-    const ReadOnlySharedMemoryRegion& region) {
-  ReadOnlySharedMemoryMapping mapping = region.Map();
-  if (!mapping.IsValid())
-    return nullptr;
-  return MakeRefCounted<RefCountedSharedMemoryMapping>(std::move(mapping));
-}
-
-}  //  namespace base
diff --git a/base/memory/ref_counted_memory.h b/base/memory/ref_counted_memory.h
deleted file mode 100644
index 92a7d7b..0000000
--- a/base/memory/ref_counted_memory.h
+++ /dev/null
@@ -1,193 +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_MEMORY_REF_COUNTED_MEMORY_H_
-#define BASE_MEMORY_REF_COUNTED_MEMORY_H_
-
-#include <stddef.h>
-
-#include <memory>
-#include <string>
-#include <vector>
-
-#include "base/base_export.h"
-#include "base/macros.h"
-#include "base/memory/ref_counted.h"
-#include "base/memory/shared_memory.h"
-#include "base/memory/shared_memory_mapping.h"
-
-namespace base {
-
-class ReadOnlySharedMemoryRegion;
-
-// A generic interface to memory. This object is reference counted because most
-// of its subclasses own the data they carry, and this interface needs to
-// support heterogeneous containers of these different types of memory.
-class BASE_EXPORT RefCountedMemory
-    : public RefCountedThreadSafe<RefCountedMemory> {
- public:
-  // Retrieves a pointer to the beginning of the data we point to. If the data
-  // is empty, this will return NULL.
-  virtual const unsigned char* front() const = 0;
-
-  // Size of the memory pointed to.
-  virtual size_t size() const = 0;
-
-  // Returns true if |other| is byte for byte equal.
-  bool Equals(const scoped_refptr<RefCountedMemory>& other) const;
-
-  // Handy method to simplify calling front() with a reinterpret_cast.
-  template<typename T> const T* front_as() const {
-    return reinterpret_cast<const T*>(front());
-  }
-
- protected:
-  friend class RefCountedThreadSafe<RefCountedMemory>;
-  RefCountedMemory();
-  virtual ~RefCountedMemory();
-};
-
-// An implementation of RefCountedMemory, where the ref counting does not
-// matter.
-class BASE_EXPORT RefCountedStaticMemory : public RefCountedMemory {
- public:
-  RefCountedStaticMemory() : data_(nullptr), length_(0) {}
-  RefCountedStaticMemory(const void* data, size_t length)
-      : data_(static_cast<const unsigned char*>(length ? data : nullptr)),
-        length_(length) {}
-
-  // RefCountedMemory:
-  const unsigned char* front() const override;
-  size_t size() const override;
-
- private:
-  ~RefCountedStaticMemory() override;
-
-  const unsigned char* data_;
-  size_t length_;
-
-  DISALLOW_COPY_AND_ASSIGN(RefCountedStaticMemory);
-};
-
-// An implementation of RefCountedMemory, where the data is stored in a STL
-// vector.
-class BASE_EXPORT RefCountedBytes : public RefCountedMemory {
- public:
-  RefCountedBytes();
-
-  // Constructs a RefCountedBytes object by copying from |initializer|.
-  explicit RefCountedBytes(const std::vector<unsigned char>& initializer);
-
-  // Constructs a RefCountedBytes object by copying |size| bytes from |p|.
-  RefCountedBytes(const unsigned char* p, size_t size);
-
-  // Constructs a RefCountedBytes object by zero-initializing a new vector of
-  // |size| bytes.
-  explicit RefCountedBytes(size_t size);
-
-  // Constructs a RefCountedBytes object by performing a swap. (To non
-  // destructively build a RefCountedBytes, use the constructor that takes a
-  // vector.)
-  static scoped_refptr<RefCountedBytes> TakeVector(
-      std::vector<unsigned char>* to_destroy);
-
-  // RefCountedMemory:
-  const unsigned char* front() const override;
-  size_t size() const override;
-
-  const std::vector<unsigned char>& data() const { return data_; }
-  std::vector<unsigned char>& data() { return data_; }
-
-  // Non-const versions of front() and front_as() that are simply shorthand for
-  // data().data().
-  unsigned char* front() { return data_.data(); }
-  template <typename T>
-  T* front_as() {
-    return reinterpret_cast<T*>(front());
-  }
-
- private:
-  ~RefCountedBytes() override;
-
-  std::vector<unsigned char> data_;
-
-  DISALLOW_COPY_AND_ASSIGN(RefCountedBytes);
-};
-
-// An implementation of RefCountedMemory, where the bytes are stored in a STL
-// string. Use this if your data naturally arrives in that format.
-class BASE_EXPORT RefCountedString : public RefCountedMemory {
- public:
-  RefCountedString();
-
-  // Constructs a RefCountedString object by performing a swap. (To non
-  // destructively build a RefCountedString, use the default constructor and
-  // copy into object->data()).
-  static scoped_refptr<RefCountedString> TakeString(std::string* to_destroy);
-
-  // RefCountedMemory:
-  const unsigned char* front() const override;
-  size_t size() const override;
-
-  const std::string& data() const { return data_; }
-  std::string& data() { return data_; }
-
- private:
-  ~RefCountedString() override;
-
-  std::string data_;
-
-  DISALLOW_COPY_AND_ASSIGN(RefCountedString);
-};
-
-// An implementation of RefCountedMemory, where the bytes are stored in
-// SharedMemory.
-class BASE_EXPORT RefCountedSharedMemory : public RefCountedMemory {
- public:
-  // Constructs a RefCountedMemory object by taking ownership of an already
-  // mapped SharedMemory object.
-  RefCountedSharedMemory(std::unique_ptr<SharedMemory> shm, size_t size);
-
-  // RefCountedMemory:
-  const unsigned char* front() const override;
-  size_t size() const override;
-
- private:
-  ~RefCountedSharedMemory() override;
-
-  const std::unique_ptr<SharedMemory> shm_;
-  const size_t size_;
-
-  DISALLOW_COPY_AND_ASSIGN(RefCountedSharedMemory);
-};
-
-// An implementation of RefCountedMemory, where the bytes are stored in
-// ReadOnlySharedMemoryMapping.
-class BASE_EXPORT RefCountedSharedMemoryMapping : public RefCountedMemory {
- public:
-  // Constructs a RefCountedMemory object by taking ownership of an already
-  // mapped ReadOnlySharedMemoryMapping object.
-  explicit RefCountedSharedMemoryMapping(ReadOnlySharedMemoryMapping mapping);
-
-  // Convenience method to map all of |region| and take ownership of the
-  // mapping. Returns an empty scoped_refptr if the map operation fails.
-  static scoped_refptr<RefCountedSharedMemoryMapping> CreateFromWholeRegion(
-      const ReadOnlySharedMemoryRegion& region);
-
-  // RefCountedMemory:
-  const unsigned char* front() const override;
-  size_t size() const override;
-
- private:
-  ~RefCountedSharedMemoryMapping() override;
-
-  const ReadOnlySharedMemoryMapping mapping_;
-  const size_t size_;
-
-  DISALLOW_COPY_AND_ASSIGN(RefCountedSharedMemoryMapping);
-};
-
-}  // namespace base
-
-#endif  // BASE_MEMORY_REF_COUNTED_MEMORY_H_
diff --git a/base/memory/shared_memory.h b/base/memory/shared_memory.h
deleted file mode 100644
index aa1f682..0000000
--- a/base/memory/shared_memory.h
+++ /dev/null
@@ -1,254 +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_MEMORY_SHARED_MEMORY_H_
-#define BASE_MEMORY_SHARED_MEMORY_H_
-
-#include <stddef.h>
-
-#include <string>
-
-#include "base/base_export.h"
-#include "base/hash.h"
-#include "base/macros.h"
-#include "base/memory/shared_memory_handle.h"
-#include "base/process/process_handle.h"
-#include "base/strings/string16.h"
-#include "build_config.h"
-
-#if defined(OS_POSIX) || defined(OS_FUCHSIA)
-#include <stdio.h>
-#include <sys/types.h>
-#include <semaphore.h>
-#include "base/file_descriptor_posix.h"
-#include "base/files/file_util.h"
-#include "base/files/scoped_file.h"
-#endif
-
-#if defined(OS_WIN)
-#include "base/win/scoped_handle.h"
-#endif
-
-namespace base {
-
-class FilePath;
-
-// Options for creating a shared memory object.
-struct BASE_EXPORT SharedMemoryCreateOptions {
-#if defined(OS_MACOSX) && !defined(OS_IOS)
-  // The type of OS primitive that should back the SharedMemory object.
-  SharedMemoryHandle::Type type = SharedMemoryHandle::MACH;
-#elif !defined(OS_FUCHSIA)
-  // DEPRECATED (crbug.com/345734):
-  // If NULL, the object is anonymous.  This pointer is owned by the caller
-  // and must live through the call to Create().
-  const std::string* name_deprecated = nullptr;
-
-  // DEPRECATED (crbug.com/345734):
-  // If true, and the shared memory already exists, Create() will open the
-  // existing shared memory and ignore the size parameter.  If false,
-  // shared memory must not exist.  This flag is meaningless unless
-  // name_deprecated is non-NULL.
-  bool open_existing_deprecated = false;
-#endif  // defined(OS_MACOSX) && !defined(OS_IOS)
-
-  // Size of the shared memory object to be created.
-  // When opening an existing object, this has no effect.
-  size_t size = 0;
-
-  // If true, mappings might need to be made executable later.
-  bool executable = false;
-
-  // If true, the file can be shared read-only to a process.
-  bool share_read_only = false;
-};
-
-// Platform abstraction for shared memory.
-// SharedMemory consumes a SharedMemoryHandle [potentially one that it created]
-// to map a shared memory OS resource into the virtual address space of the
-// current process.
-class BASE_EXPORT SharedMemory {
- public:
-  SharedMemory();
-
-#if defined(OS_WIN)
-  // Similar to the default constructor, except that this allows for
-  // calling LockDeprecated() to acquire the named mutex before either Create or
-  // Open are called on Windows.
-  explicit SharedMemory(const string16& name);
-#endif
-
-  // Create a new SharedMemory object from an existing, open
-  // shared memory file.
-  //
-  // WARNING: This does not reduce the OS-level permissions on the handle; it
-  // only affects how the SharedMemory will be mmapped. Use
-  // GetReadOnlyHandle to drop permissions. TODO(jln,jyasskin): DCHECK
-  // that |read_only| matches the permissions of the handle.
-  SharedMemory(const SharedMemoryHandle& handle, bool read_only);
-
-  // Closes any open files.
-  ~SharedMemory();
-
-  // Return true iff the given handle is valid (i.e. not the distingished
-  // invalid value; NULL for a HANDLE and -1 for a file descriptor)
-  static bool IsHandleValid(const SharedMemoryHandle& handle);
-
-  // Closes a shared memory handle.
-  static void CloseHandle(const SharedMemoryHandle& handle);
-
-  // Returns the maximum number of handles that can be open at once per process.
-  static size_t GetHandleLimit();
-
-  // Duplicates The underlying OS primitive. Returns an invalid handle on
-  // failure. The caller is responsible for destroying the duplicated OS
-  // primitive.
-  static SharedMemoryHandle DuplicateHandle(const SharedMemoryHandle& handle);
-
-#if defined(OS_POSIX)
-  // This method requires that the SharedMemoryHandle is backed by a POSIX fd.
-  static int GetFdFromSharedMemoryHandle(const SharedMemoryHandle& handle);
-#endif
-
-  // Creates a shared memory object as described by the options struct.
-  // Returns true on success and false on failure.
-  bool Create(const SharedMemoryCreateOptions& options);
-
-  // Creates and maps an anonymous shared memory segment of size size.
-  // Returns true on success and false on failure.
-  bool CreateAndMapAnonymous(size_t size);
-
-  // Creates an anonymous shared memory segment of size size.
-  // Returns true on success and false on failure.
-  bool CreateAnonymous(size_t size) {
-    SharedMemoryCreateOptions options;
-    options.size = size;
-    return Create(options);
-  }
-
-#if (!defined(OS_MACOSX) || defined(OS_IOS)) && !defined(OS_FUCHSIA)
-  // DEPRECATED (crbug.com/345734):
-  // Creates or opens a shared memory segment based on a name.
-  // If open_existing is true, and the shared memory already exists,
-  // opens the existing shared memory and ignores the size parameter.
-  // If open_existing is false, shared memory must not exist.
-  // size is the size of the block to be created.
-  // Returns true on success, false on failure.
-  bool CreateNamedDeprecated(
-      const std::string& name, bool open_existing, size_t size) {
-    SharedMemoryCreateOptions options;
-    options.name_deprecated = &name;
-    options.open_existing_deprecated = open_existing;
-    options.size = size;
-    return Create(options);
-  }
-
-  // Deletes resources associated with a shared memory segment based on name.
-  // Not all platforms require this call.
-  bool Delete(const std::string& name);
-
-  // Opens a shared memory segment based on a name.
-  // If read_only is true, opens for read-only access.
-  // Returns true on success, false on failure.
-  bool Open(const std::string& name, bool read_only);
-#endif  // !defined(OS_MACOSX) || defined(OS_IOS)
-
-  // Maps the shared memory into the caller's address space.
-  // Returns true on success, false otherwise.  The memory address
-  // is accessed via the memory() accessor.  The mapped address is guaranteed to
-  // have an alignment of at least MAP_MINIMUM_ALIGNMENT. This method will fail
-  // if this object is currently mapped.
-  bool Map(size_t bytes) {
-    return MapAt(0, bytes);
-  }
-
-  // Same as above, but with |offset| to specify from begining of the shared
-  // memory block to map.
-  // |offset| must be alignent to value of |SysInfo::VMAllocationGranularity()|.
-  bool MapAt(off_t offset, size_t bytes);
-  enum { MAP_MINIMUM_ALIGNMENT = 32 };
-
-  // Unmaps the shared memory from the caller's address space.
-  // Returns true if successful; returns false on error or if the
-  // memory is not mapped.
-  bool Unmap();
-
-  // The size requested when the map is first created.
-  size_t requested_size() const { return requested_size_; }
-
-  // The actual size of the mapped memory (may be larger than requested).
-  size_t mapped_size() const { return mapped_size_; }
-
-  // Gets a pointer to the opened memory space if it has been
-  // Mapped via Map().  Returns NULL if it is not mapped.
-  void* memory() const { return memory_; }
-
-  // Returns the underlying OS handle for this segment.
-  // Use of this handle for anything other than an opaque
-  // identifier is not portable.
-  SharedMemoryHandle handle() const;
-
-  // Returns the underlying OS handle for this segment. The caller takes
-  // ownership of the handle and memory is unmapped. This is equivalent to
-  // duplicating the handle and then calling Unmap() and Close() on this object,
-  // without the overhead of duplicating the handle.
-  SharedMemoryHandle TakeHandle();
-
-  // Closes the open shared memory segment. The memory will remain mapped if
-  // it was previously mapped.
-  // It is safe to call Close repeatedly.
-  void Close();
-
-  // Returns a read-only handle to this shared memory region. The caller takes
-  // ownership of the handle. For POSIX handles, CHECK-fails if the region
-  // wasn't Created or Opened with share_read_only=true, which is required to
-  // make the handle read-only. When the handle is passed to the IPC subsystem,
-  // that takes ownership of the handle. As such, it's not valid to pass the
-  // sample handle to the IPC subsystem twice. Returns an invalid handle on
-  // failure.
-  SharedMemoryHandle GetReadOnlyHandle() const;
-
-  // Returns an ID for the mapped region. This is ID of the SharedMemoryHandle
-  // that was mapped. The ID is valid even after the SharedMemoryHandle is
-  // Closed, as long as the region is not unmapped.
-  const UnguessableToken& mapped_id() const { return mapped_id_; }
-
- private:
-#if defined(OS_POSIX) && !defined(OS_NACL) && !defined(OS_ANDROID) && \
-    (!defined(OS_MACOSX) || defined(OS_IOS))
-  bool FilePathForMemoryName(const std::string& mem_name, FilePath* path);
-#endif
-
-#if defined(OS_WIN)
-  // If true indicates this came from an external source so needs extra checks
-  // before being mapped.
-  bool external_section_ = false;
-  string16 name_;
-#elif !defined(OS_ANDROID) && !defined(OS_FUCHSIA)
-  // If valid, points to the same memory region as shm_, but with readonly
-  // permissions.
-  SharedMemoryHandle readonly_shm_;
-#endif
-
-#if defined(OS_MACOSX) && !defined(OS_IOS)
-  // The mechanism by which the memory is mapped. Only valid if |memory_| is not
-  // |nullptr|.
-  SharedMemoryHandle::Type mapped_memory_mechanism_ = SharedMemoryHandle::MACH;
-#endif
-
-  // The OS primitive that backs the shared memory region.
-  SharedMemoryHandle shm_;
-
-  size_t mapped_size_ = 0;
-  void* memory_ = nullptr;
-  bool read_only_ = false;
-  size_t requested_size_ = 0;
-  base::UnguessableToken mapped_id_;
-
-  DISALLOW_COPY_AND_ASSIGN(SharedMemory);
-};
-
-}  // namespace base
-
-#endif  // BASE_MEMORY_SHARED_MEMORY_H_
diff --git a/base/memory/shared_memory_fuchsia.cc b/base/memory/shared_memory_fuchsia.cc
deleted file mode 100644
index 4036bf6..0000000
--- a/base/memory/shared_memory_fuchsia.cc
+++ /dev/null
@@ -1,166 +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/memory/shared_memory.h"
-
-#include <limits>
-
-#include <zircon/process.h>
-#include <zircon/rights.h>
-#include <zircon/syscalls.h>
-
-#include "base/bits.h"
-#include "base/fuchsia/scoped_zx_handle.h"
-#include "base/logging.h"
-#include "base/memory/shared_memory_tracker.h"
-#include "base/process/process_metrics.h"
-
-namespace base {
-
-SharedMemory::SharedMemory() {}
-
-SharedMemory::SharedMemory(const SharedMemoryHandle& handle, bool read_only)
-    : shm_(handle), read_only_(read_only) {}
-
-SharedMemory::~SharedMemory() {
-  Unmap();
-  Close();
-}
-
-// static
-bool SharedMemory::IsHandleValid(const SharedMemoryHandle& handle) {
-  return handle.IsValid();
-}
-
-// static
-void SharedMemory::CloseHandle(const SharedMemoryHandle& handle) {
-  DCHECK(handle.IsValid());
-  handle.Close();
-}
-
-// static
-size_t SharedMemory::GetHandleLimit() {
-  // Duplicated from the internal Magenta kernel constant kMaxHandleCount
-  // (kernel/lib/zircon/zircon.cpp).
-  return 256 * 1024u;
-}
-
-bool SharedMemory::CreateAndMapAnonymous(size_t size) {
-  return CreateAnonymous(size) && Map(size);
-}
-
-bool SharedMemory::Create(const SharedMemoryCreateOptions& options) {
-  requested_size_ = options.size;
-  mapped_size_ = bits::Align(requested_size_, GetPageSize());
-  ScopedZxHandle vmo;
-  zx_status_t status = zx_vmo_create(mapped_size_, 0, vmo.receive());
-  if (status != ZX_OK) {
-    DLOG(ERROR) << "zx_vmo_create failed, status=" << status;
-    return false;
-  }
-
-  if (!options.executable) {
-    // If options.executable isn't set, drop that permission by replacement.
-    const int kNoExecFlags = ZX_DEFAULT_VMO_RIGHTS & ~ZX_RIGHT_EXECUTE;
-    ScopedZxHandle old_vmo(std::move(vmo));
-    status = zx_handle_replace(old_vmo.get(), kNoExecFlags, vmo.receive());
-    if (status != ZX_OK) {
-      DLOG(ERROR) << "zx_handle_replace() failed: "
-                  << zx_status_get_string(status);
-      return false;
-    }
-    ignore_result(old_vmo.release());
-  }
-
-  shm_ = SharedMemoryHandle(vmo.release(), mapped_size_,
-                            UnguessableToken::Create());
-  return true;
-}
-
-bool SharedMemory::MapAt(off_t offset, size_t bytes) {
-  if (!shm_.IsValid())
-    return false;
-
-  if (bytes > static_cast<size_t>(std::numeric_limits<int>::max()))
-    return false;
-
-  if (memory_)
-    return false;
-
-  int flags = ZX_VM_FLAG_PERM_READ;
-  if (!read_only_)
-    flags |= ZX_VM_FLAG_PERM_WRITE;
-  uintptr_t addr;
-  zx_status_t status = zx_vmar_map(zx_vmar_root_self(), 0, shm_.GetHandle(),
-                                   offset, bytes, flags, &addr);
-  if (status != ZX_OK) {
-    DLOG(ERROR) << "zx_vmar_map failed, status=" << status;
-    return false;
-  }
-  memory_ = reinterpret_cast<void*>(addr);
-
-  mapped_size_ = bytes;
-  mapped_id_ = shm_.GetGUID();
-  SharedMemoryTracker::GetInstance()->IncrementMemoryUsage(*this);
-  return true;
-}
-
-bool SharedMemory::Unmap() {
-  if (!memory_)
-    return false;
-
-  SharedMemoryTracker::GetInstance()->DecrementMemoryUsage(*this);
-
-  uintptr_t addr = reinterpret_cast<uintptr_t>(memory_);
-  zx_status_t status = zx_vmar_unmap(zx_vmar_root_self(), addr, mapped_size_);
-  if (status != ZX_OK) {
-    DLOG(ERROR) << "zx_vmar_unmap failed, status=" << status;
-    return false;
-  }
-
-  memory_ = nullptr;
-  mapped_id_ = UnguessableToken();
-  return true;
-}
-
-void SharedMemory::Close() {
-  if (shm_.IsValid()) {
-    shm_.Close();
-    shm_ = SharedMemoryHandle();
-  }
-}
-
-SharedMemoryHandle SharedMemory::handle() const {
-  return shm_;
-}
-
-SharedMemoryHandle SharedMemory::TakeHandle() {
-  SharedMemoryHandle handle(shm_);
-  handle.SetOwnershipPassesToIPC(true);
-  Unmap();
-  shm_ = SharedMemoryHandle();
-  return handle;
-}
-
-SharedMemoryHandle SharedMemory::DuplicateHandle(
-    const SharedMemoryHandle& handle) {
-  return handle.Duplicate();
-}
-
-SharedMemoryHandle SharedMemory::GetReadOnlyHandle() const {
-  zx_handle_t duped_handle;
-  const int kNoWriteOrExec =
-      ZX_DEFAULT_VMO_RIGHTS &
-      ~(ZX_RIGHT_WRITE | ZX_RIGHT_EXECUTE | ZX_RIGHT_SET_PROPERTY);
-  zx_status_t status =
-      zx_handle_duplicate(shm_.GetHandle(), kNoWriteOrExec, &duped_handle);
-  if (status != ZX_OK)
-    return SharedMemoryHandle();
-
-  SharedMemoryHandle handle(duped_handle, shm_.GetSize(), shm_.GetGUID());
-  handle.SetOwnershipPassesToIPC(true);
-  return handle;
-}
-
-}  // namespace base
diff --git a/base/memory/shared_memory_handle.cc b/base/memory/shared_memory_handle.cc
deleted file mode 100644
index 085bde4..0000000
--- a/base/memory/shared_memory_handle.cc
+++ /dev/null
@@ -1,23 +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/memory/shared_memory_handle.h"
-
-namespace base {
-
-SharedMemoryHandle::SharedMemoryHandle(const SharedMemoryHandle& handle) =
-    default;
-
-SharedMemoryHandle& SharedMemoryHandle::operator=(
-    const SharedMemoryHandle& handle) = default;
-
-base::UnguessableToken SharedMemoryHandle::GetGUID() const {
-  return guid_;
-}
-
-size_t SharedMemoryHandle::GetSize() const {
-  return size_;
-}
-
-}  // namespace base
diff --git a/base/memory/shared_memory_handle.h b/base/memory/shared_memory_handle.h
deleted file mode 100644
index 18aa816..0000000
--- a/base/memory/shared_memory_handle.h
+++ /dev/null
@@ -1,236 +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_MEMORY_SHARED_MEMORY_HANDLE_H_
-#define BASE_MEMORY_SHARED_MEMORY_HANDLE_H_
-
-#include <stddef.h>
-
-#include "base/unguessable_token.h"
-#include "build_config.h"
-
-#if defined(OS_WIN)
-#include "base/process/process_handle.h"
-#include "base/win/windows_types.h"
-#elif defined(OS_MACOSX) && !defined(OS_IOS)
-#include <mach/mach.h>
-#include "base/base_export.h"
-#include "base/file_descriptor_posix.h"
-#include "base/macros.h"
-#include "base/process/process_handle.h"
-#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
-#include <sys/types.h>
-#include "base/file_descriptor_posix.h"
-#endif
-
-namespace base {
-
-// SharedMemoryHandle is the smallest possible IPC-transportable "reference" to
-// a shared memory OS resource. A "reference" can be consumed exactly once [by
-// base::SharedMemory] to map the shared memory OS resource into the virtual
-// address space of the current process.
-// TODO(erikchen): This class should have strong ownership semantics to prevent
-// leaks of the underlying OS resource. https://crbug.com/640840.
-class BASE_EXPORT SharedMemoryHandle {
- public:
-  // The default constructor returns an invalid SharedMemoryHandle.
-  SharedMemoryHandle();
-
-  // Standard copy constructor. The new instance shares the underlying OS
-  // primitives.
-  SharedMemoryHandle(const SharedMemoryHandle& handle);
-
-  // Standard assignment operator. The updated instance shares the underlying
-  // OS primitives.
-  SharedMemoryHandle& operator=(const SharedMemoryHandle& handle);
-
-  // Closes the underlying OS resource.
-  // The fact that this method needs to be "const" is an artifact of the
-  // original interface for base::SharedMemory::CloseHandle.
-  // TODO(erikchen): This doesn't clear the underlying reference, which seems
-  // like a bug, but is how this class has always worked. Fix this:
-  // https://crbug.com/716072.
-  void Close() const;
-
-  // Whether ownership of the underlying OS resource is implicitly passed to
-  // the IPC subsystem during serialization.
-  void SetOwnershipPassesToIPC(bool ownership_passes);
-  bool OwnershipPassesToIPC() const;
-
-  // Whether the underlying OS resource is valid.
-  bool IsValid() const;
-
-  // Duplicates the underlying OS resource. Using the return value as a
-  // parameter to an IPC message will cause the IPC subsystem to consume the OS
-  // resource.
-  SharedMemoryHandle Duplicate() const;
-
-  // Uniques identifies the shared memory region that the underlying OS resource
-  // points to. Multiple SharedMemoryHandles that point to the same shared
-  // memory region will have the same GUID. Preserved across IPC.
-  base::UnguessableToken GetGUID() const;
-
-  // Returns the size of the memory region that SharedMemoryHandle points to.
-  size_t GetSize() const;
-
-#if defined(OS_WIN)
-  // Takes implicit ownership of |h|.
-  // |guid| uniquely identifies the shared memory region pointed to by the
-  // underlying OS resource. If the HANDLE is associated with another
-  // SharedMemoryHandle, the caller must pass the |guid| of that
-  // SharedMemoryHandle. Otherwise, the caller should generate a new
-  // UnguessableToken.
-  // Passing the wrong |size| has no immediate consequence, but may cause errors
-  // when trying to map the SharedMemoryHandle at a later point in time.
-  SharedMemoryHandle(HANDLE h, size_t size, const base::UnguessableToken& guid);
-  HANDLE GetHandle() const;
-#elif defined(OS_FUCHSIA)
-  // Takes implicit ownership of |h|.
-  // |guid| uniquely identifies the shared memory region pointed to by the
-  // underlying OS resource. If the zx_handle_t is associated with another
-  // SharedMemoryHandle, the caller must pass the |guid| of that
-  // SharedMemoryHandle. Otherwise, the caller should generate a new
-  // UnguessableToken.
-  // Passing the wrong |size| has no immediate consequence, but may cause errors
-  // when trying to map the SharedMemoryHandle at a later point in time.
-  SharedMemoryHandle(zx_handle_t h,
-                     size_t size,
-                     const base::UnguessableToken& guid);
-  zx_handle_t GetHandle() const;
-#elif defined(OS_MACOSX) && !defined(OS_IOS)
-  enum Type {
-    // The SharedMemoryHandle is backed by a POSIX fd.
-    POSIX,
-    // The SharedMemoryHandle is backed by the Mach primitive "memory object".
-    MACH,
-  };
-
-  // Makes a Mach-based SharedMemoryHandle of the given size. On error,
-  // subsequent calls to IsValid() return false.
-  // Passing the wrong |size| has no immediate consequence, but may cause errors
-  // when trying to map the SharedMemoryHandle at a later point in time.
-  SharedMemoryHandle(mach_vm_size_t size, const base::UnguessableToken& guid);
-
-  // Makes a Mach-based SharedMemoryHandle from |memory_object|, a named entry
-  // in the current task. The memory region has size |size|.
-  // Passing the wrong |size| has no immediate consequence, but may cause errors
-  // when trying to map the SharedMemoryHandle at a later point in time.
-  SharedMemoryHandle(mach_port_t memory_object,
-                     mach_vm_size_t size,
-                     const base::UnguessableToken& guid);
-
-  // Exposed so that the SharedMemoryHandle can be transported between
-  // processes.
-  mach_port_t GetMemoryObject() const;
-
-  // The SharedMemoryHandle must be valid.
-  // Returns whether the SharedMemoryHandle was successfully mapped into memory.
-  // On success, |memory| is an output variable that contains the start of the
-  // mapped memory.
-  bool MapAt(off_t offset, size_t bytes, void** memory, bool read_only);
-#elif defined(OS_POSIX)
-  // Creates a SharedMemoryHandle from an |fd| supplied from an external
-  // service.
-  // Passing the wrong |size| has no immediate consequence, but may cause errors
-  // when trying to map the SharedMemoryHandle at a later point in time.
-  static SharedMemoryHandle ImportHandle(int fd, size_t size);
-
-  // Returns the underlying OS resource.
-  int GetHandle() const;
-
-  // Invalidates [but doesn't close] the underlying OS resource. This will leak
-  // unless the caller is careful.
-  int Release();
-#endif
-
-#if defined(OS_ANDROID)
-  // Marks the current file descriptor as read-only, for the purpose of
-  // mapping. This is independent of the region's read-only status.
-  void SetReadOnly() { read_only_ = true; }
-
-  // Returns true iff the descriptor is to be used for read-only
-  // mappings.
-  bool IsReadOnly() const { return read_only_; }
-
-  // Returns true iff the corresponding region is read-only.
-  bool IsRegionReadOnly() const;
-
-  // Try to set the region read-only. This will fail any future attempt
-  // at read-write mapping.
-  bool SetRegionReadOnly() const;
-#endif
-
-#if defined(OS_POSIX)
-  // Constructs a SharedMemoryHandle backed by a FileDescriptor. The newly
-  // created instance has the same ownership semantics as base::FileDescriptor.
-  // This typically means that the SharedMemoryHandle takes ownership of the
-  // |fd| if |auto_close| is true. Unfortunately, it's common for existing code
-  // to make shallow copies of SharedMemoryHandle, and the one that is finally
-  // passed into a base::SharedMemory is the one that "consumes" the fd.
-  //
-  // |guid| uniquely identifies the shared memory region pointed to by the
-  // underlying OS resource. If |file_descriptor| is associated with another
-  // SharedMemoryHandle, the caller must pass the |guid| of that
-  // SharedMemoryHandle. Otherwise, the caller should generate a new
-  // UnguessableToken.
-  // Passing the wrong |size| has no immediate consequence, but may cause errors
-  // when trying to map the SharedMemoryHandle at a later point in time.
-  SharedMemoryHandle(const base::FileDescriptor& file_descriptor,
-                     size_t size,
-                     const base::UnguessableToken& guid);
-#endif
-
- private:
-#if defined(OS_WIN)
-  HANDLE handle_ = nullptr;
-
-  // Whether passing this object as a parameter to an IPC message passes
-  // ownership of |handle_| to the IPC stack. This is meant to mimic the
-  // behavior of the |auto_close| parameter of FileDescriptor. This member only
-  // affects attachment-brokered SharedMemoryHandles.
-  // Defaults to |false|.
-  bool ownership_passes_to_ipc_ = false;
-#elif defined(OS_FUCHSIA)
-  zx_handle_t handle_ = ZX_HANDLE_INVALID;
-  bool ownership_passes_to_ipc_ = false;
-#elif defined(OS_MACOSX) && !defined(OS_IOS)
-  friend class SharedMemory;
-  friend bool CheckReadOnlySharedMemoryHandleForTesting(
-      SharedMemoryHandle handle);
-
-  Type type_ = MACH;
-
-  // Each instance of a SharedMemoryHandle is backed either by a POSIX fd or a
-  // mach port. |type_| determines the backing member.
-  union {
-    FileDescriptor file_descriptor_;
-
-    struct {
-      mach_port_t memory_object_ = MACH_PORT_NULL;
-
-      // Whether passing this object as a parameter to an IPC message passes
-      // ownership of |memory_object_| to the IPC stack. This is meant to mimic
-      // the behavior of the |auto_close| parameter of FileDescriptor.
-      // Defaults to |false|.
-      bool ownership_passes_to_ipc_ = false;
-    };
-  };
-#elif defined(OS_ANDROID)
-  friend class SharedMemory;
-
-  FileDescriptor file_descriptor_;
-  bool read_only_ = false;
-#elif defined(OS_POSIX)
-  FileDescriptor file_descriptor_;
-#endif
-
-  base::UnguessableToken guid_;
-
-  // The size of the region referenced by the SharedMemoryHandle.
-  size_t size_ = 0;
-};
-
-}  // namespace base
-
-#endif  // BASE_MEMORY_SHARED_MEMORY_HANDLE_H_
diff --git a/base/memory/shared_memory_handle_fuchsia.cc b/base/memory/shared_memory_handle_fuchsia.cc
deleted file mode 100644
index eab681f..0000000
--- a/base/memory/shared_memory_handle_fuchsia.cc
+++ /dev/null
@@ -1,54 +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/memory/shared_memory_handle.h"
-
-#include <zircon/syscalls.h>
-
-#include "base/logging.h"
-#include "base/unguessable_token.h"
-
-namespace base {
-
-SharedMemoryHandle::SharedMemoryHandle() {}
-
-SharedMemoryHandle::SharedMemoryHandle(zx_handle_t h,
-                                       size_t size,
-                                       const base::UnguessableToken& guid)
-    : handle_(h), guid_(guid), size_(size) {}
-
-void SharedMemoryHandle::Close() const {
-  DCHECK(handle_ != ZX_HANDLE_INVALID);
-  zx_handle_close(handle_);
-}
-
-bool SharedMemoryHandle::IsValid() const {
-  return handle_ != ZX_HANDLE_INVALID;
-}
-
-SharedMemoryHandle SharedMemoryHandle::Duplicate() const {
-  zx_handle_t duped_handle;
-  zx_status_t status =
-      zx_handle_duplicate(handle_, ZX_RIGHT_SAME_RIGHTS, &duped_handle);
-  if (status != ZX_OK)
-    return SharedMemoryHandle();
-
-  SharedMemoryHandle handle(duped_handle, GetSize(), GetGUID());
-  handle.SetOwnershipPassesToIPC(true);
-  return handle;
-}
-
-zx_handle_t SharedMemoryHandle::GetHandle() const {
-  return handle_;
-}
-
-void SharedMemoryHandle::SetOwnershipPassesToIPC(bool ownership_passes) {
-  ownership_passes_to_ipc_ = ownership_passes;
-}
-
-bool SharedMemoryHandle::OwnershipPassesToIPC() const {
-  return ownership_passes_to_ipc_;
-}
-
-}  // namespace base
diff --git a/base/memory/shared_memory_handle_mac.cc b/base/memory/shared_memory_handle_mac.cc
deleted file mode 100644
index 0e863fa..0000000
--- a/base/memory/shared_memory_handle_mac.cc
+++ /dev/null
@@ -1,154 +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/memory/shared_memory_handle.h"
-
-#include <mach/mach_vm.h>
-#include <stddef.h>
-#include <sys/mman.h>
-#include <unistd.h>
-
-#include "base/mac/mac_util.h"
-#include "base/mac/mach_logging.h"
-#include "base/posix/eintr_wrapper.h"
-#include "base/unguessable_token.h"
-
-namespace base {
-
-SharedMemoryHandle::SharedMemoryHandle() {}
-
-SharedMemoryHandle::SharedMemoryHandle(
-    const base::FileDescriptor& file_descriptor,
-    size_t size,
-    const base::UnguessableToken& guid)
-    : type_(POSIX),
-      file_descriptor_(file_descriptor),
-      guid_(guid),
-      size_(size) {}
-
-SharedMemoryHandle::SharedMemoryHandle(mach_vm_size_t size,
-                                       const base::UnguessableToken& guid) {
-  type_ = MACH;
-  mach_port_t named_right;
-  kern_return_t kr = mach_make_memory_entry_64(
-      mach_task_self(),
-      &size,
-      0,  // Address.
-      MAP_MEM_NAMED_CREATE | VM_PROT_READ | VM_PROT_WRITE,
-      &named_right,
-      MACH_PORT_NULL);  // Parent handle.
-  if (kr != KERN_SUCCESS) {
-    memory_object_ = MACH_PORT_NULL;
-    return;
-  }
-
-  memory_object_ = named_right;
-  size_ = size;
-  ownership_passes_to_ipc_ = false;
-  guid_ = guid;
-}
-
-SharedMemoryHandle::SharedMemoryHandle(mach_port_t memory_object,
-                                       mach_vm_size_t size,
-                                       const base::UnguessableToken& guid)
-    : type_(MACH),
-      memory_object_(memory_object),
-      ownership_passes_to_ipc_(false),
-      guid_(guid),
-      size_(size) {}
-
-SharedMemoryHandle SharedMemoryHandle::Duplicate() const {
-  switch (type_) {
-    case POSIX: {
-      if (!IsValid())
-        return SharedMemoryHandle();
-      int duped_fd = HANDLE_EINTR(dup(file_descriptor_.fd));
-      if (duped_fd < 0)
-        return SharedMemoryHandle();
-      return SharedMemoryHandle(FileDescriptor(duped_fd, true), size_, guid_);
-    }
-    case MACH: {
-      if (!IsValid())
-        return SharedMemoryHandle();
-
-      // Increment the ref count.
-      kern_return_t kr = mach_port_mod_refs(mach_task_self(), memory_object_,
-                                            MACH_PORT_RIGHT_SEND, 1);
-      DCHECK_EQ(kr, KERN_SUCCESS);
-      SharedMemoryHandle handle(*this);
-      handle.SetOwnershipPassesToIPC(true);
-      return handle;
-    }
-  }
-}
-
-bool SharedMemoryHandle::IsValid() const {
-  switch (type_) {
-    case POSIX:
-      return file_descriptor_.fd >= 0;
-    case MACH:
-      return memory_object_ != MACH_PORT_NULL;
-  }
-}
-
-mach_port_t SharedMemoryHandle::GetMemoryObject() const {
-  DCHECK_EQ(type_, MACH);
-  return memory_object_;
-}
-
-bool SharedMemoryHandle::MapAt(off_t offset,
-                               size_t bytes,
-                               void** memory,
-                               bool read_only) {
-  DCHECK(IsValid());
-  switch (type_) {
-    case SharedMemoryHandle::POSIX:
-      *memory = mmap(nullptr, bytes, PROT_READ | (read_only ? 0 : PROT_WRITE),
-                     MAP_SHARED, file_descriptor_.fd, offset);
-      return *memory != MAP_FAILED;
-    case SharedMemoryHandle::MACH:
-      kern_return_t kr = mach_vm_map(
-          mach_task_self(),
-          reinterpret_cast<mach_vm_address_t*>(memory),    // Output parameter
-          bytes,
-          0,                                               // Alignment mask
-          VM_FLAGS_ANYWHERE,
-          memory_object_,
-          offset,
-          FALSE,                                           // Copy
-          VM_PROT_READ | (read_only ? 0 : VM_PROT_WRITE),  // Current protection
-          VM_PROT_WRITE | VM_PROT_READ | VM_PROT_IS_MASK,  // Maximum protection
-          VM_INHERIT_NONE);
-      return kr == KERN_SUCCESS;
-  }
-}
-
-void SharedMemoryHandle::Close() const {
-  if (!IsValid())
-    return;
-
-  switch (type_) {
-    case POSIX:
-      if (IGNORE_EINTR(close(file_descriptor_.fd)) < 0)
-        DPLOG(ERROR) << "Error closing fd";
-      break;
-    case MACH:
-      kern_return_t kr = mach_port_deallocate(mach_task_self(), memory_object_);
-      if (kr != KERN_SUCCESS)
-        MACH_DLOG(ERROR, kr) << "Error deallocating mach port";
-      break;
-  }
-}
-
-void SharedMemoryHandle::SetOwnershipPassesToIPC(bool ownership_passes) {
-  DCHECK_EQ(type_, MACH);
-  ownership_passes_to_ipc_ = ownership_passes;
-}
-
-bool SharedMemoryHandle::OwnershipPassesToIPC() const {
-  DCHECK_EQ(type_, MACH);
-  return ownership_passes_to_ipc_;
-}
-
-}  // namespace base
diff --git a/base/memory/shared_memory_handle_posix.cc b/base/memory/shared_memory_handle_posix.cc
deleted file mode 100644
index 09dfb9c..0000000
--- a/base/memory/shared_memory_handle_posix.cc
+++ /dev/null
@@ -1,71 +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/memory/shared_memory_handle.h"
-
-#include <unistd.h>
-
-#include "base/logging.h"
-#include "base/posix/eintr_wrapper.h"
-#include "base/unguessable_token.h"
-
-namespace base {
-
-SharedMemoryHandle::SharedMemoryHandle() = default;
-
-SharedMemoryHandle::SharedMemoryHandle(
-    const base::FileDescriptor& file_descriptor,
-    size_t size,
-    const base::UnguessableToken& guid)
-    : file_descriptor_(file_descriptor), guid_(guid), size_(size) {}
-
-// static
-SharedMemoryHandle SharedMemoryHandle::ImportHandle(int fd, size_t size) {
-  SharedMemoryHandle handle;
-  handle.file_descriptor_.fd = fd;
-  handle.file_descriptor_.auto_close = false;
-  handle.guid_ = UnguessableToken::Create();
-  handle.size_ = size;
-  return handle;
-}
-
-int SharedMemoryHandle::GetHandle() const {
-  return file_descriptor_.fd;
-}
-
-bool SharedMemoryHandle::IsValid() const {
-  return file_descriptor_.fd >= 0;
-}
-
-void SharedMemoryHandle::Close() const {
-  if (IGNORE_EINTR(close(file_descriptor_.fd)) < 0)
-    PLOG(ERROR) << "close";
-}
-
-int SharedMemoryHandle::Release() {
-  int old_fd = file_descriptor_.fd;
-  file_descriptor_.fd = -1;
-  return old_fd;
-}
-
-SharedMemoryHandle SharedMemoryHandle::Duplicate() const {
-  if (!IsValid())
-    return SharedMemoryHandle();
-
-  int duped_handle = HANDLE_EINTR(dup(file_descriptor_.fd));
-  if (duped_handle < 0)
-    return SharedMemoryHandle();
-  return SharedMemoryHandle(FileDescriptor(duped_handle, true), GetSize(),
-                            GetGUID());
-}
-
-void SharedMemoryHandle::SetOwnershipPassesToIPC(bool ownership_passes) {
-  file_descriptor_.auto_close = ownership_passes;
-}
-
-bool SharedMemoryHandle::OwnershipPassesToIPC() const {
-  return file_descriptor_.auto_close;
-}
-
-}  // namespace base
diff --git a/base/memory/shared_memory_handle_win.cc b/base/memory/shared_memory_handle_win.cc
deleted file mode 100644
index 8c11d39..0000000
--- a/base/memory/shared_memory_handle_win.cc
+++ /dev/null
@@ -1,55 +0,0 @@
-// Copyright 2015 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/memory/shared_memory_handle.h"
-
-#include "base/logging.h"
-#include "base/unguessable_token.h"
-
-#include <windows.h>
-
-namespace base {
-
-SharedMemoryHandle::SharedMemoryHandle() {}
-
-SharedMemoryHandle::SharedMemoryHandle(HANDLE h,
-                                       size_t size,
-                                       const base::UnguessableToken& guid)
-    : handle_(h), guid_(guid), size_(size) {}
-
-void SharedMemoryHandle::Close() const {
-  DCHECK(handle_ != nullptr);
-  ::CloseHandle(handle_);
-}
-
-bool SharedMemoryHandle::IsValid() const {
-  return handle_ != nullptr;
-}
-
-SharedMemoryHandle SharedMemoryHandle::Duplicate() const {
-  HANDLE duped_handle;
-  ProcessHandle process = GetCurrentProcess();
-  BOOL success = ::DuplicateHandle(process, handle_, process, &duped_handle, 0,
-                                   FALSE, DUPLICATE_SAME_ACCESS);
-  if (!success)
-    return SharedMemoryHandle();
-
-  base::SharedMemoryHandle handle(duped_handle, GetSize(), GetGUID());
-  handle.SetOwnershipPassesToIPC(true);
-  return handle;
-}
-
-HANDLE SharedMemoryHandle::GetHandle() const {
-  return handle_;
-}
-
-void SharedMemoryHandle::SetOwnershipPassesToIPC(bool ownership_passes) {
-  ownership_passes_to_ipc_ = ownership_passes;
-}
-
-bool SharedMemoryHandle::OwnershipPassesToIPC() const {
-  return ownership_passes_to_ipc_;
-}
-
-}  // namespace base
diff --git a/base/memory/shared_memory_helper.cc b/base/memory/shared_memory_helper.cc
deleted file mode 100644
index f98b734..0000000
--- a/base/memory/shared_memory_helper.cc
+++ /dev/null
@@ -1,157 +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/memory/shared_memory_helper.h"
-
-#if defined(OS_CHROMEOS)
-#include <sys/resource.h>
-#include <sys/time.h>
-
-#include "base/debug/alias.h"
-#endif  // defined(OS_CHROMEOS)
-
-#include "base/threading/thread_restrictions.h"
-
-namespace base {
-
-struct ScopedPathUnlinkerTraits {
-  static const FilePath* InvalidValue() { return nullptr; }
-
-  static void Free(const FilePath* path) {
-    if (unlink(path->value().c_str()))
-      PLOG(WARNING) << "unlink";
-  }
-};
-
-// Unlinks the FilePath when the object is destroyed.
-using ScopedPathUnlinker =
-    ScopedGeneric<const FilePath*, ScopedPathUnlinkerTraits>;
-
-#if !defined(OS_ANDROID)
-bool CreateAnonymousSharedMemory(const SharedMemoryCreateOptions& options,
-                                 ScopedFD* fd,
-                                 ScopedFD* readonly_fd,
-                                 FilePath* path) {
-#if defined(OS_LINUX)
-  // It doesn't make sense to have a open-existing private piece of shmem
-  DCHECK(!options.open_existing_deprecated);
-#endif  // defined(OS_LINUX)
-  // Q: Why not use the shm_open() etc. APIs?
-  // A: Because they're limited to 4mb on OS X.  FFFFFFFUUUUUUUUUUU
-  FilePath directory;
-  ScopedPathUnlinker path_unlinker;
-  if (!GetShmemTempDir(options.executable, &directory))
-    return false;
-
-  fd->reset(base::CreateAndOpenFdForTemporaryFileInDir(directory, path));
-
-  if (!fd->is_valid())
-    return false;
-
-  // Deleting the file prevents anyone else from mapping it in (making it
-  // private), and prevents the need for cleanup (once the last fd is
-  // closed, it is truly freed).
-  path_unlinker.reset(path);
-
-  if (options.share_read_only) {
-    // Also open as readonly so that we can GetReadOnlyHandle.
-    readonly_fd->reset(HANDLE_EINTR(open(path->value().c_str(), O_RDONLY)));
-    if (!readonly_fd->is_valid()) {
-      DPLOG(ERROR) << "open(\"" << path->value() << "\", O_RDONLY) failed";
-      fd->reset();
-      return false;
-    }
-  }
-  return true;
-}
-
-bool PrepareMapFile(ScopedFD fd,
-                    ScopedFD readonly_fd,
-                    int* mapped_file,
-                    int* readonly_mapped_file) {
-  DCHECK_EQ(-1, *mapped_file);
-  DCHECK_EQ(-1, *readonly_mapped_file);
-  if (!fd.is_valid())
-    return false;
-
-  // This function theoretically can block on the disk, but realistically
-  // the temporary files we create will just go into the buffer cache
-  // and be deleted before they ever make it out to disk.
-  base::ThreadRestrictions::ScopedAllowIO allow_io;
-
-  if (readonly_fd.is_valid()) {
-    struct stat st = {};
-    if (fstat(fd.get(), &st))
-      NOTREACHED();
-
-    struct stat readonly_st = {};
-    if (fstat(readonly_fd.get(), &readonly_st))
-      NOTREACHED();
-    if (st.st_dev != readonly_st.st_dev || st.st_ino != readonly_st.st_ino) {
-      LOG(ERROR) << "writable and read-only inodes don't match; bailing";
-      return false;
-    }
-  }
-
-  *mapped_file = HANDLE_EINTR(dup(fd.get()));
-  if (*mapped_file == -1) {
-    NOTREACHED() << "Call to dup failed, errno=" << errno;
-
-#if defined(OS_CHROMEOS)
-    if (errno == EMFILE) {
-      // We're out of file descriptors and are probably about to crash somewhere
-      // else in Chrome anyway. Let's collect what FD information we can and
-      // crash.
-      // Added for debugging crbug.com/733718
-      int original_fd_limit = 16384;
-      struct rlimit rlim;
-      if (getrlimit(RLIMIT_NOFILE, &rlim) == 0) {
-        original_fd_limit = rlim.rlim_cur;
-        if (rlim.rlim_max > rlim.rlim_cur) {
-          // Increase fd limit so breakpad has a chance to write a minidump.
-          rlim.rlim_cur = rlim.rlim_max;
-          if (setrlimit(RLIMIT_NOFILE, &rlim) != 0) {
-            PLOG(ERROR) << "setrlimit() failed";
-          }
-        }
-      } else {
-        PLOG(ERROR) << "getrlimit() failed";
-      }
-
-      const char kFileDataMarker[] = "FDATA";
-      char buf[PATH_MAX];
-      char fd_path[PATH_MAX];
-      char crash_buffer[32 * 1024] = {0};
-      char* crash_ptr = crash_buffer;
-      base::debug::Alias(crash_buffer);
-
-      // Put a marker at the start of our data so we can confirm where it
-      // begins.
-      crash_ptr = strncpy(crash_ptr, kFileDataMarker, strlen(kFileDataMarker));
-      for (int i = original_fd_limit; i >= 0; --i) {
-        memset(buf, 0, arraysize(buf));
-        memset(fd_path, 0, arraysize(fd_path));
-        snprintf(fd_path, arraysize(fd_path) - 1, "/proc/self/fd/%d", i);
-        ssize_t count = readlink(fd_path, buf, arraysize(buf) - 1);
-        if (count < 0) {
-          PLOG(ERROR) << "readlink failed for: " << fd_path;
-          continue;
-        }
-
-        if (crash_ptr + count + 1 < crash_buffer + arraysize(crash_buffer)) {
-          crash_ptr = strncpy(crash_ptr, buf, count + 1);
-        }
-        LOG(ERROR) << i << ": " << buf;
-      }
-      LOG(FATAL) << "Logged for file descriptor exhaustion, crashing now";
-    }
-#endif  // defined(OS_CHROMEOS)
-  }
-  *readonly_mapped_file = readonly_fd.release();
-
-  return true;
-}
-#endif  // !defined(OS_ANDROID)
-
-}  // namespace base
diff --git a/base/memory/shared_memory_helper.h b/base/memory/shared_memory_helper.h
deleted file mode 100644
index 9da810e..0000000
--- a/base/memory/shared_memory_helper.h
+++ /dev/null
@@ -1,36 +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_MEMORY_SHARED_MEMORY_HELPER_H_
-#define BASE_MEMORY_SHARED_MEMORY_HELPER_H_
-
-#include "base/memory/shared_memory.h"
-#include "build_config.h"
-
-#include <fcntl.h>
-
-namespace base {
-
-#if !defined(OS_ANDROID)
-// Makes a temporary file, fdopens it, and then unlinks it. |fd| is populated
-// with the opened fd. |readonly_fd| is populated with the opened fd if
-// options.share_read_only is true. |path| is populated with the location of
-// the file before it was unlinked.
-// Returns false if there's an unhandled failure.
-bool CreateAnonymousSharedMemory(const SharedMemoryCreateOptions& options,
-                                 ScopedFD* fd,
-                                 ScopedFD* readonly_fd,
-                                 FilePath* path);
-
-// Takes the outputs of CreateAnonymousSharedMemory and maps them properly to
-// |mapped_file| or |readonly_mapped_file|, depending on which one is populated.
-bool PrepareMapFile(ScopedFD fd,
-                    ScopedFD readonly_fd,
-                    int* mapped_file,
-                    int* readonly_mapped_file);
-#endif  // !defined(OS_ANDROID)
-
-}  // namespace base
-
-#endif  // BASE_MEMORY_SHARED_MEMORY_HELPER_H_
diff --git a/base/memory/shared_memory_mac.cc b/base/memory/shared_memory_mac.cc
deleted file mode 100644
index 5e9e8fc..0000000
--- a/base/memory/shared_memory_mac.cc
+++ /dev/null
@@ -1,262 +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/memory/shared_memory.h"
-
-#include <errno.h>
-#include <mach/mach_vm.h>
-#include <stddef.h>
-#include <sys/mman.h>
-#include <sys/stat.h>
-#include <unistd.h>
-
-#include "base/files/file_util.h"
-#include "base/files/scoped_file.h"
-#include "base/logging.h"
-#include "base/mac/foundation_util.h"
-#include "base/mac/mac_util.h"
-#include "base/mac/scoped_mach_vm.h"
-#include "base/memory/shared_memory_helper.h"
-#include "base/memory/shared_memory_tracker.h"
-#include "base/posix/eintr_wrapper.h"
-#include "base/posix/safe_strerror.h"
-#include "base/process/process_metrics.h"
-#include "base/scoped_generic.h"
-#include "base/strings/utf_string_conversions.h"
-#include "base/threading/thread_restrictions.h"
-#include "base/unguessable_token.h"
-#include "build_config.h"
-
-#if defined(OS_IOS)
-#error "MacOS only - iOS uses shared_memory_posix.cc"
-#endif
-
-namespace base {
-
-namespace {
-
-// Returns whether the operation succeeded.
-// |new_handle| is an output variable, populated on success. The caller takes
-// ownership of the underlying memory object.
-// |handle| is the handle to copy.
-// If |handle| is already mapped, |mapped_addr| is its mapped location.
-// Otherwise, |mapped_addr| should be |nullptr|.
-bool MakeMachSharedMemoryHandleReadOnly(SharedMemoryHandle* new_handle,
-                                        SharedMemoryHandle handle,
-                                        void* mapped_addr) {
-  if (!handle.IsValid())
-    return false;
-
-  size_t size = handle.GetSize();
-
-  // Map if necessary.
-  void* temp_addr = mapped_addr;
-  base::mac::ScopedMachVM scoper;
-  if (!temp_addr) {
-    // Intentionally lower current prot and max prot to |VM_PROT_READ|.
-    kern_return_t kr = mach_vm_map(
-        mach_task_self(), reinterpret_cast<mach_vm_address_t*>(&temp_addr),
-        size, 0, VM_FLAGS_ANYWHERE, handle.GetMemoryObject(), 0, FALSE,
-        VM_PROT_READ, VM_PROT_READ, VM_INHERIT_NONE);
-    if (kr != KERN_SUCCESS)
-      return false;
-    scoper.reset(reinterpret_cast<vm_address_t>(temp_addr),
-                 mach_vm_round_page(size));
-  }
-
-  // Make new memory object.
-  mach_port_t named_right;
-  kern_return_t kr = mach_make_memory_entry_64(
-      mach_task_self(), reinterpret_cast<memory_object_size_t*>(&size),
-      reinterpret_cast<memory_object_offset_t>(temp_addr), VM_PROT_READ,
-      &named_right, MACH_PORT_NULL);
-  if (kr != KERN_SUCCESS)
-    return false;
-
-  *new_handle = SharedMemoryHandle(named_right, size, handle.GetGUID());
-  return true;
-}
-
-}  // namespace
-
-SharedMemory::SharedMemory() {}
-
-SharedMemory::SharedMemory(const SharedMemoryHandle& handle, bool read_only)
-    : mapped_memory_mechanism_(SharedMemoryHandle::POSIX),
-      shm_(handle),
-      read_only_(read_only) {}
-
-SharedMemory::~SharedMemory() {
-  Unmap();
-  Close();
-}
-
-// static
-bool SharedMemory::IsHandleValid(const SharedMemoryHandle& handle) {
-  return handle.IsValid();
-}
-
-// static
-void SharedMemory::CloseHandle(const SharedMemoryHandle& handle) {
-  handle.Close();
-}
-
-// static
-size_t SharedMemory::GetHandleLimit() {
-  return GetMaxFds();
-}
-
-// static
-SharedMemoryHandle SharedMemory::DuplicateHandle(
-    const SharedMemoryHandle& handle) {
-  return handle.Duplicate();
-}
-
-// static
-int SharedMemory::GetFdFromSharedMemoryHandle(
-    const SharedMemoryHandle& handle) {
-  return handle.file_descriptor_.fd;
-}
-
-bool SharedMemory::CreateAndMapAnonymous(size_t size) {
-  return CreateAnonymous(size) && Map(size);
-}
-
-// Chromium mostly only uses the unique/private shmem as specified by
-// "name == L"". The exception is in the StatsTable.
-bool SharedMemory::Create(const SharedMemoryCreateOptions& options) {
-  DCHECK(!shm_.IsValid());
-  if (options.size == 0)
-    return false;
-
-  if (options.size > static_cast<size_t>(std::numeric_limits<int>::max()))
-    return false;
-
-  if (options.type == SharedMemoryHandle::MACH) {
-    shm_ = SharedMemoryHandle(options.size, UnguessableToken::Create());
-    requested_size_ = options.size;
-    return shm_.IsValid();
-  }
-
-  // This function theoretically can block on the disk. Both profiling of real
-  // users and local instrumentation shows that this is a real problem.
-  // https://code.google.com/p/chromium/issues/detail?id=466437
-  ThreadRestrictions::ScopedAllowIO allow_io;
-
-  ScopedFD fd;
-  ScopedFD readonly_fd;
-
-  FilePath path;
-  bool result = CreateAnonymousSharedMemory(options, &fd, &readonly_fd, &path);
-  if (!result)
-    return false;
-  // Should be guaranteed by CreateAnonymousSharedMemory().
-  DCHECK(fd.is_valid());
-
-  // Get current size.
-  struct stat stat;
-  if (fstat(fd.get(), &stat) != 0)
-    return false;
-  const size_t current_size = stat.st_size;
-  if (current_size != options.size) {
-    if (HANDLE_EINTR(ftruncate(fd.get(), options.size)) != 0)
-      return false;
-  }
-  requested_size_ = options.size;
-
-  int mapped_file = -1;
-  int readonly_mapped_file = -1;
-  result = PrepareMapFile(std::move(fd), std::move(readonly_fd), &mapped_file,
-                          &readonly_mapped_file);
-  shm_ = SharedMemoryHandle(FileDescriptor(mapped_file, false), options.size,
-                            UnguessableToken::Create());
-  readonly_shm_ =
-      SharedMemoryHandle(FileDescriptor(readonly_mapped_file, false),
-                         options.size, shm_.GetGUID());
-  return result;
-}
-
-bool SharedMemory::MapAt(off_t offset, size_t bytes) {
-  if (!shm_.IsValid())
-    return false;
-  if (bytes > static_cast<size_t>(std::numeric_limits<int>::max()))
-    return false;
-  if (memory_)
-    return false;
-
-  bool success = shm_.MapAt(offset, bytes, &memory_, read_only_);
-  if (success) {
-    mapped_size_ = bytes;
-    DCHECK_EQ(0U, reinterpret_cast<uintptr_t>(memory_) &
-                      (SharedMemory::MAP_MINIMUM_ALIGNMENT - 1));
-    mapped_memory_mechanism_ = shm_.type_;
-    mapped_id_ = shm_.GetGUID();
-    SharedMemoryTracker::GetInstance()->IncrementMemoryUsage(*this);
-  } else {
-    memory_ = nullptr;
-  }
-
-  return success;
-}
-
-bool SharedMemory::Unmap() {
-  if (!memory_)
-    return false;
-
-  SharedMemoryTracker::GetInstance()->DecrementMemoryUsage(*this);
-  switch (mapped_memory_mechanism_) {
-    case SharedMemoryHandle::POSIX:
-      munmap(memory_, mapped_size_);
-      break;
-    case SharedMemoryHandle::MACH:
-      mach_vm_deallocate(mach_task_self(),
-                         reinterpret_cast<mach_vm_address_t>(memory_),
-                         mapped_size_);
-      break;
-  }
-  memory_ = nullptr;
-  mapped_size_ = 0;
-  mapped_id_ = UnguessableToken();
-  return true;
-}
-
-SharedMemoryHandle SharedMemory::handle() const {
-  return shm_;
-}
-
-SharedMemoryHandle SharedMemory::TakeHandle() {
-  SharedMemoryHandle dup = DuplicateHandle(handle());
-  Unmap();
-  Close();
-  return dup;
-}
-
-void SharedMemory::Close() {
-  shm_.Close();
-  shm_ = SharedMemoryHandle();
-  if (shm_.type_ == SharedMemoryHandle::POSIX) {
-    if (readonly_shm_.IsValid()) {
-      readonly_shm_.Close();
-      readonly_shm_ = SharedMemoryHandle();
-    }
-  }
-}
-
-SharedMemoryHandle SharedMemory::GetReadOnlyHandle() const {
-  if (shm_.type_ == SharedMemoryHandle::POSIX) {
-    // We could imagine re-opening the file from /dev/fd, but that can't make it
-    // readonly on Mac: https://codereview.chromium.org/27265002/#msg10.
-    CHECK(readonly_shm_.IsValid());
-    return readonly_shm_.Duplicate();
-  }
-
-  DCHECK(shm_.IsValid());
-  SharedMemoryHandle new_handle;
-  bool success = MakeMachSharedMemoryHandleReadOnly(&new_handle, shm_, memory_);
-  if (success)
-    new_handle.SetOwnershipPassesToIPC(true);
-  return new_handle;
-}
-
-}  // namespace base
diff --git a/base/memory/shared_memory_mapping.cc b/base/memory/shared_memory_mapping.cc
deleted file mode 100644
index 878a012..0000000
--- a/base/memory/shared_memory_mapping.cc
+++ /dev/null
@@ -1,115 +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/memory/shared_memory_mapping.h"
-
-#include <utility>
-
-#include "base/logging.h"
-#include "base/memory/shared_memory_tracker.h"
-#include "base/unguessable_token.h"
-#include "build_config.h"
-
-#if defined(OS_POSIX)
-#include <sys/mman.h>
-#endif
-
-#if defined(OS_WIN)
-#include <aclapi.h>
-#endif
-
-#if defined(OS_MACOSX) && !defined(OS_IOS)
-#include <mach/mach_vm.h>
-#include "base/mac/mach_logging.h"
-#endif
-
-#if defined(OS_FUCHSIA)
-#include <zircon/process.h>
-#include <zircon/status.h>
-#include <zircon/syscalls.h>
-#endif
-
-namespace base {
-
-SharedMemoryMapping::SharedMemoryMapping() = default;
-
-SharedMemoryMapping::SharedMemoryMapping(SharedMemoryMapping&& mapping)
-    : memory_(mapping.memory_),
-      size_(mapping.size_),
-      mapped_size_(mapping.mapped_size_),
-      guid_(mapping.guid_) {
-  mapping.memory_ = nullptr;
-}
-
-SharedMemoryMapping& SharedMemoryMapping::operator=(
-    SharedMemoryMapping&& mapping) {
-  Unmap();
-  memory_ = mapping.memory_;
-  size_ = mapping.size_;
-  mapped_size_ = mapping.mapped_size_;
-  guid_ = mapping.guid_;
-  mapping.memory_ = nullptr;
-  return *this;
-}
-
-SharedMemoryMapping::~SharedMemoryMapping() {
-  Unmap();
-}
-
-SharedMemoryMapping::SharedMemoryMapping(void* memory,
-                                         size_t size,
-                                         size_t mapped_size,
-                                         const UnguessableToken& guid)
-    : memory_(memory), size_(size), mapped_size_(mapped_size), guid_(guid) {
-  SharedMemoryTracker::GetInstance()->IncrementMemoryUsage(*this);
-}
-
-void SharedMemoryMapping::Unmap() {
-  if (!IsValid())
-    return;
-
-  SharedMemoryTracker::GetInstance()->DecrementMemoryUsage(*this);
-#if defined(OS_WIN)
-  if (!UnmapViewOfFile(memory_))
-    DPLOG(ERROR) << "UnmapViewOfFile";
-#elif defined(OS_FUCHSIA)
-  uintptr_t addr = reinterpret_cast<uintptr_t>(memory_);
-  zx_status_t status = zx_vmar_unmap(zx_vmar_root_self(), addr, size_);
-  DLOG_IF(ERROR, status != ZX_OK)
-      << "zx_vmar_unmap failed: " << zx_status_get_string(status);
-#elif defined(OS_MACOSX) && !defined(OS_IOS)
-  kern_return_t kr = mach_vm_deallocate(
-      mach_task_self(), reinterpret_cast<mach_vm_address_t>(memory_), size_);
-  MACH_DLOG_IF(ERROR, kr != KERN_SUCCESS, kr) << "mach_vm_deallocate";
-#else
-  if (munmap(memory_, size_) < 0)
-    DPLOG(ERROR) << "munmap";
-#endif
-}
-
-ReadOnlySharedMemoryMapping::ReadOnlySharedMemoryMapping() = default;
-ReadOnlySharedMemoryMapping::ReadOnlySharedMemoryMapping(
-    ReadOnlySharedMemoryMapping&&) = default;
-ReadOnlySharedMemoryMapping& ReadOnlySharedMemoryMapping::operator=(
-    ReadOnlySharedMemoryMapping&&) = default;
-ReadOnlySharedMemoryMapping::ReadOnlySharedMemoryMapping(
-    void* address,
-    size_t size,
-    size_t mapped_size,
-    const UnguessableToken& guid)
-    : SharedMemoryMapping(address, size, mapped_size, guid) {}
-
-WritableSharedMemoryMapping::WritableSharedMemoryMapping() = default;
-WritableSharedMemoryMapping::WritableSharedMemoryMapping(
-    WritableSharedMemoryMapping&&) = default;
-WritableSharedMemoryMapping& WritableSharedMemoryMapping::operator=(
-    WritableSharedMemoryMapping&&) = default;
-WritableSharedMemoryMapping::WritableSharedMemoryMapping(
-    void* address,
-    size_t size,
-    size_t mapped_size,
-    const UnguessableToken& guid)
-    : SharedMemoryMapping(address, size, mapped_size, guid) {}
-
-}  // namespace base
diff --git a/base/memory/shared_memory_mapping.h b/base/memory/shared_memory_mapping.h
deleted file mode 100644
index ace4c15..0000000
--- a/base/memory/shared_memory_mapping.h
+++ /dev/null
@@ -1,144 +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_MEMORY_SHARED_MEMORY_MAPPING_H_
-#define BASE_MEMORY_SHARED_MEMORY_MAPPING_H_
-
-#include <cstddef>
-
-#include "base/macros.h"
-#include "base/unguessable_token.h"
-
-namespace base {
-
-namespace subtle {
-class PlatformSharedMemoryRegion;
-}  // namespace subtle
-
-// Base class for scoped handles to a shared memory mapping created from a
-// shared memory region. Created shared memory mappings remain valid even if the
-// creator region is transferred or destroyed.
-//
-// Each mapping has an UnguessableToken that identifies the shared memory region
-// it was created from. This is used for memory metrics, to avoid overcounting
-// shared memory.
-class BASE_EXPORT SharedMemoryMapping {
- public:
-  // Default constructor initializes an invalid instance.
-  SharedMemoryMapping();
-
-  // Move operations are allowed.
-  SharedMemoryMapping(SharedMemoryMapping&& mapping);
-  SharedMemoryMapping& operator=(SharedMemoryMapping&& mapping);
-
-  // Unmaps the region if the mapping is valid.
-  virtual ~SharedMemoryMapping();
-
-  // Returns true iff the mapping is valid. False means there is no
-  // corresponding area of memory.
-  bool IsValid() const { return memory_ != nullptr; }
-
-  // Returns the logical size of the mapping in bytes. This is precisely the
-  // size requested by whoever created the mapping, and it is always less than
-  // or equal to |mapped_size()|. This is undefined for invalid instances.
-  size_t size() const {
-    DCHECK(IsValid());
-    return size_;
-  }
-
-  // Returns the actual size of the mapping in bytes. This is always at least
-  // as large as |size()| but may be larger due to platform mapping alignment
-  // constraints. This is undefined for invalid instances.
-  size_t mapped_size() const {
-    DCHECK(IsValid());
-    return mapped_size_;
-  }
-
-  // Returns 128-bit GUID of the region this mapping belongs to.
-  const UnguessableToken& guid() const {
-    DCHECK(IsValid());
-    return guid_;
-  }
-
- protected:
-  SharedMemoryMapping(void* address,
-                      size_t size,
-                      size_t mapped_size,
-                      const UnguessableToken& guid);
-  void* raw_memory_ptr() const { return memory_; }
-
- private:
-  friend class SharedMemoryTracker;
-
-  void Unmap();
-
-  void* memory_ = nullptr;
-  size_t size_ = 0;
-  size_t mapped_size_ = 0;
-  UnguessableToken guid_;
-
-  DISALLOW_COPY_AND_ASSIGN(SharedMemoryMapping);
-};
-
-// Class modeling a read-only mapping of a shared memory region into the
-// current process' address space. This is created by ReadOnlySharedMemoryRegion
-// instances.
-class BASE_EXPORT ReadOnlySharedMemoryMapping : public SharedMemoryMapping {
- public:
-  // Default constructor initializes an invalid instance.
-  ReadOnlySharedMemoryMapping();
-
-  // Move operations are allowed.
-  ReadOnlySharedMemoryMapping(ReadOnlySharedMemoryMapping&&);
-  ReadOnlySharedMemoryMapping& operator=(ReadOnlySharedMemoryMapping&&);
-
-  // Returns the base address of the mapping. This is read-only memory. This is
-  // page-aligned. This is nullptr for invalid instances.
-  const void* memory() const { return raw_memory_ptr(); }
-
- private:
-  friend class ReadOnlySharedMemoryRegion;
-  ReadOnlySharedMemoryMapping(void* address,
-                              size_t size,
-                              size_t mapped_size,
-                              const UnguessableToken& guid);
-
-  DISALLOW_COPY_AND_ASSIGN(ReadOnlySharedMemoryMapping);
-};
-
-// Class modeling a writable mapping of a shared memory region into the
-// current process' address space. This is created by *SharedMemoryRegion
-// instances.
-class BASE_EXPORT WritableSharedMemoryMapping : public SharedMemoryMapping {
- public:
-  // Default constructor initializes an invalid instance.
-  WritableSharedMemoryMapping();
-
-  // Move operations are allowed.
-  WritableSharedMemoryMapping(WritableSharedMemoryMapping&&);
-  WritableSharedMemoryMapping& operator=(WritableSharedMemoryMapping&&);
-
-  // Returns the base address of the mapping. This is writable memory. This is
-  // page-aligned. This is nullptr for invalid instances.
-  void* memory() const { return raw_memory_ptr(); }
-
- private:
-  friend WritableSharedMemoryMapping MapAtForTesting(
-      subtle::PlatformSharedMemoryRegion* region,
-      off_t offset,
-      size_t size);
-  friend class ReadOnlySharedMemoryRegion;
-  friend class WritableSharedMemoryRegion;
-  friend class UnsafeSharedMemoryRegion;
-  WritableSharedMemoryMapping(void* address,
-                              size_t size,
-                              size_t mapped_size,
-                              const UnguessableToken& guid);
-
-  DISALLOW_COPY_AND_ASSIGN(WritableSharedMemoryMapping);
-};
-
-}  // namespace base
-
-#endif  // BASE_MEMORY_SHARED_MEMORY_MAPPING_H_
diff --git a/base/memory/shared_memory_nacl.cc b/base/memory/shared_memory_nacl.cc
deleted file mode 100644
index 4bcbb54..0000000
--- a/base/memory/shared_memory_nacl.cc
+++ /dev/null
@@ -1,138 +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/memory/shared_memory.h"
-
-#include <errno.h>
-#include <fcntl.h>
-#include <stddef.h>
-#include <sys/mman.h>
-#include <sys/stat.h>
-#include <unistd.h>
-
-#include <limits>
-
-#include "base/logging.h"
-#include "base/memory/shared_memory_tracker.h"
-
-namespace base {
-
-SharedMemory::SharedMemory()
-    : mapped_size_(0), memory_(NULL), read_only_(false), requested_size_(0) {}
-
-SharedMemory::SharedMemory(const SharedMemoryHandle& handle, bool read_only)
-    : shm_(handle),
-      mapped_size_(0),
-      memory_(NULL),
-      read_only_(read_only),
-      requested_size_(0) {}
-
-SharedMemory::~SharedMemory() {
-  Unmap();
-  Close();
-}
-
-// static
-bool SharedMemory::IsHandleValid(const SharedMemoryHandle& handle) {
-  return handle.IsValid();
-}
-
-// static
-void SharedMemory::CloseHandle(const SharedMemoryHandle& handle) {
-  DCHECK(handle.IsValid());
-  handle.Close();
-}
-
-// static
-SharedMemoryHandle SharedMemory::DuplicateHandle(
-    const SharedMemoryHandle& handle) {
-  return handle.Duplicate();
-}
-
-bool SharedMemory::CreateAndMapAnonymous(size_t size) {
-  // Untrusted code can't create descriptors or handles.
-  return false;
-}
-
-bool SharedMemory::Create(const SharedMemoryCreateOptions& options) {
-  // Untrusted code can't create descriptors or handles.
-  return false;
-}
-
-bool SharedMemory::Delete(const std::string& name) {
-  return false;
-}
-
-bool SharedMemory::Open(const std::string& name, bool read_only) {
-  return false;
-}
-
-bool SharedMemory::MapAt(off_t offset, size_t bytes) {
-  if (!shm_.IsValid())
-    return false;
-
-  if (bytes > static_cast<size_t>(std::numeric_limits<int>::max()))
-    return false;
-
-  if (memory_)
-    return false;
-
-  memory_ = mmap(NULL, bytes, PROT_READ | (read_only_ ? 0 : PROT_WRITE),
-                 MAP_SHARED, shm_.GetHandle(), offset);
-
-  bool mmap_succeeded = memory_ != MAP_FAILED && memory_ != NULL;
-  if (mmap_succeeded) {
-    mapped_size_ = bytes;
-    DCHECK_EQ(0U, reinterpret_cast<uintptr_t>(memory_) &
-        (SharedMemory::MAP_MINIMUM_ALIGNMENT - 1));
-    mapped_id_ = shm_.GetGUID();
-    SharedMemoryTracker::GetInstance()->IncrementMemoryUsage(*this);
-  } else {
-    memory_ = NULL;
-  }
-
-  return mmap_succeeded;
-}
-
-bool SharedMemory::Unmap() {
-  if (memory_ == NULL)
-    return false;
-
-  SharedMemoryTracker::GetInstance()->DecrementMemoryUsage(*this);
-  if (munmap(memory_, mapped_size_) < 0)
-    DPLOG(ERROR) << "munmap";
-  memory_ = NULL;
-  mapped_size_ = 0;
-  mapped_id_ = UnguessableToken();
-  return true;
-}
-
-SharedMemoryHandle SharedMemory::handle() const {
-  SharedMemoryHandle handle_copy = shm_;
-  handle_copy.SetOwnershipPassesToIPC(false);
-  return handle_copy;
-}
-
-SharedMemoryHandle SharedMemory::TakeHandle() {
-  SharedMemoryHandle handle_copy = shm_;
-  handle_copy.SetOwnershipPassesToIPC(true);
-  Unmap();
-  shm_ = SharedMemoryHandle();
-  return handle_copy;
-}
-
-void SharedMemory::Close() {
-  if (shm_.IsValid()) {
-    shm_.Close();
-    shm_ = SharedMemoryHandle();
-  }
-}
-
-SharedMemoryHandle SharedMemory::GetReadOnlyHandle() const {
-  // Untrusted code can't create descriptors or handles, which is needed to
-  // drop permissions.
-  return SharedMemoryHandle();
-}
-
-}  // namespace base
diff --git a/base/memory/shared_memory_posix.cc b/base/memory/shared_memory_posix.cc
deleted file mode 100644
index f868eb2..0000000
--- a/base/memory/shared_memory_posix.cc
+++ /dev/null
@@ -1,385 +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/memory/shared_memory.h"
-
-#include <errno.h>
-#include <fcntl.h>
-#include <stddef.h>
-#include <sys/mman.h>
-#include <sys/stat.h>
-#include <unistd.h>
-
-#include "base/files/file_util.h"
-#include "base/files/scoped_file.h"
-#include "base/logging.h"
-#include "base/macros.h"
-#include "base/memory/shared_memory_helper.h"
-#include "base/memory/shared_memory_tracker.h"
-#include "base/posix/eintr_wrapper.h"
-#include "base/posix/safe_strerror.h"
-#include "base/process/process_metrics.h"
-#include "base/scoped_generic.h"
-#include "base/strings/utf_string_conversions.h"
-#include "base/threading/thread_restrictions.h"
-#include "base/unguessable_token.h"
-#include "build_config.h"
-
-#if defined(OS_ANDROID)
-#include "base/os_compat_android.h"
-#include "third_party/ashmem/ashmem.h"
-#endif
-
-#if defined(OS_MACOSX) && !defined(OS_IOS)
-#error "MacOS uses shared_memory_mac.cc"
-#endif
-
-namespace base {
-
-SharedMemory::SharedMemory() = default;
-
-SharedMemory::SharedMemory(const SharedMemoryHandle& handle, bool read_only)
-    : shm_(handle), read_only_(read_only) {}
-
-SharedMemory::~SharedMemory() {
-  Unmap();
-  Close();
-}
-
-// static
-bool SharedMemory::IsHandleValid(const SharedMemoryHandle& handle) {
-  return handle.IsValid();
-}
-
-// static
-void SharedMemory::CloseHandle(const SharedMemoryHandle& handle) {
-  DCHECK(handle.IsValid());
-  handle.Close();
-}
-
-// static
-size_t SharedMemory::GetHandleLimit() {
-  return GetMaxFds();
-}
-
-// static
-SharedMemoryHandle SharedMemory::DuplicateHandle(
-    const SharedMemoryHandle& handle) {
-  return handle.Duplicate();
-}
-
-// static
-int SharedMemory::GetFdFromSharedMemoryHandle(
-    const SharedMemoryHandle& handle) {
-  return handle.GetHandle();
-}
-
-bool SharedMemory::CreateAndMapAnonymous(size_t size) {
-  return CreateAnonymous(size) && Map(size);
-}
-
-#if !defined(OS_ANDROID)
-
-// Chromium mostly only uses the unique/private shmem as specified by
-// "name == L"". The exception is in the StatsTable.
-// TODO(jrg): there is no way to "clean up" all unused named shmem if
-// we restart from a crash.  (That isn't a new problem, but it is a problem.)
-// In case we want to delete it later, it may be useful to save the value
-// of mem_filename after FilePathForMemoryName().
-bool SharedMemory::Create(const SharedMemoryCreateOptions& options) {
-  DCHECK(!shm_.IsValid());
-  if (options.size == 0) return false;
-
-  if (options.size > static_cast<size_t>(std::numeric_limits<int>::max()))
-    return false;
-
-  // This function theoretically can block on the disk, but realistically
-  // the temporary files we create will just go into the buffer cache
-  // and be deleted before they ever make it out to disk.
-  ThreadRestrictions::ScopedAllowIO allow_io;
-
-  bool fix_size = true;
-  ScopedFD fd;
-  ScopedFD readonly_fd;
-  FilePath path;
-  if (!options.name_deprecated || options.name_deprecated->empty()) {
-    bool result =
-        CreateAnonymousSharedMemory(options, &fd, &readonly_fd, &path);
-    if (!result)
-      return false;
-  } else {
-    if (!FilePathForMemoryName(*options.name_deprecated, &path))
-      return false;
-
-    // Make sure that the file is opened without any permission
-    // to other users on the system.
-    const mode_t kOwnerOnly = S_IRUSR | S_IWUSR;
-
-    // First, try to create the file.
-    fd.reset(HANDLE_EINTR(
-        open(path.value().c_str(), O_RDWR | O_CREAT | O_EXCL, kOwnerOnly)));
-    if (!fd.is_valid() && options.open_existing_deprecated) {
-      // If this doesn't work, try and open an existing file in append mode.
-      // Opening an existing file in a world writable directory has two main
-      // security implications:
-      // - Attackers could plant a file under their control, so ownership of
-      //   the file is checked below.
-      // - Attackers could plant a symbolic link so that an unexpected file
-      //   is opened, so O_NOFOLLOW is passed to open().
-#if !defined(OS_AIX)
-      fd.reset(HANDLE_EINTR(
-          open(path.value().c_str(), O_RDWR | O_APPEND | O_NOFOLLOW)));
-#else
-      // AIX has no 64-bit support for open flags such as -
-      //  O_CLOEXEC, O_NOFOLLOW and O_TTY_INIT.
-      fd.reset(HANDLE_EINTR(open(path.value().c_str(), O_RDWR | O_APPEND)));
-#endif
-      // Check that the current user owns the file.
-      // If uid != euid, then a more complex permission model is used and this
-      // API is not appropriate.
-      const uid_t real_uid = getuid();
-      const uid_t effective_uid = geteuid();
-      struct stat sb;
-      if (fd.is_valid() &&
-          (fstat(fd.get(), &sb) != 0 || sb.st_uid != real_uid ||
-           sb.st_uid != effective_uid)) {
-        LOG(ERROR) <<
-            "Invalid owner when opening existing shared memory file.";
-        close(fd.get());
-        return false;
-      }
-
-      // An existing file was opened, so its size should not be fixed.
-      fix_size = false;
-    }
-
-    if (options.share_read_only) {
-      // Also open as readonly so that we can GetReadOnlyHandle.
-      readonly_fd.reset(HANDLE_EINTR(open(path.value().c_str(), O_RDONLY)));
-      if (!readonly_fd.is_valid()) {
-        DPLOG(ERROR) << "open(\"" << path.value() << "\", O_RDONLY) failed";
-        close(fd.get());
-        return false;
-      }
-    }
-    if (fd.is_valid()) {
-      // "a+" is always appropriate: if it's a new file, a+ is similar to w+.
-      if (!fdopen(fd.get(), "a+")) {
-        PLOG(ERROR) << "Creating file stream in " << path.value() << " failed";
-        return false;
-      }
-    }
-  }
-  if (fd.is_valid() && fix_size) {
-    // Get current size.
-    struct stat stat;
-    if (fstat(fd.get(), &stat) != 0)
-      return false;
-    const size_t current_size = stat.st_size;
-    if (current_size != options.size) {
-      if (HANDLE_EINTR(ftruncate(fd.get(), options.size)) != 0)
-        return false;
-    }
-    requested_size_ = options.size;
-  }
-  if (!fd.is_valid()) {
-    PLOG(ERROR) << "Creating shared memory in " << path.value() << " failed";
-    FilePath dir = path.DirName();
-    if (access(dir.value().c_str(), W_OK | X_OK) < 0) {
-      PLOG(ERROR) << "Unable to access(W_OK|X_OK) " << dir.value();
-      if (dir.value() == "/dev/shm") {
-        LOG(FATAL) << "This is frequently caused by incorrect permissions on "
-                   << "/dev/shm.  Try 'sudo chmod 1777 /dev/shm' to fix.";
-      }
-    }
-    return false;
-  }
-
-  int mapped_file = -1;
-  int readonly_mapped_file = -1;
-
-  bool result = PrepareMapFile(std::move(fd), std::move(readonly_fd),
-                               &mapped_file, &readonly_mapped_file);
-  shm_ = SharedMemoryHandle(FileDescriptor(mapped_file, false), options.size,
-                            UnguessableToken::Create());
-  readonly_shm_ =
-      SharedMemoryHandle(FileDescriptor(readonly_mapped_file, false),
-                         options.size, shm_.GetGUID());
-  return result;
-}
-
-// Our current implementation of shmem is with mmap()ing of files.
-// These files need to be deleted explicitly.
-// In practice this call is only needed for unit tests.
-bool SharedMemory::Delete(const std::string& name) {
-  FilePath path;
-  if (!FilePathForMemoryName(name, &path))
-    return false;
-
-  if (PathExists(path))
-    return DeleteFile(path, false);
-
-  // Doesn't exist, so success.
-  return true;
-}
-
-bool SharedMemory::Open(const std::string& name, bool read_only) {
-  FilePath path;
-  if (!FilePathForMemoryName(name, &path))
-    return false;
-
-  read_only_ = read_only;
-
-  int mode = read_only ? O_RDONLY : O_RDWR;
-  ScopedFD fd(HANDLE_EINTR(open(path.value().c_str(), mode)));
-  ScopedFD readonly_fd(HANDLE_EINTR(open(path.value().c_str(), O_RDONLY)));
-  if (!readonly_fd.is_valid()) {
-    DPLOG(ERROR) << "open(\"" << path.value() << "\", O_RDONLY) failed";
-    return false;
-  }
-  int mapped_file = -1;
-  int readonly_mapped_file = -1;
-  bool result = PrepareMapFile(std::move(fd), std::move(readonly_fd),
-                               &mapped_file, &readonly_mapped_file);
-  // This form of sharing shared memory is deprecated. https://crbug.com/345734.
-  // However, we can't get rid of it without a significant refactor because its
-  // used to communicate between two versions of the same service process, very
-  // early in the life cycle.
-  // Technically, we should also pass the GUID from the original shared memory
-  // region. We don't do that - this means that we will overcount this memory,
-  // which thankfully isn't relevant since Chrome only communicates with a
-  // single version of the service process.
-  // We pass the size |0|, which is a dummy size and wrong, but otherwise
-  // harmless.
-  shm_ = SharedMemoryHandle(FileDescriptor(mapped_file, false), 0u,
-                            UnguessableToken::Create());
-  readonly_shm_ = SharedMemoryHandle(
-      FileDescriptor(readonly_mapped_file, false), 0, shm_.GetGUID());
-  return result;
-}
-#endif  // !defined(OS_ANDROID)
-
-bool SharedMemory::MapAt(off_t offset, size_t bytes) {
-  if (!shm_.IsValid())
-    return false;
-
-  if (bytes > static_cast<size_t>(std::numeric_limits<int>::max()))
-    return false;
-
-  if (memory_)
-    return false;
-
-#if defined(OS_ANDROID)
-  // On Android, Map can be called with a size and offset of zero to use the
-  // ashmem-determined size.
-  if (bytes == 0) {
-    DCHECK_EQ(0, offset);
-    int ashmem_bytes = ashmem_get_size_region(shm_.GetHandle());
-    if (ashmem_bytes < 0)
-      return false;
-    bytes = ashmem_bytes;
-  }
-
-  // Sanity check. This shall catch invalid uses of the SharedMemory APIs
-  // but will not protect against direct mmap() attempts.
-  if (shm_.IsReadOnly()) {
-    // Use a DCHECK() to call writable mappings with read-only descriptors
-    // in debug builds immediately. Return an error for release builds
-    // or during unit-testing (assuming a ScopedLogAssertHandler was installed).
-    DCHECK(read_only_)
-        << "Trying to map a region writable with a read-only descriptor.";
-    if (!read_only_) {
-      return false;
-    }
-    if (!shm_.SetRegionReadOnly()) {  // Ensure the region is read-only.
-      return false;
-    }
-  }
-#endif
-
-  memory_ = mmap(nullptr, bytes, PROT_READ | (read_only_ ? 0 : PROT_WRITE),
-                 MAP_SHARED, shm_.GetHandle(), offset);
-
-  bool mmap_succeeded = memory_ && memory_ != reinterpret_cast<void*>(-1);
-  if (mmap_succeeded) {
-    mapped_size_ = bytes;
-    mapped_id_ = shm_.GetGUID();
-    DCHECK_EQ(0U,
-              reinterpret_cast<uintptr_t>(memory_) &
-                  (SharedMemory::MAP_MINIMUM_ALIGNMENT - 1));
-    SharedMemoryTracker::GetInstance()->IncrementMemoryUsage(*this);
-  } else {
-    memory_ = nullptr;
-  }
-
-  return mmap_succeeded;
-}
-
-bool SharedMemory::Unmap() {
-  if (!memory_)
-    return false;
-
-  SharedMemoryTracker::GetInstance()->DecrementMemoryUsage(*this);
-  munmap(memory_, mapped_size_);
-  memory_ = nullptr;
-  mapped_size_ = 0;
-  mapped_id_ = UnguessableToken();
-  return true;
-}
-
-SharedMemoryHandle SharedMemory::handle() const {
-  return shm_;
-}
-
-SharedMemoryHandle SharedMemory::TakeHandle() {
-  SharedMemoryHandle handle_copy = shm_;
-  handle_copy.SetOwnershipPassesToIPC(true);
-  Unmap();
-  shm_ = SharedMemoryHandle();
-  return handle_copy;
-}
-
-#if !defined(OS_ANDROID)
-void SharedMemory::Close() {
-  if (shm_.IsValid()) {
-    shm_.Close();
-    shm_ = SharedMemoryHandle();
-  }
-  if (readonly_shm_.IsValid()) {
-    readonly_shm_.Close();
-    readonly_shm_ = SharedMemoryHandle();
-  }
-}
-
-// For the given shmem named |mem_name|, return a filename to mmap()
-// (and possibly create).  Modifies |filename|.  Return false on
-// error, or true of we are happy.
-bool SharedMemory::FilePathForMemoryName(const std::string& mem_name,
-                                         FilePath* path) {
-  // mem_name will be used for a filename; make sure it doesn't
-  // contain anything which will confuse us.
-  DCHECK_EQ(std::string::npos, mem_name.find('/'));
-  DCHECK_EQ(std::string::npos, mem_name.find('\0'));
-
-  FilePath temp_dir;
-  if (!GetShmemTempDir(false, &temp_dir))
-    return false;
-
-#if defined(GOOGLE_CHROME_BUILD)
-  static const char kShmem[] = "com.google.Chrome.shmem.";
-#else
-  static const char kShmem[] = "org.chromium.Chromium.shmem.";
-#endif
-  CR_DEFINE_STATIC_LOCAL(const std::string, name_base, (kShmem));
-  *path = temp_dir.AppendASCII(name_base + mem_name);
-  return true;
-}
-
-SharedMemoryHandle SharedMemory::GetReadOnlyHandle() const {
-  CHECK(readonly_shm_.IsValid());
-  return readonly_shm_.Duplicate();
-}
-#endif  // !defined(OS_ANDROID)
-
-}  // namespace base
diff --git a/base/memory/shared_memory_tracker.cc b/base/memory/shared_memory_tracker.cc
deleted file mode 100644
index ee2b490..0000000
--- a/base/memory/shared_memory_tracker.cc
+++ /dev/null
@@ -1,62 +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/memory/shared_memory_tracker.h"
-
-#include "base/memory/shared_memory.h"
-#include "base/strings/string_number_conversions.h"
-
-namespace base {
-
-const char SharedMemoryTracker::kDumpRootName[] = "shared_memory";
-
-// static
-SharedMemoryTracker* SharedMemoryTracker::GetInstance() {
-  static SharedMemoryTracker* instance = new SharedMemoryTracker;
-  return instance;
-}
-
-// static
-std::string SharedMemoryTracker::GetDumpNameForTracing(
-    const UnguessableToken& id) {
-  DCHECK(!id.is_empty());
-  return std::string(kDumpRootName) + "/" + id.ToString();
-}
-
-void SharedMemoryTracker::IncrementMemoryUsage(
-    const SharedMemory& shared_memory) {
-  AutoLock hold(usages_lock_);
-  DCHECK(usages_.find(shared_memory.memory()) == usages_.end());
-  usages_.emplace(shared_memory.memory(), UsageInfo(shared_memory.mapped_size(),
-                                                    shared_memory.mapped_id()));
-}
-
-void SharedMemoryTracker::IncrementMemoryUsage(
-    const SharedMemoryMapping& mapping) {
-  AutoLock hold(usages_lock_);
-  DCHECK(usages_.find(mapping.raw_memory_ptr()) == usages_.end());
-  usages_.emplace(mapping.raw_memory_ptr(),
-                  UsageInfo(mapping.mapped_size(), mapping.guid()));
-}
-
-void SharedMemoryTracker::DecrementMemoryUsage(
-    const SharedMemory& shared_memory) {
-  AutoLock hold(usages_lock_);
-  DCHECK(usages_.find(shared_memory.memory()) != usages_.end());
-  usages_.erase(shared_memory.memory());
-}
-
-void SharedMemoryTracker::DecrementMemoryUsage(
-    const SharedMemoryMapping& mapping) {
-  AutoLock hold(usages_lock_);
-  DCHECK(usages_.find(mapping.raw_memory_ptr()) != usages_.end());
-  usages_.erase(mapping.raw_memory_ptr());
-}
-
-SharedMemoryTracker::SharedMemoryTracker() {
-}
-
-SharedMemoryTracker::~SharedMemoryTracker() = default;
-
-}  // namespace
diff --git a/base/memory/shared_memory_tracker.h b/base/memory/shared_memory_tracker.h
deleted file mode 100644
index 72c7b7a..0000000
--- a/base/memory/shared_memory_tracker.h
+++ /dev/null
@@ -1,58 +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_MEMORY_SHARED_MEMORY_TRACKER_H_
-#define BASE_MEMORY_SHARED_MEMORY_TRACKER_H_
-
-#include <map>
-#include <string>
-
-#include "base/memory/shared_memory.h"
-#include "base/memory/shared_memory_mapping.h"
-#include "base/synchronization/lock.h"
-
-namespace base {
-
-// SharedMemoryTracker tracks shared memory usage.
-class BASE_EXPORT SharedMemoryTracker {
- public:
-  // Returns a singleton instance.
-  static SharedMemoryTracker* GetInstance();
-
-  static std::string GetDumpNameForTracing(const UnguessableToken& id);
-
-  // Records shared memory usage on valid mapping.
-  void IncrementMemoryUsage(const SharedMemory& shared_memory);
-  void IncrementMemoryUsage(const SharedMemoryMapping& mapping);
-
-  // Records shared memory usage on unmapping.
-  void DecrementMemoryUsage(const SharedMemory& shared_memory);
-  void DecrementMemoryUsage(const SharedMemoryMapping& mapping);
-
-  // Root dump name for all shared memory dumps.
-  static const char kDumpRootName[];
-
- private:
-  SharedMemoryTracker();
-  ~SharedMemoryTracker();
-
-  // Information associated with each mapped address.
-  struct UsageInfo {
-    UsageInfo(size_t size, const UnguessableToken& id)
-        : mapped_size(size), mapped_id(id) {}
-
-    size_t mapped_size;
-    UnguessableToken mapped_id;
-  };
-
-  // Used to lock when |usages_| is modified or read.
-  Lock usages_lock_;
-  std::map<void*, UsageInfo> usages_;
-
-  DISALLOW_COPY_AND_ASSIGN(SharedMemoryTracker);
-};
-
-}  // namespace base
-
-#endif  // BASE_MEMORY_SHARED_MEMORY_TRACKER_H_
diff --git a/base/memory/shared_memory_win.cc b/base/memory/shared_memory_win.cc
deleted file mode 100644
index cf06dd3..0000000
--- a/base/memory/shared_memory_win.cc
+++ /dev/null
@@ -1,381 +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/memory/shared_memory.h"
-
-#include <aclapi.h>
-#include <stddef.h>
-#include <stdint.h>
-
-#include "base/allocator/partition_allocator/page_allocator.h"
-#include "base/logging.h"
-#include "base/memory/shared_memory_tracker.h"
-#include "base/metrics/histogram_functions.h"
-#include "base/metrics/histogram_macros.h"
-#include "base/rand_util.h"
-#include "base/strings/stringprintf.h"
-#include "base/strings/utf_string_conversions.h"
-#include "base/unguessable_token.h"
-
-namespace base {
-namespace {
-
-// Errors that can occur during Shared Memory construction.
-// These match tools/metrics/histograms/histograms.xml.
-// This enum is append-only.
-enum CreateError {
-  SUCCESS = 0,
-  SIZE_ZERO = 1,
-  SIZE_TOO_LARGE = 2,
-  INITIALIZE_ACL_FAILURE = 3,
-  INITIALIZE_SECURITY_DESC_FAILURE = 4,
-  SET_SECURITY_DESC_FAILURE = 5,
-  CREATE_FILE_MAPPING_FAILURE = 6,
-  REDUCE_PERMISSIONS_FAILURE = 7,
-  ALREADY_EXISTS = 8,
-  CREATE_ERROR_LAST = ALREADY_EXISTS
-};
-
-// Emits UMA metrics about encountered errors. Pass zero (0) for |winerror|
-// if there is no associated Windows error.
-void LogError(CreateError error, DWORD winerror) {
-  UMA_HISTOGRAM_ENUMERATION("SharedMemory.CreateError", error,
-                            CREATE_ERROR_LAST + 1);
-  static_assert(ERROR_SUCCESS == 0, "Windows error code changed!");
-  if (winerror != ERROR_SUCCESS)
-    UmaHistogramSparse("SharedMemory.CreateWinError", winerror);
-}
-
-typedef enum _SECTION_INFORMATION_CLASS {
-  SectionBasicInformation,
-} SECTION_INFORMATION_CLASS;
-
-typedef struct _SECTION_BASIC_INFORMATION {
-  PVOID BaseAddress;
-  ULONG Attributes;
-  LARGE_INTEGER Size;
-} SECTION_BASIC_INFORMATION, *PSECTION_BASIC_INFORMATION;
-
-typedef ULONG(__stdcall* NtQuerySectionType)(
-    HANDLE SectionHandle,
-    SECTION_INFORMATION_CLASS SectionInformationClass,
-    PVOID SectionInformation,
-    ULONG SectionInformationLength,
-    PULONG ResultLength);
-
-// Returns the length of the memory section starting at the supplied address.
-size_t GetMemorySectionSize(void* address) {
-  MEMORY_BASIC_INFORMATION memory_info;
-  if (!::VirtualQuery(address, &memory_info, sizeof(memory_info)))
-    return 0;
-  return memory_info.RegionSize - (static_cast<char*>(address) -
-         static_cast<char*>(memory_info.AllocationBase));
-}
-
-// Checks if the section object is safe to map. At the moment this just means
-// it's not an image section.
-bool IsSectionSafeToMap(HANDLE handle) {
-  static NtQuerySectionType nt_query_section_func;
-  if (!nt_query_section_func) {
-    nt_query_section_func = reinterpret_cast<NtQuerySectionType>(
-        ::GetProcAddress(::GetModuleHandle(L"ntdll.dll"), "NtQuerySection"));
-    DCHECK(nt_query_section_func);
-  }
-
-  // The handle must have SECTION_QUERY access for this to succeed.
-  SECTION_BASIC_INFORMATION basic_information = {};
-  ULONG status =
-      nt_query_section_func(handle, SectionBasicInformation, &basic_information,
-                            sizeof(basic_information), nullptr);
-  if (status)
-    return false;
-  return (basic_information.Attributes & SEC_IMAGE) != SEC_IMAGE;
-}
-
-// Returns a HANDLE on success and |nullptr| on failure.
-// This function is similar to CreateFileMapping, but removes the permissions
-// WRITE_DAC, WRITE_OWNER, READ_CONTROL, and DELETE.
-//
-// A newly created file mapping has two sets of permissions. It has access
-// control permissions (WRITE_DAC, WRITE_OWNER, READ_CONTROL, and DELETE) and
-// file permissions (FILE_MAP_READ, FILE_MAP_WRITE, etc.). ::DuplicateHandle()
-// with the parameter DUPLICATE_SAME_ACCESS copies both sets of permissions.
-//
-// The Chrome sandbox prevents HANDLEs with the WRITE_DAC permission from being
-// duplicated into unprivileged processes. But the only way to copy file
-// permissions is with the parameter DUPLICATE_SAME_ACCESS. This means that
-// there is no way for a privileged process to duplicate a file mapping into an
-// unprivileged process while maintaining the previous file permissions.
-//
-// By removing all access control permissions of a file mapping immediately
-// after creation, ::DuplicateHandle() effectively only copies the file
-// permissions.
-HANDLE CreateFileMappingWithReducedPermissions(SECURITY_ATTRIBUTES* sa,
-                                               size_t rounded_size,
-                                               LPCWSTR name) {
-  HANDLE h = CreateFileMapping(INVALID_HANDLE_VALUE, sa, PAGE_READWRITE, 0,
-                               static_cast<DWORD>(rounded_size), name);
-  if (!h) {
-    LogError(CREATE_FILE_MAPPING_FAILURE, GetLastError());
-    return nullptr;
-  }
-
-  HANDLE h2;
-  BOOL success = ::DuplicateHandle(
-      GetCurrentProcess(), h, GetCurrentProcess(), &h2,
-      FILE_MAP_READ | FILE_MAP_WRITE | SECTION_QUERY, FALSE, 0);
-  BOOL rv = ::CloseHandle(h);
-  DCHECK(rv);
-
-  if (!success) {
-    LogError(REDUCE_PERMISSIONS_FAILURE, GetLastError());
-    return nullptr;
-  }
-
-  return h2;
-}
-
-}  // namespace.
-
-SharedMemory::SharedMemory() {}
-
-SharedMemory::SharedMemory(const string16& name) : name_(name) {}
-
-SharedMemory::SharedMemory(const SharedMemoryHandle& handle, bool read_only)
-    : external_section_(true), shm_(handle), read_only_(read_only) {}
-
-SharedMemory::~SharedMemory() {
-  Unmap();
-  Close();
-}
-
-// static
-bool SharedMemory::IsHandleValid(const SharedMemoryHandle& handle) {
-  return handle.IsValid();
-}
-
-// static
-void SharedMemory::CloseHandle(const SharedMemoryHandle& handle) {
-  handle.Close();
-}
-
-// static
-size_t SharedMemory::GetHandleLimit() {
-  // Rounded down from value reported here:
-  // http://blogs.technet.com/b/markrussinovich/archive/2009/09/29/3283844.aspx
-  return static_cast<size_t>(1 << 23);
-}
-
-// static
-SharedMemoryHandle SharedMemory::DuplicateHandle(
-    const SharedMemoryHandle& handle) {
-  return handle.Duplicate();
-}
-
-bool SharedMemory::CreateAndMapAnonymous(size_t size) {
-  return CreateAnonymous(size) && Map(size);
-}
-
-bool SharedMemory::Create(const SharedMemoryCreateOptions& options) {
-  // TODO(crbug.com/210609): NaCl forces us to round up 64k here, wasting 32k
-  // per mapping on average.
-  static const size_t kSectionMask = 65536 - 1;
-  DCHECK(!options.executable);
-  DCHECK(!shm_.IsValid());
-  if (options.size == 0) {
-    LogError(SIZE_ZERO, 0);
-    return false;
-  }
-
-  // Check maximum accounting for overflow.
-  if (options.size >
-      static_cast<size_t>(std::numeric_limits<int>::max()) - kSectionMask) {
-    LogError(SIZE_TOO_LARGE, 0);
-    return false;
-  }
-
-  size_t rounded_size = (options.size + kSectionMask) & ~kSectionMask;
-  name_ = options.name_deprecated ?
-      ASCIIToUTF16(*options.name_deprecated) : L"";
-  SECURITY_ATTRIBUTES sa = {sizeof(sa), nullptr, FALSE};
-  SECURITY_DESCRIPTOR sd;
-  ACL dacl;
-
-  if (name_.empty()) {
-    // Add an empty DACL to enforce anonymous read-only sections.
-    sa.lpSecurityDescriptor = &sd;
-    if (!InitializeAcl(&dacl, sizeof(dacl), ACL_REVISION)) {
-      LogError(INITIALIZE_ACL_FAILURE, GetLastError());
-      return false;
-    }
-    if (!InitializeSecurityDescriptor(&sd, SECURITY_DESCRIPTOR_REVISION)) {
-      LogError(INITIALIZE_SECURITY_DESC_FAILURE, GetLastError());
-      return false;
-    }
-    if (!SetSecurityDescriptorDacl(&sd, TRUE, &dacl, FALSE)) {
-      LogError(SET_SECURITY_DESC_FAILURE, GetLastError());
-      return false;
-    }
-
-    // Windows ignores DACLs on certain unnamed objects (like shared sections).
-    // So, we generate a random name when we need to enforce read-only.
-    uint64_t rand_values[4];
-    RandBytes(&rand_values, sizeof(rand_values));
-    name_ = StringPrintf(L"CrSharedMem_%016llx%016llx%016llx%016llx",
-                         rand_values[0], rand_values[1],
-                         rand_values[2], rand_values[3]);
-  }
-  DCHECK(!name_.empty());
-  shm_ = SharedMemoryHandle(
-      CreateFileMappingWithReducedPermissions(&sa, rounded_size, name_.c_str()),
-      rounded_size, UnguessableToken::Create());
-  if (!shm_.IsValid()) {
-    // The error is logged within CreateFileMappingWithReducedPermissions().
-    return false;
-  }
-
-  requested_size_ = options.size;
-
-  // Check if the shared memory pre-exists.
-  if (GetLastError() == ERROR_ALREADY_EXISTS) {
-    // If the file already existed, set requested_size_ to 0 to show that
-    // we don't know the size.
-    requested_size_ = 0;
-    external_section_ = true;
-    if (!options.open_existing_deprecated) {
-      Close();
-      // From "if" above: GetLastError() == ERROR_ALREADY_EXISTS.
-      LogError(ALREADY_EXISTS, ERROR_ALREADY_EXISTS);
-      return false;
-    }
-  }
-
-  LogError(SUCCESS, ERROR_SUCCESS);
-  return true;
-}
-
-bool SharedMemory::Delete(const std::string& name) {
-  // intentionally empty -- there is nothing for us to do on Windows.
-  return true;
-}
-
-bool SharedMemory::Open(const std::string& name, bool read_only) {
-  DCHECK(!shm_.IsValid());
-  DWORD access = FILE_MAP_READ | SECTION_QUERY;
-  if (!read_only)
-    access |= FILE_MAP_WRITE;
-  name_ = ASCIIToUTF16(name);
-  read_only_ = read_only;
-
-  // This form of sharing shared memory is deprecated. https://crbug.com/345734.
-  // However, we can't get rid of it without a significant refactor because its
-  // used to communicate between two versions of the same service process, very
-  // early in the life cycle.
-  // Technically, we should also pass the GUID from the original shared memory
-  // region. We don't do that - this means that we will overcount this memory,
-  // which thankfully isn't relevant since Chrome only communicates with a
-  // single version of the service process.
-  // We pass the size |0|, which is a dummy size and wrong, but otherwise
-  // harmless.
-  shm_ = SharedMemoryHandle(
-      OpenFileMapping(access, false, name_.empty() ? nullptr : name_.c_str()),
-      0u, UnguessableToken::Create());
-  if (!shm_.IsValid())
-    return false;
-  // If a name specified assume it's an external section.
-  if (!name_.empty())
-    external_section_ = true;
-  // Note: size_ is not set in this case.
-  return true;
-}
-
-bool SharedMemory::MapAt(off_t offset, size_t bytes) {
-  if (!shm_.IsValid()) {
-    DLOG(ERROR) << "Invalid SharedMemoryHandle.";
-    return false;
-  }
-
-  if (bytes > static_cast<size_t>(std::numeric_limits<int>::max())) {
-    DLOG(ERROR) << "Bytes required exceeds the 2G limitation.";
-    return false;
-  }
-
-  if (memory_) {
-    DLOG(ERROR) << "The SharedMemory has been mapped already.";
-    return false;
-  }
-
-  if (external_section_ && !IsSectionSafeToMap(shm_.GetHandle())) {
-    DLOG(ERROR) << "SharedMemoryHandle is not safe to be mapped.";
-    return false;
-  }
-
-  // Try to map the shared memory. On the first failure, release any reserved
-  // address space for a single retry.
-  for (int i = 0; i < 2; ++i) {
-    memory_ = MapViewOfFile(
-        shm_.GetHandle(),
-        read_only_ ? FILE_MAP_READ : FILE_MAP_READ | FILE_MAP_WRITE,
-        static_cast<uint64_t>(offset) >> 32, static_cast<DWORD>(offset), bytes);
-    if (memory_)
-      break;
-    ReleaseReservation();
-  }
-  if (!memory_) {
-    DPLOG(ERROR) << "Failed executing MapViewOfFile";
-    return false;
-  }
-
-  DCHECK_EQ(0U, reinterpret_cast<uintptr_t>(memory_) &
-                    (SharedMemory::MAP_MINIMUM_ALIGNMENT - 1));
-  mapped_size_ = GetMemorySectionSize(memory_);
-  mapped_id_ = shm_.GetGUID();
-  SharedMemoryTracker::GetInstance()->IncrementMemoryUsage(*this);
-  return true;
-}
-
-bool SharedMemory::Unmap() {
-  if (!memory_)
-    return false;
-
-  SharedMemoryTracker::GetInstance()->DecrementMemoryUsage(*this);
-  UnmapViewOfFile(memory_);
-  memory_ = nullptr;
-  mapped_id_ = UnguessableToken();
-  return true;
-}
-
-SharedMemoryHandle SharedMemory::GetReadOnlyHandle() const {
-  HANDLE result;
-  ProcessHandle process = GetCurrentProcess();
-  if (!::DuplicateHandle(process, shm_.GetHandle(), process, &result,
-                         FILE_MAP_READ | SECTION_QUERY, FALSE, 0)) {
-    return SharedMemoryHandle();
-  }
-  SharedMemoryHandle handle =
-      SharedMemoryHandle(result, shm_.GetSize(), shm_.GetGUID());
-  handle.SetOwnershipPassesToIPC(true);
-  return handle;
-}
-
-void SharedMemory::Close() {
-  if (shm_.IsValid()) {
-    shm_.Close();
-    shm_ = SharedMemoryHandle();
-  }
-}
-
-SharedMemoryHandle SharedMemory::handle() const {
-  return shm_;
-}
-
-SharedMemoryHandle SharedMemory::TakeHandle() {
-  SharedMemoryHandle handle(shm_);
-  handle.SetOwnershipPassesToIPC(true);
-  Unmap();
-  shm_ = SharedMemoryHandle();
-  return handle;
-}
-
-}  // namespace base
diff --git a/base/memory/unsafe_shared_memory_region.cc b/base/memory/unsafe_shared_memory_region.cc
deleted file mode 100644
index 422b5a9..0000000
--- a/base/memory/unsafe_shared_memory_region.cc
+++ /dev/null
@@ -1,76 +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/memory/unsafe_shared_memory_region.h"
-
-#include <utility>
-
-#include "base/memory/shared_memory.h"
-
-namespace base {
-
-// static
-UnsafeSharedMemoryRegion UnsafeSharedMemoryRegion::Create(size_t size) {
-  subtle::PlatformSharedMemoryRegion handle =
-      subtle::PlatformSharedMemoryRegion::CreateUnsafe(size);
-
-  return UnsafeSharedMemoryRegion(std::move(handle));
-}
-
-// static
-UnsafeSharedMemoryRegion UnsafeSharedMemoryRegion::Deserialize(
-    subtle::PlatformSharedMemoryRegion handle) {
-  return UnsafeSharedMemoryRegion(std::move(handle));
-}
-
-// static
-subtle::PlatformSharedMemoryRegion
-UnsafeSharedMemoryRegion::TakeHandleForSerialization(
-    UnsafeSharedMemoryRegion region) {
-  return std::move(region.handle_);
-}
-
-UnsafeSharedMemoryRegion::UnsafeSharedMemoryRegion() = default;
-UnsafeSharedMemoryRegion::UnsafeSharedMemoryRegion(
-    UnsafeSharedMemoryRegion&& region) = default;
-UnsafeSharedMemoryRegion& UnsafeSharedMemoryRegion::operator=(
-    UnsafeSharedMemoryRegion&& region) = default;
-UnsafeSharedMemoryRegion::~UnsafeSharedMemoryRegion() = default;
-
-UnsafeSharedMemoryRegion UnsafeSharedMemoryRegion::Duplicate() const {
-  return UnsafeSharedMemoryRegion(handle_.Duplicate());
-}
-
-WritableSharedMemoryMapping UnsafeSharedMemoryRegion::Map() const {
-  return MapAt(0, handle_.GetSize());
-}
-
-WritableSharedMemoryMapping UnsafeSharedMemoryRegion::MapAt(off_t offset,
-                                                            size_t size) const {
-  if (!IsValid())
-    return {};
-
-  void* memory = nullptr;
-  size_t mapped_size = 0;
-  if (!handle_.MapAt(offset, size, &memory, &mapped_size))
-    return {};
-
-  return WritableSharedMemoryMapping(memory, size, mapped_size,
-                                     handle_.GetGUID());
-}
-
-bool UnsafeSharedMemoryRegion::IsValid() const {
-  return handle_.IsValid();
-}
-
-UnsafeSharedMemoryRegion::UnsafeSharedMemoryRegion(
-    subtle::PlatformSharedMemoryRegion handle)
-    : handle_(std::move(handle)) {
-  if (handle_.IsValid()) {
-    CHECK_EQ(handle_.GetMode(),
-             subtle::PlatformSharedMemoryRegion::Mode::kUnsafe);
-  }
-}
-
-}  // namespace base
diff --git a/base/memory/unsafe_shared_memory_region.h b/base/memory/unsafe_shared_memory_region.h
deleted file mode 100644
index d77eaaa..0000000
--- a/base/memory/unsafe_shared_memory_region.h
+++ /dev/null
@@ -1,112 +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_MEMORY_UNSAFE_SHARED_MEMORY_REGION_H_
-#define BASE_MEMORY_UNSAFE_SHARED_MEMORY_REGION_H_
-
-#include "base/gtest_prod_util.h"
-#include "base/macros.h"
-#include "base/memory/platform_shared_memory_region.h"
-#include "base/memory/shared_memory_mapping.h"
-
-namespace base {
-
-// Scoped move-only handle to a region of platform shared memory. The instance
-// owns the platform handle it wraps. Mappings created by this region are
-// writable. These mappings remain valid even after the region handle is moved
-// or destroyed.
-//
-// NOTE: UnsafeSharedMemoryRegion cannot be converted to a read-only region. Use
-// with caution as the region will be writable to any process with a handle to
-// the region.
-//
-// Use this if and only if the following is true:
-// - You do not need to share the region as read-only, and,
-// - You need to have several instances of the region simultaneously, possibly
-//   in different processes, that can produce writable mappings.
-
-class BASE_EXPORT UnsafeSharedMemoryRegion {
- public:
-  using MappingType = WritableSharedMemoryMapping;
-  // Creates a new UnsafeSharedMemoryRegion instance of a given size that can be
-  // used for mapping writable shared memory into the virtual address space.
-  static UnsafeSharedMemoryRegion Create(size_t size);
-
-  // Returns an UnsafeSharedMemoryRegion built from a platform-specific handle
-  // that was taken from another UnsafeSharedMemoryRegion instance. Returns an
-  // invalid region iff the |handle| is invalid. CHECK-fails if the |handle|
-  // isn't unsafe.
-  // This should be used only by the code passing a handle across
-  // process boundaries.
-  static UnsafeSharedMemoryRegion Deserialize(
-      subtle::PlatformSharedMemoryRegion handle);
-
-  // Extracts a platform handle from the region. Ownership is transferred to the
-  // returned region object.
-  // This should be used only for sending the handle from the current
-  // process to another.
-  static subtle::PlatformSharedMemoryRegion TakeHandleForSerialization(
-      UnsafeSharedMemoryRegion region);
-
-  // Default constructor initializes an invalid instance.
-  UnsafeSharedMemoryRegion();
-
-  // Move operations are allowed.
-  UnsafeSharedMemoryRegion(UnsafeSharedMemoryRegion&&);
-  UnsafeSharedMemoryRegion& operator=(UnsafeSharedMemoryRegion&&);
-
-  // Destructor closes shared memory region if valid.
-  // All created mappings will remain valid.
-  ~UnsafeSharedMemoryRegion();
-
-  // Duplicates the underlying platform handle and creates a new
-  // UnsafeSharedMemoryRegion instance that owns the newly created handle.
-  // Returns a valid UnsafeSharedMemoryRegion on success, invalid otherwise.
-  // The current region instance remains valid in any case.
-  UnsafeSharedMemoryRegion Duplicate() const;
-
-  // Maps the shared memory region into the caller's address space with write
-  // access. The mapped address is guaranteed to have an alignment of
-  // at least |subtle::PlatformSharedMemoryRegion::kMapMinimumAlignment|.
-  // Returns a valid WritableSharedMemoryMapping instance on success, invalid
-  // otherwise.
-  WritableSharedMemoryMapping Map() const;
-
-  // Same as above, but maps only |size| bytes of the shared memory region
-  // starting with the given |offset|. |offset| must be aligned to value of
-  // |SysInfo::VMAllocationGranularity()|. Returns an invalid mapping if
-  // requested bytes are out of the region limits.
-  WritableSharedMemoryMapping MapAt(off_t offset, size_t size) const;
-
-  // Whether the underlying platform handle is valid.
-  bool IsValid() const;
-
-  // Returns the maximum mapping size that can be created from this region.
-  size_t GetSize() const {
-    DCHECK(IsValid());
-    return handle_.GetSize();
-  }
-
- private:
-  FRIEND_TEST_ALL_PREFIXES(DiscardableSharedMemoryTest,
-                           LockShouldFailIfPlatformLockPagesFails);
-  friend class DiscardableSharedMemory;
-
-  explicit UnsafeSharedMemoryRegion(subtle::PlatformSharedMemoryRegion handle);
-
-  // Returns a platform shared memory handle. |this| remains the owner of the
-  // handle.
-  subtle::PlatformSharedMemoryRegion::PlatformHandle GetPlatformHandle() const {
-    DCHECK(IsValid());
-    return handle_.GetPlatformHandle();
-  }
-
-  subtle::PlatformSharedMemoryRegion handle_;
-
-  DISALLOW_COPY_AND_ASSIGN(UnsafeSharedMemoryRegion);
-};
-
-}  // namespace base
-
-#endif  // BASE_MEMORY_UNSAFE_SHARED_MEMORY_REGION_H_
diff --git a/base/memory/writable_shared_memory_region.cc b/base/memory/writable_shared_memory_region.cc
deleted file mode 100644
index 7a29522..0000000
--- a/base/memory/writable_shared_memory_region.cc
+++ /dev/null
@@ -1,84 +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/memory/writable_shared_memory_region.h"
-
-#include <utility>
-
-#include "base/memory/shared_memory.h"
-#include "build_config.h"
-
-namespace base {
-
-// static
-WritableSharedMemoryRegion WritableSharedMemoryRegion::Create(size_t size) {
-  subtle::PlatformSharedMemoryRegion handle =
-      subtle::PlatformSharedMemoryRegion::CreateWritable(size);
-
-  return WritableSharedMemoryRegion(std::move(handle));
-}
-
-// static
-WritableSharedMemoryRegion WritableSharedMemoryRegion::Deserialize(
-    subtle::PlatformSharedMemoryRegion handle) {
-  return WritableSharedMemoryRegion(std::move(handle));
-}
-
-// static
-subtle::PlatformSharedMemoryRegion
-WritableSharedMemoryRegion::TakeHandleForSerialization(
-    WritableSharedMemoryRegion region) {
-  return std::move(region.handle_);
-}
-
-// static
-ReadOnlySharedMemoryRegion WritableSharedMemoryRegion::ConvertToReadOnly(
-    WritableSharedMemoryRegion region) {
-  subtle::PlatformSharedMemoryRegion handle = std::move(region.handle_);
-  if (!handle.ConvertToReadOnly())
-    return {};
-
-  return ReadOnlySharedMemoryRegion::Deserialize(std::move(handle));
-}
-
-WritableSharedMemoryRegion::WritableSharedMemoryRegion() = default;
-WritableSharedMemoryRegion::WritableSharedMemoryRegion(
-    WritableSharedMemoryRegion&& region) = default;
-WritableSharedMemoryRegion& WritableSharedMemoryRegion::operator=(
-    WritableSharedMemoryRegion&& region) = default;
-WritableSharedMemoryRegion::~WritableSharedMemoryRegion() = default;
-
-WritableSharedMemoryMapping WritableSharedMemoryRegion::Map() const {
-  return MapAt(0, handle_.GetSize());
-}
-
-WritableSharedMemoryMapping WritableSharedMemoryRegion::MapAt(
-    off_t offset,
-    size_t size) const {
-  if (!IsValid())
-    return {};
-
-  void* memory = nullptr;
-  size_t mapped_size = 0;
-  if (!handle_.MapAt(offset, size, &memory, &mapped_size))
-    return {};
-
-  return WritableSharedMemoryMapping(memory, size, mapped_size,
-                                     handle_.GetGUID());
-}
-
-bool WritableSharedMemoryRegion::IsValid() const {
-  return handle_.IsValid();
-}
-
-WritableSharedMemoryRegion::WritableSharedMemoryRegion(
-    subtle::PlatformSharedMemoryRegion handle)
-    : handle_(std::move(handle)) {
-  if (handle_.IsValid()) {
-    CHECK_EQ(handle_.GetMode(),
-             subtle::PlatformSharedMemoryRegion::Mode::kWritable);
-  }
-}
-
-}  // namespace base
diff --git a/base/memory/writable_shared_memory_region.h b/base/memory/writable_shared_memory_region.h
deleted file mode 100644
index b953a10..0000000
--- a/base/memory/writable_shared_memory_region.h
+++ /dev/null
@@ -1,97 +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_MEMORY_WRITABLE_SHARED_MEMORY_REGION_H_
-#define BASE_MEMORY_WRITABLE_SHARED_MEMORY_REGION_H_
-
-#include "base/macros.h"
-#include "base/memory/platform_shared_memory_region.h"
-#include "base/memory/read_only_shared_memory_region.h"
-#include "base/memory/shared_memory_mapping.h"
-
-namespace base {
-
-// Scoped move-only handle to a region of platform shared memory. The instance
-// owns the platform handle it wraps. Mappings created by this region are
-// writable. These mappings remain valid even after the region handle is moved
-// or destroyed.
-//
-// This region can be locked to read-only access by converting it to a
-// ReadOnlySharedMemoryRegion. However, unlike ReadOnlySharedMemoryRegion and
-// UnsafeSharedMemoryRegion, ownership of this region (while writable) is unique
-// and may only be transferred, not duplicated.
-class BASE_EXPORT WritableSharedMemoryRegion {
- public:
-  using MappingType = WritableSharedMemoryMapping;
-  // Creates a new WritableSharedMemoryRegion instance of a given
-  // size that can be used for mapping writable shared memory into the virtual
-  // address space.
-  static WritableSharedMemoryRegion Create(size_t size);
-
-  // Returns a WritableSharedMemoryRegion built from a platform handle that was
-  // taken from another WritableSharedMemoryRegion instance. Returns an invalid
-  // region iff the |handle| is invalid. CHECK-fails if the |handle| isn't
-  // writable.
-  // This should be used only by the code passing handles across process
-  // boundaries.
-  static WritableSharedMemoryRegion Deserialize(
-      subtle::PlatformSharedMemoryRegion handle);
-
-  // Extracts a platform handle from the region. Ownership is transferred to the
-  // returned region object.
-  // This should be used only for sending the handle from the current
-  // process to another.
-  static subtle::PlatformSharedMemoryRegion TakeHandleForSerialization(
-      WritableSharedMemoryRegion region);
-
-  // Makes the region read-only. No new writable mappings of the region can be
-  // created after this call. Returns an invalid region on failure.
-  static ReadOnlySharedMemoryRegion ConvertToReadOnly(
-      WritableSharedMemoryRegion region);
-
-  // Default constructor initializes an invalid instance.
-  WritableSharedMemoryRegion();
-
-  // Move operations are allowed.
-  WritableSharedMemoryRegion(WritableSharedMemoryRegion&&);
-  WritableSharedMemoryRegion& operator=(WritableSharedMemoryRegion&&);
-
-  // Destructor closes shared memory region if valid.
-  // All created mappings will remain valid.
-  ~WritableSharedMemoryRegion();
-
-  // Maps the shared memory region into the caller's address space with write
-  // access. The mapped address is guaranteed to have an alignment of
-  // at least |subtle::PlatformSharedMemoryRegion::kMapMinimumAlignment|.
-  // Returns a valid WritableSharedMemoryMapping instance on success, invalid
-  // otherwise.
-  WritableSharedMemoryMapping Map() const;
-
-  // Same as above, but maps only |size| bytes of the shared memory block
-  // starting with the given |offset|. |offset| must be aligned to value of
-  // |SysInfo::VMAllocationGranularity()|. Returns an invalid mapping if
-  // requested bytes are out of the region limits.
-  WritableSharedMemoryMapping MapAt(off_t offset, size_t size) const;
-
-  // Whether underlying platform handles are valid.
-  bool IsValid() const;
-
-  // Returns the maximum mapping size that can be created from this region.
-  size_t GetSize() const {
-    DCHECK(IsValid());
-    return handle_.GetSize();
-  }
-
- private:
-  explicit WritableSharedMemoryRegion(
-      subtle::PlatformSharedMemoryRegion handle);
-
-  subtle::PlatformSharedMemoryRegion handle_;
-
-  DISALLOW_COPY_AND_ASSIGN(WritableSharedMemoryRegion);
-};
-
-}  // namespace base
-
-#endif  // BASE_MEMORY_WRITABLE_SHARED_MEMORY_REGION_H_
diff --git a/build/gen.py b/build/gen.py
index 5f73187..95f8fe1 100755
--- a/build/gen.py
+++ b/build/gen.py
@@ -263,13 +263,7 @@
         'base/location.cc',
         'base/logging.cc',
         'base/md5.cc',
-        'base/memory/platform_shared_memory_region.cc',
-        'base/memory/read_only_shared_memory_region.cc',
         'base/memory/ref_counted.cc',
-        'base/memory/ref_counted_memory.cc',
-        'base/memory/shared_memory_mapping.cc',
-        'base/memory/shared_memory_handle.cc',
-        'base/memory/shared_memory_tracker.cc',
         'base/memory/weak_ptr.cc',
         'base/message_loop/incoming_task_queue.cc',
         'base/message_loop/message_loop.cc',
@@ -554,19 +548,6 @@
       ], 'tool': 'cxx', 'include_dirs': [], 'libs': []},
   }
 
-  if is_win:
-    static_libraries['base']['sources'].extend([
-        'base/memory/platform_shared_memory_region_win.cc'
-    ])
-  elif is_mac:
-    static_libraries['base']['sources'].extend([
-        'base/memory/platform_shared_memory_region_mac.cc'
-    ])
-  elif is_linux:
-    static_libraries['base']['sources'].extend([
-        'base/memory/platform_shared_memory_region_posix.cc'
-    ])
-
   if is_posix:
     static_libraries['base']['sources'].extend([
         'base/base_paths_posix.cc',
@@ -577,7 +558,6 @@
         'base/files/file_posix.cc',
         'base/files/file_util_posix.cc',
         'base/files/memory_mapped_file_posix.cc',
-        'base/memory/shared_memory_helper.cc',
         'base/message_loop/message_pump_libevent.cc',
         'base/posix/file_descriptor_shuffle.cc',
         'base/posix/global_descriptors.cc',
@@ -626,8 +606,6 @@
         'tool': 'cxx',
     }
     static_libraries['base']['sources'].extend([
-        'base/memory/shared_memory_handle_posix.cc',
-        'base/memory/shared_memory_posix.cc',
         'base/nix/xdg_util.cc',
         'base/process/internal_linux.cc',
         'base/process/memory_linux.cc',
@@ -675,8 +653,6 @@
         'base/mac/scoped_mach_port.cc',
         'base/mac/scoped_mach_vm.cc',
         'base/mac/scoped_nsautorelease_pool.mm',
-        'base/memory/shared_memory_handle_mac.cc',
-        'base/memory/shared_memory_mac.cc',
         'base/message_loop/message_pump_mac.mm',
         'base/process/process_handle_mac.cc',
         'base/process/process_info_mac.cc',
@@ -723,9 +699,6 @@
         'base/files/memory_mapped_file_win.cc',
         'base/guid.cc',
         'base/logging_win.cc',
-        'base/memory/memory_pressure_monitor_win.cc',
-        'base/memory/shared_memory_handle_win.cc',
-        'base/memory/shared_memory_win.cc',
         'base/message_loop/message_pump_win.cc',
         'base/native_library_win.cc',
         'base/power_monitor/power_monitor_device_source_win.cc',