Propagate opener to BackgroundsContents.

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 <stddef.h>
 
 #include <cmath>
 #include <utility>
@@ skipping 247 matching lines @@
 };
 
 // Helper for GetInnerWebContents().
 bool GetInnerWebContentsHelper(
     std::vector<WebContentsImpl*>* all_guest_contents,
     WebContents* guest_contents) {
   all_guest_contents->push_back(static_cast<WebContentsImpl*>(guest_contents));
   return false;
 }
 
-}  // namespace
-
-WebContents* WebContents::Create(const WebContents::CreateParams& params) {
+FrameTreeNode* FindOpener(const WebContents::CreateParams& params) {
   FrameTreeNode* opener_node = nullptr;
   if (params.opener_render_frame_id != MSG_ROUTING_NONE) {
     RenderFrameHostImpl* opener_rfh = RenderFrameHostImpl::FromID(
         params.opener_render_process_id, params.opener_render_frame_id);
     if (opener_rfh)
       opener_node = opener_rfh->frame_tree_node();
   }
-  return WebContentsImpl::CreateWithOpener(params, opener_node);
+  return opener_node;
+}
+
+}  // namespace
+
+WebContents* WebContents::Create(const WebContents::CreateParams& params) {
+  return WebContentsImpl::CreateWithOpener(params, FindOpener(params));
 }
 
 WebContents* WebContents::CreateWithSessionStorage(
     const WebContents::CreateParams& params,
     const SessionStorageNamespaceMap& session_storage_namespace_map) {
   WebContentsImpl* new_contents = new WebContentsImpl(params.browser_context);
+  new_contents->SetOpenerForNewContents(FindOpener(params),
+                                        params.opener_suppressed);
 
   for (SessionStorageNamespaceMap::const_iterator it =
            session_storage_namespace_map.begin();
        it != session_storage_namespace_map.end();
        ++it) {
     new_contents->GetController()
         .SetSessionStorageNamespace(it->first, it->second.get());
   }
 
   new_contents->Init(params);
@@ skipping 335 matching lines @@
     observer.ResetWebContents();
 
   SetDelegate(NULL);
 }
 
 WebContentsImpl* WebContentsImpl::CreateWithOpener(
     const WebContents::CreateParams& params,
     FrameTreeNode* opener) {
   TRACE_EVENT0("browser", "WebContentsImpl::CreateWithOpener");
   WebContentsImpl* new_contents = new WebContentsImpl(params.browser_context);
-
-  FrameTreeNode* new_root = new_contents->GetFrameTree()->root();
-
-  if (opener) {
-    // For the "original opener", track the opener's main frame instead, because
-    // if the opener is a subframe, the opener tracking could be easily bypassed
-    // by spawning from a subframe and deleting the subframe.
-    // https://crbug.com/705316
-    new_root->SetOriginalOpener(opener->frame_tree()->root());
-
-    if (!params.opener_suppressed) {
-      new_root->SetOpener(opener);
-      new_contents->created_with_opener_ = true;
-    }
-  }
+  new_contents->SetOpenerForNewContents(opener, params.opener_suppressed);
 
   // If the opener is sandboxed, a new popup must inherit the opener's sandbox
   // flags, and these flags take effect immediately.  An exception is if the
   // opener's sandbox flags lack the PropagatesToAuxiliaryBrowsingContexts
   // bit (which is controlled by the "allow-popups-to-escape-sandbox" token).
   // See https://html.spec.whatwg.org/#attr-iframe-sandbox.
+  FrameTreeNode* new_root = new_contents->GetFrameTree()->root();
   if (opener) {
     blink::WebSandboxFlags opener_flags = opener->effective_sandbox_flags();
     const blink::WebSandboxFlags inherit_flag =
         blink::WebSandboxFlags::kPropagatesToAuxiliaryBrowsingContexts;
     if ((opener_flags & inherit_flag) == inherit_flag) {
       new_root->SetPendingSandboxFlags(opener_flags);
       new_root->CommitPendingFramePolicy();
     }
   }
 
@@ skipping 1529 matching lines @@
   StoragePartition* partition = BrowserContext::GetStoragePartition(
       GetBrowserContext(), site_instance.get());
   DOMStorageContextWrapper* dom_storage_context =
       static_cast<DOMStorageContextWrapper*>(partition->GetDOMStorageContext());
   SessionStorageNamespaceImpl* session_storage_namespace_impl =
       static_cast<SessionStorageNamespaceImpl*>(session_storage_namespace);
   CHECK(session_storage_namespace_impl->IsFromContext(dom_storage_context));
 
   if (delegate_ &&
       !delegate_->ShouldCreateWebContents(
-          this, source_site_instance, render_view_route_id, main_frame_route_id,
-          main_frame_widget_route_id, params.window_container_type,
-          opener->GetLastCommittedURL(), params.frame_name, params.target_url,
-          partition_id, session_storage_namespace)) {
+          this, opener, source_site_instance, render_view_route_id,
+          main_frame_route_id, main_frame_widget_route_id,
+          params.window_container_type, opener->GetLastCommittedURL(),
+          params.frame_name, params.target_url, partition_id,
+          session_storage_namespace)) {
     // Note: even though we're not creating a WebContents here, it could have
     // been created by the embedder so ensure that the RenderFrameHost is
     // properly initialized.
     // It's safe to only target the frame because the render process will not
     // have a chance to create more frames at this point.
     RenderFrameHostImpl* rfh =
         RenderFrameHostImpl::FromID(render_process_id, main_frame_route_id);
     if (rfh) {
       DCHECK(rfh->IsRenderFrameLive());
       rfh->Init();
@@ skipping 1117 matching lines @@
     current->mouse_lock_widget_ = nullptr;
   }
 
   return false;
 }
 
 bool WebContentsImpl::HasOpener() const {
   return GetOpener() != NULL;
 }
 
