Back out r269483 and the line of fixes that followed it.

base/process/process_metrics_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/process/process_metrics.h"
 
 #include <mach/mach.h>
 #include <mach/mach_vm.h>
 #include <mach/shared_region.h>
 #include <sys/sysctl.h>
 
 #include "base/containers/hash_tables.h"
 #include "base/logging.h"
-#include "base/mac/mach_logging.h"
 #include "base/mac/scoped_mach_port.h"
 #include "base/sys_info.h"
 
 #if !defined(TASK_POWER_INFO)
 // Doesn't exist in the 10.6 or 10.7 SDKs.
 #define TASK_POWER_INFO        21
 struct task_power_info {
         uint64_t                total_user;
         uint64_t                total_system;
         uint64_t                task_interrupt_wakeups;
@@ skipping 85 matching lines @@
 
 size_t ProcessMetrics::GetPeakWorkingSetSize() const {
   return 0;
 }
 
 // This is a rough approximation of the algorithm that libtop uses.
 // private_bytes is the size of private resident memory.
 // shared_bytes is the size of shared resident memory.
 bool ProcessMetrics::GetMemoryBytes(size_t* private_bytes,
                                     size_t* shared_bytes) {
+  kern_return_t kr;
   size_t private_pages_count = 0;
   size_t shared_pages_count = 0;
 
   if (!private_bytes && !shared_bytes)
     return true;
 
   mach_port_t task = TaskForPid(process_);
   if (task == MACH_PORT_NULL) {
     DLOG(ERROR) << "Invalid process";
     return false;
@@ skipping 16 matching lines @@
   // Private memory is much simpler. We simply count the pages that are marked
   // as private or copy on write (COW).
   //
   // See libtop_update_vm_regions in
   // http://www.opensource.apple.com/source/top/top-67/libtop.c
   mach_vm_size_t size = 0;
   for (mach_vm_address_t address = MACH_VM_MIN_ADDRESS;; address += size) {
     vm_region_top_info_data_t info;
     mach_msg_type_number_t info_count = VM_REGION_TOP_INFO_COUNT;
     mach_port_t object_name;
-    kern_return_t kr = mach_vm_region(task,
-                                      &address,
-                                      &size,
-                                      VM_REGION_TOP_INFO,
-                                      reinterpret_cast<vm_region_info_t>(&info),
-                                      &info_count,
-                                      &object_name);
+    kr = mach_vm_region(task,
+                        &address,
+                        &size,
+                        VM_REGION_TOP_INFO,
+                        (vm_region_info_t)&info,
+                        &info_count,
+                        &object_name);
     if (kr == KERN_INVALID_ADDRESS) {
       // We're at the end of the address space.
       break;
     } else if (kr != KERN_SUCCESS) {
-      MACH_DLOG(ERROR, kr) << "mach_vm_region";
+      DLOG(ERROR) << "Calling mach_vm_region failed with error: "
+                 << mach_error_string(kr);
       return false;
     }
 
-    // The kernel always returns a null object for VM_REGION_TOP_INFO, but
-    // balance it with a deallocate in case this ever changes. See 10.9.2
-    // xnu-2422.90.20/osfmk/vm/vm_map.c vm_map_region.
-    mach_port_deallocate(mach_task_self(), object_name);
-
     if (IsAddressInSharedRegion(address, cpu_type) &&
         info.share_mode != SM_PRIVATE)
       continue;
 
     if (info.share_mode == SM_COW && info.ref_count == 1)
       info.share_mode = SM_PRIVATE;
 
     switch (info.share_mode) {
       case SM_PRIVATE:
         private_pages_count += info.private_pages_resident;
         private_pages_count += info.shared_pages_resident;
         break;
       case SM_COW:
         private_pages_count += info.private_pages_resident;
         // Fall through
       case SM_SHARED:
         if (seen_objects.count(info.obj_id) == 0) {
           // Only count the first reference to this region.
           seen_objects.insert(info.obj_id);
           shared_pages_count += info.shared_pages_resident;
         }
         break;
       default:
         break;
     }
   }
 
+  vm_size_t page_size;
+  kr = host_page_size(task, &page_size);
+  if (kr != KERN_SUCCESS) {
+    DLOG(ERROR) << "Failed to fetch host page size, error: "
+               << mach_error_string(kr);
+    return false;
+  }
+
   if (private_bytes)
-    *private_bytes = private_pages_count * PAGE_SIZE;
+    *private_bytes = private_pages_count * page_size;
   if (shared_bytes)
-    *shared_bytes = shared_pages_count * PAGE_SIZE;
+    *shared_bytes = shared_pages_count * page_size;
 
   return true;
 }
 
 void ProcessMetrics::GetCommittedKBytes(CommittedKBytes* usage) const {
 }
 
 bool ProcessMetrics::GetWorkingSetKBytes(WorkingSetKBytes* ws_usage) const {
   size_t priv = GetWorkingSetSize();
   if (!priv)
     return false;
   ws_usage->priv = priv / 1024;
   ws_usage->shareable = 0;
   ws_usage->shared = 0;
   return true;
 }
 
 #define TIME_VALUE_TO_TIMEVAL(a, r) do {  \
   (r)->tv_sec = (a)->seconds;             \
   (r)->tv_usec = (a)->microseconds;       \
 } while (0)
 
 double ProcessMetrics::GetCPUUsage() {
   mach_port_t task = TaskForPid(process_);
   if (task == MACH_PORT_NULL)
     return 0;
 
+  kern_return_t kr;
+
   // Libtop explicitly loops over the threads (libtop_pinfo_update_cpu_usage()
   // in libtop.c), but this is more concise and gives the same results:
   task_thread_times_info thread_info_data;
   mach_msg_type_number_t thread_info_count = TASK_THREAD_TIMES_INFO_COUNT;
-  kern_return_t kr = task_info(task,
-                               TASK_THREAD_TIMES_INFO,
-                               reinterpret_cast<task_info_t>(&thread_info_data),
-                               &thread_info_count);
+  kr = task_info(task,
+                 TASK_THREAD_TIMES_INFO,
+                 reinterpret_cast<task_info_t>(&thread_info_data),
+                 &thread_info_count);
   if (kr != KERN_SUCCESS) {
     // Most likely cause: |task| is a zombie.
     return 0;
   }
 
   task_basic_info_64 task_info_data;
   if (!GetTaskInfo(task, &task_info_data))
     return 0;
 
   /* Set total_time. */
@@ skipping 29 matching lines @@
   last_system_time_ = task_time;
 
   return static_cast<double>(system_time_delta * 100.0) / time_delta;
 }
 
 int ProcessMetrics::GetIdleWakeupsPerSecond() {
   mach_port_t task = TaskForPid(process_);
   if (task == MACH_PORT_NULL)
     return 0;
 
+  kern_return_t kr;
+
   task_power_info power_info_data;
   mach_msg_type_number_t power_info_count = TASK_POWER_INFO_COUNT;
-  kern_return_t kr = task_info(task,
-                               TASK_POWER_INFO,
-                               reinterpret_cast<task_info_t>(&power_info_data),
-                               &power_info_count);
+  kr = task_info(task,
+                 TASK_POWER_INFO,
+                 reinterpret_cast<task_info_t>(&power_info_data),
+                 &power_info_count);
   if (kr != KERN_SUCCESS) {
     // Most likely cause: |task| is a zombie, or this is on a pre-10.8.4 system
     // where TASK_POWER_INFO isn't supported yet.
     return 0;
   }
   uint64_t absolute_idle_wakeups = power_info_data.task_platform_idle_wakeups;
 
   TimeTicks time = TimeTicks::Now();
 
   if (last_absolute_idle_wakeups_ == 0) {
@@ skipping 40 matching lines @@
 }
 
 // Bytes committed by the system.
 size_t GetSystemCommitCharge() {
   base::mac::ScopedMachPort host(mach_host_self());
   mach_msg_type_number_t count = HOST_VM_INFO_COUNT;
   vm_statistics_data_t data;
   kern_return_t kr = host_statistics(host, HOST_VM_INFO,
                                      reinterpret_cast<host_info_t>(&data),
                                      &count);
-  if (kr != KERN_SUCCESS) {
-    MACH_DLOG(WARNING, kr) << "host_statistics";
+  if (kr) {
+    DLOG(WARNING) << "Failed to fetch host statistics.";
     return 0;
   }
 
-  return (data.active_count * PAGE_SIZE) / 1024;
+  vm_size_t page_size;
+  kr = host_page_size(host, &page_size);
+  if (kr) {
+    DLOG(ERROR) << "Failed to fetch host page size.";
+    return 0;
+  }
+
+  return (data.active_count * page_size) / 1024;
 }
 
 }  // namespace base