Conversion of more places in Blink to use WebLocalFrame

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 335 matching lines @@
     runPendingTasks();
     webViewHelper.webView()->layout();
 
     std::string content = webViewHelper.webView()->mainFrame()->contentAsText(1024).utf8();
     EXPECT_EQ("http://www.test.com:0/" + fileName, content);
 }
 
 class CSSCallbackWebFrameClient : public FrameTestHelpers::TestWebFrameClient {
 public:
     CSSCallbackWebFrameClient() : m_updateCount(0) { }
-    virtual void didMatchCSS(WebFrame*, const WebVector<WebString>& newlyMatchingSelectors, const WebVector<WebString>& stoppedMatchingSelectors) OVERRIDE;
+    virtual void didMatchCSS(WebLocalFrame*, const WebVector<WebString>& newlyMatchingSelectors, const WebVector<WebString>& stoppedMatchingSelectors) OVERRIDE;
 
-    std::map<WebFrame*, std::set<std::string> > m_matchedSelectors;
+    std::map<WebLocalFrame*, std::set<std::string> > m_matchedSelectors;
     int m_updateCount;
 };
 
-void CSSCallbackWebFrameClient::didMatchCSS(WebFrame* frame, const WebVector<WebString>& newlyMatchingSelectors, const WebVector<WebString>& stoppedMatchingSelectors)
+void CSSCallbackWebFrameClient::didMatchCSS(WebLocalFrame* frame, const WebVector<WebString>& newlyMatchingSelectors, const WebVector<WebString>& stoppedMatchingSelectors)
 {
     ++m_updateCount;
     std::set<std::string>& frameSelectors = m_matchedSelectors[frame];
     for (size_t i = 0; i < newlyMatchingSelectors.size(); ++i) {
         std::string selector = newlyMatchingSelectors[i].utf8();
         EXPECT_EQ(0U, frameSelectors.count(selector)) << selector;
         frameSelectors.insert(selector);
     }
     for (size_t i = 0; i < stoppedMatchingSelectors.size(); ++i) {
         std::string selector = stoppedMatchingSelectors[i].utf8();
         EXPECT_EQ(1U, frameSelectors.count(selector)) << selector;
         frameSelectors.erase(selector);
     }
 }
 
 class WebFrameCSSCallbackTest : public testing::Test {
 protected:
     WebFrameCSSCallbackTest()
     {
 
-        m_frame = m_helper.initializeAndLoad("about:blank", true, &m_client)->mainFrame();
+        m_frame = m_helper.initializeAndLoad("about:blank", true, &m_client)->mainFrame()->toWebLocalFrame();
     }
 
     ~WebFrameCSSCallbackTest()
     {
         EXPECT_EQ(1U, m_client.m_matchedSelectors.size());
     }
 
     WebDocument doc() const
     {
         return m_frame->document();
@@ skipping 17 matching lines @@
 
     void executeScript(const WebString& code)
     {
         m_frame->executeScript(WebScriptSource(code));
         m_frame->view()->layout();
         runPendingTasks();
     }
 
     CSSCallbackWebFrameClient m_client;
     FrameTestHelpers::WebViewHelper m_helper;
-    WebFrame* m_frame;
+    WebLocalFrame* m_frame;
 };
 
 TEST_F(WebFrameCSSCallbackTest, AuthorStyleSheet)
 {
     loadHTML(
         "<style>"
         // This stylesheet checks that the internal property and value can't be
         // set by a stylesheet, only WebDocument::watchCSSSelectors().
         "div.initial_on { -internal-callback: none; }"
         "div.initial_off { -internal-callback: -internal-presence; }"
@@ skipping 2226 matching lines @@
     // Move focus back to the first edit box.
     webViewHelper.webView()->advanceFocus(true);
     webViewHelper.webViewImpl()->computeScaleAndScrollForFocusedNode(webViewHelper.webViewImpl()->focusedElement(), scale, scroll, needAnimation);
     // The position should have stayed the same since this box was already on screen with the right scale.
     EXPECT_FALSE(needAnimation);
 }
 
 class TestReloadDoesntRedirectWebFrameClient : public FrameTestHelpers::TestWebFrameClient {
 public:
     virtual WebNavigationPolicy decidePolicyForNavigation(
-        WebFrame*, WebDataSource::ExtraData*, const WebURLRequest&, WebNavigationType,
+        WebLocalFrame*, WebDataSource::ExtraData*, const WebURLRequest&, WebNavigationType,
         WebNavigationPolicy defaultPolicy, bool isRedirect) OVERRIDE
     {
         EXPECT_FALSE(isRedirect);
         return WebNavigationPolicyCurrentTab;
     }
 };
 
 TEST_F(WebFrameTest, ReloadDoesntSetRedirect)
 {
     // Test for case in http://crbug.com/73104. Reloading a frame very quickly
@@ skipping 117 matching lines @@
     // Now retrieve the FocusedNode and test it should be null.
     EXPECT_EQ(0, webViewHelper.webViewImpl()->focusedElement());
 }
 
 // Implementation of WebFrameClient that tracks the v8 contexts that are created
 // and destroyed for verification.
 class ContextLifetimeTestWebFrameClient : public FrameTestHelpers::TestWebFrameClient {
 public:
     struct Notification {
     public:
-        Notification(WebFrame* frame, v8::Handle<v8::Context> context, int worldId)
+        Notification(WebLocalFrame* frame, v8::Handle<v8::Context> context, int worldId)
             : frame(frame)
             , context(context->GetIsolate(), context)
             , worldId(worldId)
         {
         }
 
         ~Notification()
         {
             context.Reset();
         }
 
         bool Equals(Notification* other)
         {
             return other && frame == other->frame && context == other->context && worldId == other->worldId;
         }
 
-        WebFrame* frame;
+        WebLocalFrame* frame;
         v8::Persistent<v8::Context> context;
         int worldId;
     };
 
     virtual ~ContextLifetimeTestWebFrameClient()
     {
         reset();
     }
 
     void reset()
     {
         for (size_t i = 0; i < createNotifications.size(); ++i)
             delete createNotifications[i];
 
         for (size_t i = 0; i < releaseNotifications.size(); ++i)
             delete releaseNotifications[i];
 
         createNotifications.clear();
         releaseNotifications.clear();
     }
 
     std::vector<Notification*> createNotifications;
     std::vector<Notification*> releaseNotifications;
 
  private:
-    virtual void didCreateScriptContext(WebFrame* frame, v8::Handle<v8::Context> context, int extensionGroup, int worldId) OVERRIDE
+    virtual void didCreateScriptContext(WebLocalFrame* frame, v8::Handle<v8::Context> context, int extensionGroup, int worldId) OVERRIDE
     {
         createNotifications.push_back(new Notification(frame, context, worldId));
     }
 
-    virtual void willReleaseScriptContext(WebFrame* frame, v8::Handle<v8::Context> context, int worldId) OVERRIDE
+    virtual void willReleaseScriptContext(WebLocalFrame* frame, v8::Handle<v8::Context> context, int worldId) OVERRIDE
     {
         releaseNotifications.push_back(new Notification(frame, context, worldId));
     }
 };
 
 // TODO(aa): Deflake this test.
 TEST_F(WebFrameTest, FLAKY_ContextNotificationsLoadUnload)
 {
     v8::HandleScope handleScope(v8::Isolate::GetCurrent());
 
@@ skipping 248 matching lines @@
     frame->executeCommand(WebString::fromUTF8("SelectAll"));
     EXPECT_TRUE(frame->hasSelection());
     frame->executeCommand(WebString::fromUTF8("Unselect"));
     EXPECT_FALSE(frame->hasSelection());
     WebString selectionHtml = frame->selectionAsMarkup();
     EXPECT_TRUE(selectionHtml.isEmpty());
 }
 
 class TestExecuteScriptDuringDidCreateScriptContext : public FrameTestHelpers::TestWebFrameClient {
 public:
-    virtual void didCreateScriptContext(WebFrame* frame, v8::Handle<v8::Context> context, int extensionGroup, int worldId) OVERRIDE
+    virtual void didCreateScriptContext(WebLocalFrame* frame, v8::Handle<v8::Context> context, int extensionGroup, int worldId) OVERRIDE
     {
         frame->executeScript(WebScriptSource("window.history = 'replaced';"));
     }
 };
 
 TEST_F(WebFrameTest, ExecuteScriptDuringDidCreateScriptContext)
 {
     registerMockedHttpURLLoad("hello_world.html");
 
     TestExecuteScriptDuringDidCreateScriptContext webFrameClient;
@@ skipping 926 matching lines @@
     EXPECT_FALSE(client.triggered());
 }
 
 class TestSubstituteDataWebFrameClient : public FrameTestHelpers::TestWebFrameClient {
 public:
     TestSubstituteDataWebFrameClient()
         : m_commitCalled(false)
     {
     }
 
-    virtual void didFailProvisionalLoad(WebFrame* frame, const WebURLError& error)
+    virtual void didFailProvisionalLoad(WebLocalFrame* frame, const WebURLError& error)
     {
         frame->loadHTMLString("This should appear", toKURL("data:text/html,chromewebdata"), error.unreachableURL, true);
         runPendingTasks();
     }
 
-    virtual void didCommitProvisionalLoad(WebFrame* frame, bool)
+    virtual void didCommitProvisionalLoad(WebLocalFrame* frame, bool)
     {
         if (frame->dataSource()->response().url() != WebURL(URLTestHelpers::toKURL("about:blank")))
             m_commitCalled = true;
     }
 
     bool commitCalled() const { return m_commitCalled; }
 
 private:
     bool m_commitCalled;
 };
@@ skipping 31 matching lines @@
     EXPECT_EQ("This should appear", text.utf8());
     EXPECT_TRUE(webFrameClient.commitCalled());
 }
 
 class TestWillInsertBodyWebFrameClient : public FrameTestHelpers::TestWebFrameClient {
 public:
     TestWillInsertBodyWebFrameClient() : m_numBodies(0), m_didLoad(false)
     {
     }
 
-    virtual void didCommitProvisionalLoad(WebFrame*, bool) OVERRIDE
+    virtual void didCommitProvisionalLoad(WebLocalFrame*, bool) OVERRIDE
     {
         m_numBodies = 0;
         m_didLoad = true;
     }
 
-    virtual void didCreateDocumentElement(WebFrame*) OVERRIDE
+    virtual void didCreateDocumentElement(WebLocalFrame*) OVERRIDE
     {
         EXPECT_EQ(0, m_numBodies);
     }
 
-    virtual void willInsertBody(WebFrame*) OVERRIDE
+    virtual void willInsertBody(WebLocalFrame*) OVERRIDE
     {
         m_numBodies++;
     }
 
     int m_numBodies;
     bool m_didLoad;
 };
 
 TEST_F(WebFrameTest, HTMLDocument)
 {
@@ skipping 304 matching lines @@
     ASSERT_NE(static_cast<DocumentMarker*>(0), document->markers().markers()[0]);
     EXPECT_EQ(DocumentMarker::InvisibleSpellcheck, document->markers().markers()[0]->type());
 }
 
 class TestAccessInitialDocumentWebFrameClient : public FrameTestHelpers::TestWebFrameClient {
 public:
     TestAccessInitialDocumentWebFrameClient() : m_didAccessInitialDocument(false)
     {
     }
 
-    virtual void didAccessInitialDocument(WebFrame* frame)
+    virtual void didAccessInitialDocument(WebLocalFrame* frame)
     {
         EXPECT_TRUE(!m_didAccessInitialDocument);
         m_didAccessInitialDocument = true;
     }
 
     bool m_didAccessInitialDocument;
 };
 
 TEST_F(WebFrameTest, DidAccessInitialDocumentBody)
 {
@@ skipping 137 matching lines @@
     TestMainFrameUserOrProgrammaticScrollFrameClient() { reset(); }
     void reset()
     {
         m_didScrollMainFrame = false;
         m_wasProgrammaticScroll = false;
     }
     bool wasUserScroll() const { return m_didScrollMainFrame && !m_wasProgrammaticScroll; }
     bool wasProgrammaticScroll() const { return m_didScrollMainFrame && m_wasProgrammaticScroll; }
 
     // WebFrameClient:
-    virtual void didChangeScrollOffset(WebFrame* frame) OVERRIDE
+    virtual void didChangeScrollOffset(WebLocalFrame* frame) OVERRIDE
     {
         if (frame->parent())
             return;
         EXPECT_FALSE(m_didScrollMainFrame);
         WebCore::FrameView* view = toWebFrameImpl(frame)->frameView();
         // FrameView can be scrolled in FrameView::setFixedVisibleContentRect
         // which is called from LocalFrame::createView (before the frame is associated
         // with the the view).
         if (view) {
             m_didScrollMainFrame = true;
@@ skipping 102 matching lines @@
     Platform::current()->unitTestSupport()->registerMockedURL(redirectURL, finalResponse, filePath);
 
     FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "first_party_redirect.html", true);
     EXPECT_TRUE(webViewHelper.webView()->mainFrame()->document().firstPartyForCookies() == redirectURL);
 }
 
 class TestNavigationPolicyWebFrameClient : public FrameTestHelpers::TestWebFrameClient {
 public:
 
-    virtual void didNavigateWithinPage(WebFrame*, bool)
+    virtual void didNavigateWithinPage(WebLocalFrame*, bool)
     {
         EXPECT_TRUE(false);
     }
 };
 
 TEST_F(WebFrameTest, SimulateFragmentAnchorMiddleClick)
 {
     registerMockedHttpURLLoad("fragment_middle_click.html");
     TestNavigationPolicyWebFrameClient client;
     FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "fragment_middle_click.html", true, &client);
 
     WebCore::Document* document = webViewHelper.webViewImpl()->page()->mainFrame()->document();
     WebCore::KURL destination = document->url();
     destination.setFragmentIdentifier("test");
 
     RefPtr<WebCore::Event> event = WebCore::MouseEvent::create(WebCore::EventTypeNames::click, false, false,
         document->domWindow(), 0, 0, 0, 0, 0, 0, 0, false, false, false, false, 1, nullptr, nullptr);
     WebCore::FrameLoadRequest frameRequest(document, WebCore::ResourceRequest(destination));
     frameRequest.setTriggeringEvent(event);
     webViewHelper.webViewImpl()->page()->mainFrame()->loader().load(frameRequest);
 }
 
 class TestNewWindowWebViewClient : public WebViewClient {
 public:
-    virtual WebView* createView(WebFrame*, const WebURLRequest&, const WebWindowFeatures&,
+    virtual WebView* createView(WebLocalFrame*, const WebURLRequest&, const WebWindowFeatures&,
         const WebString&, WebNavigationPolicy, bool) OVERRIDE
     {
         EXPECT_TRUE(false);
         return 0;
     }
 };
 
 class TestNewWindowWebFrameClient : public FrameTestHelpers::TestWebFrameClient {
 public:
     TestNewWindowWebFrameClient()
         : m_decidePolicyCallCount(0)
     {
     }
 
-    virtual WebNavigationPolicy decidePolicyForNavigation(WebFrame*, WebDataSource::ExtraData*, const WebURLRequest&,
+    virtual WebNavigationPolicy decidePolicyForNavigation(WebLocalFrame*, WebDataSource::ExtraData*, const WebURLRequest&,
         WebNavigationType, WebNavigationPolicy policy, bool) OVERRIDE
     {
         m_decidePolicyCallCount++;
         return policy;
     }
 
     int decidePolicyCallCount() const { return m_decidePolicyCallCount; }
 
 private:
     int m_decidePolicyCallCount;
@@ skipping 123 matching lines @@
         , m_willSendRequestCallCount(0)
         , m_childFrameCreationCount(0)
     {
     }
 
     void setChildWebFrameClient(WebFrameClient* client) { m_client = client; }
     WebURLRequest::CachePolicy cachePolicy() const { return m_policy; }
     int willSendRequestCallCount() const { return m_willSendRequestCallCount; }
     int childFrameCreationCount() const { return m_childFrameCreationCount; }
 
-    virtual WebFrame* createChildFrame(WebFrame* parent, const WebString&)
+    virtual WebFrame* createChildFrame(WebLocalFrame* parent, const WebString&)
     {
         m_childFrameCreationCount++;
         WebFrame* frame = WebFrame::create(m_client);
         parent->appendChild(frame);
         return frame;
     }
 
     virtual void frameDetached(WebFrame* frame) OVERRIDE
     {
         if (frame->parent())
             frame->parent()->removeChild(frame);
         frame->close();
     }
 
-    virtual void willSendRequest(WebFrame* frame, unsigned, WebURLRequest& request, const WebURLResponse&) OVERRIDE
+    virtual void willSendRequest(WebLocalFrame* frame, unsigned, WebURLRequest& request, const WebURLResponse&) OVERRIDE
     {
         m_policy = request.cachePolicy();
         m_willSendRequestCallCount++;
     }
 
 private:
     WebURLRequest::CachePolicy m_policy;
     WebFrameClient* m_client;
     int m_willSendRequestCallCount;
     int m_childFrameCreationCount;
@@ skipping 45 matching lines @@
     EXPECT_EQ(item.urlString().utf8(), m_baseURL + "iframe_reload.html");
 }
 
 class TestSameDocumentWebFrameClient : public FrameTestHelpers::TestWebFrameClient {
 public:
     TestSameDocumentWebFrameClient()
         : m_frameLoadTypeSameSeen(false)
     {
     }
 
-    virtual void willSendRequest(WebFrame* frame, unsigned, WebURLRequest&, const WebURLResponse&)
+    virtual void willSendRequest(WebLocalFrame* frame, unsigned, WebURLRequest&, const WebURLResponse&)
     {
         if (toWebFrameImpl(frame)->frame()->loader().loadType() == WebCore::FrameLoadTypeSame)
             m_frameLoadTypeSameSeen = true;
     }
 
     bool frameLoadTypeSameSeen() const { return m_frameLoadTypeSameSeen; }
 
 private:
     bool m_frameLoadTypeSameSeen;
 };
@@ skipping 84 matching lines @@
     EXPECT_EQ(client.differentDocumentStartCount(), 1);
 }
 
 class TestHistoryWebFrameClient : public WebFrameClient {
 public:
     TestHistoryWebFrameClient()
     {
         m_replacesCurrentHistoryItem = false;
         m_frame = 0;
     }
-    void didStartProvisionalLoad(WebFrame* frame)
+    void didStartProvisionalLoad(WebLocalFrame* frame)
     {
         WebDataSource* ds = frame->provisionalDataSource();
         m_replacesCurrentHistoryItem = ds->replacesCurrentHistoryItem();
         m_frame = frame;
     }
 
     bool replacesCurrentHistoryItem() { return m_replacesCurrentHistoryItem; }
     WebFrame* frame() { return m_frame; }
 
 private:
@@ skipping 141 matching lines @@
     // After commit, there is.
     WebHistoryItem item = frame->currentHistoryItem();
     ASSERT_FALSE(item.isNull());
     EXPECT_EQ(url, item.urlString().utf8());
 }
 
 class FailCreateChildFrame : public WebFrameClient {
 public:
     FailCreateChildFrame() : m_callCount(0) { }
 
-    virtual WebFrame* createChildFrame(WebFrame* parent, const WebString& frameName) OVERRIDE
+    virtual WebFrame* createChildFrame(WebLocalFrame* parent, const WebString& frameName) OVERRIDE
     {
         ++m_callCount;
         return 0;
     }
 
     virtual void frameDetached(WebFrame* frame) OVERRIDE
     {
         frame->close();
     }
 
@@ skipping 193 matching lines @@
     EXPECT_EQ(2U, container->percentHeightDescendants()->size());
     EXPECT_TRUE(container->percentHeightDescendants()->contains(percentHeightInAnonymous));
     EXPECT_TRUE(container->percentHeightDescendants()->contains(percentHeightDirectChild));
 
     WebCore::RenderBlock* anonymousBlock = percentHeightInAnonymous->containingBlock();
     EXPECT_TRUE(anonymousBlock->isAnonymous());
     EXPECT_FALSE(anonymousBlock->hasPercentHeightDescendants());
 }
 
 } // namespace