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/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:
-  explicit DiscardableMemoryShmemChunkImpl(
+  explicit DiscardableMemoryImpl(
       scoped_ptr<base::DiscardableSharedMemory> shared_memory)
       : shared_memory_(shared_memory.Pass()), is_locked_(true) {}
-  ~DiscardableMemoryShmemChunkImpl() override {
+  ~DiscardableMemoryImpl() override {
     if (is_locked_)
       shared_memory_->Unlock(0, 0);
     shared_memory_->Purge(base::Time::Now());
   }
 
-  // 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_;
   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;
 
 }  // namespace
@@ skipping 22 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) {
   // 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()));
+  return make_scoped_ptr(new DiscardableMemoryImpl(memory.Pass()));
 }
 
 void HostDiscardableSharedMemoryManager::
     AllocateLockedDiscardableSharedMemoryForChild(
         base::ProcessHandle process_handle,
         size_t size,
         base::SharedMemoryHandle* shared_memory_handle) {
   AllocateLockedDiscardableSharedMemory(process_handle, size,
                                         shared_memory_handle);
 }
@@ skipping 219 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