Cross-process postMessage

content/browser/tab_contents/render_view_host_manager.cc

 // Copyright (c) 2011 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/tab_contents/render_view_host_manager.h"
 
 #include "base/command_line.h"
 #include "base/logging.h"
+#include "content/browser/browser_context.h"
 #include "content/browser/debugger/devtools_manager_impl.h"
 #include "content/browser/renderer_host/render_view_host.h"
 #include "content/browser/renderer_host/render_view_host_delegate.h"
 #include "content/browser/renderer_host/render_view_host_factory.h"
 #include "content/browser/renderer_host/render_widget_host_view.h"
 #include "content/browser/site_instance.h"
 #include "content/browser/tab_contents/navigation_controller.h"
 #include "content/browser/tab_contents/navigation_entry.h"
 #include "content/browser/tab_contents/tab_contents_view.h"
 #include "content/browser/webui/web_ui.h"
@@ skipping 45 matching lines @@
   // ref counted.
   if (!site_instance)
     site_instance = SiteInstance::CreateSiteInstance(browser_context);
   render_view_host_ = RenderViewHostFactory::Create(
       site_instance, render_view_delegate_, routing_id, delegate_->
       GetControllerForRenderManager().session_storage_namespace());
 
   // Keep track of renderer processes as they start to shut down.
   registrar_.Add(this, content::NOTIFICATION_RENDERER_PROCESS_CLOSING,
                  content::NotificationService::AllSources());
+
+  browser_context_ = browser_context;
 }
 
 RenderWidgetHostView* RenderViewHostManager::GetRenderWidgetHostView() const {
   if (!render_view_host_)
     return NULL;
   return render_view_host_->view();
 }
 
 RenderViewHost* RenderViewHostManager::Navigate(const NavigationEntry& entry) {
   // Create a pending RenderViewHost. It will give us the one we should use
   RenderViewHost* dest_render_view_host = UpdateRendererStateForNavigate(entry);
   if (!dest_render_view_host)
     return NULL;  // We weren't able to create a pending render view host.
 
   // If the current render_view_host_ isn't live, we should create it so
   // that we don't show a sad tab while the dest_render_view_host fetches
   // its first page.  (Bug 1145340)
   if (dest_render_view_host != render_view_host_ &&
       !render_view_host_->IsRenderViewLive()) {
     // Note: we don't call InitRenderView here because we are navigating away
     // soon anyway, and we don't have the NavigationEntry for this host.
-    delegate_->CreateRenderViewForRenderManager(render_view_host_);
+    delegate_->CreateRenderViewForRenderManager(render_view_host_,
+                                                MSG_ROUTING_NONE);
   }
 
   // If the renderer crashed, then try to create a new one to satisfy this
   // navigation request.
   if (!dest_render_view_host->IsRenderViewLive()) {
-    if (!InitRenderView(dest_render_view_host, entry))
+    if (!InitRenderView(dest_render_view_host, entry, MSG_ROUTING_NONE))
       return NULL;
 
     // 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_view_host != render_view_host_ &&
         dest_render_view_host->view()) {
       dest_render_view_host->view()->Hide();
     } else {
       // This is our primary renderer, notify here as we won't be calling
@@ skipping 370 matching lines @@
     // Start the new renderer in a new SiteInstance, but in the current
     // BrowsingInstance.  It is important to immediately give this new
     // SiteInstance to a RenderViewHost (if it is different than our current
     // SiteInstance), so that it is ref counted.  This will happen in
     // CreatePendingRenderView.
     return curr_instance->GetRelatedSiteInstance(dest_url);
   }
 }
 
 bool RenderViewHostManager::CreatePendingRenderView(
-    const NavigationEntry& entry, SiteInstance* instance) {
+    const NavigationEntry& entry, SiteInstance* instance, int opener_route_id) {
   NavigationEntry* curr_entry =
       delegate_->GetControllerForRenderManager().GetLastCommittedEntry();
   if (curr_entry) {
     DCHECK(!curr_entry->content_state().empty());
     // TODO(creis): Should send a message to the RenderView to let it know
     // we're about to switch away, so that it sends an UpdateState message.
   }
 
   // Check if we've already created an RVH for this SiteInstance.
   CHECK(instance);
@@ skipping 10 matching lines @@
     return true;
   }
 
   pending_render_view_host_ = RenderViewHostFactory::Create(
       instance, render_view_delegate_, MSG_ROUTING_NONE, delegate_->
       GetControllerForRenderManager().session_storage_namespace());
 
   // Prevent the process from exiting while we're trying to use it.
   pending_render_view_host_->process()->AddPendingView();
 
