Create swapped-out opener RVHs after a process swap.

content/browser/web_contents/web_contents_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/web_contents/web_contents_impl.h"
 
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/metrics/histogram.h"
@@ skipping 218 matching lines @@
     BrowserContext* browser_context,
     SiteInstance* site_instance,
     int routing_id,
     const WebContents* base_web_contents,
     SessionStorageNamespace* session_storage_namespace) {
   return new WebContentsImpl(
       browser_context,
       site_instance,
       routing_id,
       static_cast<const WebContentsImpl*>(base_web_contents),
+      NULL,
       static_cast<SessionStorageNamespaceImpl*>(session_storage_namespace));
 }
 }
 
 // WebContentsImpl -------------------------------------------------------------
 
 WebContentsImpl::WebContentsImpl(
     content::BrowserContext* browser_context,
     SiteInstance* site_instance,
     int routing_id,
     const WebContentsImpl* base_web_contents,
+    WebContentsImpl* opener,
     SessionStorageNamespaceImpl* session_storage_namespace)
     : delegate_(NULL),
       ALLOW_THIS_IN_INITIALIZER_LIST(controller_(
           this, browser_context, session_storage_namespace)),
+      opener_(opener),
       ALLOW_THIS_IN_INITIALIZER_LIST(render_manager_(this, this)),
       is_loading_(false),
       crashed_status_(base::TERMINATION_STATUS_STILL_RUNNING),
       crashed_error_code_(0),
       waiting_for_response_(false),
       load_state_(net::LOAD_STATE_IDLE, string16()),
       upload_size_(0),
       upload_position_(0),
       displayed_insecure_content_(false),
       capturing_contents_(false),
       is_being_destroyed_(false),
       notify_disconnection_(false),
       dialog_creator_(NULL),
 #if defined(OS_WIN)
       message_box_active_(CreateEvent(NULL, TRUE, FALSE, NULL)),
 #endif
       is_showing_before_unload_dialog_(false),
       opener_web_ui_type_(WebUI::kNoWebUI),
       closed_by_user_gesture_(false),
       minimum_zoom_percent_(
           static_cast<int>(content::kMinimumZoomFactor * 100)),
       maximum_zoom_percent_(
           static_cast<int>(content::kMaximumZoomFactor * 100)),
       temporary_zoom_settings_(false),
       content_restrictions_(0),
       view_type_(content::VIEW_TYPE_WEB_CONTENTS),
-      has_opener_(false),
       color_chooser_(NULL) {
   render_manager_.Init(browser_context, site_instance, routing_id);
 
   view_.reset(content::GetContentClient()->browser()->
       OverrideCreateWebContentsView(this));
   if (!view_.get()) {
     content::WebContentsViewDelegate* delegate =
         content::GetContentClient()->browser()->GetWebContentsViewDelegate(
             this);
 #if defined(USE_AURA)
     view_.reset(new WebContentsViewAura(this, delegate));
 #elif defined(OS_WIN)
     view_.reset(new WebContentsViewWin(this, delegate));
 #elif defined(TOOLKIT_GTK)
     view_.reset(new content::WebContentsViewGtk(this, delegate));
 #elif defined(OS_MACOSX)
     view_.reset(web_contents_view_mac::CreateWebContentsView(this, delegate));
 #elif defined(OS_ANDROID)
     view_.reset(new WebContentsViewAndroid(this));
 #endif
     (void)delegate;
   }
   CHECK(view_.get());
 
   // We have the initial size of the view be based on the size of the view of
   // the passed in WebContents.
   view_->CreateView(base_web_contents ?
       base_web_contents->GetView()->GetContainerSize() : gfx::Size());
 
+  // Listen for whether our opener gets destroyed.
+  if (opener_) {
+    registrar_.Add(this, content::NOTIFICATION_WEB_CONTENTS_DESTROYED,
+                   content::Source<WebContents>(opener_));
+  }
+
 #if defined(ENABLE_JAVA_BRIDGE)
   java_bridge_dispatcher_host_manager_.reset(
       new JavaBridgeDispatcherHostManager(this));
 #endif
 
   browser_plugin_web_contents_observer_.reset(
       new content::BrowserPluginWebContentsObserver(this));
 }
 
 WebContentsImpl::~WebContentsImpl() {
   is_being_destroyed_ = true;
 
   // Clear out any JavaScript state.
   if (dialog_creator_)
     dialog_creator_->ResetJavaScriptState(this);
 
   if (color_chooser_)
     color_chooser_->End();
 
+  if (opener_) {
+    registrar_.Remove(this, content::NOTIFICATION_WEB_CONTENTS_DESTROYED,

[Matt Perry, 2012/05/01 20:45:17]

You don't need to explicitly remove the notification here, do you? registrar_
will do it upon destruction.

[Charlie Reis, 2012/05/01 21:25:53]

This one's different.  We're listening to when our *opener* WebContents is
closed, and then clearing our opener_ field.  That can happen at any time, and
it's important to realize we no longer have an opener after that point.

[Matt Perry, 2012/05/01 21:45:56]

We're in the WebContents destructor. Are you saying the opener could be
destroyed before we reach the end of the method?

[Charlie Reis, 2012/05/01 21:57:06]

D'oh!  That's what I get for not looking closely.  (Thought we were talking
about OnWebContentsDestroyed.)

Removed.

+                      content::Source<WebContents>(opener_));
+    opener_ = NULL;
+  }
+
   NotifyDisconnected();
 
   // Notify any observer that have a reference on this WebContents.
   content::NotificationService::current()->Notify(
       content::NOTIFICATION_WEB_CONTENTS_DESTROYED,
       content::Source<WebContents>(this),
       content::NotificationService::NoDetails());
 
   // TODO(brettw) this should be moved to the view.
 #if defined(OS_WIN) && !defined(USE_AURA)
@@ skipping 562 matching lines @@
       !static_cast<RenderViewHostImpl*>(
           GetRenderViewHost())->SuddenTerminationAllowed();
 }
 
 void WebContentsImpl::Stop() {
   render_manager_.Stop();
   FOR_EACH_OBSERVER(WebContentsObserver, observers_, StopNavigation());
 }
 
 WebContents* WebContentsImpl::Clone() {
-  // We create a new SiteInstance so that the new tab won't share processes
-  // with the old one. This can be changed in the future if we need it to share
-  // processes for some reason.
+  // We use our current SiteInstance since the cloned entry will use it anyway.
+  // We pass |this| for the |base_web_contents| to size the view correctly, and
+  // our own opener so that the cloned page can access it if it was before.
   WebContentsImpl* tc = new WebContentsImpl(
-      GetBrowserContext(),
-      SiteInstance::Create(GetBrowserContext()),
-      MSG_ROUTING_NONE, this, NULL);
+      GetBrowserContext(), GetSiteInstance(),
+      MSG_ROUTING_NONE, this, opener_, NULL);
   tc->GetControllerImpl().CopyStateFrom(controller_);
   return tc;
 }
 
 void WebContentsImpl::AddNewContents(WebContents* new_contents,
                                      WindowOpenDisposition disposition,
                                      const gfx::Rect& initial_pos,
                                      bool user_gesture) {
   if (!delegate_)
     return;
@@ skipping 11 matching lines @@
 }
 
 void WebContentsImpl::GetContainerBounds(gfx::Rect* out) const {
   view_->GetContainerBounds(out);
 }
 
 void WebContentsImpl::Focus() {
   view_->Focus();
 }
 
