Migrate ProcessesEventRouter to the new task manager

chrome/browser/task_management/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_management/sampling/task_group.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/stl_util.h"
 #include "build/build_config.h"
 #include "chrome/browser/task_management/task_manager_observer.h"
 #include "components/nacl/browser/nacl_browser.h"
 #include "content/public/browser/browser_thread.h"
 #include "gpu/ipc/common/memory_stats.h"
 
 namespace task_management {
 
 namespace {
 
+// A mask for the refresh types that are done in the background thread.
+const int kBackgroundRefreshTypesMask =
+    REFRESH_TYPE_CPU |
+    REFRESH_TYPE_MEMORY |
+    REFRESH_TYPE_IDLE_WAKEUPS |
+#if defined(OS_LINUX)
+    REFRESH_TYPE_FD_COUNT |
+#endif  // defined(OS_LINUX)
+    REFRESH_TYPE_PRIORITY;
+
 inline bool IsResourceRefreshEnabled(RefreshType refresh_type,
                                      int refresh_flags) {
   return (refresh_flags & refresh_type) != 0;
 }
 
 #if defined(OS_WIN)
 // Gets the GDI and USER Handles on Windows at one shot.
 void GetWindowsHandles(base::ProcessHandle handle,
                        int64_t* out_gdi_current,
                        int64_t* out_gdi_peak,
@@ skipping 20 matching lines @@
     CloseHandle(process_with_query_rights);
   }
 }
 #endif  // defined(OS_WIN)
 
 }  // namespace
 
 TaskGroup::TaskGroup(
     base::ProcessHandle proc_handle,
     base::ProcessId proc_id,
+    const base::Closure& on_background_calculations_done,
     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),
-      tasks_(),
+      expected_on_bg_done_flags_(kBackgroundRefreshTypesMask),
+      current_on_bg_done_flags_(0),
       cpu_usage_(0.0),
       memory_usage_(),
       gpu_memory_(-1),
       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)
@@ skipping 41 matching lines @@
   DCHECK(ContainsKey(tasks_, task->task_id()));
 
   tasks_.erase(task->task_id());
 }
 
 void TaskGroup::Refresh(const gpu::VideoMemoryUsageStats& gpu_memory_stats,
                         base::TimeDelta update_interval,
                         int64_t refresh_flags) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
+  expected_on_bg_done_flags_ = refresh_flags & kBackgroundRefreshTypesMask;
+  // If a refresh type was recently disabled, we need to account for that too.
+  current_on_bg_done_flags_ &= expected_on_bg_done_flags_;
+
   // First refresh the enabled non-expensive resources usages on the UI thread.
   // 1- Refresh all the tasks as well as the total network usage (if enabled).
   const bool network_usage_refresh_enabled =
       IsResourceRefreshEnabled(REFRESH_TYPE_NETWORK_USAGE, refresh_flags);
   per_process_network_usage_ = network_usage_refresh_enabled ? 0 : -1;
   for (auto& task_pair : tasks_) {
     Task* task = task_pair.second;
     task->Refresh(update_interval, refresh_flags);
 
-    if (network_usage_refresh_enabled && task->ReportsNetworkUsage()) {
+    if (network_usage_refresh_enabled && task->ReportsNetworkUsage())
       per_process_network_usage_ += task->network_usage();
-    }
   }
 
   // 2- Refresh GPU memory (if enabled).
   if (IsResourceRefreshEnabled(REFRESH_TYPE_GPU_MEMORY, refresh_flags))
     RefreshGpuMemory(gpu_memory_stats);
 
   // 3- Refresh Windows handles (if enabled).
 #if defined(OS_WIN)
   if (IsResourceRefreshEnabled(REFRESH_TYPE_HANDLES, refresh_flags))
     RefreshWindowsHandles();
@@ skipping 24 matching lines @@
   for (const auto& task_pair : tasks_)
     out_list->push_back(task_pair.first);
 }
 
 Task* TaskGroup::GetTaskById(TaskId task_id) const {
   DCHECK(ContainsKey(tasks_, task_id));
 
   return tasks_.at(task_id);
 }
 
+void TaskGroup::ClearCurrentBackgroundCalculationsFlags() {
+  current_on_bg_done_flags_ = 0;
+}
+
+bool TaskGroup::AreBackgroundCalculationsDone() const {
+  return expected_on_bg_done_flags_ == current_on_bg_done_flags_;
+}
+
 void TaskGroup::RefreshGpuMemory(
     const gpu::VideoMemoryUsageStats& gpu_memory_stats) {
   auto itr = gpu_memory_stats.process_map.find(process_id_);
   if (itr == gpu_memory_stats.process_map.end()) {
     gpu_memory_ = -1;
     gpu_memory_has_duplicates_ = false;
     return;
   }
 
   gpu_memory_ = itr->second.video_memory;
@@ skipping 15 matching lines @@
   nacl::NaClBrowser* nacl_browser = nacl::NaClBrowser::GetInstance();
   nacl_debug_stub_port_ =
       nacl_browser->GetProcessGdbDebugStubPort(child_process_unique_id);
 #endif // !defined(DISABLE_NACL)
 }
 
 void TaskGroup::OnCpuRefreshDone(double cpu_usage) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   cpu_usage_ = cpu_usage;
+  OnBackgroundRefreshTypeFinished(REFRESH_TYPE_CPU);
 }
 
 void TaskGroup::OnMemoryUsageRefreshDone(MemoryUsageStats memory_usage) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   memory_usage_ = memory_usage;
+  OnBackgroundRefreshTypeFinished(REFRESH_TYPE_MEMORY);
 }
 
 void TaskGroup::OnIdleWakeupsRefreshDone(int idle_wakeups_per_second) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   idle_wakeups_per_second_ = idle_wakeups_per_second;
+  OnBackgroundRefreshTypeFinished(REFRESH_TYPE_IDLE_WAKEUPS);
 }
 
 #if defined(OS_LINUX)
 void TaskGroup::OnOpenFdCountRefreshDone(int open_fd_count) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   open_fd_count_ = open_fd_count;
+  OnBackgroundRefreshTypeFinished(REFRESH_TYPE_FD_COUNT);
 }
 #endif  // defined(OS_LINUX)
 
 void TaskGroup::OnProcessPriorityDone(bool is_backgrounded) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   is_backgrounded_ = is_backgrounded;
+  OnBackgroundRefreshTypeFinished(REFRESH_TYPE_PRIORITY);
+}
+
+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_management