New Task Manager - Phase 1.3.2.B: Implement Tab Contents Task Providing (Prerender)

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/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"
@@ skipping 17 matching lines @@
 class WebContentsEntry : public content::WebContentsObserver {
  public:
   WebContentsEntry(content::WebContents* web_contents,
                    WebContentsTaskProvider* provider);
   ~WebContentsEntry() override;
 
   // Creates all the tasks associated with each |RenderFrameHost| in this
   // entry's WebContents.
   void CreateAllTasks();
 
+  // Clears all the tasks in this entry. The provider's observer will be
+  // notified if |notify_observer| is true.
+  void ClearAllTasks(bool notify_observer);
+
   // Returns the |RendererTask| that corresponds to the given
   // |render_frame_host| or |nullptr| if the given frame is not tracked by this
   // entry.
   RendererTask* GetTaskForFrame(RenderFrameHost* render_frame_host) const;
 
   // content::WebContentsObserver:
   void RenderFrameDeleted(RenderFrameHost* render_frame_host) override;
   void RenderFrameHostChanged(RenderFrameHost* old_host,
                               RenderFrameHost* new_host) override;
   void RenderViewReady() override;
   void WebContentsDestroyed() override;
   void RenderProcessGone(base::TerminationStatus status) override;
   void TitleWasSet(content::NavigationEntry* entry, bool explicit_set) override;
   void DidUpdateFaviconURL(
       const std::vector<content::FaviconURL>& candidates) override;
 
  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);
 
-  // Clears all the tasks in this entry. The provider's observer will be
-  // notified if |notify_observer| is true.
-  void ClearAllTasks(bool notify_observer);
-
   // The provider that owns this entry.
   WebContentsTaskProvider* provider_;
 
   // The RenderFrameHosts associated with this entry's WebContents that we're
   // tracking mapped by their SiteInstances.
   typedef std::vector<RenderFrameHost*> FramesList;
   typedef std::map<SiteInstance*, FramesList> SiteInstanceToFramesMap;
   SiteInstanceToFramesMap frames_by_site_instance_;
 
   // The RendererTasks that we create for the task manager, mapped by their
@@ skipping 21 matching lines @@
 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 (auto& pair : frames_by_site_instance_) {
+    FramesList& frames_list = pair.second;
+    DCHECK(!frames_list.empty());
+    RendererTask* task = tasks_by_frames_[frames_list[0]];
+    if (notify_observer)
+      provider_->NotifyObserverTaskRemoved(task);
+    delete task;
+  }
+
+  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())
     return nullptr;
 
   return itr->second;
 }
 
 void WebContentsEntry::RenderFrameDeleted(RenderFrameHost* render_frame_host) {
@@ skipping 112 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::ClearAllTasks(bool notify_observer) {
-  for (auto& pair : frames_by_site_instance_) {
-    FramesList& frames_list = pair.second;
-    DCHECK(!frames_list.empty());
-    RendererTask* task = tasks_by_frames_[frames_list[0]];
-    if (notify_observer)
-      provider_->NotifyObserverTaskRemoved(task);
-    delete task;
-  }
-
-  frames_by_site_instance_.clear();
-  tasks_by_frames_.clear();
-  main_frame_site_instance_ = nullptr;
-}
-
 ////////////////////////////////////////////////////////////////////////////////
 
 WebContentsTaskProvider::WebContentsTaskProvider() : entries_map_() {
 }
 
 WebContentsTaskProvider::~WebContentsTaskProvider() {
   STLDeleteValues(&entries_map_);
 }
 
-void WebContentsTaskProvider::OnWebContentsTagCreated(WebContentsTag* tag) {
+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 (entries_map_.count(web_contents)) {
     // 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->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;
+}
+
 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);
@@ skipping 42 matching lines @@
 
   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;
 }
 
 }  // namespace task_management