Add ref-count on RenderViewHost for each new RenderFrameProxyHost.

content/browser/frame_host/frame_tree.cc

 // Copyright 2013 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 "content/browser/frame_host/frame_tree.h"
 
 #include <queue>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 281 matching lines @@
 }
 
 RenderViewHostImpl* FrameTree::GetRenderViewHost(SiteInstance* site_instance) {
   RenderViewHostMap::iterator iter =
       render_view_host_map_.find(site_instance->GetId());
   if (iter == render_view_host_map_.end())
     return nullptr;
   return iter->second;
 }
 
-void FrameTree::RegisterRenderFrameHost(
-    RenderFrameHostImpl* render_frame_host) {
-  SiteInstance* site_instance = render_frame_host->GetSiteInstance();
+void FrameTree::RegisterRenderViewHost(
+    RenderViewHostImpl* render_view_host) {
+  SiteInstance* site_instance = render_view_host->GetSiteInstance();
   RenderViewHostMap::iterator iter =
       render_view_host_map_.find(site_instance->GetId());

[Charlie Reis, 2015/05/20 23:05:00]

I'm trying to remember from our chat: did we decide it's ok to keep the map on
FrameTree, even though the RVH may not have any RFHs in the tree?  I think so,
since the RVH is still associated with the tree and will have an RFPH in the
tree in that case.

[nasko, 2015/05/21 16:22:12]

I'm not sure if we discussed it explicitly, but I think the map should stay in
the FrameTree. All RVHs in that map are associated with objects in this
FrameTree, so it doesn't make sense to move it.
I'll leave it as is.

[Charlie Reis, 2015/05/21 18:48:16]

Acknowledged.

   CHECK(iter != render_view_host_map_.end());
+  CHECK(iter->second == render_view_host);
 
   iter->second->increment_ref_count();
 }
 
-void FrameTree::UnregisterRenderFrameHost(
-    RenderFrameHostImpl* render_frame_host) {
-  SiteInstance* site_instance = render_frame_host->GetSiteInstance();
+void FrameTree::UnregisterRenderViewHost(
+    RenderViewHostImpl* render_view_host) {
+  SiteInstance* site_instance = render_view_host->GetSiteInstance();
   int32 site_instance_id = site_instance->GetId();
   RenderViewHostMap::iterator iter =
       render_view_host_map_.find(site_instance_id);
-  if (iter != render_view_host_map_.end() &&
-      iter->second == render_frame_host->render_view_host()) {
+  if (iter != render_view_host_map_.end() && iter->second == render_view_host) {
     // Decrement the refcount and shutdown the RenderViewHost if no one else is
     // using it.
     CHECK_GT(iter->second->ref_count(), 0);
     iter->second->decrement_ref_count();
     if (iter->second->ref_count() == 0) {
       iter->second->Shutdown();
       render_view_host_map_.erase(iter);
     }
   } else {
     // The RenderViewHost should be in the list of RenderViewHosts pending
     // shutdown.
     bool render_view_host_found = false;
     std::pair<RenderViewHostMultiMap::iterator,
               RenderViewHostMultiMap::iterator> result =
         render_view_host_pending_shutdown_map_.equal_range(site_instance_id);
     for (RenderViewHostMultiMap::iterator multi_iter = result.first;
          multi_iter != result.second;
          ++multi_iter) {
-      if (multi_iter->second != render_frame_host->render_view_host())
+      if (multi_iter->second != render_view_host)
         continue;
       render_view_host_found = true;
-      RenderViewHostImpl* rvh = multi_iter->second;
       // Decrement the refcount and shutdown the RenderViewHost if no one else
       // is using it.
-      CHECK_GT(rvh->ref_count(), 0);
-      rvh->decrement_ref_count();
-      if (rvh->ref_count() == 0) {
-        rvh->Shutdown();
+      CHECK_GT(render_view_host->ref_count(), 0);
+      render_view_host->decrement_ref_count();
+      if (render_view_host->ref_count() == 0) {
+        render_view_host->Shutdown();
         render_view_host_pending_shutdown_map_.erase(multi_iter);
       }
       break;
     }
     CHECK(render_view_host_found);
   }
 }
 
 void FrameTree::FrameRemoved(FrameTreeNode* frame) {
   if (frame->frame_tree_node_id() == focused_frame_tree_node_id_)
@@ skipping 31 matching lines @@
   load_progress_ = 0.0;
 }
 
 bool FrameTree::IsLoading() {
   bool is_loading = false;
   ForEach(base::Bind(&IsNodeLoading, &is_loading));
   return is_loading;
 }
 
 }  // namespace content