TaskManager: when shown or activated, select the last active tab.

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 <algorithm>
 #include <string>
 #include <unordered_map>
 #include <unordered_set>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/containers/adapters.h"
 #include "base/stl_util.h"
 #include "build/build_config.h"
 #include "chrome/browser/task_management/providers/browser_process_task_provider.h"
 #include "chrome/browser/task_management/providers/child_process_task_provider.h"
 #include "chrome/browser/task_management/providers/web_contents/web_contents_task_provider.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/gpu_data_manager.h"
+#include "content/public/browser/render_frame_host.h"
+#include "content/public/browser/render_process_host.h"
+#include "content/public/browser/web_contents.h"
 
 #if defined(OS_CHROMEOS)
 #include "chrome/browser/task_management/providers/arc/arc_process_task_provider.h"
 #include "components/arc/arc_bridge_service.h"
 #endif  // defined(OS_CHROMEOS)
 
 namespace task_management {
 
 namespace {
 
@@ skipping 10 matching lines @@
 }  // namespace
 
 TaskManagerImpl::TaskManagerImpl()
     : 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());
+  task_providers_.emplace_back(new BrowserProcessTaskProvider());
+  task_providers_.emplace_back(new ChildProcessTaskProvider());
+  task_providers_.emplace_back(new WebContentsTaskProvider());
 #if defined(OS_CHROMEOS)
   if (arc::ArcBridgeService::GetEnabled(
           base::CommandLine::ForCurrentProcess())) {
-    task_providers_.push_back(new ArcProcessTaskProvider());
+    task_providers_.emplace_back(new ArcProcessTaskProvider());
   }
 #endif  // defined(OS_CHROMEOS)
 
   content::GpuDataManager::GetInstance()->AddObserver(this);
 }
 
 TaskManagerImpl::~TaskManagerImpl() {
   content::GpuDataManager::GetInstance()->RemoveObserver(this);
 
   STLDeleteValues(&task_groups_by_proc_id_);
@@ skipping 286 matching lines @@
     for (Task* task : group->tasks())
       result.push_back(task->task_id());
   }
   return result;
 }
 
 size_t TaskManagerImpl::GetNumberOfTasksOnSameProcess(TaskId task_id) const {
   return GetTaskGroupByTaskId(task_id)->num_tasks();
 }
 
+TaskId TaskManagerImpl::GetTaskIdForWebContents(
+    content::WebContents* web_contents) const {
+  if (!web_contents)
+    return -1;
+  content::RenderFrameHost* rfh = web_contents->GetMainFrame();
+  Task* task =
+      GetTaskByPidOrRoute(0, rfh->GetProcess()->GetID(), rfh->GetRoutingID());
+  if (!task)
+    return -1;
+  return task->task_id();
+}
+
 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(),
@@ skipping 88 matching lines @@
 
   NotifyObserversOnRefresh(GetTaskIdsList());
 }
 
 void TaskManagerImpl::StartUpdating() {
   if (is_running_)
     return;
 
   is_running_ = true;
 
-  for (auto* provider : task_providers_)
+  for (const auto& provider : task_providers_)
     provider->SetObserver(this);
 
   io_thread_helper_manager_.reset(new IoThreadHelperManager);
 }
 
 void TaskManagerImpl::StopUpdating() {
   if (!is_running_)
     return;
 
   is_running_ = false;
 
   io_thread_helper_manager_.reset();
 
-  for (auto* provider : task_providers_)
+  for (const auto& provider : task_providers_)
     provider->ClearObserver();
 
   STLDeleteValues(&task_groups_by_proc_id_);
   task_groups_by_task_id_.clear();
   sorted_task_ids_.clear();
 }
 
+Task* TaskManagerImpl::GetTaskByPidOrRoute(int origin_pid,
+                                           int child_id,
+                                           int route_id) const {
+  for (const auto& task_provider : task_providers_) {
+    Task* task =
+        task_provider->GetTaskOfUrlRequest(origin_pid, child_id, route_id);
+    if (task)
+      return task;
+  }
+  return nullptr;
+}
+
 bool TaskManagerImpl::UpdateTasksWithBytesRead(const BytesReadParam& param) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
-  for (auto* task_provider : task_providers_) {
-    Task* task = task_provider->GetTaskOfUrlRequest(param.origin_pid,
-                                                    param.child_id,
-                                                    param.route_id);
-    if (task) {
-      task->OnNetworkBytesRead(param.byte_count);
-      return true;
-    }
+  Task* task =
+      GetTaskByPidOrRoute(param.origin_pid, param.child_id, param.route_id);
+  if (task) {
+    task->OnNetworkBytesRead(param.byte_count);
+    return true;
   }
 
   // Couldn't match the bytes to any existing task.
   return false;
 }
 
 TaskGroup* TaskManagerImpl::GetTaskGroupByTaskId(TaskId task_id) const {
   auto it = task_groups_by_task_id_.find(task_id);
   DCHECK(it != task_groups_by_task_id_.end());
   return it->second;
@@ skipping 11 matching lines @@
         groups_itr.second->AreBackgroundCalculationsDone();
   }
   if (are_all_processes_data_ready) {
     NotifyObserversOnRefreshWithBackgroundCalculations(GetTaskIdsList());
     for (const auto& groups_itr : task_groups_by_proc_id_)
       groups_itr.second->ClearCurrentBackgroundCalculationsFlags();
   }
 }
 
 }  // namespace task_management