Fix iOS after r269483.

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 <mach/mach_vm.h>
 
 #include "base/basictypes.h"
@@ skipping 15 matching lines @@
 
 class DiscardableMemoryMac : public DiscardableMemory {
  public:
   explicit DiscardableMemoryMac(size_t size)
       : memory_(0, 0),
         size_(mach_vm_round_page(size)) {
   }
 
   bool Initialize() {
     DCHECK_EQ(memory_.size(), 0u);
-    mach_vm_address_t address = 0;
-    kern_return_t ret = mach_vm_allocate(mach_task_self(),
-                                         &address,
-                                         size_,
-                                         VM_FLAGS_PURGABLE |
-                                             VM_FLAGS_ANYWHERE |
-                                             kDiscardableMemoryTag);
+    vm_address_t address = 0;
+    kern_return_t ret = vm_allocate(mach_task_self(),
+                                    &address,
+                                    size_,
+                                    VM_FLAGS_PURGABLE |
+                                        VM_FLAGS_ANYWHERE |
+                                        kDiscardableMemoryTag);
     if (ret != KERN_SUCCESS) {
-      MACH_DLOG(ERROR, ret) << "mach_vm_allocate";
+      MACH_DLOG(ERROR, ret) << "vm_allocate";
       return false;
     }
 
     memory_.reset(address, size_);
 
     return true;
   }
 
   virtual ~DiscardableMemoryMac() {
   }
 
   virtual DiscardableMemoryLockStatus Lock() OVERRIDE {
     kern_return_t ret;
-    MACH_DCHECK((ret = mach_vm_protect(mach_task_self(),
-                                       memory_.address(),
-                                       memory_.size(),
-                                       FALSE,
-                                       VM_PROT_DEFAULT)) == KERN_SUCCESS, ret);
+    MACH_DCHECK((ret = vm_protect(mach_task_self(),
+                                  memory_.address(),
+                                  memory_.size(),
+                                  FALSE,
+                                  VM_PROT_DEFAULT)) == KERN_SUCCESS, ret);
     int state = VM_PURGABLE_NONVOLATILE;
-    ret = mach_vm_purgable_control(mach_task_self(),
-                                   memory_.address(),
-                                   VM_PURGABLE_SET_STATE,
-                                   &state);
+    ret = vm_purgable_control(mach_task_self(),
+                              memory_.address(),
+                              VM_PURGABLE_SET_STATE,
+                              &state);
     if (ret != KERN_SUCCESS)
       return DISCARDABLE_MEMORY_LOCK_STATUS_FAILED;
 
     return state & VM_PURGABLE_EMPTY ? DISCARDABLE_MEMORY_LOCK_STATUS_PURGED
                                      : DISCARDABLE_MEMORY_LOCK_STATUS_SUCCESS;
   }
 
   virtual void Unlock() OVERRIDE {
     int state = VM_PURGABLE_VOLATILE | VM_VOLATILE_GROUP_DEFAULT;
-    kern_return_t ret = mach_vm_purgable_control(mach_task_self(),
-                                                 memory_.address(),
-                                                 VM_PURGABLE_SET_STATE,
-                                                 &state);
-    MACH_DLOG_IF(ERROR, ret != KERN_SUCCESS, ret) << "mach_vm_purgable_control";
-    MACH_DCHECK((ret = mach_vm_protect(mach_task_self(),
-                                       memory_.address(),
-                                       memory_.size(),
-                                       FALSE,
-                                       VM_PROT_NONE)) == KERN_SUCCESS, ret);
+    kern_return_t ret = vm_purgable_control(mach_task_self(),
+                                            memory_.address(),
+                                            VM_PURGABLE_SET_STATE,
+                                            &state);
+    MACH_DLOG_IF(ERROR, ret != KERN_SUCCESS, ret) << "vm_purgable_control";
+    MACH_DCHECK((ret = vm_protect(mach_task_self(),
+                                  memory_.address(),
+                                  memory_.size(),
+                                  FALSE,
+                                  VM_PROT_NONE)) == KERN_SUCCESS, ret);
   }
 
   virtual void* Memory() const OVERRIDE {
     return reinterpret_cast<void*>(memory_.address());
   }
 
  private:
   mac::ScopedMachVM memory_;
   size_t size_;
 
@@ skipping 55 matching lines @@
     }
   }
 
   NOTREACHED();
   return scoped_ptr<DiscardableMemory>();
 }
 
 // static
 void DiscardableMemory::PurgeForTesting() {
   int state = 0;
-  mach_vm_purgable_control(mach_task_self(), 0, VM_PURGABLE_PURGE_ALL, &state);
+  vm_purgable_control(mach_task_self(), 0, VM_PURGABLE_PURGE_ALL, &state);
   internal::DiscardableMemoryEmulated::PurgeForTesting();
 }
 
 }  // namespace base