mac: Fix calulation for number of resident pages in a process.

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 <stddef.h>
@@ skipping 92 matching lines @@
   if (!GetTaskInfo(TaskForPid(process_), &task_info_data))
     return 0;
   return task_info_data.virtual_size;
 }
 
 size_t ProcessMetrics::GetPeakPagefileUsage() const {
   return 0;
 }
 
 size_t ProcessMetrics::GetWorkingSetSize() const {
-  task_basic_info_64 task_info_data;
-  if (!GetTaskInfo(TaskForPid(process_), &task_info_data))
+  size_t private_bytes = 0;
+  size_t shared_bytes = 0;
+  size_t resident_bytes = 0;
+  if (!GetMemoryBytes(&private_bytes, &shared_bytes, &resident_bytes))
     return 0;
-  return task_info_data.resident_size;
+  return resident_bytes;
 }
 
 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) {
+                                    size_t* shared_bytes) const {
   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 44 matching lines @@
     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_LARGE_PAGE:
       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:
+      case SM_PRIVATE_ALIASED:
+      case SM_TRUESHARED:
+      case SM_SHARED_ALIASED:
         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;
     }
   }
@@ skipping 29 matching lines @@
   usage->mapped = 0;
   usage->image = 0;
 
   ws_usage->priv = task_info_data.resident_size / 1024;
   ws_usage->shareable = 0;
   ws_usage->shared = 0;
 
   return true;
 }
 
+bool ProcessMetrics::GetMemoryBytes(size_t* private_bytes,
+                                    size_t* shared_bytes,
+                                    size_t* resident_bytes) const {
+  if (!GetMemoryBytes(private_bytes, shared_bytes))
+    return false;
+  *resident_bytes = *private_bytes + *shared_bytes;
+  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;
 
@@ skipping 140 matching lines @@
     return false;
   }
 
   meminfo->free = static_cast<int>(
       (vm_info.free_count - vm_info.speculative_count) * PAGE_SIZE / 1024);
 
   return true;
 }
 
 }  // namespace base