[DRAFT] Create RenderFrameHostManager.

content/browser/frame_host/render_frame_host_manager.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/render_frame_host_manager.h"
 
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
@@ skipping 89 matching lines @@
                                   int view_routing_id,
                                   int frame_routing_id) {
   // Create a RenderViewHost and RenderFrameHost, once we have an instance.  It
   // is important to immediately give this SiteInstance to a RenderViewHost so
   // that the SiteInstance is ref counted.
   if (!site_instance)
     site_instance = SiteInstance::Create(browser_context);
 
   // TODO(creis): Make render_frame_host_ a scoped_ptr.
   render_frame_host_ = CreateRenderFrameHost(site_instance, view_routing_id,
-                                             frame_routing_id, false, false);
+                                             frame_routing_id, false,
+                                             delegate_->IsHidden());
 
   // Keep track of renderer processes as they start to shut down or are
   // crashed/killed.
   registrar_.Add(this, NOTIFICATION_RENDERER_PROCESS_CLOSED,
                  NotificationService::AllSources());
   registrar_.Add(this, NOTIFICATION_RENDERER_PROCESS_CLOSING,
                  NotificationService::AllSources());
 }
 
 RenderViewHostImpl* RenderFrameHostManager::current_host() const {
@@ skipping 65 matching lines @@
 
     // Now that we've created a new renderer, be sure to hide it if it isn't
     // our primary one.  Otherwise, we might crash if we try to call Show()
     // on it later.
     if (dest_render_frame_host != render_frame_host_ &&
         dest_render_frame_host->render_view_host()->GetView()) {
       dest_render_frame_host->render_view_host()->GetView()->Hide();
     } else {
       // This is our primary renderer, notify here as we won't be calling
       // CommitPending (which does the notify).
+      // TODO(creis): only do this for top-level frames, when the RVH changes.
       delegate_->NotifySwappedFromRenderManager(
           NULL, render_frame_host_->render_view_host());
     }
   }
 
   // TODO(creis): Return the RFH instead, once we can navigate RFHs.
   return dest_render_frame_host->render_view_host();
 }
 
 void RenderFrameHostManager::Stop() {
@@ skipping 41 matching lines @@
     // in this case because it took too long.
     if (pending_render_frame_host_->render_view_host()->
             are_navigations_suspended()) {
       pending_render_frame_host_->render_view_host()->SetNavigationsSuspended(
           false, base::TimeTicks::Now());
     }
   }
   return false;
 }
 
-// TODO(creis): This should take in a RenderFrameHost.
+// TODO(creis): Remove this in favor of SwappedOutFrame.
 void RenderFrameHostManager::SwappedOut(RenderViewHost* render_view_host) {
   // Make sure this is from our current RVH, and that we have a pending
   // navigation from OnCrossSiteResponse.  (There may be no pending navigation
   // for data URLs that don't make network requests, for example.)   If not,
   // just return early and ignore.
   if (render_view_host != render_frame_host_->render_view_host() ||
       !pending_nav_params_.get()) {
     pending_nav_params_.reset();
     return;
   }
 
+  // We should probably sanity check that this is for the correct frame.
+  // TODO(creis): Is this frame ID trusted?  Which frame is it for?
+  //DCHECK_EQ(frame_tree_node_->GetID()?, pending_nav_params_->frame_id);
+
   // Now that the unload handler has run, we need to either initiate the
   // pending transfer (if there is one) or resume the paused response (if not).
   // TODO(creis): The blank swapped out page is visible during this time, but
   // we can shorten this by delivering the response directly, rather than
   // forcing an identical request to be made.
   if (pending_nav_params_->is_transfer) {
     // Treat the last URL in the chain as the destination and the remainder as
     // the redirect chain.
     CHECK(pending_nav_params_->transfer_url_chain.size());
     GURL transfer_url = pending_nav_params_->transfer_url_chain.back();
     pending_nav_params_->transfer_url_chain.pop_back();
 
     // We don't know whether the original request had |user_action| set to true.
     // However, since we force the navigation to be in the current tab, it
     // doesn't matter.
+    // TODO(creis): Move RequestTransferURL to RenderFrameHost's navigator.
     render_view_host->GetDelegate()->RequestTransferURL(
         transfer_url,
         pending_nav_params_->transfer_url_chain,
         pending_nav_params_->referrer,
         pending_nav_params_->page_transition,
         CURRENT_TAB,
         pending_nav_params_->frame_id,
         pending_nav_params_->global_request_id,
         pending_nav_params_->should_replace_current_entry,
         true);
   } else if (pending_render_frame_host_) {
     RenderProcessHostImpl* pending_process =
         static_cast<RenderProcessHostImpl*>(
             pending_render_frame_host_->GetProcess());
     pending_process->ResumeDeferredNavigation(
         pending_nav_params_->global_request_id);
   }
   pending_nav_params_.reset();
 }
 
