Remove a bunch of provisionalDataSource() usage.

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 99 matching lines @@
 #include "public/web/WebScriptExecutionCallback.h"
 #include "public/web/WebScriptSource.h"
 #include "public/web/WebSearchableFormData.h"
 #include "public/web/WebSecurityPolicy.h"
 #include "public/web/WebSelection.h"
 #include "public/web/WebSettings.h"
 #include "public/web/WebSpellCheckClient.h"
 #include "public/web/WebTextCheckingCompletion.h"
 #include "public/web/WebTextCheckingResult.h"
 #include "public/web/WebViewClient.h"
+#include "web/WebDataSourceImpl.h"
 #include "web/WebLocalFrameImpl.h"
 #include "web/WebRemoteFrameImpl.h"
 #include "web/WebViewImpl.h"
 #include "web/tests/FrameTestHelpers.h"
 #include "wtf/Forward.h"
 #include "wtf/dtoa/utils.h"
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 #include <map>
 #include <stdarg.h>
@@ skipping 4889 matching lines @@
 
     client.resetTriggered();
     webViewHelper.webView()->handleInputEvent(fatTap(690, 570));
     EXPECT_FALSE(client.triggered());
 }
 
 class TestSubstituteDataWebFrameClient : public FrameTestHelpers::TestWebFrameClient {
 public:
     TestSubstituteDataWebFrameClient()
         : m_commitCalled(false)
+        , m_frame(nullptr)
     {
     }
 
-    virtual void didFailProvisionalLoad(WebLocalFrame* frame, const WebURLError& error, WebHistoryCommitType)
+    virtual void didFailProvisionalLoad(WebDataSource*, const WebURLError& error, WebHistoryCommitType)
     {
-        frame->loadHTMLString("This should appear", toKURL("data:text/html,chromewebdata"), error.unreachableURL, true);
+        m_frame->loadHTMLString("This should appear", toKURL("data:text/html,chromewebdata"), error.unreachableURL, true);
     }
 
     virtual void didCommitProvisionalLoad(WebLocalFrame* frame, const WebHistoryItem&, WebHistoryCommitType)
     {
         if (frame->dataSource()->response().url() != WebURL(URLTestHelpers::toKURL("about:blank")))
             m_commitCalled = true;
     }
 
     bool commitCalled() const { return m_commitCalled; }
+    void setFrame(WebLocalFrame* frame) { m_frame = frame; }
 
 private:
     bool m_commitCalled;
+    WebLocalFrame* m_frame;
 };
 
 TEST_P(ParameterizedWebFrameTest, ReplaceNavigationAfterHistoryNavigation)
 {
     TestSubstituteDataWebFrameClient webFrameClient;
 
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     webViewHelper.initializeAndLoad("about:blank", true, &webFrameClient);
     WebFrame* frame = webViewHelper.webView()->mainFrame();
+    webFrameClient.setFrame(frame->toWebLocalFrame());
 
     // Load a url as a history navigation that will return an error. TestSubstituteDataWebFrameClient
     // will start a SubstituteData load in response to the load failure, which should get fully committed.
     // Due to https://bugs.webkit.org/show_bug.cgi?id=91685, FrameLoader::didReceiveData() wasn't getting
     // called in this case, which resulted in the SubstituteData document not getting displayed.
     WebURLError error;
     error.reason = 1337;
     error.domain = "WebFrameTest";
     std::string errorURL = "http://0.0.0.0";
     WebURLResponse response;
@@ skipping 876 matching lines @@
 
     virtual void didStopLoading()
     {
         if (m_parentClient) {
             m_parentClient->didStopLoading();
             return;
         }
         TestWebFrameClient::didStopLoading();
     }
 
-    void willSendRequest(WebLocalFrame* frame, unsigned, WebURLRequest& request, const WebURLResponse&) override
+    void willSendRequest(WebDataSource*, unsigned, WebURLRequest& request, const WebURLResponse&) override
     {
         m_policy = request.cachePolicy();
         m_willSendRequestCallCount++;
     }
 
 private:
     TestCachePolicyWebFrameClient* m_parentClient;
 
     WebURLRequest::CachePolicy m_policy;
     TestCachePolicyWebFrameClient* m_childClient;
@@ skipping 30 matching lines @@
     EXPECT_EQ(childClient.cachePolicy(), WebURLRequest::ReloadIgnoringCacheData);
 }
 
 class TestSameDocumentWebFrameClient : public FrameTestHelpers::TestWebFrameClient {
 public:
     TestSameDocumentWebFrameClient()
         : m_frameLoadTypeSameSeen(false)
     {
     }
 
-    virtual void willSendRequest(WebLocalFrame* frame, unsigned, WebURLRequest&, const WebURLResponse&)
+    virtual void willSendRequest(WebDataSource* dataSource, unsigned, WebURLRequest&, const WebURLResponse&)
     {
-        if (toWebLocalFrameImpl(frame)->frame()->loader().loadType() == FrameLoadTypeSame)
+        if (static_cast<WebDataSourceImpl*>(dataSource)->frame()->loader().loadType() == FrameLoadTypeSame)
             m_frameLoadTypeSameSeen = true;
     }
 
     bool frameLoadTypeSameSeen() const { return m_frameLoadTypeSameSeen; }
 
 private:
     bool m_frameLoadTypeSameSeen;
 };
 
 TEST_P(ParameterizedWebFrameTest, NavigateToSame)
