Plumbing blink::Interface{Provider|Registry} through WebLocalFrame's constructor.

third_party/WebKit/Source/web/tests/WebFrameTest.cpp

 /*
  * Copyright (C) 2010 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 7057 matching lines @@
 
   virtual WebLocalFrame* createChildFrame(
       WebLocalFrame* parent,
       WebTreeScopeType scope,
       const WebString&,
       const WebString&,
       WebSandboxFlags,
       const WebFrameOwnerProperties& frameOwnerProperties) {
     DCHECK(m_childClient);
     m_childFrameCreationCount++;
-    WebLocalFrame* frame = WebLocalFrame::create(scope, m_childClient);
+    WebLocalFrame* frame =
+        WebLocalFrame::create(scope, m_childClient, nullptr, nullptr);
     parent->appendChild(frame);
     return frame;
   }
 
   virtual void didStartLoading(bool toDifferentDocument) {
     if (m_parentClient) {
       m_parentClient->didStartLoading(toDifferentDocument);
       return;
     }
     TestWebFrameClient::didStartLoading(toDifferentDocument);
@@ skipping 1392 matching lines @@
   FrameTestHelpers::WebViewHelper m_webViewHelper;
 };
 
 TEST_F(WebFrameSwapTest, SwapMainFrame) {
   WebRemoteFrame* remoteFrame =
       WebRemoteFrame::create(WebTreeScopeType::Document, nullptr);
   mainFrame()->swap(remoteFrame);
 
   FrameTestHelpers::TestWebFrameClient client;
   WebLocalFrame* localFrame = WebLocalFrame::createProvisional(
-      &client, remoteFrame, WebSandboxFlags::None);
+      &client, nullptr, nullptr, remoteFrame, WebSandboxFlags::None);
   FrameTestHelpers::TestWebWidgetClient webWidgetClient;
   WebFrameWidget::create(&webWidgetClient, localFrame);
   remoteFrame->swap(localFrame);
 
   // Finally, make sure an embedder triggered load in the local frame swapped
   // back in works.
   FrameTestHelpers::loadFrame(localFrame, m_baseURL + "subframe-hello.html");
 
   std::string content =
       WebFrameContentDumper::dumpWebViewAsText(webView(), 1024).utf8();
   EXPECT_EQ("hello", content);
 
   // Manually reset to break WebViewHelper's dependency on the stack allocated
   // TestWebFrameClient.
   reset();
   remoteFrame->close();
 }
 
 TEST_F(WebFrameSwapTest, ValidateSizeOnRemoteToLocalMainFrameSwap) {
   WebSize size(111, 222);
 
   WebRemoteFrame* remoteFrame =
       WebRemoteFrame::create(WebTreeScopeType::Document, nullptr);
   mainFrame()->swap(remoteFrame);
 
   remoteFrame->view()->resize(size);
 
   FrameTestHelpers::TestWebFrameClient client;
   WebLocalFrame* localFrame = WebLocalFrame::createProvisional(
-      &client, remoteFrame, WebSandboxFlags::None);
+      &client, nullptr, nullptr, remoteFrame, WebSandboxFlags::None);
   remoteFrame->swap(localFrame);
 
   // Verify that the size that was set with a remote main frame is correct
   // after swapping to a local frame.
   FrameHost* host =
       toWebViewImpl(localFrame->view())->page()->mainFrame()->host();
   EXPECT_EQ(size.width, host->visualViewport().size().width());
   EXPECT_EQ(size.height, host->visualViewport().size().height());
 
   // Manually reset to break WebViewHelper's dependency on the stack allocated
@@ skipping 58 matching lines @@
 }
 
 TEST_F(WebFrameSwapTest, SwapFirstChild) {
   FrameTestHelpers::TestWebRemoteFrameClient remoteFrameClient;
   WebRemoteFrame* remoteFrame =
       WebRemoteFrame::create(WebTreeScopeType::Document, &remoteFrameClient);
   swapAndVerifyFirstChildConsistency("local->remote", mainFrame(), remoteFrame);
 
   FrameTestHelpers::TestWebFrameClient client;
   WebLocalFrame* localFrame = WebLocalFrame::createProvisional(
-      &client, remoteFrame, WebSandboxFlags::None);
+      &client, nullptr, nullptr, remoteFrame, WebSandboxFlags::None);
   swapAndVerifyFirstChildConsistency("remote->local", mainFrame(), localFrame);
 
   // FIXME: This almost certainly fires more load events on the iframe element
   // than it should.
   // Finally, make sure an embedder triggered load in the local frame swapped
   // back in works.
   FrameTestHelpers::loadFrame(localFrame, m_baseURL + "subframe-hello.html");
   std::string content =
       WebFrameContentDumper::dumpWebViewAsText(webView(), 1024).utf8();
   EXPECT_EQ("  \n\nhello\n\nb \n\na\n\nc", content);
@@ skipping 22 matching lines @@
 
 TEST_F(WebFrameSwapTest, SwapMiddleChild) {
   FrameTestHelpers::TestWebRemoteFrameClient remoteFrameClient;
   WebRemoteFrame* remoteFrame =
       WebRemoteFrame::create(WebTreeScopeType::Document, &remoteFrameClient);
   swapAndVerifyMiddleChildConsistency("local->remote", mainFrame(),
                                       remoteFrame);
 
   FrameTestHelpers::TestWebFrameClient client;
   WebLocalFrame* localFrame = WebLocalFrame::createProvisional(
-      &client, remoteFrame, WebSandboxFlags::None);
+      &client, nullptr, nullptr, remoteFrame, WebSandboxFlags::None);
   swapAndVerifyMiddleChildConsistency("remote->local", mainFrame(), localFrame);
 
   // FIXME: This almost certainly fires more load events on the iframe element
   // than it should.
   // Finally, make sure an embedder triggered load in the local frame swapped
   // back in works.
   FrameTestHelpers::loadFrame(localFrame, m_baseURL + "subframe-hello.html");
   std::string content =
       WebFrameContentDumper::dumpWebViewAsText(webView(), 1024).utf8();
   EXPECT_EQ("  \n\na\n\nhello\n\nc", content);
@@ skipping 17 matching lines @@
 }
 
 TEST_F(WebFrameSwapTest, SwapLastChild) {
   FrameTestHelpers::TestWebRemoteFrameClient remoteFrameClient;
   WebRemoteFrame* remoteFrame =
       WebRemoteFrame::create(WebTreeScopeType::Document, &remoteFrameClient);
   swapAndVerifyLastChildConsistency("local->remote", mainFrame(), remoteFrame);
 
   FrameTestHelpers::TestWebFrameClient client;
   WebLocalFrame* localFrame = WebLocalFrame::createProvisional(
-      &client, remoteFrame, WebSandboxFlags::None);
+      &client, nullptr, nullptr, remoteFrame, WebSandboxFlags::None);
   swapAndVerifyLastChildConsistency("remote->local", mainFrame(), localFrame);
 
   // FIXME: This almost certainly fires more load events on the iframe element
   // than it should.
   // Finally, make sure an embedder triggered load in the local frame swapped
   // back in works.
   FrameTestHelpers::loadFrame(localFrame, m_baseURL + "subframe-hello.html");
   std::string content =
       WebFrameContentDumper::dumpWebViewAsText(webView(), 1024).utf8();
   EXPECT_EQ("  \n\na\n\nb \n\na\n\nhello", content);
 
   // Manually reset to break WebViewHelper's dependency on the stack allocated
   // TestWebFrameClient.
   reset();
   remoteFrame->close();
 }
 
 TEST_F(WebFrameSwapTest, DetachProvisionalFrame) {
   FrameTestHelpers::TestWebRemoteFrameClient remoteFrameClient;
   WebRemoteFrameImpl* remoteFrame = WebRemoteFrameImpl::create(
       WebTreeScopeType::Document, &remoteFrameClient);
   swapAndVerifyMiddleChildConsistency("local->remote", mainFrame(),
                                       remoteFrame);
 
   FrameTestHelpers::TestWebFrameClient client;
   WebLocalFrameImpl* provisionalFrame = WebLocalFrameImpl::createProvisional(
-      &client, remoteFrame, WebSandboxFlags::None);
+      &client, nullptr, nullptr, remoteFrame, WebSandboxFlags::None);
 
   // The provisional frame should have a local frame owner.
   FrameOwner* owner = provisionalFrame->frame()->owner();
   ASSERT_TRUE(owner->isLocal());
 
   // But the owner should point to |remoteFrame|, since the new frame is still
   // provisional.
   EXPECT_EQ(remoteFrame->frame(), owner->contentFrame());
 
   // After detaching the provisional frame, the frame owner should still point
@@ skipping 32 matching lines @@
   targetFrame = mainFrame()->firstChild()->nextSibling();
   EXPECT_TRUE(targetFrame);
 
   // Create child frames in the target frame before testing the swap.
   FrameTestHelpers::TestWebRemoteFrameClient remoteFrameClient2;
   WebRemoteFrame* childRemoteFrame =
       FrameTestHelpers::createRemoteChild(remoteFrame, &remoteFrameClient2);
 
   FrameTestHelpers::TestWebFrameClient client;
   WebLocalFrame* localFrame = WebLocalFrame::createProvisional(
-      &client, remoteFrame, WebSandboxFlags::None);
+      &client, nullptr, nullptr, remoteFrame, WebSandboxFlags::None);
   swapAndVerifySubframeConsistency("remote->local", targetFrame, localFrame);
 
   // FIXME: This almost certainly fires more load events on the iframe element
   // than it should.
   // Finally, make sure an embedder triggered load in the local frame swapped
   // back in works.
   FrameTestHelpers::loadFrame(localFrame, m_baseURL + "subframe-hello.html");
   std::string content =
       WebFrameContentDumper::dumpWebViewAsText(webView(), 1024).utf8();
   EXPECT_EQ("  \n\na\n\nhello\n\nc", content);
@@ skipping 27 matching lines @@
   // Check that its view is consistent with the world.
   v8::Local<v8::Value> remoteWindowTop =
       mainFrame()->executeScriptAndReturnValue(WebScriptSource(
           "document.querySelector('#frame2').contentWindow.top;"));
   EXPECT_TRUE(windowTop->StrictEquals(remoteWindowTop));
 
   // Now check that remote -> local works too, since it goes through a different
   // code path.
   FrameTestHelpers::TestWebFrameClient client;
   WebLocalFrame* localFrame = WebLocalFrame::createProvisional(
-      &client, remoteFrame, WebSandboxFlags::None);
+      &client, nullptr, nullptr, remoteFrame, WebSandboxFlags::None);
   remoteFrame->swap(localFrame);
   v8::Local<v8::Value> localWindow = mainFrame()->executeScriptAndReturnValue(
       WebScriptSource("document.querySelector('#frame2').contentWindow;"));
   EXPECT_TRUE(originalWindow->StrictEquals(localWindow));
   v8::Local<v8::Value> localWindowTop =
       mainFrame()->executeScriptAndReturnValue(WebScriptSource(
           "document.querySelector('#frame2').contentWindow.top;"));
   EXPECT_TRUE(windowTop->StrictEquals(localWindowTop));
 
   // Manually reset to break WebViewHelper's dependency on the stack allocated
@@ skipping 16 matching lines @@
   WebRemoteFrame* remoteFrame = remoteClient.frame();
   WebFrameTest::lastChild(mainFrame())->swap(remoteFrame);
   remoteFrame->setReplicatedOrigin(SecurityOrigin::createUnique());
   v8::Local<v8::Value> remoteWindowTop =
       mainFrame()->executeScriptAndReturnValue(WebScriptSource("saved.top"));
   EXPECT_TRUE(remoteWindowTop->IsObject());
   EXPECT_TRUE(windowTop->StrictEquals(remoteWindowTop));
 
   FrameTestHelpers::TestWebFrameClient client;
   WebLocalFrame* localFrame = WebLocalFrame::createProvisional(
-      &client, remoteFrame, WebSandboxFlags::None);
+      &client, nullptr, nullptr, remoteFrame, WebSandboxFlags::None);
   remoteFrame->swap(localFrame);
   v8::Local<v8::Value> localWindowTop =
       mainFrame()->executeScriptAndReturnValue(WebScriptSource("saved.top"));
   EXPECT_TRUE(localWindowTop->IsObject());
   EXPECT_TRUE(windowTop->StrictEquals(localWindowTop));
 
   reset();
 }
 
 TEST_F(WebFrameSwapTest, RemoteFramesAreIndexable) {
@@ skipping 136 matching lines @@
   WebRemoteFrame* remoteFrame =
       WebRemoteFrame::create(WebTreeScopeType::Document, &remoteFrameClient);
   WebFrame* targetFrame = mainFrame()->firstChild();
   ASSERT_TRUE(targetFrame);
   targetFrame->swap(remoteFrame);
   ASSERT_TRUE(mainFrame()->firstChild());
   ASSERT_EQ(mainFrame()->firstChild(), remoteFrame);
 
   RemoteToLocalSwapWebFrameClient client(remoteFrame);
   WebLocalFrame* localFrame = WebLocalFrame::createProvisional(
-      &client, remoteFrame, WebSandboxFlags::None);
+      &client, nullptr, nullptr, remoteFrame, WebSandboxFlags::None);
   FrameTestHelpers::loadFrame(localFrame, m_baseURL + "subframe-hello.html");
   EXPECT_EQ(WebInitialCommitInChildFrame, client.historyCommitType());
 
   // Manually reset to break WebViewHelper's dependency on the stack allocated
   // TestWebFrameClient.
   reset();
   remoteFrame->close();
 }
 
 // The commit type should be Standard if we are swapping a RemoteFrame to a
 // LocalFrame after commits have already happened in the frame.  The browser
 // process will inform us via setCommittedFirstRealLoad.
 TEST_F(WebFrameSwapTest, HistoryCommitTypeAfterExistingRemoteToLocalSwap) {
   FrameTestHelpers::TestWebRemoteFrameClient remoteFrameClient;
   WebRemoteFrame* remoteFrame =
       WebRemoteFrame::create(WebTreeScopeType::Document, &remoteFrameClient);
   WebFrame* targetFrame = mainFrame()->firstChild();
   ASSERT_TRUE(targetFrame);
   targetFrame->swap(remoteFrame);
   ASSERT_TRUE(mainFrame()->firstChild());
   ASSERT_EQ(mainFrame()->firstChild(), remoteFrame);
 
   RemoteToLocalSwapWebFrameClient client(remoteFrame);
   WebLocalFrame* localFrame = WebLocalFrame::createProvisional(
-      &client, remoteFrame, WebSandboxFlags::None);
+      &client, nullptr, nullptr, remoteFrame, WebSandboxFlags::None);
   localFrame->setCommittedFirstRealLoad();
   FrameTestHelpers::loadFrame(localFrame, m_baseURL + "subframe-hello.html");
   EXPECT_EQ(WebStandardCommit, client.historyCommitType());
 
   // Manually reset to break WebViewHelper's dependency on the stack allocated
   // TestWebFrameClient.
   reset();
   remoteFrame->close();
 }
 
@@ skipping 12 matching lines @@
       WebTreeScopeType::Document, &remoteFrameClient);
   targetFrame->swap(remoteFrame);
   ASSERT_TRUE(mainFrame()->firstChild());
   ASSERT_EQ(mainFrame()->firstChild(), remoteFrame);
   EXPECT_EQ(uniqueName.utf8(),
             WebString(remoteFrame->frame()->tree().uniqueName()).utf8());
 
   // Swap back to a LocalFrame.
   RemoteToLocalSwapWebFrameClient client(remoteFrame);
   WebLocalFrame* localFrame = WebLocalFrame::createProvisional(
-      &client, remoteFrame, WebSandboxFlags::None);
+      &client, nullptr, nullptr, remoteFrame, WebSandboxFlags::None);
   FrameTestHelpers::loadFrame(localFrame, m_baseURL + "subframe-hello.html");
   EXPECT_EQ(uniqueName.utf8(), localFrame->uniqueName().utf8());
   EXPECT_EQ(uniqueName.utf8(), WebString(toWebLocalFrameImpl(localFrame)
                                              ->frame()
                                              ->loader()
                                              .currentItem()
                                              ->target())
                                    .utf8());
 
   // Repeat with no name on the frame.
   // (note that uniqueName is immutable after first real commit).
   localFrame->setName("");
   WebString uniqueName2 = localFrame->uniqueName();
   EXPECT_EQ("frame1", uniqueName2.utf8());
 
   FrameTestHelpers::TestWebRemoteFrameClient remoteFrameClient2;
   WebRemoteFrameImpl* remoteFrame2 = WebRemoteFrameImpl::create(
       WebTreeScopeType::Document, &remoteFrameClient2);
   localFrame->swap(remoteFrame2);
   ASSERT_TRUE(mainFrame()->firstChild());
   ASSERT_EQ(mainFrame()->firstChild(), remoteFrame2);
   EXPECT_EQ(uniqueName2.utf8(),
             WebString(remoteFrame2->frame()->tree().uniqueName()).utf8());
 
   RemoteToLocalSwapWebFrameClient client2(remoteFrame2);
   WebLocalFrame* localFrame2 = WebLocalFrame::createProvisional(
-      &client2, remoteFrame2, WebSandboxFlags::None);
+      &client2, nullptr, nullptr, remoteFrame2, WebSandboxFlags::None);
   FrameTestHelpers::loadFrame(localFrame2, m_baseURL + "subframe-hello.html");
   EXPECT_EQ(uniqueName2.utf8(), localFrame2->uniqueName().utf8());
   EXPECT_EQ(uniqueName2.utf8(), WebString(toWebLocalFrameImpl(localFrame2)
                                               ->frame()
                                               ->loader()
                                               .currentItem()
                                               ->target())
                                     .utf8());
 
   // Manually reset to break WebViewHelper's dependency on the stack allocated
@@ skipping 124 matching lines @@
   WebRemoteFrame* popupRemoteFrame = popupRemoteClient.frame();
   popupView->setMainFrame(popupRemoteFrame);
   popupRemoteFrame->setOpener(mainFrame);
   popupRemoteFrame->setReplicatedOrigin(
       WebSecurityOrigin::createFromString("http://foo.com"));
   EXPECT_FALSE(mainFrame->getSecurityOrigin().canAccess(
       popupView->mainFrame()->getSecurityOrigin()));
 
   // Do a remote-to-local swap in the popup.
   FrameTestHelpers::TestWebFrameClient popupLocalClient;
-  WebLocalFrame* popupLocalFrame = WebLocalFrame::createProvisional(
-      &popupLocalClient, popupRemoteFrame, WebSandboxFlags::None);
+  WebLocalFrame* popupLocalFrame =
+      WebLocalFrame::createProvisional(&popupLocalClient, nullptr, nullptr,
+                                       popupRemoteFrame, WebSandboxFlags::None);
   popupRemoteFrame->swap(popupLocalFrame);
 
   // The initial document created during the remote-to-local swap should have
   // inherited its opener's SecurityOrigin.
   EXPECT_TRUE(mainFrame->getSecurityOrigin().canAccess(
       popupView->mainFrame()->getSecurityOrigin()));
 
   popupView->close();
 }
 
 TEST_F(WebFrameTest, SwapWithOpenerCycle) {
   // First, create a remote main frame with itself as the opener.
   FrameTestHelpers::TestWebViewClient viewClient;
   WebView* view = WebView::create(&viewClient, WebPageVisibilityStateVisible);
   FrameTestHelpers::TestWebRemoteFrameClient remoteClient;
   WebRemoteFrame* remoteFrame = remoteClient.frame();
   view->setMainFrame(remoteFrame);
   remoteFrame->setOpener(remoteFrame);
 
   // Now swap in a local frame. It shouldn't crash.
   FrameTestHelpers::TestWebFrameClient localClient;
   WebLocalFrame* localFrame = WebLocalFrame::createProvisional(
-      &localClient, remoteFrame, WebSandboxFlags::None);
+      &localClient, nullptr, nullptr, remoteFrame, WebSandboxFlags::None);
   remoteFrame->swap(localFrame);
 
   // And the opener cycle should still be preserved.
   EXPECT_EQ(localFrame, localFrame->opener());
 
   view->close();
 }
 
 class CommitTypeWebFrameClient : public FrameTestHelpers::TestWebFrameClient {
  public:
@@ skipping 385 matching lines @@
   WebView* view = WebView::create(&viewClient, WebPageVisibilityStateVisible);
   view->setMainFrame(remoteClient.frame());
   WebRemoteFrame* remoteRoot = view->mainFrame()->toWebRemoteFrame();
   remoteRoot->setReplicatedOrigin(SecurityOrigin::createUnique());
 
   FrameTestHelpers::createLocalChild(remoteRoot);
 
   // Do a remote-to-local swap of the top frame.
   FrameTestHelpers::TestWebFrameClient localClient;
   WebLocalFrame* localRoot = WebLocalFrame::createProvisional(
-      &localClient, remoteRoot, WebSandboxFlags::None);
+      &localClient, nullptr, nullptr, remoteRoot, WebSandboxFlags::None);
   FrameTestHelpers::TestWebWidgetClient webWidgetClient;
   WebFrameWidget::create(&webWidgetClient, localRoot);
   remoteRoot->swap(localRoot);
 
   // Load a page with a child frame in the new root to make sure this doesn't
   // crash when the child frame invokes setCoreFrame.
   registerMockedHttpURLLoad("single_iframe.html");
   registerMockedHttpURLLoad("visible_iframe.html");
   FrameTestHelpers::loadFrame(localRoot, m_baseURL + "single_iframe.html");
 
@@ skipping 1529 matching lines @@
   };
 
   class MainFrameClient : public FrameTestHelpers::TestWebFrameClient {
    public:
     WebLocalFrame* createChildFrame(WebLocalFrame* parent,
                                     WebTreeScopeType scope,
                                     const WebString& name,
                                     const WebString& uniqueName,
                                     WebSandboxFlags sandboxFlags,
                                     const WebFrameOwnerProperties&) override {
-      WebLocalFrame* frame = WebLocalFrame::create(scope, &m_childClient);
+      WebLocalFrame* frame =
+          WebLocalFrame::create(scope, &m_childClient, nullptr, nullptr);
       parent->appendChild(frame);
       return frame;
     }
 
     LoadingObserverFrameClient& childClient() { return m_childClient; }
 
    private:
     LoadingObserverFrameClient m_childClient;
   };
 
@@ skipping 10 matching lines @@
 
   EXPECT_TRUE(mainFrameClient.childClient().didCallFrameDetached());
   EXPECT_TRUE(mainFrameClient.childClient().didCallDidStopLoading());
   EXPECT_TRUE(mainFrameClient.childClient().didCallDidFinishDocumentLoad());
   EXPECT_TRUE(mainFrameClient.childClient().didCallDidHandleOnloadEvents());
 
   webViewHelper.reset();
 }
 
 }  // namespace blink