+void RenderFrameHostManager::SwappedOutFrame(
+    RenderFrameHostImpl* render_frame_host) {
+  // Make sure this is from our current RFH, and that we have a pending
+  // navigation from OnCrossSiteResponse.  (There may be no pending navigation
+  // for data URLs that don't make network requests, for example.)   If not,
+  // just return early and ignore.
+  if (render_frame_host != render_frame_host_ || !pending_nav_params_.get()) {
+    pending_nav_params_.reset();
+    return;
+  }
+
+  // We should probably sanity check that this is for the correct frame.
+  // TODO(creis): Is this frame ID trusted?  Which frame is it for?
+  //DCHECK_EQ(frame_tree_node_->GetID()?, pending_nav_params_->frame_id);
+
+  // Now that the unload handler has run, we need to either initiate the
+  // pending transfer (if there is one) or resume the paused response (if not).
+  // TODO(creis): The blank swapped out page is visible during this time, but
+  // we can shorten this by delivering the response directly, rather than
+  // forcing an identical request to be made.
+  if (pending_nav_params_->is_transfer) {
+    // Treat the last URL in the chain as the destination and the remainder as
+    // the redirect chain.
+    CHECK(pending_nav_params_->transfer_url_chain.size());
+    GURL transfer_url = pending_nav_params_->transfer_url_chain.back();
+    pending_nav_params_->transfer_url_chain.pop_back();
+
+    // We don't know whether the original request had |user_action| set to true.
+    // However, since we force the navigation to be in the current tab, it
+    // doesn't matter.
+    // TODO(creis): Move RequestTransferURL to RenderFrameHost's navigator.
+    render_frame_host->render_view_host()->GetDelegate()->RequestTransferURL(
+        transfer_url,
+        pending_nav_params_->transfer_url_chain,
+        pending_nav_params_->referrer,
+        pending_nav_params_->page_transition,
+        CURRENT_TAB,
+        pending_nav_params_->frame_id,
+        pending_nav_params_->global_request_id,
+        false,
+        true);
+  } else if (pending_render_frame_host_) {
+    RenderProcessHostImpl* pending_process =
+        static_cast<RenderProcessHostImpl*>(
+            pending_render_frame_host_->GetProcess());
+    pending_process->ResumeDeferredNavigation(
+        pending_nav_params_->global_request_id);
+  }
+  pending_nav_params_.reset();
+}
+
 // TODO(creis): This should take in a RenderFrameHost.
 void RenderFrameHostManager::DidNavigateMainFrame(
     RenderViewHost* render_view_host) {
   if (!cross_navigation_pending_) {
     DCHECK(!pending_render_frame_host_);
 
     // We should only hear this from our current renderer.
     DCHECK(render_view_host == render_frame_host_->render_view_host());
 
     // Even when there is no pending RVH, there may be a pending Web UI.
@@ skipping 159 matching lines @@
   // Now close any modal dialogs that would prevent us from swapping out.  This
   // must be done separately from SwapOut, so that the PageGroupLoadDeferrer is
   // no longer on the stack when we send the SwapOut message.
   delegate_->CancelModalDialogsForRenderManager();
 
   // Tell the old renderer it is being swapped out.  This will fire the unload
   // handler (without firing the beforeunload handler a second time).  When the
   // unload handler finishes and the navigation completes, we will send a
   // message to the ResourceDispatcherHost, allowing the pending RVH's response
   // to resume.
-  // TODO(creis): We should do this on the RFH or else we'll swap out the
-  // top-level page when subframes navigate.
-  render_frame_host_->render_view_host()->SwapOut();
+  // Note: this must be done on the RFH or else we'll swap out the
+  // top-level page.
+  if (frame_tree_node_->IsMainFrame())
+    render_frame_host_->render_view_host()->SwapOut();
+  else
+    render_frame_host_->SwapOut();
 
   // ResourceDispatcherHost has told us to run the onunload handler, which
   // means it is not a download or unsafe page, and we are going to perform the
-  // navigation.  Thus, we no longer need to remember that the RenderViewHost
+  // navigation.  Thus, we no longer need to remember that the RenderFrameHost
   // is part of a pending cross-site request.
   if (pending_render_frame_host_) {
     pending_render_frame_host_->render_view_host()->
         SetHasPendingCrossSiteRequest(false);
   }
 }
 
 void RenderFrameHostManager::Observe(
     int type,
     const NotificationSource& source,
@@ skipping 269 matching lines @@
     frame_routing_id = site_instance->GetProcess()->GetNextRoutingID();
 
   // Create a RVH for main frames, or find the existing one for subframes.
   FrameTree* frame_tree = frame_tree_node_->frame_tree();
   RenderViewHostImpl* render_view_host = NULL;
   if (frame_tree_node_->IsMainFrame()) {
     render_view_host = frame_tree->CreateRenderViewHostForMainFrame(
         site_instance, view_routing_id, frame_routing_id, swapped_out, hidden);
   } else {
     render_view_host = frame_tree->GetRenderViewHostForSubFrame(site_instance);
+    // TODO(creis): Mirror the frame tree so this check isn't necessary.
+    if (!render_view_host) {
+      render_view_host = frame_tree->CreateRenderViewHostForMainFrame(
+          site_instance, view_routing_id, frame_routing_id, swapped_out,
+          hidden);
+    }
   }
 
   // TODO(creis): Make render_frame_host a scoped_ptr.
   // TODO(creis): Pass hidden to RFH.
   RenderFrameHostImpl* render_frame_host =
       RenderFrameHostFactory::Create(render_view_host,
                                      render_frame_delegate_,
                                      frame_tree,
                                      frame_tree_node_,
                                      frame_routing_id,
@@ skipping 36 matching lines @@
     } else {
       new_render_frame_host->GetProcess()->AddPendingView();
     }
 
     RenderViewHostImpl* render_view_host =
         new_render_frame_host->render_view_host();
     bool success = InitRenderView(render_view_host, opener_route_id);
     if (success && frame_tree_node_->IsMainFrame()) {
       // Don't show the main frame's view until we get a DidNavigate from it.
       render_view_host->GetView()->Hide();
-    } else if (!swapped_out) {
+    } else if (!swapped_out && pending_render_frame_host_) {
+      // TODO(creis): The lack of pending RFH check from before was a bug.
       CancelPending();
     }
   }
 
   // Use this as our new pending RFH if it isn't swapped out.
   if (!swapped_out)
     pending_render_frame_host_ = new_render_frame_host;
 
   return new_render_frame_host->render_view_host()->GetRoutingID();
 }
