Refactor DiscardableMemory for the upcoming DiscardableMemoryAllocator.

base/memory/discardable_memory_mac.cc

 // 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.
 
 #include "base/memory/discardable_memory.h"
 
 #include <mach/mach.h>
+#include <sys/mman.h>
 
+#include "base/basictypes.h"
+#include "base/compiler_specific.h"
 #include "base/logging.h"
+#include "base/memory/scoped_ptr.h"
 
 namespace base {
-
 namespace {
 
 // The VM subsystem allows tagging of memory and 240-255 is reserved for
 // application use (see mach/vm_statistics.h). Pick 252 (after chromium's atomic
 // weight of ~52).
 const int kDiscardableMemoryTag = VM_MAKE_TAG(252);
 
+class DiscardableMemoryMac : public DiscardableMemory {
+ public:
+  DiscardableMemoryMac(void* memory, size_t size)
+      : memory_(memory),
+        size_(size) {
+    DCHECK(memory_);
+  }
+
+  virtual ~DiscardableMemoryMac() {
+    vm_deallocate(mach_task_self(),
+                  reinterpret_cast<vm_address_t>(memory_),
+                  size_);
+  }
+
+  virtual LockDiscardableMemoryStatus Lock() OVERRIDE {
+    DCHECK_EQ(0, mprotect(memory_, size_, PROT_READ | PROT_WRITE));
+    int state = VM_PURGABLE_NONVOLATILE;
+    kern_return_t ret = vm_purgable_control(
+        mach_task_self(),
+        reinterpret_cast<vm_address_t>(memory_),
+        VM_PURGABLE_SET_STATE,
+        &state);
+    if (ret != KERN_SUCCESS)
+      return DISCARDABLE_MEMORY_FAILED;
+    return state & VM_PURGABLE_EMPTY ? DISCARDABLE_MEMORY_PURGED

[Avi (use Gerrit), 2013/10/17 17:58:55]

I liked the extra line before this one.

[Philippe, 2013/10/18 08:25:21]

Yeah, sorry. I tend to be quite aggressive at removing blank lines. I was very
used to code with a lot of blank lines before joining Google but got used to the
very packed style in Google3 (at least in my previous team). IMO blank lines
create inconsistencies since people have very different preferences with regards
to their position so I prefer to split functions when it's possible and when it
improves readability but this is only my opinion :)

+                                     : DISCARDABLE_MEMORY_SUCCESS;
+  }
+
+  virtual void Unlock() OVERRIDE {
+    int state = VM_PURGABLE_VOLATILE | VM_VOLATILE_GROUP_DEFAULT;
+    kern_return_t ret = vm_purgable_control(
+        mach_task_self(),
+        reinterpret_cast<vm_address_t>(memory_),
+        VM_PURGABLE_SET_STATE,
+        &state);
+    DCHECK_EQ(0, mprotect(memory_, size_, PROT_NONE));
+    if (ret != KERN_SUCCESS)
+      DLOG(ERROR) << "Failed to unlock memory.";
+  }
+
+  virtual void* Memory() const OVERRIDE {
+    return memory_;
+  }
+
+ private:
+  void* const memory_;
+  const size_t size_;
+
+  DISALLOW_COPY_AND_ASSIGN(DiscardableMemoryMac);
+};
+
 }  // namespace
 
 // static
 bool DiscardableMemory::Supported() {
   return true;
 }
 
-DiscardableMemory::~DiscardableMemory() {
-  if (memory_) {
-    vm_deallocate(mach_task_self(),
-                  reinterpret_cast<vm_address_t>(memory_),
-                  size_);
-  }
-}
-
-bool DiscardableMemory::InitializeAndLock(size_t size) {
-  DCHECK(!memory_);
-  size_ = size;
-
+// static
+scoped_ptr<DiscardableMemory> DiscardableMemory::CreateLockedMemory(
+    size_t size) {
   vm_address_t buffer = 0;
   kern_return_t ret = vm_allocate(mach_task_self(),
                                   &buffer,
                                   size,
                                   VM_FLAGS_PURGABLE |
                                   VM_FLAGS_ANYWHERE |
                                   kDiscardableMemoryTag);
-
   if (ret != KERN_SUCCESS) {
     DLOG(ERROR) << "vm_allocate() failed";
-    return false;
+    return scoped_ptr<DiscardableMemory>();
   }
-
-  is_locked_ = true;
-  memory_ = reinterpret_cast<void*>(buffer);
-  return true;
-}
-
-LockDiscardableMemoryStatus DiscardableMemory::Lock() {
-  DCHECK(!is_locked_);
-
-  int state = VM_PURGABLE_NONVOLATILE;
-  kern_return_t ret = vm_purgable_control(
-      mach_task_self(),
-      reinterpret_cast<vm_address_t>(memory_),
-      VM_PURGABLE_SET_STATE,
-      &state);
-
-  if (ret != KERN_SUCCESS)
-    return DISCARDABLE_MEMORY_FAILED;
-
-  is_locked_ = true;
-  return state & VM_PURGABLE_EMPTY ? DISCARDABLE_MEMORY_PURGED
-                                   : DISCARDABLE_MEMORY_SUCCESS;
-}
-
-void DiscardableMemory::Unlock() {
-  DCHECK(is_locked_);
-
-  int state = VM_PURGABLE_VOLATILE | VM_VOLATILE_GROUP_DEFAULT;
-  kern_return_t ret = vm_purgable_control(
-      mach_task_self(),
-      reinterpret_cast<vm_address_t>(memory_),
-      VM_PURGABLE_SET_STATE,
-      &state);
-
-  if (ret != KERN_SUCCESS)
-    DLOG(ERROR) << "Failed to unlock memory.";
-
-  is_locked_ = false;
+  return scoped_ptr<DiscardableMemory>(
+      new DiscardableMemoryMac(reinterpret_cast<void*>(buffer), size));
 }
 
 // static
 bool DiscardableMemory::PurgeForTestingSupported() {
   return true;
 }
 
 // static
 void DiscardableMemory::PurgeForTesting() {
   int state = 0;
   vm_purgable_control(mach_task_self(), 0, VM_PURGABLE_PURGE_ALL, &state);
 }
 
 }  // namespace base