Fix free memory calculation.

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 62 matching lines @@
   } else if (type == CPU_TYPE_X86_64) {
     return addr >= SHARED_REGION_BASE_X86_64 &&
            addr < (SHARED_REGION_BASE_X86_64 + SHARED_REGION_SIZE_X86_64);
   } else {
     return false;
   }
 }
 
 }  // namespace
 
-SystemMemoryInfoKB::SystemMemoryInfoKB() : total(0), free(0) {}
-
-SystemMemoryInfoKB::SystemMemoryInfoKB(const SystemMemoryInfoKB& other) =
-    default;
-
 // Getting a mach task from a pid for another process requires permissions in
 // general, so there doesn't really seem to be a way to do these (and spinning
 // up ps to fetch each stats seems dangerous to put in a base api for anyone to
 // call). Child processes ipc their port, so return something if available,
 // otherwise return 0.
 
 // static
 std::unique_ptr<ProcessMetrics> ProcessMetrics::CreateProcessMetrics(
     ProcessHandle process,
     PortProvider* port_provider) {
@@ skipping 272 matching lines @@
                                      reinterpret_cast<host_info_t>(&data),
                                      &count);
   if (kr != KERN_SUCCESS) {
     MACH_DLOG(WARNING, kr) << "host_statistics";
     return 0;
   }
 
   return (data.active_count * PAGE_SIZE) / 1024;
 }
 
-// On Mac, We only get total memory and free memory from the system.
 bool GetSystemMemoryInfo(SystemMemoryInfoKB* meminfo) {
   struct host_basic_info hostinfo;
   mach_msg_type_number_t count = HOST_BASIC_INFO_COUNT;
   base::mac::ScopedMachSendRight host(mach_host_self());
   int result = host_info(host.get(), HOST_BASIC_INFO,
                          reinterpret_cast<host_info_t>(&hostinfo), &count);
   if (result != KERN_SUCCESS)
     return false;
 
   DCHECK_EQ(HOST_BASIC_INFO_COUNT, count);
   meminfo->total = static_cast<int>(hostinfo.max_mem / 1024);
 
-  vm_statistics_data_t vm_info;
-  count = HOST_VM_INFO_COUNT;
+  vm_statistics64_data_t vm_info;
+  count = HOST_VM_INFO64_COUNT;
 
-  if (host_statistics(host.get(), HOST_VM_INFO,
-                      reinterpret_cast<host_info_t>(&vm_info),
-                      &count) != KERN_SUCCESS) {
+  if (host_statistics64(host.get(), HOST_VM_INFO64,
+                        reinterpret_cast<host_info64_t>(&vm_info),
+                        &count) != KERN_SUCCESS) {
     return false;
   }
+  DCHECK_EQ(HOST_VM_INFO64_COUNT, count);
 
+  static_assert(PAGE_SIZE % 1024 == 0, "Invalid page size");
   meminfo->free = static_cast<int>(
-      (vm_info.free_count - vm_info.speculative_count) * PAGE_SIZE / 1024);
+      PAGE_SIZE / 1024 * (vm_info.free_count - vm_info.speculative_count));

[danakj, 2017/03/13 16:01:21]

Thanks, this seems good, can you use saturated_cast then too? It shouldn't hurt
but makes it impossible to have weirder problems.

[Michael K. (Yandex Team), 2017/03/14 03:49:09]

I think you are worried too much about these casts.
But Ok, I'll use saturated_cast.

[danakj, 2017/03/14 14:41:46]

You're probably right, but then saturated_cast won't hurt either :)

+  meminfo->speculative =
+      static_cast<int>(PAGE_SIZE / 1024 * vm_info.speculative_count);
+  meminfo->file_backed =
+      static_cast<int>(PAGE_SIZE / 1024 * vm_info.external_page_count);
+  meminfo->purgeable =
+      static_cast<int>(PAGE_SIZE / 1024 * vm_info.purgeable_count);
 
   return true;
 }
 
 }  // namespace base