@@ skipping 55 matching lines @@
       delegate_->SetFocusToLocationBar(false);
     return;
   }
 
   // Remember if the page was focused so we can focus the new renderer in
   // that case.
   bool focus_render_view = !will_focus_location_bar &&
       render_frame_host_->render_view_host()->GetView() &&
       render_frame_host_->render_view_host()->GetView()->HasFocus();
 
+  // TODO(creis): As long as show/hide are on RVH, we don't want to do them for
+  // subframe navigations or they'll interfere with the top-level page.
+  bool is_main_frame = frame_tree_node_->IsMainFrame();
+
   // Swap in the pending frame and make it active. Also ensure the FrameTree
   // stays in sync.
   RenderFrameHostImpl* old_render_frame_host = render_frame_host_;
   render_frame_host_ = pending_render_frame_host_;
   pending_render_frame_host_ = NULL;
-  render_frame_host_->render_view_host()->AttachToFrameTree();
+  if (is_main_frame)
+    frame_tree_node_->frame_tree()->ResetForMainFrameSwap();
 
   // The process will no longer try to exit, so we can decrement the count.
   render_frame_host_->GetProcess()->RemovePendingView();
 
-  // TODO(creis): As long as show/hide are on RVH, we don't want to do them for
-  // subframe navigations or they'll interfere with the top-level page.
-  bool is_main_frame = frame_tree_node_->IsMainFrame();
-
   // If the view is gone, then this RenderViewHost died while it was hidden.
   // We ignored the RenderProcessGone call at the time, so we should send it now
   // to make sure the sad tab shows up, etc.
   if (!render_frame_host_->render_view_host()->GetView()) {
     delegate_->RenderProcessGoneFromRenderManager(
         render_frame_host_->render_view_host());
   } else if (!delegate_->IsHidden() && is_main_frame) {
     render_frame_host_->render_view_host()->GetView()->Show();
   }
 
   // Hide the old view now that the new one is visible.
