TaskManager: unique_ptr<> ownership of TaskGroups

chrome/browser/task_management/providers/child_process_task_provider.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/providers/child_process_task_provider.h"
 
 #include "base/process/process.h"
-#include "base/stl_util.h"
 #include "chrome/browser/task_management/providers/child_process_task.h"
 #include "content/public/browser/browser_child_process_host_iterator.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/child_process_data.h"
 
 using content::BrowserChildProcessHostIterator;
 using content::BrowserThread;
 using content::ChildProcessData;
 
 namespace task_management {
@@ skipping 78 matching lines @@
   // we must invalidate the weak pointers.
   weak_ptr_factory_.InvalidateWeakPtrs();
 
   // First, stop observing.
   BrowserChildProcessObserver::Remove(this);
 
   // Remember: You can't notify the observer of tasks removal here,
   // StopUpdating() is called after the observer has been cleared.
 
   // Then delete all tasks (if any).
-  STLDeleteValues(&tasks_by_handle_);  // This will clear |tasks_by_handle_|.
+  tasks_by_handle_.clear();
   tasks_by_pid_.clear();
 }
 
 void ChildProcessTaskProvider::ChildProcessDataCollected(
     std::unique_ptr<const std::vector<content::ChildProcessData>>
         child_processes) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   for (const auto& process_data : *child_processes)
     CreateTask(process_data);
 
   // Now start observing.
   BrowserChildProcessObserver::Add(this);
 }
 
 void ChildProcessTaskProvider::CreateTask(
     const content::ChildProcessData& data) {
-  if (tasks_by_handle_.find(data.handle) != tasks_by_handle_.end()) {
-    // This case can happen when some of the child process data we collect upon
-    // StartUpdating() might be of BrowserChildProcessHosts whose process
-    // hadn't launched yet. So we just return.
+  std::unique_ptr<ChildProcessTask>& task = tasks_by_handle_[data.handle];
+  if (task) {
+    // This task is already known to us. This case can happen when some of the
+    // child process data we collect upon StartUpdating() might be of
+    // BrowserChildProcessHosts whose process hadn't launched yet. So we just
+    // return.
     return;
   }
 
   // Create the task and notify the observer.
-  ChildProcessTask* task = new ChildProcessTask(data);
-  tasks_by_handle_[data.handle] = task;
-  tasks_by_pid_[task->process_id()] = task;
-  NotifyObserverTaskAdded(task);
+  task.reset(new ChildProcessTask(data));
+  tasks_by_pid_[task->process_id()] = task.get();
+  NotifyObserverTaskAdded(task.get());
 }
 
 void ChildProcessTaskProvider::DeleteTask(base::ProcessHandle handle) {
   auto itr = tasks_by_handle_.find(handle);
 
   // The following case should never happen since we start observing
   // |BrowserChildProcessObserver| only after we collect all pre-existing child
   // processes and are notified (on the UI thread) that the collection is
   // completed at |ChildProcessDataCollected()|.
   if (itr == tasks_by_handle_.end()) {
     // BUG(crbug.com/611067): Temporarily removing due to test flakes. The
     // reason why this happens is well understood (see bug), but there's no
     // quick and easy fix.
     // NOTREACHED();
     return;
   }
 
-  ChildProcessTask* task = itr->second;
+  NotifyObserverTaskRemoved(itr->second.get());
 
-  NotifyObserverTaskRemoved(task);
+  // Clear from the pid index.
+  tasks_by_pid_.erase(itr->second->process_id());
 
   // Finally delete the task.
   tasks_by_handle_.erase(itr);
-  tasks_by_pid_.erase(task->process_id());
-  delete task;
 }
 
 }  // namespace task_management