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);

[gavinp, 2015/06/22 18:38:04]

Nit: I think the method definition should move to as well to keep in style, see
https://google-styleguide.googlecode.com/svn/trunk/cppguide.html#Declaration_...
. 

[afakhry, 2015/06/22 21:56:18]

Thanks for catching that! I forgot to do it.
Done!

+
   // 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 177 matching lines @@
 
 ////////////////////////////////////////////////////////////////////////////////
 
 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