Revert "base: Implement browser process support for discardable memory."

content/common/host_discardable_shared_memory_manager.cc

Index: content/common/host_discardable_shared_memory_manager.cc
diff --git a/content/common/host_discardable_shared_memory_manager.cc b/content/common/host_discardable_shared_memory_manager.cc
index 3d2be9d22c1e32bcad935e4cc8694b60e1282df7..e150fc63dcf00a11da58b0b4ae912f8a94ada2e5 100644
--- a/content/common/host_discardable_shared_memory_manager.cc
+++ b/content/common/host_discardable_shared_memory_manager.cc
@@ -18,46 +18,6 @@
 namespace content {
 namespace {
 
-class DiscardableMemoryShmemChunkImpl
-    : public base::DiscardableMemoryShmemChunk {
- public:
-  explicit DiscardableMemoryShmemChunkImpl(
-      scoped_ptr<base::DiscardableSharedMemory> shared_memory)
-      : shared_memory_(shared_memory.Pass()), is_locked_(true) {}
-  ~DiscardableMemoryShmemChunkImpl() override {
-    if (is_locked_)
-      shared_memory_->Unlock(0, 0);
-    shared_memory_->Purge(base::Time::Now());
-  }
-
-  // Overridden from base::DiscardableMemoryShmemChunk:
-  bool Lock() override {
-    DCHECK(!is_locked_);
-
-    if (shared_memory_->Lock(0, 0) != base::DiscardableSharedMemory::SUCCESS)
-      return false;
-
-    is_locked_ = true;
-    return true;
-  }
-  void Unlock() override {
-    DCHECK(is_locked_);
-
-    shared_memory_->Unlock(0, 0);
-    is_locked_ = false;
-  }
-  void* Memory() const override {
-    DCHECK(is_locked_);
-    return shared_memory_->memory();
-  }
-
- private:
-  scoped_ptr<base::DiscardableSharedMemory> shared_memory_;
-  bool is_locked_;
-
-  DISALLOW_COPY_AND_ASSIGN(DiscardableMemoryShmemChunkImpl);
-};
-
 base::LazyInstance<HostDiscardableSharedMemoryManager>
     g_discardable_shared_memory_manager = LAZY_INSTANCE_INITIALIZER;
 
@@ -101,16 +61,10 @@ HostDiscardableSharedMemoryManager::current() {
 scoped_ptr<base::DiscardableMemoryShmemChunk>
 HostDiscardableSharedMemoryManager::AllocateLockedDiscardableMemory(
     size_t size) {
-  // Note: Use DiscardableSharedMemoryHeap for in-process allocation
-  // of discardable memory if the cost of each allocation is too high.
-  base::SharedMemoryHandle handle;
-  AllocateLockedDiscardableSharedMemory(base::GetCurrentProcessHandle(), size,
-                                        &handle);
-  CHECK(base::SharedMemory::IsHandleValid(handle));
-  scoped_ptr<base::DiscardableSharedMemory> memory(
-      new base::DiscardableSharedMemory(handle));
-  CHECK(memory->Map(size));
-  return make_scoped_ptr(new DiscardableMemoryShmemChunkImpl(memory.Pass()));
+  // TODO(reveman): Need to implement this for discardable memory support in
+  // the browser process.
+  NOTIMPLEMENTED();
+  return nullptr;
 }
 
 void HostDiscardableSharedMemoryManager::
@@ -118,60 +72,11 @@ void HostDiscardableSharedMemoryManager::
         base::ProcessHandle process_handle,
         size_t size,
         base::SharedMemoryHandle* shared_memory_handle) {
-  AllocateLockedDiscardableSharedMemory(process_handle, size,
-                                        shared_memory_handle);
-}
-
-void HostDiscardableSharedMemoryManager::ProcessRemoved(
-    base::ProcessHandle process_handle) {
-  base::AutoLock lock(lock_);
-
-  size_t bytes_allocated_before_purging = bytes_allocated_;
-  for (auto& segment : segments_) {
-    // Skip segments that belong to a different process.
-    if (segment.process_handle != process_handle)
-      continue;
-
-    size_t size = segment.memory->mapped_size();
-    DCHECK_GE(bytes_allocated_, size);
-
-    // This will unmap the memory segment and drop our reference. The result
-    // is that the memory will be released to the OS if the child process is
-    // no longer referencing it.
-    // Note: We intentionally leave the segment in the vector to avoid
-    // reconstructing the heap. The element will be removed from the heap
-    // when its last usage time is older than all other segments.
-    segment.memory->Close();
-    bytes_allocated_ -= size;
-  }
-
-  if (bytes_allocated_ != bytes_allocated_before_purging)
-    BytesAllocatedChanged(bytes_allocated_);
-}
-
-void HostDiscardableSharedMemoryManager::SetMemoryLimit(size_t limit) {
-  base::AutoLock lock(lock_);
-
-  memory_limit_ = limit;
-  ReduceMemoryUsageUntilWithinMemoryLimit();
-}
-
-void HostDiscardableSharedMemoryManager::EnforceMemoryPolicy() {
-  base::AutoLock lock(lock_);
-
-  enforce_memory_policy_pending_ = false;
-  ReduceMemoryUsageUntilWithinMemoryLimit();
-}
-
-void HostDiscardableSharedMemoryManager::AllocateLockedDiscardableSharedMemory(
-    base::ProcessHandle process_handle,
-    size_t size,
-    base::SharedMemoryHandle* shared_memory_handle) {
   // TODO(erikchen): Remove ScopedTracker below once http://crbug.com/466405
   // is fixed.
   tracked_objects::ScopedTracker tracking_profile1(
       FROM_HERE_WITH_EXPLICIT_FUNCTION(
-          "466405 AllocateLockedDiscardableSharedMemory::Start"));
+          "466405 AllocateLockedDiscardableSharedMemoryForChild::Start"));
   base::AutoLock lock(lock_);
 
   // Memory usage must be reduced to prevent the addition of |size| from
@@ -189,7 +94,8 @@ void HostDiscardableSharedMemoryManager::AllocateLockedDiscardableSharedMemory(
   // is fixed.
   tracked_objects::ScopedTracker tracking_profile2(
       FROM_HERE_WITH_EXPLICIT_FUNCTION(
-          "466405 AllocateLockedDiscardableSharedMemory::ReduceMemoryUsage"));
+          "466405 "
+          "AllocateLockedDiscardableSharedMemoryForChild::ReduceMemoryUsage"));
   if (bytes_allocated_ > limit)
     ReduceMemoryUsageUntilWithinLimit(limit);
 
