TaskManager: unique_ptr<> ownership of TaskGroups

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"
 
@@ skipping 34 matching lines @@
           base::CommandLine::ForCurrentProcess())) {
     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_);
 }
 
 // static
 TaskManagerImpl* TaskManagerImpl::GetInstance() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   return lazy_task_manager_instance.Pointer();
 }
 
 void TaskManagerImpl::ActivateTask(TaskId task_id) {
@@ skipping 291 matching lines @@
   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(),
-                               proc_id,
-                               on_background_data_ready_callback_,
-                               blocking_pool_runner_);
-    task_groups_by_proc_id_[proc_id] = task_group;
-  } else {
-    task_group = itr->second;
-  }
+  std::unique_ptr<TaskGroup>& task_group = task_groups_by_proc_id_[proc_id];
+  if (!task_group)
+    task_group.reset(new TaskGroup(task->process_handle(), proc_id,
+                                   on_background_data_ready_callback_,
+                                   blocking_pool_runner_));
 
   task_group->AddTask(task);
 
-  task_groups_by_task_id_[task_id] = task_group;
+  task_groups_by_task_id_[task_id] = task_group.get();
 
   // Invalidate the cached sorted IDs by clearing the list.
   sorted_task_ids_.clear();
 
   NotifyObserversOnTaskAdded(task_id);
 }
 
 void TaskManagerImpl::TaskRemoved(Task* task) {
   DCHECK(task);
 
   const base::ProcessId proc_id = task->process_id();
   const TaskId task_id = task->task_id();
 
-  DCHECK(ContainsKey(task_groups_by_proc_id_, proc_id));
-  DCHECK(ContainsKey(task_groups_by_task_id_, task_id));
+  DCHECK(task_groups_by_proc_id_.count(proc_id));
 
   NotifyObserversOnTaskToBeRemoved(task_id);
 
-  TaskGroup* task_group = task_groups_by_proc_id_[proc_id];
+  TaskGroup* task_group = GetTaskGroupByTaskId(task_id);
   task_group->RemoveTask(task);
+  task_groups_by_task_id_.erase(task_id);
 
-  task_groups_by_task_id_.erase(task_id);
+  if (task_group->empty())
+    task_groups_by_proc_id_.erase(proc_id);  // Deletes |task_group|.
 
   // 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);
@@ skipping 54 matching lines @@
   if (!is_running_)
     return;
 
   is_running_ = false;
 
   io_thread_helper_manager_.reset();
 
   for (const auto& provider : task_providers_)
     provider->ClearObserver();
 
-  STLDeleteValues(&task_groups_by_proc_id_);
+  task_groups_by_proc_id_.clear();
   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);
@@ skipping 35 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