-  bool success = InitRenderView(pending_render_view_host_, entry);
+  bool success = InitRenderView(pending_render_view_host_, entry,
+                                opener_route_id);
   if (success) {
     // Don't show the view until we get a DidNavigate from it.
     pending_render_view_host_->view()->Hide();
   } else {
     CancelPending();
   }
   return success;
 }
 
 bool RenderViewHostManager::InitRenderView(RenderViewHost* render_view_host,
-                                           const NavigationEntry& entry) {
+                                           const NavigationEntry& entry,
+                                           int opener_route_id) {
   // If the pending navigation is to a WebUI, tell the RenderView about any
   // bindings it will need enabled.
   if (pending_web_ui_.get())
     render_view_host->AllowBindings(pending_web_ui_->bindings());
 
-  return delegate_->CreateRenderViewForRenderManager(render_view_host);
+  return delegate_->CreateRenderViewForRenderManager(render_view_host,
+                                                     opener_route_id);
 }
 
 void RenderViewHostManager::CommitPending() {
   // First check whether we're going to want to focus the location bar after
   // this commit.  We do this now because the navigation hasn't formally
   // committed yet, so if we've already cleared |pending_web_ui_| the call chain
   // this triggers won't be able to figure out what's going on.
   bool will_focus_location_bar = delegate_->FocusLocationBarByDefault();
 
   // Next commit the Web UI, if any.
@@ skipping 108 matching lines @@
 
   // Determine if we need a new SiteInstance for this entry.
   // Again, new_instance won't be deleted before the end of this method, so it
   // is safe to use a normal pointer here.
   SiteInstance* new_instance = curr_instance;
   bool force_swap = ShouldSwapProcessesForNavigation(
       delegate_->GetLastCommittedNavigationEntryForRenderManager(), &entry);
   if (ShouldTransitionCrossSite() || force_swap)
     new_instance = GetSiteInstanceForEntry(entry, curr_instance);
 
+  int opener_route_id = MSG_ROUTING_NONE;
+
   if (new_instance != curr_instance || force_swap) {
     // New SiteInstance.
     DCHECK(!cross_navigation_pending_);
 
+    // Create proxies for the RenderView's opener chain.
+    // TODO(supersat): This current only creates a proxy for the direct opener.
+    if (entry.opener_content_frame_id() != -1) {
+      content::ContentFrame* opener_frame =
+          browser_context_->frame_mapper()->FindFrame(
+              entry.opener_content_frame_id());
+      // TODO(supersat): Don't use the testing method.
+      RenderViewHostManager* opener_rvhm =
+          opener_frame->tab_contents().render_manager_for_testing();
+      RenderViewHost* opener_rvh = opener_rvhm->SwappedOutRVHForNavigationEntry(
+          entry, MSG_ROUTING_NONE);
+      opener_route_id = opener_rvh->routing_id();
+    }
+
     // Create a pending RVH and navigate it.
-    bool success = CreatePendingRenderView(entry, new_instance);
+    bool success = CreatePendingRenderView(entry, new_instance,
+                                           opener_route_id);
     if (!success)
       return NULL;
 
     // Check if our current RVH is live before we set up a transition.
     if (!render_view_host_->IsRenderViewLive()) {
       if (!cross_navigation_pending_) {
         // The current RVH is not live.  There's no reason to sit around with a
         // sad tab or a newly created RVH while we wait for the pending RVH to
         // navigate.  Just switch to the pending RVH now and go back to non
         // cross-navigating (Note that we don't care about on{before}unload
@@ skipping 120 matching lines @@
   }
 }
 
 bool RenderViewHostManager::IsSwappedOut(RenderViewHost* rvh) {
   if (!rvh->site_instance())
     return false;
 
   return swapped_out_hosts_.find(rvh->site_instance()->id()) !=
       swapped_out_hosts_.end();
 }
+
+RenderViewHost* RenderViewHostManager::SwappedOutRVHForNavigationEntry(
+    const NavigationEntry& entry, int opener_route_id) {
+  SiteInstance* site_instance = GetSiteInstanceForEntry(
+      entry, render_view_host_->site_instance());
+
+  // If we already have a swapped out RVH.
+  RenderViewHostMap::iterator iter =
+      swapped_out_hosts_.find(site_instance->id());
+  if (iter != swapped_out_hosts_.end())
+    return iter->second;
+
+  RenderViewHost* rvh = RenderViewHostFactory::Create(
+      site_instance, render_view_delegate_, MSG_ROUTING_NONE, delegate_->
+      GetControllerForRenderManager().session_storage_namespace());
+
+  // TODO(supersat): Do we need to call this?
+  // Prevent the process from exiting while we're trying to use it.
+  //rvh->process()->AddPendingView();
+
+  bool success = InitRenderView(rvh, entry, opener_route_id);
+  if (success) {
+    content::ContentFrame* frame = browser_context_->frame_mapper()->FindFrame(
+        entry.opener_content_frame_id());
+    browser_context_->frame_mapper()->AddSwappedOutRendererToFrame(frame,
+        rvh->process()->GetID(), rvh->routing_id(), -1);
+
+    rvh->view()->Hide();
+    // We're not swapping in a new RenderView, so the new ids are set to -1.
+    rvh->SwapOutAndProxy(-1, -1, entry.opener_content_frame_id());
+    swapped_out_hosts_[site_instance->id()] = rvh;
+    return rvh;
+  } else {
+    return NULL;
+  }
+}