@@ -197,7 +103,7 @@ void HostDiscardableSharedMemoryManager::AllocateLockedDiscardableSharedMemory(
   // is fixed.
   tracked_objects::ScopedTracker tracking_profile3(
       FROM_HERE_WITH_EXPLICIT_FUNCTION(
-          "466405 AllocateLockedDiscardableSharedMemory::NewMemory"));
+          "466405 AllocateLockedDiscardableSharedMemoryForChild::NewMemory"));
   linked_ptr<base::DiscardableSharedMemory> memory(
       new base::DiscardableSharedMemory);
   if (!memory->CreateAndMap(size)) {
@@ -209,7 +115,8 @@ void HostDiscardableSharedMemoryManager::AllocateLockedDiscardableSharedMemory(
   // is fixed.
   tracked_objects::ScopedTracker tracking_profile4(
       FROM_HERE_WITH_EXPLICIT_FUNCTION(
-          "466405 AllocateLockedDiscardableSharedMemory::ShareToProcess"));
+          "466405 "
+          "AllocateLockedDiscardableSharedMemoryForChild::ShareToProcess"));
   if (!memory->ShareToProcess(process_handle, shared_memory_handle)) {
     LOG(ERROR) << "Cannot share discardable memory segment";
     *shared_memory_handle = base::SharedMemory::NULLHandle();
@@ -228,7 +135,8 @@ void HostDiscardableSharedMemoryManager::AllocateLockedDiscardableSharedMemory(
   tracked_objects::ScopedTracker tracking_profile5(
       FROM_HERE_WITH_EXPLICIT_FUNCTION(
           "466405 "
-          "AllocateLockedDiscardableSharedMemory::BytesAllocatedChanged"));
+          "AllocateLockedDiscardableSharedMemoryForChild::"
+          "BytesAllocatedChanged"));
   bytes_allocated_ = checked_bytes_allocated.ValueOrDie();
   BytesAllocatedChanged(bytes_allocated_);
 
@@ -240,12 +148,53 @@ void HostDiscardableSharedMemoryManager::AllocateLockedDiscardableSharedMemory(
   tracked_objects::ScopedTracker tracking_profile6(
       FROM_HERE_WITH_EXPLICIT_FUNCTION(
           "466405 "
-          "AllocateLockedDiscardableSharedMemory::"
+          "AllocateLockedDiscardableSharedMemoryForChild::"
           "ScheduleEnforceMemoryPolicy"));
   if (bytes_allocated_ > memory_limit_)
     ScheduleEnforceMemoryPolicy();
 }
 
+void HostDiscardableSharedMemoryManager::ProcessRemoved(
+    base::ProcessHandle process_handle) {
+  base::AutoLock lock(lock_);
+
+  size_t bytes_allocated_before_purging = bytes_allocated_;
+  for (auto& segment : segments_) {
+    // Skip segments that belong to a different process.
+    if (segment.process_handle != process_handle)
+      continue;
+
+    size_t size = segment.memory->mapped_size();
+    DCHECK_GE(bytes_allocated_, size);
+
+    // This will unmap the memory segment and drop our reference. The result
+    // is that the memory will be released to the OS if the child process is
+    // no longer referencing it.
+    // Note: We intentionally leave the segment in the vector to avoid
+    // reconstructing the heap. The element will be removed from the heap
+    // when its last usage time is older than all other segments.
+    segment.memory->Close();
+    bytes_allocated_ -= size;
+  }
+
+  if (bytes_allocated_ != bytes_allocated_before_purging)
+    BytesAllocatedChanged(bytes_allocated_);
+}
+
+void HostDiscardableSharedMemoryManager::SetMemoryLimit(size_t limit) {
+  base::AutoLock lock(lock_);
+
+  memory_limit_ = limit;
+  ReduceMemoryUsageUntilWithinMemoryLimit();
+}
+
+void HostDiscardableSharedMemoryManager::EnforceMemoryPolicy() {
+  base::AutoLock lock(lock_);
+
+  enforce_memory_policy_pending_ = false;
+  ReduceMemoryUsageUntilWithinMemoryLimit();
+}
+
 void HostDiscardableSharedMemoryManager::OnMemoryPressure(
     base::MemoryPressureListener::MemoryPressureLevel memory_pressure_level) {
   base::AutoLock lock(lock_);