Add a task manager column that shows memory state of processes

chrome/browser/task_manager/sampling/task_group.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_manager/sampling/task_group.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "build/build_config.h"
 #include "chrome/browser/task_manager/sampling/shared_sampler.h"
 #include "chrome/browser/task_manager/task_manager_observer.h"
 #include "components/nacl/browser/nacl_browser.h"
 #include "content/public/browser/browser_thread.h"
+#include "content/public/browser/memory_coordinator.h"
+#include "content/public/common/content_features.h"
 #include "gpu/ipc/common/memory_stats.h"
 
 namespace task_manager {
 
 namespace {
 
 // A mask for the refresh types that are done in the background thread.
 const int kBackgroundRefreshTypesMask =
     REFRESH_TYPE_CPU |
     REFRESH_TYPE_MEMORY |
@@ skipping 43 matching lines @@
     const scoped_refptr<base::SequencedTaskRunner>& blocking_pool_runner)
     : process_handle_(proc_handle),
       process_id_(proc_id),
       on_background_calculations_done_(on_background_calculations_done),
       worker_thread_sampler_(nullptr),
       shared_sampler_(shared_sampler),
       expected_on_bg_done_flags_(kBackgroundRefreshTypesMask),
       current_on_bg_done_flags_(0),
       cpu_usage_(0.0),
       gpu_memory_(-1),
+      memory_state_(base::MemoryState::UNKNOWN),
       per_process_network_usage_(-1),
 #if defined(OS_WIN)
       gdi_current_handles_(-1),
       gdi_peak_handles_(-1),
       user_current_handles_(-1),
       user_peak_handles_(-1),
 #endif  // defined(OS_WIN)
 #if !defined(DISABLE_NACL)
       nacl_debug_stub_port_(-1),
 #endif  // !defined(DISABLE_NACL)
@@ skipping 91 matching lines @@
       refresh_flags & shared_sampler_->GetSupportedFlags();
 
   // 5- Refresh resources via SharedSampler if the current platform
   // implementation supports that. The actual work is done on the worker thread.
   // At the moment this is supported only on OS_WIN.
   if (shared_refresh_flags != 0) {
     shared_sampler_->Refresh(process_id_, shared_refresh_flags);
     refresh_flags &= ~shared_refresh_flags;
   }
 
+  // 6- Refresh memory state when memory coordinator is enabled.
+  if (TaskManagerObserver::IsResourceRefreshEnabled(REFRESH_TYPE_MEMORY_STATE,
+                                                    refresh_flags) &&
+      base::FeatureList::IsEnabled(features::kMemoryCoordinator)) {
+    memory_state_ =
+        content::MemoryCoordinator::GetInstance()->GetStateForProcess(
+            process_handle_);
+  }
+
   // The remaining resource refreshes are time consuming and cannot be done on
   // the UI thread. Do them all on the worker thread using the TaskGroupSampler.
-  // 6-  CPU usage.
-  // 7-  Memory usage.
-  // 8-  Idle Wakeups per second.
-  // 9-  (Linux and ChromeOS only) The number of file descriptors current open.
-  // 10- Process priority (foreground vs. background).
+  // 7-  CPU usage.
+  // 8-  Memory usage.
+  // 9-  Idle Wakeups per second.
+  // 10-  (Linux and ChromeOS only) The number of file descriptors current open.
+  // 11- Process priority (foreground vs. background).
   worker_thread_sampler_->Refresh(refresh_flags);
 }
 
 Task* TaskGroup::GetTaskById(TaskId task_id) const {
   for (Task* task : tasks_) {
     if (task->task_id() == task_id)
       return task;
   }
   NOTREACHED();
   return nullptr;
@@ skipping 92 matching lines @@
 
 void TaskGroup::OnBackgroundRefreshTypeFinished(int64_t finished_refresh_type) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   current_on_bg_done_flags_ |= finished_refresh_type;
   if (AreBackgroundCalculationsDone())
     on_background_calculations_done_.Run();
 }
 
 }  // namespace task_manager