base: Rename discardable memory allocator interface and remove unnecessary class.

content/common/host_discardable_shared_memory_manager.cc

 // 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 "content/common/host_discardable_shared_memory_manager.h"
 
 #include <algorithm>
 
 #include "base/atomic_sequence_num.h"
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/debug/crash_logging.h"
 #include "base/lazy_instance.h"
+#include "base/memory/discardable_memory.h"
 #include "base/numerics/safe_math.h"
 #include "base/profiler/scoped_tracker.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/sys_info.h"
 #include "base/trace_event/trace_event.h"
 
 namespace content {
 namespace {
 
-class DiscardableMemoryShmemChunkImpl
-    : public base::DiscardableMemoryShmemChunk {
+class DiscardableMemoryImpl : public base::DiscardableMemory {
  public:
-  DiscardableMemoryShmemChunkImpl(
-      scoped_ptr<base::DiscardableSharedMemory> shared_memory,
-      const base::Closure& deleted_callback)
+  DiscardableMemoryImpl(scoped_ptr<base::DiscardableSharedMemory> shared_memory,
+                        const base::Closure& deleted_callback)
       : shared_memory_(shared_memory.Pass()),
         deleted_callback_(deleted_callback),
         is_locked_(true) {}
-  ~DiscardableMemoryShmemChunkImpl() override {
+
+  ~DiscardableMemoryImpl() override {
     if (is_locked_)
       shared_memory_->Unlock(0, 0);
 
     deleted_callback_.Run();
   }
 
-  // Overridden from base::DiscardableMemoryShmemChunk:
+  // Overridden from base::DiscardableMemory:
   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_;
   const base::Closure deleted_callback_;
   bool is_locked_;
 
-  DISALLOW_COPY_AND_ASSIGN(DiscardableMemoryShmemChunkImpl);
+  DISALLOW_COPY_AND_ASSIGN(DiscardableMemoryImpl);
 };
 
 base::LazyInstance<HostDiscardableSharedMemoryManager>
     g_discardable_shared_memory_manager = LAZY_INSTANCE_INITIALIZER;
 
 const int64_t kMaxDefaultMemoryLimit = 512 * 1024 * 1024;
 
 const int kEnforceMemoryPolicyDelayMs = 1000;
 
 // Global atomic to generate unique discardable shared memory IDs.
@@ skipping 24 matching lines @@
 }
 
 HostDiscardableSharedMemoryManager::~HostDiscardableSharedMemoryManager() {
 }
 
 HostDiscardableSharedMemoryManager*
 HostDiscardableSharedMemoryManager::current() {
   return g_discardable_shared_memory_manager.Pointer();
 }
 
-scoped_ptr<base::DiscardableMemoryShmemChunk>
+scoped_ptr<base::DiscardableMemory>
 HostDiscardableSharedMemoryManager::AllocateLockedDiscardableMemory(
     size_t size) {
   DiscardableSharedMemoryId new_id =
       g_next_discardable_shared_memory_id.GetNext();
   base::ProcessHandle current_process_handle = base::GetCurrentProcessHandle();
 
   // Note: Use DiscardableSharedMemoryHeap for in-process allocation
   // of discardable memory if the cost of each allocation is too high.
   base::SharedMemoryHandle handle;
   AllocateLockedDiscardableSharedMemory(current_process_handle, size, new_id,
                                         &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(
+  return make_scoped_ptr(new DiscardableMemoryImpl(
       memory.Pass(),
       base::Bind(
           &HostDiscardableSharedMemoryManager::DeletedDiscardableSharedMemory,
           base::Unretained(this), new_id, current_process_handle)));
 }
 
 void HostDiscardableSharedMemoryManager::
     AllocateLockedDiscardableSharedMemoryForChild(
         base::ProcessHandle process_handle,
         size_t size,
@@ skipping 281 matching lines @@
 
   enforce_memory_policy_pending_ = true;
   base::MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
       base::Bind(&HostDiscardableSharedMemoryManager::EnforceMemoryPolicy,
                  weak_ptr_factory_.GetWeakPtr()),
       base::TimeDelta::FromMilliseconds(kEnforceMemoryPolicyDelayMs));
 }
 
 }  // namespace content