+void WebContentsImpl::Observe(int type,
+                              const content::NotificationSource& source,
+                              const content::NotificationDetails& details) {
+  switch (type) {
+    case content::NOTIFICATION_WEB_CONTENTS_DESTROYED:
+      OnWebContentsDestroyed(
+          content::Source<content::WebContents>(source).ptr());
+      break;
+    default:
+      NOTREACHED();
+  }
+}
+
+void WebContentsImpl::OnWebContentsDestroyed(WebContents* web_contents) {
+  // Clear the opener if it has been closed.
+  if (web_contents == opener_) {
+    registrar_.Remove(this, content::NOTIFICATION_WEB_CONTENTS_DESTROYED,
+                      content::Source<WebContents>(opener_));
+    opener_ = NULL;
+  }
+}
+
 void WebContentsImpl::AddObserver(WebContentsObserver* observer) {
   observers_.AddObserver(observer);
 }
 
 void WebContentsImpl::RemoveObserver(WebContentsObserver* observer) {
   observers_.RemoveObserver(observer);
 }
 
 void WebContentsImpl::Activate() {
   if (delegate_)
@@ skipping 430 matching lines @@
     return render_manager_.pending_web_ui();
   return render_manager_.web_ui();
 }
 
 bool WebContentsImpl::GotResponseToLockMouseRequest(bool allowed) {
   return GetRenderViewHost() ?
       GetRenderViewHostImpl()->GotResponseToLockMouseRequest(allowed) : false;
 }
 
 bool WebContentsImpl::HasOpener() const {
-  return has_opener_;
+  return opener_ != NULL;
 }
 
 void WebContentsImpl::DidChooseColorInColorChooser(int color_chooser_id,
                                                    SkColor color) {
   GetRenderViewHost()->Send(new ViewMsg_DidChooseColorResponse(
       GetRenderViewHost()->GetRoutingID(), color_chooser_id, color));
 }
 
 void WebContentsImpl::DidEndColorChooser(int color_chooser_id) {
   GetRenderViewHost()->Send(new ViewMsg_DidEndColorChooser(
@@ skipping 571 matching lines @@
   return view_type_;
 }
 
 gfx::Rect WebContentsImpl::GetRootWindowResizerRect() const {
   if (delegate_)
     return delegate_->GetRootWindowResizerRect();
   return gfx::Rect();
 }
 
 void WebContentsImpl::RenderViewCreated(RenderViewHost* render_view_host) {
+  // Don't send notifications if we are just creating a swapped-out RVH for
+  // the opener chain.  These won't be used for view-source or WebUI, so it's
+  // ok to return early.
+  if (static_cast<RenderViewHostImpl*>(render_view_host)->is_swapped_out())
+    return;
+
   content::NotificationService::current()->Notify(
       content::NOTIFICATION_RENDER_VIEW_HOST_CREATED_FOR_TAB,
       content::Source<WebContents>(this),
       content::Details<RenderViewHost>(render_view_host));
   NavigationEntry* entry = controller_.GetActiveEntry();
   if (!entry)
     return;
 
   // When we're creating views, we're still doing initial setup, so we always
   // use the pending Web UI rather than any possibly existing committed one.
@@ skipping 527 matching lines @@
   // later. In case of tab duplication this resizing to 0x0 prevents setting
   // normal size later so just ignore it.
   if (!size.IsEmpty())
     view_->SizeContents(size);
 }
 
 void WebContentsImpl::NotifySwappedFromRenderManager() {
   NotifySwapped();
 }
 
+int WebContentsImpl::CreateOpenerRenderViewsForRenderManager(
+    SiteInstance* instance) {
+  if (!opener_)
+    return MSG_ROUTING_NONE;
+
+  // Recursively create RenderViews for anything else in the opener chain.
+  return opener_->CreateOpenerRenderViews(instance);
+}
+
+int WebContentsImpl::CreateOpenerRenderViews(SiteInstance* instance) {
+  int opener_route_id = MSG_ROUTING_NONE;
+
+  // If this tab has an opener, ensure it has a RenderView in the given
+  // SiteInstance as well.

[Matt Perry, 2012/05/01 20:45:17]

I'm confused.. Doesn't this mean the opener RenderViews will all share a
SiteInstance? It seems like RenderViewHostManager assumes that there is only 1
RenderView per SiteInstance (e.g. the swapped_out_hosts_ map).

[Charlie Reis, 2012/05/01 21:25:53]

There's only one RVH per SiteInstance, for a given tab.  This CL is making sure
that other related tabs *also* have a RVH for that SiteInstance, so that the
tabs can find each other in the renderer process.

Basic use case:
Tab 1 has page A1, opens Tab 2 with page A2.  Tab 2's opener_ is Tab 1.
User navigates Tab 2 to page B2 in a different SiteInstance.
We transparently need to create a swapped out RVH for SiteInstance B in Tab 1.
This will let page B2 say window.opener.postMessage(msg).

[Matt Perry, 2012/05/01 21:45:56]

Where I was getting confused was that each tab has its own RVHManager. I think
I've got it now.

+  if (opener_)
+    opener_route_id = opener_->CreateOpenerRenderViews(instance);
+
+  // Create a swapped out RenderView in the given SiteInstance if none exists,
+  // setting its opener to the given route_id.  Return the new view's route_id.
+  return render_manager_.CreateRenderView(instance, opener_route_id, true);
+}
+
 NavigationControllerImpl& WebContentsImpl::GetControllerForRenderManager() {
   return GetControllerImpl();
 }
 
 WebUIImpl* WebContentsImpl::CreateWebUIForRenderManager(const GURL& url) {
   return static_cast<WebUIImpl*>(CreateWebUI(url));
 }
 
 NavigationEntry*
     WebContentsImpl::GetLastCommittedNavigationEntryForRenderManager() {
   return controller_.GetLastCommittedEntry();
 }
 
 bool WebContentsImpl::CreateRenderViewForRenderManager(
-    RenderViewHost* render_view_host) {
+    RenderViewHost* render_view_host, int opener_route_id) {
   // Can be NULL during tests.
   RenderWidgetHostView* rwh_view = view_->CreateViewForWidget(render_view_host);
 
   // Now that the RenderView has been created, we need to tell it its size.
   if (rwh_view)
     rwh_view->SetSize(view_->GetContainerSize());
 
   // Make sure we use the correct starting page_id in the new RenderView.
   UpdateMaxPageIDIfNecessary(render_view_host);
   int32 max_page_id =
       GetMaxPageIDForSiteInstance(render_view_host->GetSiteInstance());
 
   if (!static_cast<RenderViewHostImpl*>(
-          render_view_host)->CreateRenderView(string16(), max_page_id))
+          render_view_host)->CreateRenderView(string16(), opener_route_id,
+                                              max_page_id)) {
     return false;
+  }
 
 #if defined(OS_LINUX) || defined(OS_OPENBSD)
   // Force a ViewMsg_Resize to be sent, needed to make plugins show up on
   // linux. See crbug.com/83941.
   if (rwh_view) {
     if (RenderWidgetHost* render_widget_host = rwh_view->GetRenderWidgetHost())
       render_widget_host->WasResized();
   }
 #endif
 
@@ skipping 48 matching lines @@
 void WebContentsImpl::CreateViewAndSetSizeForRVH(RenderViewHost* rvh) {
   RenderWidgetHostView* rwh_view = GetView()->CreateViewForWidget(rvh);
   // Can be NULL during tests.
   if (rwh_view)
     rwh_view->SetSize(GetView()->GetContainerSize());
 }
 
 RenderViewHostImpl* WebContentsImpl::GetRenderViewHostImpl() {
   return static_cast<RenderViewHostImpl*>(GetRenderViewHost());
 }