Improve TDI render process naming in the task manager.

chrome/browser/task_manager/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_manager/providers/web_contents/web_contents_task_provider.h"
 
 #include "base/bind.h"
 #include "base/macros.h"
 #include "chrome/browser/task_manager/providers/web_contents/subframe_task.h"
 #include "chrome/browser/task_manager/providers/web_contents/web_contents_tags_manager.h"
@@ skipping 50 matching lines @@
  private:
   // Defines a callback for WebContents::ForEachFrame() to create a
   // corresponding task for the given |render_frame_host| and notifying the
   // provider's observer of the new task.
   void CreateTaskForFrame(RenderFrameHost* render_frame_host);
 
   // Clears the task that corresponds to the given |render_frame_host| and
   // notifies the provider's observer of the tasks removal.
   void ClearTaskForFrame(RenderFrameHost* render_frame_host);
 
+  // Calls |on_task| for each task managed by this WebContentsEntry.
+  void ForEachTask(const base::Callback<void(RendererTask*)>& on_task);
+
   // The provider that owns this entry.
   WebContentsTaskProvider* provider_;
 
   // The RenderFrameHosts associated with this entry's WebContents that we're
   // tracking mapped by their SiteInstances.
   using FramesList = std::vector<RenderFrameHost*>;
-  using SiteInstanceToFramesMap = std::map<SiteInstance*, FramesList>;
-  SiteInstanceToFramesMap frames_by_site_instance_;
+  std::map<SiteInstance*, FramesList> frames_by_site_instance_;
 
   // The RendererTasks that we create for the task manager, mapped by their
-  // RenderFrameHosts.
-  using FramesToTasksMap = std::map<RenderFrameHost*, RendererTask*>;
-  FramesToTasksMap tasks_by_frames_;
+  // RenderFrameHosts. This owns the RenderTasks.
+  std::map<RenderFrameHost*, RendererTask*> tasks_by_frames_;
 
   // States whether we did record a main frame for this entry.
   SiteInstance* main_frame_site_instance_;
 
   DISALLOW_COPY_AND_ASSIGN(WebContentsEntry);
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 
 WebContentsEntry::WebContentsEntry(content::WebContents* web_contents,
                                    WebContentsTaskProvider* provider)
     : WebContentsObserver(web_contents),
       provider_(provider),
       main_frame_site_instance_(nullptr) {
 }
 
 WebContentsEntry::~WebContentsEntry() {
   ClearAllTasks(false);
 }
 
 void WebContentsEntry::CreateAllTasks() {
   DCHECK(web_contents()->GetMainFrame());
   web_contents()->ForEachFrame(base::Bind(&WebContentsEntry::CreateTaskForFrame,
                                           base::Unretained(this)));
 }
 
 void WebContentsEntry::ClearAllTasks(bool notify_observer) {
-  for (const auto& pair : frames_by_site_instance_) {
-    const FramesList& frames_list = pair.second;
-    DCHECK(!frames_list.empty());
-    RendererTask* task = tasks_by_frames_[frames_list[0]];
+  ForEachTask(base::Bind(
+      [](WebContentsTaskProvider* provider, bool notify_observer,
+         content::WebContents* web_contents, RendererTask* task) {
+        task->set_termination_status(web_contents->GetCrashedStatus());
+        task->set_termination_error_code(web_contents->GetCrashedErrorCode());
 
-    task->set_termination_status(web_contents()->GetCrashedStatus());
-    task->set_termination_error_code(web_contents()->GetCrashedErrorCode());
-
-    if (notify_observer)
-      provider_->NotifyObserverTaskRemoved(task);
-    delete task;
-  }
+        if (notify_observer)
+          provider->NotifyObserverTaskRemoved(task);
+        delete task;
+      },
+      provider_, notify_observer, web_contents()));
 
   frames_by_site_instance_.clear();
   tasks_by_frames_.clear();
   main_frame_site_instance_ = nullptr;
 }
 
 RendererTask* WebContentsEntry::GetTaskForFrame(
     RenderFrameHost* render_frame_host) const {
   auto itr = tasks_by_frames_.find(render_frame_host);
   if (itr == tasks_by_frames_.end())
@@ skipping 33 matching lines @@
     return;
 
   DCHECK_EQ(render_widget_host->GetProcess(),
             web_contents()->GetMainFrame()->GetProcess());
 
   provider_->NotifyObserverTaskUnresponsive(task);
 }
 
 void WebContentsEntry::DidFinishNavigation(
     content::NavigationHandle* navigation_handle) {
-  RendererTask* task = GetTaskForFrame(web_contents()->GetMainFrame());
-  if (!task)
+  RendererTask* main_frame_task =
+      GetTaskForFrame(web_contents()->GetMainFrame());
+  if (!main_frame_task)
     return;
 
-  // Listening to WebContentsObserver::TitleWasSet() only is not enough in
-  // some cases when the the webpage doesn't have a title. That's why we update
-  // the title here as well.
-  task->UpdateTitle();
+  main_frame_task->UpdateRapporSampleName();
 
-  // Call RendererTask::UpdateFavicon() to set the current favicon to the
-  // default favicon. If the page has a non-default favicon,
-  // RendererTask::OnFaviconUpdated() will update the current favicon once
-  // FaviconDriver figures out the correct favicon for the page.
-  task->UpdateFavicon();
-  task->UpdateRapporSampleName();
+  ForEachTask(base::Bind([](RendererTask* task) {
+    // Listening to WebContentsObserver::TitleWasSet() only is not enough in
+    // some cases when the the web page doesn't have a title. That's why we
+    // update the title here as well.
+    task->UpdateTitle();
+
+    // Call RendererTask::UpdateFavicon() to set the current favicon to the
+    // default favicon. If the page has a non-default favicon,
+    // RendererTask::OnFaviconUpdated() will update the current favicon once
+    // FaviconDriver figures out the correct favicon for the page.
+    task->UpdateFavicon();
+  }));
 }
 
 void WebContentsEntry::TitleWasSet(content::NavigationEntry* entry,
                                    bool explicit_set) {
-  RendererTask* task = GetTaskForFrame(web_contents()->GetMainFrame());
-  if (!task)
-    return;
-
-  task->UpdateTitle();
-  task->UpdateFavicon();
+  ForEachTask(base::Bind([](RendererTask* task) {
+    task->UpdateTitle();
+    task->UpdateFavicon();
+  }));
 }
 
 void WebContentsEntry::CreateTaskForFrame(RenderFrameHost* 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 =
@@ skipping 60 matching lines @@
   if (frames.empty()) {
     frames_by_site_instance_.erase(site_instance);
     provider_->NotifyObserverTaskRemoved(task);
     delete task;
 
     if (site_instance == main_frame_site_instance_)
       main_frame_site_instance_ = nullptr;
   }
 }
 
+void WebContentsEntry::ForEachTask(
+    const base::Callback<void(RendererTask*)>& on_task) {
+  for (const auto& pair : frames_by_site_instance_) {
+    const FramesList& frames_list = pair.second;
+    DCHECK(!frames_list.empty());
+    RendererTask* task = tasks_by_frames_[frames_list[0]];
+
+    on_task.Run(task);
+  }
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 
 WebContentsTaskProvider::WebContentsTaskProvider()
     : is_updating_(false) {
 }
 
 WebContentsTaskProvider::~WebContentsTaskProvider() {
   if (is_updating_) {
     StopUpdating();
   }
@@ skipping 85 matching lines @@
 }
 
 void WebContentsTaskProvider::DeleteEntry(content::WebContents* web_contents) {
   // 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_manager