chrome/browser/task_management/sampling/task_manager_impl.cc

   1 // Copyright 2015 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/task_management/sampling/task_manager_impl.h"
   6
   7 #include "base/stl_util.h"
   8 #include "chrome/browser/task_management/sampling/task_group.h"
   9 #include "content/public/browser/browser_thread.h"
  10
  11 namespace task_management {
  12
  13 namespace {
  14
  15 inline scoped_refptr<base::SequencedTaskRunner> GetBlockingPoolRunner() {
  16   base::SequencedWorkerPool* blocking_pool =
  17       content::BrowserThread::GetBlockingPool();
  18   return blocking_pool->GetSequencedTaskRunner(
  19       blocking_pool->GetSequenceToken());
  20 }
  21
  22 }  // namespace
  23
  24 TaskManagerImpl::TaskManagerImpl()
  25     : task_groups_by_proc_id_(),
  26       task_groups_by_task_id_(),
  27       gpu_memory_stats_(),
  28       blocking_pool_runner_(GetBlockingPoolRunner()) {
  29 }
  30
  31 TaskManagerImpl::~TaskManagerImpl() {
  32   STLDeleteValues(&task_groups_by_proc_id_);
  33 }
  34
  35 void TaskManagerImpl::ActivateTask(TaskId task_id) {
  36   GetTaskByTaskId(task_id)->Activate();
  37 }
  38
  39 double TaskManagerImpl::GetCpuUsage(TaskId task_id) const {
  40   return GetTaskGroupByTaskId(task_id)->cpu_usage();
  41 }
  42
  43 int64 TaskManagerImpl::GetPhysicalMemoryUsage(TaskId task_id) const {
  44   return GetTaskGroupByTaskId(task_id)->physical_bytes();
  45 }
  46
  47 int64 TaskManagerImpl::GetPrivateMemoryUsage(TaskId task_id) const {
  48   return GetTaskGroupByTaskId(task_id)->private_bytes();
  49 }
  50
  51 int64 TaskManagerImpl::GetSharedMemoryUsage(TaskId task_id) const {
  52   return GetTaskGroupByTaskId(task_id)->shared_bytes();
  53 }
  54
  55 int64 TaskManagerImpl::GetGpuMemoryUsage(TaskId task_id,
  56                                          bool* has_duplicates) const {
  57   const TaskGroup* task_group = GetTaskGroupByTaskId(task_id);
  58   if (has_duplicates)
  59     *has_duplicates = task_group->gpu_memory_has_duplicates();
  60   return task_group->gpu_memory();
  61 }
  62
  63 int TaskManagerImpl::GetIdleWakeupsPerSecond(TaskId task_id) const {
  64   return GetTaskGroupByTaskId(task_id)->idle_wakeups_per_second();
  65 }
  66
  67 int TaskManagerImpl::GetNaClDebugStubPort(TaskId task_id) const {
  68 #if !defined(DISABLE_NACL)
  69   return GetTaskGroupByTaskId(task_id)->nacl_debug_stub_port();
  70 #else
  71   return -1;
  72 #endif  // !defined(DISABLE_NACL)
  73 }
  74
  75 void TaskManagerImpl::GetGDIHandles(TaskId task_id,
  76                                     int64* current,
  77                                     int64* peak) const {
  78 #if defined(OS_WIN)
  79   const TaskGroup* task_group = GetTaskGroupByTaskId(task_id);
  80   *current = task_group->gdi_current_handles();
  81   *peak = task_group->gdi_peak_handles();
  82 #else
  83   *current = -1;
  84   *peak = -1;
  85 #endif  // defined(OS_WIN)
  86 }
  87
  88 void TaskManagerImpl::GetUSERHandles(TaskId task_id,
  89                                      int64* current,
  90                                      int64* peak) const {
  91 #if defined(OS_WIN)
  92   const TaskGroup* task_group = GetTaskGroupByTaskId(task_id);
  93   *current = task_group->user_current_handles();
  94   *peak = task_group->user_peak_handles();
  95 #else
  96   *current = -1;
  97   *peak = -1;
  98 #endif  // defined(OS_WIN)
  99 }
 100
 101 const base::string16& TaskManagerImpl::GetTitle(TaskId task_id) const {
 102   return GetTaskByTaskId(task_id)->title();
 103 }
 104
 105 base::string16 TaskManagerImpl::GetProfileName(TaskId task_id) const {
 106   return GetTaskByTaskId(task_id)->GetProfileName();
 107 }
 108
 109 const gfx::ImageSkia& TaskManagerImpl::GetIcon(TaskId task_id) const {
 110   return GetTaskByTaskId(task_id)->icon();
 111 }
 112
 113 const base::ProcessHandle& TaskManagerImpl::GetProcessHandle(
 114     TaskId task_id) const {
 115   return GetTaskByTaskId(task_id)->process_handle();
 116 }
 117
 118 const base::ProcessId& TaskManagerImpl::GetProcessId(TaskId task_id) const {
 119   return GetTaskByTaskId(task_id)->process_id();
 120 }
 121
 122 Task::Type TaskManagerImpl::GetType(TaskId task_id) const {
 123   return GetTaskByTaskId(task_id)->GetType();
 124 }
 125
 126 int64 TaskManagerImpl::GetNetworkUsage(TaskId task_id) const {
 127   return GetTaskByTaskId(task_id)->network_usage();
 128 }
 129
 130 int64 TaskManagerImpl::GetSqliteMemoryUsed(TaskId task_id) const {
 131   return GetTaskByTaskId(task_id)->GetSqliteMemoryUsed();
 132 }
 133
 134 bool TaskManagerImpl::GetV8Memory(TaskId task_id,
 135                                   int64* allocated,
 136                                   int64* used) const {
 137   const Task* task = GetTaskByTaskId(task_id);
 138   if (!task->ReportsV8Memory())
 139     return false;
 140
 141   *allocated = task->GetV8MemoryAllocated();
 142   *used = task->GetV8MemoryUsed();
 143
 144   return true;
 145 }
 146
 147 bool TaskManagerImpl::GetWebCacheStats(
 148     TaskId task_id,
 149     blink::WebCache::ResourceTypeStats* stats) const {
 150   const Task* task = GetTaskByTaskId(task_id);
 151   if (!task->ReportsWebCacheStats())
 152     return false;
 153
 154   *stats = task->GetWebCacheStats();
 155
 156   return true;
 157 }
 158
 159 void TaskManagerImpl::TaskAdded(Task* task) {
 160   DCHECK(task);
 161
 162   TaskGroup* task_group = nullptr;
 163   const base::ProcessId proc_id = task->process_id();
 164   const TaskId task_id = task->task_id();
 165
 166   auto itr = task_groups_by_proc_id_.find(proc_id);
 167   if (itr == task_groups_by_proc_id_.end()) {
 168     task_group = new TaskGroup(task->process_handle(),
 169                                proc_id,
 170                                blocking_pool_runner_.get());
 171     task_groups_by_proc_id_[proc_id] = task_group;
 172   } else {
 173     task_group = itr->second;
 174   }
 175
 176   task_group->AddTask(task);
 177   task_groups_by_task_id_[task_id] = task_group;
 178
 179   NotifyObserversOnTaskAdded(task_id);
 180 }
 181
 182 void TaskManagerImpl::TaskRemoved(Task* task) {
 183   DCHECK(task);
 184
 185   const base::ProcessId proc_id = task->process_id();
 186   const TaskId task_id = task->task_id();
 187
 188   DCHECK(ContainsKey(task_groups_by_proc_id_, proc_id));
 189   DCHECK(ContainsKey(task_groups_by_task_id_, task_id));
 190
 191   NotifyObserversOnTaskToBeRemoved(task_id);
 192
 193   TaskGroup* task_group = task_groups_by_proc_id_.at(proc_id);
 194   task_group->RemoveTask(task);
 195   task_groups_by_task_id_.erase(task_id);
 196
 197   if (task_group->empty()) {
 198     task_groups_by_proc_id_.erase(proc_id);
 199     delete task_group;
 200   }
 201 }
 202
 203 void TaskManagerImpl::OnVideoMemoryUsageStatsUpdate(
 204     const content::GPUVideoMemoryUsageStats& gpu_memory_stats) {
 205   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 206
 207   gpu_memory_stats_ = gpu_memory_stats;
 208 }
 209
 210 void TaskManagerImpl::Refresh() {
 211   for (auto& groups_itr : task_groups_by_proc_id_) {
 212     groups_itr.second->Refresh(gpu_memory_stats_,
 213                                GetCurrentRefreshTime(),
 214                                enabled_resources_flags());
 215   }
 216
 217   std::vector<TaskId> task_ids;
 218   task_ids.reserve(task_groups_by_task_id_.size());
 219   for (auto& ids_itr : task_groups_by_task_id_)
 220     task_ids.push_back(ids_itr.first);
 221
 222   NotifyObserversOnRefresh(task_ids);
 223 }
 224
 225 TaskGroup* TaskManagerImpl::GetTaskGroupByTaskId(TaskId task_id) const {
 226   DCHECK(ContainsKey(task_groups_by_task_id_, task_id));
 227
 228   return task_groups_by_task_id_.at(task_id);
 229 }
 230
 231 Task* TaskManagerImpl::GetTaskByTaskId(TaskId task_id) const {
 232   return GetTaskGroupByTaskId(task_id)->GetTaskById(task_id);
 233 }
 234
 235 }  // namespace task_management