Use the new ScopedMachVM class and the MACH_LOG family of logging macros

base/mac/scoped_mach_vm.h

 // 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.
 
 #ifndef BASE_MAC_SCOPED_MACH_VM_H_
 #define BASE_MAC_SCOPED_MACH_VM_H_
 
 #include <mach/mach.h>
-#include <mach/mach_vm.h>
 
 #include <algorithm>
 
+#include "base/base_export.h"
 #include "base/basictypes.h"
 #include "base/logging.h"
 
 // Use ScopedMachVM to supervise ownership of pages in the current process
-// through the Mach VM subsystem. Pages allocated with mach_vm_allocate can be
+// through the Mach VM subsystem. Pages allocated with vm_allocate can be
 // released when exiting a scope with ScopedMachVM.
 //
 // The Mach VM subsystem operates on a page-by-page basis, and a single VM
 // allocation managed by a ScopedMachVM object may span multiple pages. As far
 // as Mach is concerned, allocated pages may be deallocated individually. This
 // is in contrast to higher-level allocators such as malloc, where the base
 // address of an allocation implies the size of an allocated block.
 // Consequently, it is not sufficient to just pass the base address of an
 // allocation to ScopedMachVM, it also needs to know the size of the
 // allocation. To avoid any confusion, both the base address and size must
 // be page-aligned.
 //
 // When dealing with Mach VM, base addresses will naturally be page-aligned,
 // but user-specified sizes may not be. If there's a concern that a size is
 // not page-aligned, use the mach_vm_round_page macro to correct it.
 //
 // Example:
 //
-//   mach_vm_address_t address = 0;
-//   mach_vm_size_t size = 12345;  // This requested size is not page-aligned.
+//   vm_address_t address = 0;
+//   vm_size_t size = 12345;  // This requested size is not page-aligned.
 //   kern_return_t kr =
-//       mach_vm_allocate(mach_task_self(), &address, size, VM_FLAGS_ANYWHERE);
+//       vm_allocate(mach_task_self(), &address, size, VM_FLAGS_ANYWHERE);
 //   if (kr != KERN_SUCCESS) {
 //     return false;
 //   }
 //   ScopedMachVM vm_owner(address, mach_vm_round_page(size));
 
 namespace base {
 namespace mac {
 
-class ScopedMachVM {
+class BASE_EXPORT ScopedMachVM {
  public:
-  explicit ScopedMachVM(mach_vm_address_t address = 0, mach_vm_size_t size = 0)
+  explicit ScopedMachVM(vm_address_t address = 0, vm_size_t size = 0)
       : address_(address),
         size_(size) {
     DCHECK(address % PAGE_SIZE == 0);
     DCHECK(size % PAGE_SIZE == 0);
   }
 
   ~ScopedMachVM() {
     if (size_) {
-      mach_vm_deallocate(mach_task_self(), address_, size_);
+      vm_deallocate(mach_task_self(), address_, size_);
     }
   }
 
-  void reset(mach_vm_address_t address = 0, mach_vm_size_t size = 0);
+  void reset(vm_address_t address = 0, vm_size_t size = 0);
 
-  mach_vm_address_t address() const {
+  vm_address_t address() const {
     return address_;
   }
 
-  mach_vm_size_t size() const {
+  vm_size_t size() const {
     return size_;
   }
 
   void swap(ScopedMachVM& that) {
     std::swap(address_, that.address_);
     std::swap(size_, that.size_);
   }
 
   void release() {
     address_ = 0;
     size_ = 0;
   }
 
  private:
-  mach_vm_address_t address_;
-  mach_vm_size_t size_;
+  vm_address_t address_;
+  vm_size_t size_;
 
   DISALLOW_COPY_AND_ASSIGN(ScopedMachVM);
 };
 
 }  // namespace mac
 }  // namespace base
 
 #endif  // BASE_MAC_SCOPED_MACH_VM_H_