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));

[Avi (use Gerrit), 2013/10/17 15:09:38]

If you're going to mprotect, do it _after_ you get the memory back with the
vm_purgable_control.

[Philippe, 2013/10/17 16:20:35]

The memory must be touchable to let vm_purgeable_control() work. See my attempt
to address your comment in the next patch set (patch set 9) that failed (just
like the initial mistake that I had made in Unlock() below in patch set 7) :/

+    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
+                                     : 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));

[Avi (use Gerrit), 2013/10/17 15:09:38]

Can we mprotect before we mark it as purgeable? Purgeable memory is
underdocumented enough that I want to not play with it when it's in that state.

[Philippe, 2013/10/17 16:20:35]

See the previous patch set (patch set 7) and my comment above.

+    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