[DRAFT] Create RenderFrameHostManager.

content/browser/renderer_host/render_view_host_impl.cc

 // Copyright (c) 2012 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/renderer_host/render_view_host_impl.h"
 
 #include <set>
 #include <string>
 #include <utility>
 #include <vector>
@@ skipping 155 matching lines @@
                            routing_id,
                            hidden),
       delegate_(delegate),
       instance_(static_cast<SiteInstanceImpl*>(instance)),
       waiting_for_drag_context_response_(false),
       enabled_bindings_(0),
       navigations_suspended_(false),
       has_accessed_initial_document_(false),
       is_swapped_out_(swapped_out),
       is_subframe_(false),
-      main_frame_id_(-1),
+      main_frame_routing_id_(main_frame_routing_id),
       run_modal_reply_msg_(NULL),
       run_modal_opener_id_(MSG_ROUTING_NONE),
       is_waiting_for_beforeunload_ack_(false),
       is_waiting_for_unload_ack_(false),
       has_timed_out_on_unload_(false),
       unload_ack_is_for_cross_site_transition_(false),
       are_javascript_messages_suppressed_(false),
       sudden_termination_allowed_(false),
       render_view_termination_status_(base::TERMINATION_STATUS_STILL_RUNNING) {
   DCHECK(instance_.get());
   CHECK(delegate_);  // http://crbug.com/82827
 
-  if (main_frame_routing_id == MSG_ROUTING_NONE)
-    main_frame_routing_id = GetProcess()->GetNextRoutingID();
-
-  main_render_frame_host_.reset(
-      new RenderFrameHostImpl(this, delegate_->GetFrameTree(),
-                              main_frame_routing_id, is_swapped_out_));
-
   GetProcess()->EnableSendQueue();
 
   if (!swapped_out)
     instance_->increment_active_view_count();
 
   if (ResourceDispatcherHostImpl::Get()) {
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
         base::Bind(&ResourceDispatcherHostImpl::OnRenderViewHostCreated,
                    base::Unretained(ResourceDispatcherHostImpl::Get()),
                    GetProcess()->GetID(), GetRoutingID()));
   }
+  LOG(INFO) << "NEW RVH: process " << GetProcess()->GetID() <<
+      ", route " << GetRoutingID() << ", SID " <<
+      instance_->GetId() << ", site " << instance_->GetSiteURL();
 
 #if defined(OS_ANDROID)
   media_player_manager_.reset(BrowserMediaPlayerManager::Create(this));
 #endif
 }
 
 RenderViewHostImpl::~RenderViewHostImpl() {
+  LOG(INFO) << "DELETE RVH: process " << GetProcess()->GetID() <<
+      ", route " << GetRoutingID() << ", SID " << instance_->GetId();
   if (ResourceDispatcherHostImpl::Get()) {
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
         base::Bind(&ResourceDispatcherHostImpl::OnRenderViewHostDeleted,
                    base::Unretained(ResourceDispatcherHostImpl::Get()),
                    GetProcess()->GetID(), GetRoutingID()));
   }
 
   delegate_->RenderViewDeleted(this);
 
   // Be sure to clean up any leftover state from cross-site requests.
   CrossSiteRequestManager::GetInstance()->SetHasPendingCrossSiteRequest(
       GetProcess()->GetID(), GetRoutingID(), false);
 
   // If this was swapped out, it already decremented the active view
   // count of the SiteInstance it belongs to.
   if (!is_swapped_out_)
     instance_->decrement_active_view_count();
 }
 
 RenderViewHostDelegate* RenderViewHostImpl::GetDelegate() const {
   return delegate_;
 }
 
 SiteInstance* RenderViewHostImpl::GetSiteInstance() const {
   return instance_.get();
 }
 
