Migrate ProcessesEventRouter to the new task manager

chrome/browser/task_management/sampling/task_manager_impl.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_manager_impl.h"
 
 #include <string>
 #include <vector>
 
 #include "base/command_line.h"
@@ skipping 24 matching lines @@
 
   return blocking_pool->GetSequencedTaskRunner(token);
 }
 
 base::LazyInstance<TaskManagerImpl> lazy_task_manager_instance =
     LAZY_INSTANCE_INITIALIZER;
 
 }  // namespace
 
 TaskManagerImpl::TaskManagerImpl()
-    : blocking_pool_runner_(GetBlockingPoolRunner()),
+    : on_background_data_ready_callback_(base::Bind(
+          &TaskManagerImpl::OnTaskGroupBackgroundCalculationsDone,
+          base::Unretained(this))),
+      blocking_pool_runner_(GetBlockingPoolRunner()),
       is_running_(false) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   task_providers_.push_back(new BrowserProcessTaskProvider());
   task_providers_.push_back(new ChildProcessTaskProvider());
   task_providers_.push_back(new WebContentsTaskProvider());
 #if defined(OS_CHROMEOS)
   if (arc::ArcBridgeService::GetEnabled(
           base::CommandLine::ForCurrentProcess())) {
     task_providers_.push_back(new ArcProcessTaskProvider());
@@ skipping 120 matching lines @@
 }
 
 const base::ProcessId& TaskManagerImpl::GetProcessId(TaskId task_id) const {
   return GetTaskGroupByTaskId(task_id)->process_id();
 }
 
 Task::Type TaskManagerImpl::GetType(TaskId task_id) const {
   return GetTaskByTaskId(task_id)->GetType();
 }
 
+int TaskManagerImpl::GetTabId(TaskId task_id) const {
+  return GetTaskByTaskId(task_id)->GetTabId();
+}
+
+int TaskManagerImpl::GetChildProcessUniqueId(TaskId task_id) const {
+  return GetTaskByTaskId(task_id)->GetChildProcessUniqueID();
+}
+
+void TaskManagerImpl::GetTerminationStatus(TaskId task_id,
+                                           base::TerminationStatus* out_status,
+                                           int* out_error_code) const {
+  GetTaskByTaskId(task_id)->GetTerminationStatus(out_status, out_error_code);
+}
+
 int64_t TaskManagerImpl::GetNetworkUsage(TaskId task_id) const {
   return GetTaskByTaskId(task_id)->network_usage();
 }
 
 int64_t TaskManagerImpl::GetProcessTotalNetworkUsage(TaskId task_id) const {
   return GetTaskGroupByTaskId(task_id)->per_process_network_usage();
 }
 
 int64_t TaskManagerImpl::GetSqliteMemoryUsed(TaskId task_id) const {
   return GetTaskByTaskId(task_id)->GetSqliteMemoryUsed();
@@ skipping 41 matching lines @@
       if (groups_pair.second == browser_group)
         continue;
 
       groups_pair.second->AppendSortedTaskIds(&sorted_task_ids_);
     }
   }
 
   return sorted_task_ids_;
 }
 
+TaskIdList TaskManagerImpl::GetIdsOfTasksSharingSameProcess(
+    TaskId task_id) const {
+  DCHECK(is_running_) << "Task manager is not running. You must observe the "
+      "task manager for it to start running";
+
+  TaskIdList result;
+  GetTaskGroupByTaskId(task_id)->AppendSortedTaskIds(&result);
+  return result;
+}
+
 size_t TaskManagerImpl::GetNumberOfTasksOnSameProcess(TaskId task_id) const {
   return GetTaskGroupByTaskId(task_id)->num_tasks();
 }
 
 void TaskManagerImpl::TaskAdded(Task* task) {
   DCHECK(task);
 
   TaskGroup* task_group = nullptr;
   const base::ProcessId proc_id = task->process_id();
   const TaskId task_id = task->task_id();
 
   auto itr = task_groups_by_proc_id_.find(proc_id);
   if (itr == task_groups_by_proc_id_.end()) {
     task_group = new TaskGroup(task->process_handle(),
                                proc_id,
+                               on_background_data_ready_callback_,
                                blocking_pool_runner_);
     task_groups_by_proc_id_[proc_id] = task_group;
   } else {
     task_group = itr->second;
   }
 
   task_group->AddTask(task);
 
   task_groups_by_task_id_[task_id] = task_group;
 
@@ skipping 21 matching lines @@
 
   // Invalidate the cached sorted IDs by clearing the list.
   sorted_task_ids_.clear();
 
   if (task_group->empty()) {
     task_groups_by_proc_id_.erase(proc_id);
     delete task_group;
   }
 }
 
+void TaskManagerImpl::TaskUnresponsive(Task* task) {
+  DCHECK(task);
+  NotifyObserversOnTaskUnresponsive(task->task_id());
+}
+
 void TaskManagerImpl::OnVideoMemoryUsageStatsUpdate(
     const gpu::VideoMemoryUsageStats& gpu_memory_stats) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   gpu_memory_stats_ = gpu_memory_stats;
 }
 
 // static
 void TaskManagerImpl::OnMultipleBytesReadUI(
     std::vector<BytesReadParam>* params) {
@@ skipping 79 matching lines @@
 TaskGroup* TaskManagerImpl::GetTaskGroupByTaskId(TaskId task_id) const {
   DCHECK(ContainsKey(task_groups_by_task_id_, task_id));
 
   return task_groups_by_task_id_.at(task_id);
 }
 
 Task* TaskManagerImpl::GetTaskByTaskId(TaskId task_id) const {
   return GetTaskGroupByTaskId(task_id)->GetTaskById(task_id);
 }
 
+void TaskManagerImpl::OnTaskGroupBackgroundCalculationsDone() {
+  // TODO(afakhry): There should be a better way for doing this!
+  bool are_all_processes_data_ready = true;
+  for (auto& groups_itr : task_groups_by_proc_id_) {
+    are_all_processes_data_ready &=
+        groups_itr.second->AreBackgroundCalculationsDone();
+  }
+  if (are_all_processes_data_ready) {
+    NotifyObserversOnRefreshWithBackgroundCalculations(GetTaskIdsList());
+    for (auto& groups_itr : task_groups_by_proc_id_)
+      groups_itr.second->ClearCurrentBackgroundCalculationsFlags();
+  }
+}
+
 }  // namespace task_management