-WebContentsImpl* WebContentsImpl::GetOpener() const {
+RenderFrameHostImpl* WebContentsImpl::GetOpener() const {
   FrameTreeNode* opener_ftn = frame_tree_.root()->opener();
-  return opener_ftn ? FromFrameTreeNode(opener_ftn) : nullptr;
+  return opener_ftn ? opener_ftn->current_frame_host() : nullptr;
 }
 
 bool WebContentsImpl::HasOriginalOpener() const {
   return GetOriginalOpener() != NULL;
 }
 
-WebContents* WebContentsImpl::GetOriginalOpener() const {
+RenderFrameHostImpl* WebContentsImpl::GetOriginalOpener() const {
   FrameTreeNode* opener_ftn = frame_tree_.root()->original_opener();
-  return opener_ftn ? FromFrameTreeNode(opener_ftn) : nullptr;
+  return opener_ftn ? opener_ftn->current_frame_host() : nullptr;
 }
 
 void WebContentsImpl::DidChooseColorInColorChooser(SkColor color) {
   if (!color_chooser_info_.get())
     return;
   RenderFrameHost* rfh = RenderFrameHost::FromID(
       color_chooser_info_->render_process_id,
       color_chooser_info_->render_frame_id);
   if (!rfh)
     return;
@@ skipping 2228 matching lines @@
       continue;
     RenderViewHost* render_view_host = RenderViewHost::From(render_widget_host);
     if (!render_view_host)
       continue;
     render_view_host_set.insert(render_view_host);
   }
   for (RenderViewHost* render_view_host : render_view_host_set)
     render_view_host->OnWebkitPreferencesChanged();
 }
 
+void WebContentsImpl::SetOpenerForNewContents(FrameTreeNode* opener,
+                                              bool opener_suppressed) {
+  if (opener) {
+    FrameTreeNode* new_root = GetFrameTree()->root();
+
+    // For the "original opener", track the opener's main frame instead, because
+    // if the opener is a subframe, the opener tracking could be easily bypassed
+    // by spawning from a subframe and deleting the subframe.
+    // https://crbug.com/705316
+    new_root->SetOriginalOpener(opener->frame_tree()->root());
+
+    if (!opener_suppressed) {
+      new_root->SetOpener(opener);
+      created_with_opener_ = true;
+    }
+  }
+}
+
 }  // namespace content