+void RenderViewHostImpl::RegisterRenderFrameHost(
+    RenderFrameHostImpl* render_frame_host) {
+  LOG(INFO) << "RVH incrementing refcount with instance " <<
+      instance_->GetId() << " for " << instance_->GetSiteURL();
+  CHECK(rfh_list_.find(render_frame_host) == rfh_list_.end());
+  rfh_list_.insert(render_frame_host);
+}
+
+void RenderViewHostImpl::UnregisterRenderFrameHost(
+    RenderFrameHostImpl* render_frame_host) {
+  LOG(INFO) << "RVH decrementing refcount with instance " <<
+      instance_->GetId() << " for " << instance_->GetSiteURL();
+  CHECK(rfh_list_.find(render_frame_host) != rfh_list_.end());
+  rfh_list_.erase(render_frame_host);
+  if (rfh_list_.size() == 0)
+    Shutdown();
+}
+
+void RenderViewHostImpl::RegisterFrameID(int64 frame_id,
+                                         int64 frame_tree_node_id) {
+  frame_id_map_[frame_id] = frame_tree_node_id;
+}
+
+void RenderViewHostImpl::UnregisterFrameID(int64 frame_id) {
+  CHECK(HasFrameID(frame_id));
+  frame_id_map_.erase(frame_id);
+}
+
+bool RenderViewHostImpl::HasFrameID(int64 frame_id) const {
+  return frame_id_map_.find(frame_id) != frame_id_map_.end();
+}
+
+int64 RenderViewHostImpl::GetFrameTreeNodeID(int64 frame_id) {
+  return frame_id_map_[frame_id];
+}
+
+int64 RenderViewHostImpl::GetFrameIDForTesting(int64 frame_tree_node_id) const {
+  for (FrameIDMap::const_iterator iter = frame_id_map_.begin();
+       iter != frame_id_map_.end();
+       iter++) {
+    if (iter->second == frame_tree_node_id)
+      return iter->first;
+  }
+  return -1;
+}
+
 bool RenderViewHostImpl::CreateRenderView(
     const string16& frame_name,
     int opener_route_id,
     int32 max_page_id) {
   TRACE_EVENT0("renderer_host", "RenderViewHostImpl::CreateRenderView");
   DCHECK(!IsRenderViewLive()) << "Creating view twice";
 
   // The process may (if we're sharing a process with another host that already
   // initialized it) or may not (we have our own process or the old process
   // crashed) have been initialized. Calling Init multiple times will be
@@ skipping 12 matching lines @@
   // page ID it might be asked to render.
   int32 next_page_id = 1;
   if (max_page_id > -1)
     next_page_id = max_page_id + 1;
 
   ViewMsg_New_Params params;
   params.renderer_preferences =
       delegate_->GetRendererPrefs(GetProcess()->GetBrowserContext());
   params.web_preferences = delegate_->GetWebkitPrefs();
   params.view_id = GetRoutingID();
-  params.main_frame_routing_id = main_render_frame_host()->routing_id();
+  params.main_frame_routing_id = main_frame_routing_id_;
   params.surface_id = surface_id();
   params.session_storage_namespace_id =
       delegate_->GetSessionStorageNamespace(instance_)->id();
   params.frame_name = frame_name;
   // Ensure the RenderView sets its opener correctly.
   params.opener_route_id = opener_route_id;
   params.swapped_out = is_swapped_out_;
   params.hidden = is_hidden();
   params.next_page_id = next_page_id;
   GetWebScreenInfo(&params.screen_info);
@@ skipping 377 matching lines @@
   }
 }
 
 void RenderViewHostImpl::OnCrossSiteResponse(
     const GlobalRequestID& global_request_id,
     bool is_transfer,
     const std::vector<GURL>& transfer_url_chain,
     const Referrer& referrer,
     PageTransition page_transition,
     int64 frame_id) {
-  RenderViewHostDelegate::RendererManagement* manager =
-      delegate_->GetRendererManagementDelegate();
+  FrameTreeNode* node = NULL;
+  if (frame_id != -1) {
+    CHECK(HasFrameID(frame_id));
+    int64 frame_tree_node_id = GetFrameTreeNodeID(frame_id);
+    node = delegate_->GetFrameTree()->FindByID(frame_tree_node_id);
+  }
+
+  // TODO(creis): We should always be able to get the RFHM for a frame_id,
+  // but today the frame_id is -1 for the main frame.
+  RenderViewHostDelegate::RendererManagement* manager = node ?
+      node->render_manager() : delegate_->GetRenderManager();
+  CHECK(manager);
   if (manager) {
     manager->OnCrossSiteResponse(this, global_request_id, is_transfer,
                                  transfer_url_chain, referrer, page_transition,
                                  frame_id);
   }
 }
 
 void RenderViewHostImpl::SuppressDialogsUntilSwapOut() {
   Send(new ViewMsg_SuppressDialogsUntilSwapOut(GetRoutingID()));
 }