@@ skipping 11 matching lines @@
     EXPECT_TRUE(client.frameLoadTypeSameSeen());
 }
 
 class TestSameDocumentWithImageWebFrameClient : public FrameTestHelpers::TestWebFrameClient {
 public:
     TestSameDocumentWithImageWebFrameClient()
         : m_numOfImageRequests(0)
     {
     }
 
-    virtual void willSendRequest(WebLocalFrame* frame, unsigned, WebURLRequest& request, const WebURLResponse&)
+    virtual void willSendRequest(WebDataSource*, unsigned, WebURLRequest& request, const WebURLResponse&)
     {
         if (request.requestContext() == WebURLRequest::RequestContextImage) {
             m_numOfImageRequests++;
             EXPECT_EQ(WebURLRequest::UseProtocolCachePolicy, request.cachePolicy());
         }
     }
 
     int numOfImageRequests() const { return m_numOfImageRequests; }
 
 private:
@@ skipping 117 matching lines @@
             item.get(), UseProtocolCachePolicy)),
         FrameLoadTypeBackForward, item.get(), HistorySameDocumentLoad);
     EXPECT_EQ(WebBackForwardCommit, client.lastCommitType());
 }
 
 class TestHistoryWebFrameClient : public FrameTestHelpers::TestWebFrameClient {
 public:
     TestHistoryWebFrameClient()
     {
         m_replacesCurrentHistoryItem = false;
-        m_frame = nullptr;
     }
 
-    void didStartProvisionalLoad(WebLocalFrame* frame, double)
+    void didStartProvisionalLoad(WebDataSource* ds, double)
     {
-        WebDataSource* ds = frame->provisionalDataSource();
         m_replacesCurrentHistoryItem = ds->replacesCurrentHistoryItem();
-        m_frame = frame;
     }
 
     bool replacesCurrentHistoryItem() { return m_replacesCurrentHistoryItem; }
-    WebFrame* frame() { return m_frame; }
 
 private:
     bool m_replacesCurrentHistoryItem;
-    WebFrame* m_frame;
 };
 
 // Tests that the first navigation in an initially blank subframe will result in
 // a history entry being replaced and not a new one being added.
 TEST_P(ParameterizedWebFrameTest, FirstBlankSubframeNavigation)
 {
     registerMockedHttpURLLoad("history.html");
     registerMockedHttpURLLoad("find.html");
 
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     TestHistoryWebFrameClient client;
     webViewHelper.initializeAndLoad("about:blank", true, &client);
 
     WebFrame* frame = webViewHelper.webView()->mainFrame();
 
     frame->executeScript(WebScriptSource(WebString::fromUTF8(
         "document.body.appendChild(document.createElement('iframe'))")));
 
     WebFrame* iframe = frame->firstChild();
     ASSERT_EQ(&client, toWebLocalFrameImpl(iframe)->client());
-    EXPECT_EQ(iframe, client.frame());
 
     std::string url1 = m_baseURL + "history.html";
     FrameTestHelpers::loadFrame(iframe, url1);
-    EXPECT_EQ(iframe, client.frame());
     EXPECT_EQ(url1, iframe->document().url().string().utf8());
     EXPECT_TRUE(client.replacesCurrentHistoryItem());
 
     std::string url2 = m_baseURL + "find.html";
     FrameTestHelpers::loadFrame(iframe, url2);
-    EXPECT_EQ(iframe, client.frame());
     EXPECT_EQ(url2, iframe->document().url().string().utf8());
     EXPECT_FALSE(client.replacesCurrentHistoryItem());
 }
 
 // Tests that a navigation in a frame with a non-blank initial URL will create
 // a new history item, unlike the case above.
 TEST_P(ParameterizedWebFrameTest, FirstNonBlankSubframeNavigation)
 {
     registerMockedHttpURLLoad("history.html");
     registerMockedHttpURLLoad("find.html");
 
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     TestHistoryWebFrameClient client;
     webViewHelper.initializeAndLoad("about:blank", true, &client);
 
     WebFrame* frame = webViewHelper.webView()->mainFrame();
 
     std::string url1 = m_baseURL + "history.html";
     FrameTestHelpers::loadFrame(frame,
         "javascript:var f = document.createElement('iframe'); "
         "f.src = '" + url1 + "';"
         "document.body.appendChild(f)");
 
     WebFrame* iframe = frame->firstChild();
-    EXPECT_EQ(iframe, client.frame());
     EXPECT_EQ(url1, iframe->document().url().string().utf8());
 
     std::string url2 = m_baseURL + "find.html";
     FrameTestHelpers::loadFrame(iframe, url2);
-    EXPECT_EQ(iframe, client.frame());
     EXPECT_EQ(url2, iframe->document().url().string().utf8());
     EXPECT_FALSE(client.replacesCurrentHistoryItem());
 }
 
 // Test verifies that layout will change a layer's scrollable attibutes
 TEST_F(WebFrameTest, overflowHiddenRewrite)
 {
     registerMockedHttpURLLoad("non-scrollable.html");
     OwnPtr<FakeCompositingWebViewClient> fakeCompositingWebViewClient = adoptPtr(new FakeCompositingWebViewClient());
     FrameTestHelpers::WebViewHelper webViewHelper;
@@ skipping 1954 matching lines @@
 
 TEST_F(WebFrameTest, MaxFramesDetach)
 {
     registerMockedHttpURLLoad("max-frames-detach.html");
     FrameTestHelpers::WebViewHelper webViewHelper;
     WebViewImpl* webViewImpl = webViewHelper.initializeAndLoad(m_baseURL + "max-frames-detach.html", true);
     webViewImpl->mainFrameImpl()->collectGarbage();
 }
 
 } // namespace blink