TaskManager: unique_ptr<> ownership of TaskGroups

chrome/browser/task_management/providers/web_contents/web_contents_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/web_contents/web_contents_task_provider.h"
 
 #include "base/bind.h"
 #include "base/macros.h"
-#include "base/stl_util.h"
 #include "chrome/browser/task_management/providers/web_contents/subframe_task.h"
 #include "chrome/browser/task_management/providers/web_contents/web_contents_tags_manager.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_widget_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_observer.h"
 
 using content::RenderFrameHost;
 using content::RenderWidgetHost;
@@ skipping 175 matching lines @@
                                    bool explicit_set) {
   RendererTask* task = GetTaskForFrame(web_contents()->GetMainFrame());
   if (!task)
     return;
 
   task->UpdateTitle();
   task->UpdateFavicon();
 }
 
 void WebContentsEntry::CreateTaskForFrame(RenderFrameHost* render_frame_host) {
-  DCHECK(!ContainsKey(tasks_by_frames_, render_frame_host));
+  DCHECK(!tasks_by_frames_.count(render_frame_host));
 
   content::SiteInstance* site_instance = render_frame_host->GetSiteInstance();
   if (!site_instance->GetProcess()->HasConnection())
     return;
 
   bool site_instance_exists =
-      ContainsKey(frames_by_site_instance_, site_instance);
+      frames_by_site_instance_.count(site_instance) != 0;
   bool is_main_frame = (render_frame_host == web_contents()->GetMainFrame());
   bool site_instance_is_main = (site_instance == main_frame_site_instance_);
 
   RendererTask* new_task = nullptr;
   // We don't create a task if there's one for this site_instance AND
   // if this is not the main frame or we did record a main frame for the entry.
   if (!site_instance_exists || (is_main_frame && !site_instance_is_main)) {
     if (is_main_frame) {
       const WebContentsTag* tag =
           WebContentsTag::FromWebContents(web_contents());
@@ skipping 69 matching lines @@
 }
 
 void WebContentsTaskProvider::OnWebContentsTagCreated(
     const WebContentsTag* tag) {
   DCHECK(tag);
   content::WebContents* web_contents = tag->web_contents();
   DCHECK(web_contents);
 
   // TODO(afakhry): Check if we need this check. It seems that we no longer
   // need it in the new implementation.
-  if (HasWebContents(web_contents)) {
+  std::unique_ptr<WebContentsEntry>& entry = entries_map_[web_contents];
+  if (entry) {
     // This case may happen if we added a WebContents while collecting all the
     // pre-existing ones at the time |StartUpdating()| was called, but the
     // notification of its connection hasn't been fired yet. In this case we
     // ignore it since we're already tracking it.
     return;
   }
 
-  WebContentsEntry* entry = new WebContentsEntry(web_contents, this);
-  entries_map_[web_contents] = entry;
+  entry.reset(new WebContentsEntry(web_contents, this));
   entry->CreateAllTasks();
 }
 
 void WebContentsTaskProvider::OnWebContentsTagRemoved(
     const WebContentsTag* tag) {
   DCHECK(tag);
   content::WebContents* web_contents = tag->web_contents();
   DCHECK(web_contents);
 
   auto itr = entries_map_.find(web_contents);
   DCHECK(itr != entries_map_.end());
-  WebContentsEntry* entry = itr->second;
 
   // Must manually clear the tasks and notify the observer.
-  entry->ClearAllTasks(true);
-  entries_map_.erase(itr);
-  delete entry;
+  itr->second->ClearAllTasks(true);
+  entries_map_.erase(itr);  // Deletes the WebContentsEntry.
 }
 
 Task* WebContentsTaskProvider::GetTaskOfUrlRequest(int origin_pid,
                                                    int child_id,
                                                    int route_id) {
   // If an origin PID was specified then the URL request originated in a plugin
   // working on the WebContents' behalf, so ignore it.
   if (origin_pid)
     return nullptr;
 
   content::RenderFrameHost* rfh =
       content::RenderFrameHost::FromID(child_id, route_id);
   content::WebContents* web_contents =
       content::WebContents::FromRenderFrameHost(rfh);
 
   auto itr = entries_map_.find(web_contents);
   if (itr == entries_map_.end()) {
     // Can happen if the tab was closed while a network request was being
     // performed.
     return nullptr;
   }
 
   return itr->second->GetTaskForFrame(rfh);
 }
 
 bool WebContentsTaskProvider::HasWebContents(
     content::WebContents* web_contents) const {
-  return ContainsKey(entries_map_, web_contents);
+  return entries_map_.count(web_contents) != 0;
 }
 
 void WebContentsTaskProvider::StartUpdating() {
   is_updating_ = true;
 
   // 1- Collect all pre-existing WebContents from the WebContentsTagsManager.
   WebContentsTagsManager* tags_manager = WebContentsTagsManager::GetInstance();
   for (const auto* tag : tags_manager->tracked_tags())
     OnWebContentsTagCreated(tag);
 
   // 2- Start observing newly connected ones.
   tags_manager->SetProvider(this);
 }
 
 void WebContentsTaskProvider::StopUpdating() {
   is_updating_ = false;
 
   // 1- Stop observing.
   WebContentsTagsManager::GetInstance()->ClearProvider();
 
   // 2- Clear storage.
-  STLDeleteValues(&entries_map_);
+  entries_map_.clear();
 }
 
 void WebContentsTaskProvider::DeleteEntry(content::WebContents* web_contents) {
-  auto itr = entries_map_.find(web_contents);
-  if (itr == entries_map_.end()) {
-    NOTREACHED();
-    return;
-  }
-
-  WebContentsEntry* entry = itr->second;
-  entries_map_.erase(itr);
-
-  // The entry we're about to delete is our caller, however its' still fine to
-  // delete it.
-  delete entry;
+  // This erase() will delete the WebContentsEntry, which is actually our
+  // caller, but it's expecting us to delete it.
+  bool success = entries_map_.erase(web_contents) != 0;
+  DCHECK(success);
 }
 
 }  // namespace task_management