Fix the views Task Manager on Mac showing 0s for the Shared Memory

chrome/browser/task_management/sampling/task_group_sampler.cc

 // Copyright 2015 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 "chrome/browser/task_management/sampling/task_group_sampler.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 104 matching lines @@
 
 double TaskGroupSampler::RefreshCpuUsage() {
   DCHECK(worker_pool_sequenced_checker_.CalledOnValidSequencedThread());
 
   return process_metrics_->GetCPUUsage();
 }
 
 MemoryUsageStats TaskGroupSampler::RefreshMemoryUsage() {
   DCHECK(worker_pool_sequenced_checker_.CalledOnValidSequencedThread());
 
-  // TODO(afakhry): Integrate Bruce's CL for faster retrieval of physical memory
-  // on Windows here.

[ncarter (slow), 2016/05/19 22:30:36]

Did we ever do this?

[afakhry, 2016/05/20 00:34:35]

We haven't. One reason was that Bruce's approach doesn't match our
task/group/group sampler architecture.

I wanted to discuss this with you, actually. I think it's not worth it adding
ugliness and code complexity to our design, from which the return is not big.
Our design is already fast and running in a background thread. WDT? I can leave
that TODO if you want.

-
   MemoryUsageStats memory_usage;
+#if defined(OS_MACOSX)
+  if (process_metrics_->GetMemoryBytes(&memory_usage.private_bytes,
+                                       &memory_usage.shared_bytes)) {
+    memory_usage.physical_bytes = memory_usage.private_bytes;
+  }
+#else
   // Refreshing the physical/private/shared memory at one shot.
   base::WorkingSetKBytes ws_usage;
   if (process_metrics_->GetWorkingSetKBytes(&ws_usage)) {
     memory_usage.private_bytes = static_cast<int64_t>(ws_usage.priv * 1024);
     memory_usage.shared_bytes = static_cast<int64_t>(ws_usage.shared * 1024);
 #if defined(OS_LINUX)
     // On Linux private memory is also resident. Just use it.
     memory_usage.physical_bytes = memory_usage.private_bytes;
 #else
     // Memory = working_set.private which is working set minus shareable. This
     // avoids the unpredictable counting that occurs when calculating memory as
     // working set minus shared (renderer code counted when one tab is open and
     // not counted when two or more are open) and it is much more efficient to
     // calculate on Windows.
     memory_usage.physical_bytes =
         static_cast<int64_t>(process_metrics_->GetWorkingSetSize());
     memory_usage.physical_bytes -=
         static_cast<int64_t>(ws_usage.shareable * 1024);
-#endif
+#endif  // defined(OS_LINUX)
+
 #if defined(OS_CHROMEOS)
     memory_usage.swapped_bytes = ws_usage.swapped * 1024;
-#endif
+#endif  // defined(OS_CHROMEOS)
   }
+#endif  // defined(OS_MACOSX)
 
   return memory_usage;
 }
 
 int TaskGroupSampler::RefreshIdleWakeupsPerSecond() {
   DCHECK(worker_pool_sequenced_checker_.CalledOnValidSequencedThread());
 
   return process_metrics_->GetIdleWakeupsPerSecond();
 }
 
 #if defined(OS_LINUX)
 int TaskGroupSampler::RefreshOpenFdCount() {
   DCHECK(worker_pool_sequenced_checker_.CalledOnValidSequencedThread());
 
   return process_metrics_->GetOpenFdCount();
 }
 #endif  // defined(OS_LINUX)
 
 bool TaskGroupSampler::RefreshProcessPriority() {
   DCHECK(worker_pool_sequenced_checker_.CalledOnValidSequencedThread());
 
   return process_.IsProcessBackgrounded();
 }
 
 }  // namespace task_management