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

content/child/child_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/child/child_discardable_shared_memory_manager.h"
 
 #include "base/atomic_sequence_num.h"
 #include "base/bind.h"
 #include "base/debug/crash_logging.h"
+#include "base/memory/discardable_memory.h"
 #include "base/memory/discardable_shared_memory.h"
 #include "base/metrics/histogram.h"
 #include "base/process/process_metrics.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/trace_event/trace_event.h"
 #include "content/common/child_process_messages.h"
 
 namespace content {
 namespace {
 
 // Default allocation size.
 #if defined(OS_ANDROID)
 // Larger allocation size on Android to avoid reaching the FD-limit.
 const size_t kAllocationSize = 32 * 1024 * 1024;
 #else
 const size_t kAllocationSize = 4 * 1024 * 1024;
 #endif
 
 // Global atomic to generate unique discardable shared memory IDs.
 base::StaticAtomicSequenceNumber g_next_discardable_shared_memory_id;
 
-class DiscardableMemoryShmemChunkImpl
-    : public base::DiscardableMemoryShmemChunk {
+class DiscardableMemoryImpl : public base::DiscardableMemory {
  public:
-  DiscardableMemoryShmemChunkImpl(
-      ChildDiscardableSharedMemoryManager* manager,
-      scoped_ptr<DiscardableSharedMemoryHeap::Span> span)
-      : manager_(manager), span_(span.Pass()) {}
-  ~DiscardableMemoryShmemChunkImpl() override {
+  DiscardableMemoryImpl(ChildDiscardableSharedMemoryManager* manager,
+                        scoped_ptr<DiscardableSharedMemoryHeap::Span> span)
+      : manager_(manager), span_(span.Pass()), is_locked_(true) {}
+
+  ~DiscardableMemoryImpl() override {
+    if (is_locked_)
+      manager_->UnlockSpan(span_.get());
+
     manager_->ReleaseSpan(span_.Pass());
   }
 
-  // Overridden from DiscardableMemoryShmemChunk:
-  bool Lock() override { return manager_->LockSpan(span_.get()); }
-  void Unlock() override { manager_->UnlockSpan(span_.get()); }
+  // Overridden from base::DiscardableMemory:
+  bool Lock() override {
+    DCHECK(!is_locked_);
+
+    if (!manager_->LockSpan(span_.get()))
+      return false;
+
+    is_locked_ = true;
+    return true;
+  }
+  void Unlock() override {
+    DCHECK(is_locked_);
+
+    manager_->UnlockSpan(span_.get());
+    is_locked_ = false;
+  }
   void* Memory() const override {
+    DCHECK(is_locked_);
     return reinterpret_cast<void*>(span_->start() * base::GetPageSize());
   }
 
  private:
-  ChildDiscardableSharedMemoryManager* manager_;
+  ChildDiscardableSharedMemoryManager* const manager_;
   scoped_ptr<DiscardableSharedMemoryHeap::Span> span_;
+  bool is_locked_;
 
-  DISALLOW_COPY_AND_ASSIGN(DiscardableMemoryShmemChunkImpl);
+  DISALLOW_COPY_AND_ASSIGN(DiscardableMemoryImpl);
 };
 
 void DeletedDiscardableSharedMemory(scoped_refptr<ThreadSafeSender> sender,
                                     DiscardableSharedMemoryId id) {
   sender->Send(new ChildProcessHostMsg_DeletedDiscardableSharedMemory(id));
 }
 
 }  // namespace
 
 ChildDiscardableSharedMemoryManager::ChildDiscardableSharedMemoryManager(
     ThreadSafeSender* sender)
     : heap_(base::GetPageSize()), sender_(sender) {
 }
 
 ChildDiscardableSharedMemoryManager::~ChildDiscardableSharedMemoryManager() {
   // TODO(reveman): Determine if this DCHECK can be enabled. crbug.com/430533
   // DCHECK_EQ(heap_.GetSize(), heap_.GetSizeOfFreeLists());
   if (heap_.GetSize())
     MemoryUsageChanged(0, 0);
 }
 
-scoped_ptr<base::DiscardableMemoryShmemChunk>
+scoped_ptr<base::DiscardableMemory>
 ChildDiscardableSharedMemoryManager::AllocateLockedDiscardableMemory(
     size_t size) {
   base::AutoLock lock(lock_);
 
   DCHECK_NE(size, 0u);
 
   UMA_HISTOGRAM_CUSTOM_COUNTS("Memory.DiscardableAllocationSize",
                               size / 1024,  // In KB
                               1,
                               4 * 1024 * 1024,  // 4 GB
@@ skipping 33 matching lines @@
       // We have to release purged memory before |free_span| can be destroyed.
       heap_.ReleasePurgedMemory();
       DCHECK(!free_span->shared_memory());
       continue;
     }
 
     // Memory usage is guaranteed to have changed after having removed
     // at least one span from the free lists.
     MemoryUsageChanged(heap_.GetSize(), heap_.GetSizeOfFreeLists());
 
-    return make_scoped_ptr(
-        new DiscardableMemoryShmemChunkImpl(this, free_span.Pass()));
+    return make_scoped_ptr(new DiscardableMemoryImpl(this, free_span.Pass()));
   }
 
   // Release purged memory to free up the address space before we attempt to
   // allocate more memory.
   heap_.ReleasePurgedMemory();
 
   // Make sure crash keys are up to date in case allocation fails.
   if (heap_.GetSize() != heap_size_prior_to_releasing_purged_memory)
     MemoryUsageChanged(heap_.GetSize(), heap_.GetSizeOfFreeLists());
 
@@ skipping 19 matching lines @@
         heap_.Split(new_span.get(), pages);
     leftover->shared_memory()->Unlock(
         leftover->start() * base::GetPageSize() -
             reinterpret_cast<size_t>(leftover->shared_memory()->memory()),
         leftover->length() * base::GetPageSize());
     heap_.MergeIntoFreeLists(leftover.Pass());
   }
 
   MemoryUsageChanged(heap_.GetSize(), heap_.GetSizeOfFreeLists());
 
-  return make_scoped_ptr(
-      new DiscardableMemoryShmemChunkImpl(this, new_span.Pass()));
+  return make_scoped_ptr(new DiscardableMemoryImpl(this, new_span.Pass()));
 }
 
 void ChildDiscardableSharedMemoryManager::ReleaseFreeMemory() {
   base::AutoLock lock(lock_);
 
   size_t heap_size_prior_to_releasing_memory = heap_.GetSize();
 
   // Release both purged and free memory.
   heap_.ReleasePurgedMemory();
   heap_.ReleaseFreeMemory();
@@ skipping 82 matching lines @@
   static const char kDiscardableMemoryUsageKey[] = "dm-usage";
   base::debug::SetCrashKeyValue(kDiscardableMemoryUsageKey,
                                 base::Uint64ToString(new_bytes_total));
 
   static const char kDiscardableMemoryUsageFreeKey[] = "dm-usage-free";
   base::debug::SetCrashKeyValue(kDiscardableMemoryUsageFreeKey,
                                 base::Uint64ToString(new_bytes_free));
 }
 
 }  // namespace content