+  // TODO(creis): We don't want to hide the top-level view based on a frame
+  // swap.  Hack for now.
   if (old_render_frame_host->render_view_host()->GetView()) {
-    old_render_frame_host->render_view_host()->GetView()->Hide();
-    old_render_frame_host->render_view_host()->WasSwappedOut();
+    if (is_main_frame) {
+      old_render_frame_host->render_view_host()->GetView()->Hide();
+      old_render_frame_host->render_view_host()->WasSwappedOut();
+    } else {
+      // TODO(creis): We'll need to set this back to false when navigating a
+      // subframe RFH, but we can't navigate a subframe RFH yet.
+      old_render_frame_host->set_swapped_out(true);
+    }
   }
 
   // Make sure the size is up to date.  (Fix for bug 1079768.)
   delegate_->UpdateRenderViewSizeForRenderManager();
 
   if (will_focus_location_bar) {
     delegate_->SetFocusToLocationBar(false);
   } else if (focus_render_view &&
              render_frame_host_->render_view_host()->GetView()) {
     RenderWidgetHostViewPort::FromRWHV(
@@ skipping 10 matching lines @@
         render_frame_host_->render_view_host());
   }
 
   // If the pending frame was on the swapped out list, we can remove it.
   swapped_out_hosts_.erase(render_frame_host_->render_view_host()->
                                GetSiteInstance()->GetId());
 
   if (old_render_frame_host->render_view_host()->IsRenderViewLive()) {
     // If the old RFH is live, we are swapping it out and should keep track of
     // it in case we navigate back to it.
-    DCHECK(old_render_frame_host->render_view_host()->is_swapped_out());
+    DCHECK(old_render_frame_host->is_swapped_out() ||
+           old_render_frame_host->render_view_host()->is_swapped_out());
     // Temp fix for http://crbug.com/90867 until we do a better cleanup to make
     // sure we don't get different rvh instances for the same site instance
     // in the same rvhmgr.
     // TODO(creis): Clean this up.
     int32 old_site_instance_id =
         old_render_frame_host->render_view_host()->GetSiteInstance()->GetId();
     RenderFrameHostMap::iterator iter =
         swapped_out_hosts_.find(old_site_instance_id);
     if (iter != swapped_out_hosts_.end() &&
         iter->second != old_render_frame_host) {
@@ skipping 305 matching lines @@
     SiteInstance* instance) const {
   RenderFrameHostMap::const_iterator iter =
       swapped_out_hosts_.find(instance->GetId());
   if (iter != swapped_out_hosts_.end())
     return iter->second;
 
   return NULL;
 }
 
 }  // namespace content