@@ skipping 580 matching lines @@
     // Kill the renderer.
     RecordAction(UserMetricsAction("BadMessageTerminate_RVH"));
     GetProcess()->ReceivedBadMessage();
   }
 
   return handled;
 }
 
 void RenderViewHostImpl::Init() {
   RenderWidgetHostImpl::Init();
-  main_render_frame_host()->Init();
+  // TODO(creis): The caller of this should call Init on the RFH as well.
+  //main_render_frame_host()->Init();
 }
 
 void RenderViewHostImpl::Shutdown() {
   // If we are being run modally (see RunModal), then we need to cleanup.
   if (run_modal_reply_msg_) {
     Send(run_modal_reply_msg_);
     run_modal_reply_msg_ = NULL;
     RenderViewHostImpl* opener =
         RenderViewHostImpl::FromID(GetProcess()->GetID(), run_modal_opener_id_);
     if (opener) {
@@ skipping 89 matching lines @@
   delegate_->RenderViewReady(this);
 }
 
 void RenderViewHostImpl::OnRenderProcessGone(int status, int exit_code) {
   // Keep the termination status so we can get at it later when we
   // need to know why it died.
   render_view_termination_status_ =
       static_cast<base::TerminationStatus>(status);
 
   // Reset state.
-  main_frame_id_ = -1;
+  frame_id_map_.clear();
 
   // Our base class RenderWidgetHost needs to reset some stuff.
   RendererExited(render_view_termination_status_, exit_code);
 
   delegate_->RenderViewTerminated(this,
                                   static_cast<base::TerminationStatus>(status),
                                   exit_code);
 }
 
 void RenderViewHostImpl::OnDidStartProvisionalLoadForFrame(
@@ skipping 53 matching lines @@
   // Navigate message, then the renderer was navigating before it received the
   // unload request.  It will either respond to the unload request soon or our
   // timer will expire.  Either way, we should ignore this message, because we
   // have already committed to closing this renderer.
   if (is_waiting_for_unload_ack_)
     return;
 
   // Cache the main frame id, so we can use it for creating the frame tree
   // root node when needed.
   if (PageTransitionIsMainFrame(validated_params.transition)) {
-    if (main_frame_id_ == -1) {
-      main_frame_id_ = validated_params.frame_id;
+    int frame_tree_node_id =
+        delegate_->GetFrameTree()->root()->frame_tree_node_id();
+    if (!HasFrameID(validated_params.frame_id)) {
+      RegisterFrameID(validated_params.frame_id, frame_tree_node_id);
     } else {
       // TODO(nasko): We plan to remove the usage of frame_id in navigation
       // and move to routing ids. This is in place to ensure that a
       // renderer is not misbehaving and sending us incorrect data.
-      DCHECK_EQ(main_frame_id_, validated_params.frame_id);
+      DCHECK_EQ(frame_tree_node_id,
+                GetFrameTreeNodeID(validated_params.frame_id));
     }
   }
   RenderProcessHost* process = GetProcess();
 
   // Attempts to commit certain off-limits URL should be caught more strictly
   // than our FilterURL checks below.  If a renderer violates this policy, it
   // should be killed.
   if (!CanCommitURL(validated_params.url)) {
     VLOG(1) << "Blocked URL " << validated_params.url.spec();
     validated_params.url = GURL(kAboutBlankURL);
@@ skipping 327 matching lines @@
   StopHangMonitorTimeout();
   // If this renderer navigated while the beforeunload request was in flight, we
   // may have cleared this state in OnNavigate, in which case we can ignore
   // this message.
   if (!is_waiting_for_beforeunload_ack_ || is_swapped_out_)
     return;
 
   is_waiting_for_beforeunload_ack_ = false;
 
   RenderViewHostDelegate::RendererManagement* management_delegate =
-      delegate_->GetRendererManagementDelegate();
+      delegate_->GetRenderManager();
   if (management_delegate) {
     base::TimeTicks before_unload_end_time;
     if (!send_should_close_start_time_.is_null() &&
         !renderer_before_unload_start_time.is_null() &&
         !renderer_before_unload_end_time.is_null()) {
       // When passing TimeTicks across process boundaries, we need to compensate
       // for any skew between the processes. Here we are converting the
       // renderer's notion of before_unload_end_time to TimeTicks in the browser
       // process. See comments in inter_process_time_ticks_converter.h for more.
       InterProcessTimeTicksConverter converter(
@@ skipping 443 matching lines @@
 
   const std::vector<base::FilePath>& file_paths = state.GetReferencedFiles();
   for (std::vector<base::FilePath>::const_iterator file = file_paths.begin();
        file != file_paths.end(); ++file) {
     if (!policy->CanReadFile(GetProcess()->GetID(), *file))
       return false;
   }
   return true;
 }
 
-void RenderViewHostImpl::AttachToFrameTree() {
-  FrameTree* frame_tree = delegate_->GetFrameTree();
-
-  frame_tree->SwapMainFrame(main_render_frame_host_.get());
-  if (main_frame_id() != FrameTreeNode::kInvalidFrameId) {
-    frame_tree->OnFirstNavigationAfterSwap(main_frame_id());
-  }
-}
-
 }  // namespace content