Make the embedder responsible for creating the WebFrame

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 120 matching lines @@
 private:
     OwnPtr<WebLayerTreeView> m_layerTreeView;
 };
 
 class WebFrameTest : public testing::Test {
 public:
     WebFrameTest()
         : m_baseURL("http://www.test.com/")
         , m_chromeURL("chrome://")
         , m_webView(0)
+        , m_mainFrame(0)
     {
     }
 
     virtual ~WebFrameTest()
     {
+        Platform::current()->unitTestSupport()->unregisterAllMockedURLs();
+
         if (m_webView)
             m_webView->close();
-    }
-
-    virtual void TearDown()
-    {
-        Platform::current()->unitTestSupport()->unregisterAllMockedURLs();
+        if (m_mainFrame)
+            m_mainFrame->close();
     }
 
     void registerMockedHttpURLLoad(const std::string& fileName)
     {
         URLTestHelpers::registerMockedURLFromBaseURL(WebString::fromUTF8(m_baseURL.c_str()), WebString::fromUTF8(fileName.c_str()));
     }
 
     void registerMockedChromeURLLoad(const std::string& fileName)
     {
         URLTestHelpers::registerMockedURLFromBaseURL(WebString::fromUTF8(m_chromeURL.c_str()), WebString::fromUTF8(fileName.c_str()));
     }
 
     void createCompositingWebView()
     {
         m_fakeCompositingWebViewClient = adoptPtr(new FakeCompositingWebViewClient());
+        m_mainFrame = WebFrame::create(&m_fakeCompositingWebViewClient->m_fakeWebFrameClient);
         m_webView = WebView::create(m_fakeCompositingWebViewClient.get());
         m_webView->settings()->setJavaScriptEnabled(true);
         m_webView->settings()->setForceCompositingMode(true);
         m_webView->settings()->setAcceleratedCompositingEnabled(true);
         m_webView->settings()->setAcceleratedCompositingForFixedPositionEnabled(true);
         m_webView->settings()->setAcceleratedCompositingForOverflowScrollEnabled(true);
         m_webView->settings()->setAcceleratedCompositingForScrollableFramesEnabled(true);
         m_webView->settings()->setCompositedScrollingForFramesEnabled(true);
         m_webView->settings()->setFixedPositionCreatesStackingContext(true);
-        m_webView->initializeMainFrame(&m_fakeCompositingWebViewClient->m_fakeWebFrameClient);
+        m_webView->initializeMainFrame(m_mainFrame);
+    }
+
+    // Wrapper around FrameTestHelpers::createWebViewAndLoad() that allows the test fixture to handle the main frame's lifetime.
+    void initializeWebViewAndLoad(const std::string& url, bool enableJavascript = false, WebFrameClient* webFrameClient = 0, WebViewClient* webViewClient = 0)
+    {
+        ASSERT(!m_webView);
+        ASSERT(!m_mainFrame);
+        m_mainFrame = WebFrame::create(webFrameClient);
+        initializeWebViewAndLoad(m_mainFrame, url, enableJavascript, webViewClient);
+    }
+
+    void initializeWebView(bool enableJavascript, WebFrameClient* webFrameClient, WebViewClient* webViewClient = 0)
+    {
+        ASSERT(!m_webView);
+        ASSERT(!m_mainFrame);
+        m_mainFrame = WebFrame::create(webFrameClient);
+        initializeWebView(m_mainFrame, enableJavascript, webViewClient);
     }
 
 protected:
     WebViewImpl* webViewImpl() const { return toWebViewImpl(m_webView); }
 
     std::string m_baseURL;
     std::string m_chromeURL;
     OwnPtr<FakeCompositingWebViewClient> m_fakeCompositingWebViewClient;
 
     WebView* m_webView;
+    WebFrame* m_mainFrame;
 };
 
 TEST_F(WebFrameTest, ContentText)
 {
     registerMockedHttpURLLoad("iframes_test.html");
     registerMockedHttpURLLoad("visible_iframe.html");
     registerMockedHttpURLLoad("invisible_iframe.html");
     registerMockedHttpURLLoad("zero_sized_iframe.html");
 
-    m_webView = FrameTestHelpers::createWebViewAndLoad(m_baseURL + "iframes_test.html");
+    initializeWebViewAndLoad(m_baseURL + "iframes_test.html");
 
     // Now retrieve the frames text and test it only includes visible elements.
     std::string content = std::string(m_webView->mainFrame()->contentAsText(1024).utf8().data());
     EXPECT_NE(std::string::npos, content.find(" visible paragraph"));
     EXPECT_NE(std::string::npos, content.find(" visible iframe"));
     EXPECT_EQ(std::string::npos, content.find(" invisible pararaph"));
     EXPECT_EQ(std::string::npos, content.find(" invisible iframe"));
     EXPECT_EQ(std::string::npos, content.find("iframe with zero size"));
 }
 
 TEST_F(WebFrameTest, FrameForEnteredContext)
 {
     registerMockedHttpURLLoad("iframes_test.html");
     registerMockedHttpURLLoad("visible_iframe.html");
     registerMockedHttpURLLoad("invisible_iframe.html");
     registerMockedHttpURLLoad("zero_sized_iframe.html");
 
-    m_webView = FrameTestHelpers::createWebViewAndLoad(m_baseURL + "iframes_test.html", true);
+    initializeWebViewAndLoad(m_baseURL + "iframes_test.html", true);
 
     v8::HandleScope scope(v8::Isolate::GetCurrent());
     EXPECT_EQ(m_webView->mainFrame(),
               WebFrame::frameForContext(
                   m_webView->mainFrame()->mainWorldScriptContext()));
     EXPECT_EQ(m_webView->mainFrame()->firstChild(),
               WebFrame::frameForContext(
                   m_webView->mainFrame()->firstChild()->mainWorldScriptContext()));
 }
 
 TEST_F(WebFrameTest, FormWithNullFrame)
 {
     registerMockedHttpURLLoad("form.html");
 
-    m_webView = FrameTestHelpers::createWebViewAndLoad(m_baseURL + "form.html");
+    initializeWebViewAndLoad(m_baseURL + "form.html");
 
     WebVector<WebFormElement> forms;
     m_webView->mainFrame()->document().forms(forms);
     m_webView->close();
     m_webView = 0;
 
     EXPECT_EQ(forms.size(), 1U);
 
     // This test passes if this doesn't crash.
     WebSearchableFormData searchableDataForm(forms[0]);
 }
 
 TEST_F(WebFrameTest, ChromePageJavascript)
 {
     registerMockedChromeURLLoad("history.html");
 
     // Pass true to enable JavaScript.
-    m_webView = FrameTestHelpers::createWebViewAndLoad(m_chromeURL + "history.html", true);
+    initializeWebViewAndLoad(m_chromeURL + "history.html", true);
 
     // Try to run JS against the chrome-style URL.
     FrameTestHelpers::loadFrame(m_webView->mainFrame(), "javascript:document.body.appendChild(document.createTextNode('Clobbered'))");
 
     // Required to see any updates in contentAsText.
     m_webView->layout();
 
     // Now retrieve the frame's text and ensure it was modified by running javascript.
     std::string content = std::string(m_webView->mainFrame()->contentAsText(1024).utf8().data());
     EXPECT_NE(std::string::npos, content.find("Clobbered"));
 }
 
 TEST_F(WebFrameTest, ChromePageNoJavascript)
 {
     registerMockedChromeURLLoad("history.html");
 
     /// Pass true to enable JavaScript.
-    m_webView = FrameTestHelpers::createWebViewAndLoad(m_chromeURL + "history.html", true);
+    initializeWebViewAndLoad(m_chromeURL + "history.html", true);
 
     // Try to run JS against the chrome-style URL after prohibiting it.
     WebSecurityPolicy::registerURLSchemeAsNotAllowingJavascriptURLs("chrome");
     FrameTestHelpers::loadFrame(m_webView->mainFrame(), "javascript:document.body.appendChild(document.createTextNode('Clobbered'))");
 
     // Required to see any updates in contentAsText.
     m_webView->layout();
 
     // Now retrieve the frame's text and ensure it wasn't modified by running javascript.
     std::string content = std::string(m_webView->mainFrame()->contentAsText(1024).utf8().data());
     EXPECT_EQ(std::string::npos, content.find("Clobbered"));
 }
 
 TEST_F(WebFrameTest, DispatchMessageEventWithOriginCheck)
 {
     registerMockedHttpURLLoad("postmessage_test.html");
 
     // Pass true to enable JavaScript.
-    m_webView = FrameTestHelpers::createWebViewAndLoad(m_baseURL + "postmessage_test.html", true);
+    initializeWebViewAndLoad(m_baseURL + "postmessage_test.html", true);
 
     // Send a message with the correct origin.
     WebSecurityOrigin correctOrigin(WebSecurityOrigin::create(toKURL(m_baseURL)));
     WebDOMEvent event = m_webView->mainFrame()->document().createEvent("MessageEvent");
     WebDOMMessageEvent message = event.to<WebDOMMessageEvent>();
     WebSerializedScriptValue data(WebSerializedScriptValue::fromString("foo"));
     message.initMessageEvent("message", false, false, data, "http://origin.com", 0, "");
     m_webView->mainFrame()->dispatchMessageEventWithOriginCheck(correctOrigin, message);
 
     // Send another message with incorrect origin.
@@ skipping 19 matching lines @@
 TEST_F(WebFrameTest, FrameViewNeedsLayoutOnFixedLayoutResize)
 {
     registerMockedHttpURLLoad("fixed_layout.html");
 
     FixedLayoutTestWebViewClient client;
     int viewportWidth = 640;
     int viewportHeight = 480;
 
     // Make sure we initialize to minimum scale, even if the window size
     // only becomes available after the load begins.
-    m_webView = FrameTestHelpers::createWebViewAndLoad(m_baseURL + "fixed_layout.html", true, 0, &client);
+    initializeWebViewAndLoad(m_baseURL + "fixed_layout.html", true, 0, &client);
     m_webView->enableFixedLayoutMode(true);
     m_webView->settings()->setViewportEnabled(true);
     m_webView->resize(WebSize(viewportWidth, viewportHeight));
     m_webView->layout();
 
     webViewImpl()->mainFrameImpl()->frameView()->setFixedLayoutSize(WebCore::IntSize(100, 100));
     EXPECT_TRUE(webViewImpl()->mainFrameImpl()->frameView()->needsLayout());
 
     int prevLayoutCount = webViewImpl()->mainFrameImpl()->frameView()->layoutCount();
     webViewImpl()->mainFrameImpl()->frameView()->setFrameRect(WebCore::IntRect(0, 0, 641, 481));
     EXPECT_EQ(prevLayoutCount, webViewImpl()->mainFrameImpl()->frameView()->layoutCount());
 
     webViewImpl()->layout();
 }
 
 TEST_F(WebFrameTest, ChangeInFixedLayoutTriggersTextAutosizingRecalculate)
 {
     registerMockedHttpURLLoad("fixed_layout.html");
 
     FixedLayoutTestWebViewClient client;
     int viewportWidth = 640;
     int viewportHeight = 480;
 
     // Make sure we initialize to minimum scale, even if the window size
     // only becomes available after the load begins.
-    m_webView = FrameTestHelpers::createWebViewAndLoad(m_baseURL + "fixed_layout.html", true, 0, &client);
+    initializeWebViewAndLoad(m_baseURL + "fixed_layout.html", true, 0, &client);
     m_webView->enableFixedLayoutMode(true);
     m_webView->settings()->setViewportEnabled(true);
 
     WebCore::Document* document = webViewImpl()->page()->mainFrame()->document();
     document->settings()->setTextAutosizingEnabled(true);
     EXPECT_TRUE(document->settings()->textAutosizingEnabled());
     webViewImpl()->resize(WebSize(viewportWidth, viewportHeight));
     webViewImpl()->layout();
 
     WebCore::RenderObject* renderer = document->renderer();
@@ skipping 29 matching lines @@
 TEST_F(WebFrameTest, DeviceScaleFactorUsesDefaultWithoutViewportTag)
 {
     registerMockedHttpURLLoad("no_viewport_tag.html");
 
     int viewportWidth = 640;
     int viewportHeight = 480;
 
     FixedLayoutTestWebViewClient client;
     client.m_screenInfo.deviceScaleFactor = 2;
 
-    m_webView = FrameTestHelpers::createWebViewAndLoad(m_baseURL + "no_viewport_tag.html", true, 0, &client);
+    initializeWebViewAndLoad(m_baseURL + "no_viewport_tag.html", true, 0, &client);
 
     m_webView->settings()->setViewportEnabled(true);
     m_webView->enableFixedLayoutMode(true);
     m_webView->resize(WebSize(viewportWidth, viewportHeight));
     m_webView->layout();
 
     EXPECT_EQ(2, m_webView->deviceScaleFactor());
 
     // Device scale factor should be independent of page scale.
     m_webView->setPageScaleFactorLimits(1, 2);
@@ skipping 12 matching lines @@
 
     registerMockedHttpURLLoad("fixed_layout.html");
 
     FixedLayoutTestWebViewClient client;
     client.m_screenInfo.deviceScaleFactor = 1;
     int viewportWidth = 640;
     int viewportHeight = 480;
 
     // Make sure we initialize to minimum scale, even if the window size
     // only becomes available after the load begins.
-    m_webView = FrameTestHelpers::createWebViewAndLoad(m_baseURL + "fixed_layout.html", true, 0, &client);
+    initializeWebViewAndLoad(m_baseURL + "fixed_layout.html", true, 0, &client);
     m_webView->enableFixedLayoutMode(true);
     m_webView->settings()->setViewportEnabled(true);
     m_webView->resize(WebSize(viewportWidth, viewportHeight));
 
     int defaultFixedLayoutWidth = 980;
     float minimumPageScaleFactor = viewportWidth / (float) defaultFixedLayoutWidth;
     EXPECT_EQ(minimumPageScaleFactor, m_webView->pageScaleFactor());
     EXPECT_EQ(minimumPageScaleFactor, m_webView->minimumPageScaleFactor());
 
     // Assume the user has pinch zoomed to page scale factor 2.
@@ skipping 19 matching lines @@
 
     registerMockedHttpURLLoad("wide_document.html");
 
     FixedLayoutTestWebViewClient client;
     client.m_screenInfo.deviceScaleFactor = 1;
     int viewportWidth = 640;
     int viewportHeight = 480;
 
     // Make sure we initialize to minimum scale, even if the window size
     // only becomes available after the load begins.
-    m_webView = FrameTestHelpers::createWebViewAndLoad(m_baseURL + "wide_document.html", true, 0, &client);
+    initializeWebViewAndLoad(m_baseURL + "wide_document.html", true, 0, &client);
     m_webView->enableFixedLayoutMode(true);
     m_webView->settings()->setViewportEnabled(true);
     m_webView->resize(WebSize(viewportWidth, viewportHeight));
 
     int wideDocumentWidth = 1500;
     float minimumPageScaleFactor = viewportWidth / (float) wideDocumentWidth;
     EXPECT_EQ(minimumPageScaleFactor, m_webView->pageScaleFactor());
     EXPECT_EQ(minimumPageScaleFactor, m_webView->minimumPageScaleFactor());
 
     // Assume the user has pinch zoomed to page scale factor 2.
@@ skipping 14 matching lines @@
 
 TEST_F(WebFrameTest, setLoadWithOverviewModeToFalse)
 {
     registerMockedHttpURLLoad("viewport-auto-initial-scale.html");
 
     FixedLayoutTestWebViewClient client;
     client.m_screenInfo.deviceScaleFactor = 1;
     int viewportWidth = 640;
     int viewportHeight = 480;
 
-    m_webView = FrameTestHelpers::createWebViewAndLoad(m_baseURL + "viewport-auto-initial-scale.html", true, 0, &client);
+    initializeWebViewAndLoad(m_baseURL + "viewport-auto-initial-scale.html", true, 0, &client);
     m_webView->enableFixedLayoutMode(true);
     m_webView->settings()->setViewportEnabled(true);
     m_webView->settings()->setLoadWithOverviewMode(false);
     m_webView->settings()->setSupportDeprecatedTargetDensityDPI(true);
     m_webView->resize(WebSize(viewportWidth, viewportHeight));
 
     // The page must be displayed at 100% zoom.
     EXPECT_EQ(1.0f, m_webView->pageScaleFactor());
 }
 
 TEST_F(WebFrameTest, SetLoadWithOverviewModeToFalseAndNoWideViewport)
 {
     registerMockedHttpURLLoad("large-div.html");
 
     FixedLayoutTestWebViewClient client;
     client.m_screenInfo.deviceScaleFactor = 1;
     int viewportWidth = 640;
     int viewportHeight = 480;
 
-    m_webView = FrameTestHelpers::createWebViewAndLoad(m_baseURL + "large-div.html", true, 0, &client);
+    initializeWebViewAndLoad(m_baseURL + "large-div.html", true, 0, &client);
     m_webView->enableFixedLayoutMode(true);
     m_webView->settings()->setViewportEnabled(true);
     m_webView->settings()->setLoadWithOverviewMode(false);
     m_webView->settings()->setUseWideViewport(false);
     m_webView->settings()->setSupportDeprecatedTargetDensityDPI(true);
     m_webView->resize(WebSize(viewportWidth, viewportHeight));
 
     // The page must be displayed at 100% zoom, despite that it hosts a wide div element.
     EXPECT_EQ(1.0f, m_webView->pageScaleFactor());
 }
 
 TEST_F(WebFrameTest, NoWideViewportIgnoresPageViewportWidth)
 {
     registerMockedHttpURLLoad("viewport-auto-initial-scale.html");
 
     FixedLayoutTestWebViewClient client;
     client.m_screenInfo.deviceScaleFactor = 1;
     int viewportWidth = 640;
     int viewportHeight = 480;
 
-    m_webView = FrameTestHelpers::createWebViewAndLoad(m_baseURL + "viewport-auto-initial-scale.html", true, 0, &client);
+    initializeWebViewAndLoad(m_baseURL + "viewport-auto-initial-scale.html", true, 0, &client);
     m_webView->enableFixedLayoutMode(true);
     m_webView->settings()->setViewportEnabled(true);
     m_webView->settings()->setUseWideViewport(false);
     m_webView->settings()->setSupportDeprecatedTargetDensityDPI(true);
     m_webView->resize(WebSize(viewportWidth, viewportHeight));
 
     // The page sets viewport width to 3000, but with UseWideViewport == false is must be ignored.
     EXPECT_EQ(viewportWidth, webViewImpl()->mainFrameImpl()->frameView()->contentsSize().width());
     EXPECT_EQ(viewportHeight, webViewImpl()->mainFrameImpl()->frameView()->contentsSize().height());
 }
 
 TEST_F(WebFrameTest, NoWideViewportIgnoresPageViewportWidthButAccountsScale)
 {
     registerMockedHttpURLLoad("viewport-wide-2x-initial-scale.html");
 
     FixedLayoutTestWebViewClient client;
     client.m_screenInfo.deviceScaleFactor = 1;
     int viewportWidth = 640;
     int viewportHeight = 480;
 
-    m_webView = FrameTestHelpers::createWebViewAndLoad(m_baseURL + "viewport-wide-2x-initial-scale.html", true, 0, &client);
+    initializeWebViewAndLoad(m_baseURL + "viewport-wide-2x-initial-scale.html", true, 0, &client);
     m_webView->enableFixedLayoutMode(true);
     m_webView->settings()->setViewportEnabled(true);
     m_webView->settings()->setUseWideViewport(false);
     m_webView->settings()->setSupportDeprecatedTargetDensityDPI(true);
     m_webView->resize(WebSize(viewportWidth, viewportHeight));
 
     // The page sets viewport width to 3000, but with UseWideViewport == false is must be ignored.
     // While the initial scale specified by the page must be accounted.
     EXPECT_EQ(viewportWidth / 2, webViewImpl()->mainFrameImpl()->frameView()->contentsSize().width());
     EXPECT_EQ(viewportHeight / 2, webViewImpl()->mainFrameImpl()->frameView()->contentsSize().height());
 }
 
 TEST_F(WebFrameTest, WideViewportSetsTo980WithoutViewportTag)
 {
     registerMockedHttpURLLoad("no_viewport_tag.html");
 
     FixedLayoutTestWebViewClient client;
     client.m_screenInfo.deviceScaleFactor = 1;
     int viewportWidth = 640;
     int viewportHeight = 480;
 
-    m_webView = FrameTestHelpers::createWebViewAndLoad(m_baseURL + "no_viewport_tag.html", true, 0, &client);
+    initializeWebViewAndLoad(m_baseURL + "no_viewport_tag.html", true, 0, &client);
     m_webView->settings()->setSupportDeprecatedTargetDensityDPI(true);
     m_webView->enableFixedLayoutMode(true);
     m_webView->settings()->setUseWideViewport(true);
     m_webView->settings()->setViewportEnabled(true);
     m_webView->resize(WebSize(viewportWidth, viewportHeight));
 
     EXPECT_EQ(980, webViewImpl()->mainFrameImpl()->frameView()->contentsSize().width());
     EXPECT_EQ(980.0 / viewportWidth * viewportHeight, webViewImpl()->mainFrameImpl()->frameView()->contentsSize().height());
 }
 
 TEST_F(WebFrameTest, NoWideViewportAndHeightInMeta)
 {
     registerMockedHttpURLLoad("viewport-height-1000.html");
 
     FixedLayoutTestWebViewClient client;
     client.m_screenInfo.deviceScaleFactor = 1;
     int viewportWidth = 640;
     int viewportHeight = 480;
 
-    m_webView = FrameTestHelpers::createWebViewAndLoad(m_baseURL + "viewport-height-1000.html", true, 0, &client);
+    initializeWebViewAndLoad(m_baseURL + "viewport-height-1000.html", true, 0, &client);
     m_webView->settings()->setSupportDeprecatedTargetDensityDPI(true);
     m_webView->enableFixedLayoutMode(true);
     m_webView->settings()->setUseWideViewport(false);
     m_webView->settings()->setViewportEnabled(true);
     m_webView->resize(WebSize(viewportWidth, viewportHeight));
 
     EXPECT_EQ(viewportWidth, webViewImpl()->mainFrameImpl()->frameView()->contentsSize().width());
 }
 
 TEST_F(WebFrameTest, WideViewportSetsTo980WithAutoWidth)
 {
     registerMockedHttpURLLoad("viewport-2x-initial-scale.html");
 
     FixedLayoutTestWebViewClient client;
     client.m_screenInfo.deviceScaleFactor = 1;
     int viewportWidth = 640;
     int viewportHeight = 480;
 
-    m_webView = FrameTestHelpers::createWebViewAndLoad(m_baseURL + "viewport-2x-initial-scale.html", true, 0, &client);
+    initializeWebViewAndLoad(m_baseURL + "viewport-2x-initial-scale.html", true, 0, &client);
     m_webView->settings()->setSupportDeprecatedTargetDensityDPI(true);
     m_webView->enableFixedLayoutMode(true);
     m_webView->settings()->setUseWideViewport(true);
     m_webView->settings()->setViewportEnabled(true);
     m_webView->resize(WebSize(viewportWidth, viewportHeight));
 
     EXPECT_EQ(980, webViewImpl()->mainFrameImpl()->frameView()->contentsSize().width());
     EXPECT_EQ(980.0 / viewportWidth * viewportHeight, webViewImpl()->mainFrameImpl()->frameView()->contentsSize().height());
 }
 
 TEST_F(WebFrameTest, PageViewportInitialScaleOverridesLoadWithOverviewMode)
 {
     registerMockedHttpURLLoad("viewport-wide-2x-initial-scale.html");
 
     FixedLayoutTestWebViewClient client;
     client.m_screenInfo.deviceScaleFactor = 1;
     int viewportWidth = 640;
     int viewportHeight = 480;
 
-    m_webView = FrameTestHelpers::createWebViewAndLoad(m_baseURL + "viewport-wide-2x-initial-scale.html", true, 0, &client);
+    initializeWebViewAndLoad(m_baseURL + "viewport-wide-2x-initial-scale.html", true, 0, &client);
     m_webView->enableFixedLayoutMode(true);
     m_webView->settings()->setSupportDeprecatedTargetDensityDPI(true);
     m_webView->settings()->setViewportEnabled(true);
     m_webView->settings()->setLoadWithOverviewMode(false);
     m_webView->resize(WebSize(viewportWidth, viewportHeight));
 
     // The page must be displayed at 200% zoom, as specified in its viewport meta tag.
     EXPECT_EQ(2.0f, m_webView->pageScaleFactor());
 }
 
 TEST_F(WebFrameTest, setInitialPageScaleFactorPermanently)
 {
     WebCore::Settings::setMockScrollbarsEnabled(true);
     WebCore::Settings::setUsesOverlayScrollbars(true);
 
     registerMockedHttpURLLoad("fixed_layout.html");
 
     FixedLayoutTestWebViewClient client;
     client.m_screenInfo.deviceScaleFactor = 1;
     float enforcedPageScaleFactor = 2.0f;
 
-    m_webView = FrameTestHelpers::createWebViewAndLoad(m_baseURL + "fixed_layout.html", true, 0, &client);
+    initializeWebViewAndLoad(m_baseURL + "fixed_layout.html", true, 0, &client);
     m_webView->settings()->setSupportDeprecatedTargetDensityDPI(true);
     m_webView->settings()->setLoadWithOverviewMode(false);
     m_webView->setInitialPageScaleOverride(enforcedPageScaleFactor);
     m_webView->enableFixedLayoutMode(true);
     m_webView->settings()->setViewportEnabled(true);
     m_webView->layout();
 
     EXPECT_EQ(enforcedPageScaleFactor, m_webView->pageScaleFactor());
 
     int viewportWidth = 640;
@@ skipping 11 matching lines @@
 TEST_F(WebFrameTest, PermanentInitialPageScaleFactorOverridesLoadWithOverviewMode)
 {
     registerMockedHttpURLLoad("viewport-auto-initial-scale.html");
 
     FixedLayoutTestWebViewClient client;
     client.m_screenInfo.deviceScaleFactor = 1;
     int viewportWidth = 640;
     int viewportHeight = 480;
     float enforcedPageScalePactor = 0.5f;
 
-    m_webView = FrameTestHelpers::createWebViewAndLoad(m_baseURL + "viewport-auto-initial-scale.html", true, 0, &client);
+    initializeWebViewAndLoad(m_baseURL + "viewport-auto-initial-scale.html", true, 0, &client);
     m_webView->enableFixedLayoutMode(true);
     m_webView->settings()->setSupportDeprecatedTargetDensityDPI(true);
     m_webView->settings()->setViewportEnabled(true);
     m_webView->settings()->setLoadWithOverviewMode(false);
     m_webView->setInitialPageScaleOverride(enforcedPageScalePactor);
     m_webView->resize(WebSize(viewportWidth, viewportHeight));
 
     EXPECT_EQ(enforcedPageScalePactor, m_webView->pageScaleFactor());
 }
 
 TEST_F(WebFrameTest, PermanentInitialPageScaleFactorOverridesPageViewportInitialScale)
 {
     registerMockedHttpURLLoad("viewport-wide-2x-initial-scale.html");
 
     FixedLayoutTestWebViewClient client;
     client.m_screenInfo.deviceScaleFactor = 1;
     int viewportWidth = 640;
     int viewportHeight = 480;
     float enforcedPageScalePactor = 0.5f;
 
-    m_webView = FrameTestHelpers::createWebViewAndLoad(m_baseURL + "viewport-wide-2x-initial-scale.html", true, 0, &client);
+    initializeWebViewAndLoad(m_baseURL + "viewport-wide-2x-initial-scale.html", true, 0, &client);
     m_webView->enableFixedLayoutMode(true);
     m_webView->settings()->setViewportEnabled(true);
     m_webView->setInitialPageScaleOverride(enforcedPageScalePactor);
     m_webView->resize(WebSize(viewportWidth, viewportHeight));
 
     EXPECT_EQ(enforcedPageScalePactor, m_webView->pageScaleFactor());
 }
 
 TEST_F(WebFrameTest, WideViewportInitialScaleDoesNotExpandFixedLayoutWidth)
 {
     registerMockedHttpURLLoad("viewport-device-0.5x-initial-scale.html");
 
     FixedLayoutTestWebViewClient client;
     client.m_screenInfo.deviceScaleFactor = 1;
     int viewportWidth = 640;
     int viewportHeight = 480;
 
-    m_webView = FrameTestHelpers::createWebViewAndLoad(m_baseURL + "viewport-device-0.5x-initial-scale.html", true, 0, &client);
+    initializeWebViewAndLoad(m_baseURL + "viewport-device-0.5x-initial-scale.html", true, 0, &client);
     m_webView->enableFixedLayoutMode(true);
     m_webView->settings()->setViewportEnabled(true);
     m_webView->settings()->setUseWideViewport(true);
     m_webView->settings()->setSupportDeprecatedTargetDensityDPI(true);
     m_webView->settings()->setViewportMetaLayoutSizeQuirk(true);
     m_webView->resize(WebSize(viewportWidth, viewportHeight));
 
     WebViewImpl* webViewImpl = static_cast<WebViewImpl*>(m_webView);
     EXPECT_EQ(viewportWidth, webViewImpl->mainFrameImpl()->frameView()->fixedLayoutSize().width());
 }
 
 TEST_F(WebFrameTest, ZeroValuesQuirk)
 {
     registerMockedHttpURLLoad("viewport-zero-values.html");
 
     FixedLayoutTestWebViewClient client;
     client.m_screenInfo.deviceScaleFactor = 1;
     int viewportWidth = 640;
     int viewportHeight = 480;
 
-    m_webView = FrameTestHelpers::createWebView(true, 0, &client);
+    initializeWebView(true, 0, &client);
     m_webView->enableFixedLayoutMode(true);
     m_webView->settings()->setViewportEnabled(true);
     m_webView->settings()->setSupportDeprecatedTargetDensityDPI(true);
     m_webView->settings()->setViewportMetaZeroValuesQuirk(true);
     FrameTestHelpers::loadFrame(m_webView->mainFrame(), m_baseURL + "viewport-zero-values.html");
     Platform::current()->unitTestSupport()->serveAsynchronousMockedRequests();
     m_webView->resize(WebSize(viewportWidth, viewportHeight));
 
     WebViewImpl* webViewImpl = static_cast<WebViewImpl*>(m_webView);
     EXPECT_EQ(viewportWidth, webViewImpl->mainFrameImpl()->frameView()->fixedLayoutSize().width());
     EXPECT_EQ(1.0f, m_webView->pageScaleFactor());
 
     m_webView->settings()->setUseWideViewport(true);
     m_webView->layout();
     EXPECT_EQ(viewportWidth, webViewImpl->mainFrameImpl()->frameView()->fixedLayoutSize().width());
     EXPECT_EQ(1.0f, m_webView->pageScaleFactor());
 }
 
 TEST_F(WebFrameTest, ScaleFactorShouldNotOscillate)
 {
     registerMockedHttpURLLoad("scale_oscillate.html");
 
     FixedLayoutTestWebViewClient client;
     client.m_screenInfo.deviceScaleFactor = static_cast<float>(1.325);
     int viewportWidth = 800;
     int viewportHeight = 1057;
 
-    m_webView = FrameTestHelpers::createWebViewAndLoad(m_baseURL + "scale_oscillate.html", true, 0, &client);
+    initializeWebViewAndLoad(m_baseURL + "scale_oscillate.html", true, 0, &client);
     m_webView->enableFixedLayoutMode(true);
     m_webView->settings()->setViewportEnabled(true);
     m_webView->resize(WebSize(viewportWidth, viewportHeight));
     m_webView->layout();
 }
 
 TEST_F(WebFrameTest, setPageScaleFactorDoesNotLayout)
 {
     registerMockedHttpURLLoad("fixed_layout.html");
 
     FixedLayoutTestWebViewClient client;
     client.m_screenInfo.deviceScaleFactor = 1;
     // Small viewport to ensure there are always scrollbars.
     int viewportWidth = 64;
     int viewportHeight = 48;
 
-    m_webView = FrameTestHelpers::createWebViewAndLoad(m_baseURL + "fixed_layout.html", true, 0, &client);
+    initializeWebViewAndLoad(m_baseURL + "fixed_layout.html", true, 0, &client);
     m_webView->enableFixedLayoutMode(true);
     m_webView->settings()->setViewportEnabled(true);
     m_webView->resize(WebSize(viewportWidth, viewportHeight));
     m_webView->layout();
 
     int prevLayoutCount = webViewImpl()->mainFrameImpl()->frameView()->layoutCount();
     webViewImpl()->setPageScaleFactor(3, WebPoint());
     EXPECT_FALSE(webViewImpl()->mainFrameImpl()->frameView()->needsLayout());
     EXPECT_EQ(prevLayoutCount, webViewImpl()->mainFrameImpl()->frameView()->layoutCount());
 }
 
 TEST_F(WebFrameTest, setPageScaleFactorWithOverlayScrollbarsDoesNotLayout)
 {
     WebCore::Settings::setMockScrollbarsEnabled(true);
     WebCore::Settings::setUsesOverlayScrollbars(true);
     EXPECT_TRUE(WebCore::ScrollbarTheme::theme()->usesOverlayScrollbars());
 
     registerMockedHttpURLLoad("fixed_layout.html");
 
     FixedLayoutTestWebViewClient client;
     client.m_screenInfo.deviceScaleFactor = 1;
     int viewportWidth = 640;
     int viewportHeight = 480;
 
-    m_webView = FrameTestHelpers::createWebViewAndLoad(m_baseURL + "fixed_layout.html", true, 0, &client);
+    initializeWebViewAndLoad(m_baseURL + "fixed_layout.html", true, 0, &client);
     m_webView->enableFixedLayoutMode(true);
     m_webView->settings()->setViewportEnabled(true);
     m_webView->resize(WebSize(viewportWidth, viewportHeight));
     m_webView->layout();
 
     int prevLayoutCount = webViewImpl()->mainFrameImpl()->frameView()->layoutCount();
     webViewImpl()->setPageScaleFactor(30, WebPoint());
     EXPECT_FALSE(webViewImpl()->mainFrameImpl()->frameView()->needsLayout());
     EXPECT_EQ(prevLayoutCount, webViewImpl()->mainFrameImpl()->frameView()->layoutCount());
 
     WebCore::Settings::setMockScrollbarsEnabled(false);
     WebCore::Settings::setUsesOverlayScrollbars(false);
 }
 
 TEST_F(WebFrameTest, setPageScaleFactorBeforeFrameHasView)
 {
     registerMockedHttpURLLoad("fixed_layout.html");
 
     float pageScaleFactor = 3;
-    m_webView = FrameTestHelpers::createWebViewAndLoad("about:html", true, 0, 0);
+    initializeWebViewAndLoad("about:html", true, 0, 0);
     m_webView->setPageScaleFactor(pageScaleFactor, WebPoint());
 
     FrameTestHelpers::loadFrame(m_webView->mainFrame(), m_baseURL + "fixed_layout.html");
     Platform::current()->unitTestSupport()->serveAsynchronousMockedRequests();
     WebCore::FrameView* view = webViewImpl()->mainFrameImpl()->frameView();
     EXPECT_EQ(pageScaleFactor, view->visibleContentScaleFactor());
 }
 
 TEST_F(WebFrameTest, pageScaleFactorWrittenToHistoryItem)
 {
     registerMockedHttpURLLoad("fixed_layout.html");
 
     FixedLayoutTestWebViewClient client;
     client.m_screenInfo.deviceScaleFactor = 1;
     int viewportWidth = 640;
     int viewportHeight = 480;
 
-    m_webView = FrameTestHelpers::createWebViewAndLoad(m_baseURL + "fixed_layout.html", true, 0, &client);
+    initializeWebViewAndLoad(m_baseURL + "fixed_layout.html", true, 0, &client);
     m_webView->enableFixedLayoutMode(true);
     m_webView->settings()->setViewportEnabled(true);
     m_webView->resize(WebSize(viewportWidth, viewportHeight));
     m_webView->layout();
 
     m_webView->setPageScaleFactor(3, WebPoint());
     webViewImpl()->page()->mainFrame()->loader()->history()->saveDocumentAndScrollState();
     m_webView->setPageScaleFactor(1, WebPoint());
     webViewImpl()->page()->mainFrame()->loader()->history()->restoreScrollPositionAndViewState();
     EXPECT_EQ(3, m_webView->pageScaleFactor());
 }
 
 TEST_F(WebFrameTest, pageScaleFactorShrinksViewport)
 {
     registerMockedHttpURLLoad("fixed_layout.html");
 
     FixedLayoutTestWebViewClient client;
     client.m_screenInfo.deviceScaleFactor = 1;
     // Small viewport to ensure there are always scrollbars.
     int viewportWidth = 64;
     int viewportHeight = 48;
 
-    m_webView = FrameTestHelpers::createWebViewAndLoad(m_baseURL + "fixed_layout.html", true, 0, &client);
+    initializeWebViewAndLoad(m_baseURL + "fixed_layout.html", true, 0, &client);
     m_webView->enableFixedLayoutMode(true);
     m_webView->settings()->setViewportEnabled(true);
     m_webView->resize(WebSize(viewportWidth, viewportHeight));
     m_webView->layout();
 
     WebCore::FrameView* view = webViewImpl()->mainFrameImpl()->frameView();
     int viewportWidthMinusScrollbar = viewportWidth - (view->verticalScrollbar()->isOverlayScrollbar() ? 0 : 15);
     int viewportHeightMinusScrollbar = viewportHeight - (view->horizontalScrollbar()->isOverlayScrollbar() ? 0 : 15);
 
     m_webView->setPageScaleFactor(2, WebPoint());
@@ skipping 13 matching lines @@
 
 TEST_F(WebFrameTest, pageScaleFactorDoesNotApplyCssTransform)
 {
     registerMockedHttpURLLoad("fixed_layout.html");
 
     FixedLayoutTestWebViewClient client;
     client.m_screenInfo.deviceScaleFactor = 1;
     int viewportWidth = 640;
     int viewportHeight = 480;
 
-    m_webView = FrameTestHelpers::createWebViewAndLoad(m_baseURL + "fixed_layout.html", true, 0, &client);
+    initializeWebViewAndLoad(m_baseURL + "fixed_layout.html", true, 0, &client);
     m_webView->enableFixedLayoutMode(true);
     m_webView->settings()->setViewportEnabled(true);
     m_webView->resize(WebSize(viewportWidth, viewportHeight));
     m_webView->layout();
 
     m_webView->setPageScaleFactor(2, WebPoint());
 
     EXPECT_EQ(980, webViewImpl()->page()->mainFrame()->contentRenderer()->unscaledDocumentRect().width());
     EXPECT_EQ(980, webViewImpl()->mainFrameImpl()->frameView()->contentsSize().width());
 }
 
 TEST_F(WebFrameTest, targetDensityDpiHigh)
 {
     WebCore::Settings::setMockScrollbarsEnabled(true);
     WebCore::Settings::setUsesOverlayScrollbars(true);
     registerMockedHttpURLLoad("viewport-target-densitydpi-high.html");
 
     FixedLayoutTestWebViewClient client;
     // high-dpi = 240
     float targetDpi = 240.0f;
     float deviceScaleFactors[] = { 1.0f, 4.0f / 3.0f, 2.0f };
     int viewportWidth = 640;
     int viewportHeight = 480;
 
     for (size_t i = 0; i < ARRAY_SIZE(deviceScaleFactors); ++i) {
         float deviceScaleFactor = deviceScaleFactors[i];
         float deviceDpi = deviceScaleFactor * 160.0f;
         client.m_screenInfo.deviceScaleFactor = deviceScaleFactor;
 
-        m_webView = FrameTestHelpers::createWebViewAndLoad(m_baseURL + "viewport-target-densitydpi-high.html", true, 0, &client);
+        initializeWebViewAndLoad(m_baseURL + "viewport-target-densitydpi-high.html", true, 0, &client);
         m_webView->enableFixedLayoutMode(true);
         m_webView->settings()->setViewportEnabled(true);
         m_webView->settings()->setSupportDeprecatedTargetDensityDPI(true);
         m_webView->resize(WebSize(viewportWidth, viewportHeight));
 
         // We need to account for the fact that logical pixels are unconditionally multiplied by deviceScaleFactor to produce
         // physical pixels.
         float densityDpiScaleRatio = deviceScaleFactor * targetDpi / deviceDpi;
         EXPECT_NEAR(viewportWidth * densityDpiScaleRatio, m_webView->fixedLayoutSize().width, 1.0f);
         EXPECT_NEAR(viewportHeight * densityDpiScaleRatio, m_webView->fixedLayoutSize().height, 1.0f);
@@ skipping 12 matching lines @@
 
     float deviceScaleFactors[] = { 1.0f, 4.0f / 3.0f, 2.0f };
 
     FixedLayoutTestWebViewClient client;
     int viewportWidth = 640;
     int viewportHeight = 480;
 
     for (size_t i = 0; i < ARRAY_SIZE(deviceScaleFactors); ++i) {
         client.m_screenInfo.deviceScaleFactor = deviceScaleFactors[i];
 
-        m_webView = FrameTestHelpers::createWebViewAndLoad(m_baseURL + "viewport-target-densitydpi-device.html", true, 0, &client);
+        initializeWebViewAndLoad(m_baseURL + "viewport-target-densitydpi-device.html", true, 0, &client);
         m_webView->enableFixedLayoutMode(true);
         m_webView->settings()->setViewportEnabled(true);
         m_webView->settings()->setSupportDeprecatedTargetDensityDPI(true);
         m_webView->resize(WebSize(viewportWidth, viewportHeight));
 
         EXPECT_NEAR(viewportWidth * client.m_screenInfo.deviceScaleFactor, m_webView->fixedLayoutSize().width, 1.0f);
         EXPECT_NEAR(viewportHeight * client.m_screenInfo.deviceScaleFactor, m_webView->fixedLayoutSize().height, 1.0f);
         EXPECT_NEAR(1.0f / client.m_screenInfo.deviceScaleFactor, m_webView->pageScaleFactor(), 0.01f);
 
         m_webView->close();
@@ skipping 13 matching lines @@
 
     void testResizeYieldsCorrectScrollAndScale(const char* url,
                                                const float initialPageScaleFactor,
                                                const WebSize scrollOffset,
                                                const WebSize viewportSize,
                                                const bool shouldScaleRelativeToViewportWidth) {
         registerMockedHttpURLLoad(url);
 
         const float aspectRatio = static_cast<float>(viewportSize.width) / viewportSize.height;
 
-        m_webView = FrameTestHelpers::createWebViewAndLoad(m_baseURL + url, true);
+        initializeWebViewAndLoad(m_baseURL + url, true);
         m_webView->settings()->setViewportEnabled(true);
         m_webView->enableFixedLayoutMode(true);
 
         // Origin scrollOffsets preserved under resize.
         {
             webViewImpl()->resize(WebSize(viewportSize.width, viewportSize.height));
             webViewImpl()->setPageScaleFactor(initialPageScaleFactor, WebPoint());
             ASSERT_EQ(viewportSize, webViewImpl()->size());
             ASSERT_EQ(initialPageScaleFactor, webViewImpl()->pageScaleFactor());
             webViewImpl()->resize(WebSize(viewportSize.height, viewportSize.width));
@@ skipping 86 matching lines @@
 
 TEST_F(WebFrameTest, pageScaleFactorScalesPaintClip)
 {
     registerMockedHttpURLLoad("fixed_layout.html");
 
     FixedLayoutTestWebViewClient client;
     client.m_screenInfo.deviceScaleFactor = 1;
     int viewportWidth = 50;
     int viewportHeight = 50;
 
-    m_webView = FrameTestHelpers::createWebViewAndLoad(m_baseURL + "fixed_layout.html", true, 0, &client);
+    initializeWebViewAndLoad(m_baseURL + "fixed_layout.html", true, 0, &client);
     m_webView->enableFixedLayoutMode(true);
     m_webView->settings()->setViewportEnabled(true);
     m_webView->resize(WebSize(viewportWidth, viewportHeight));
     m_webView->layout();
 
     // Set <1 page scale so that the clip rect should be larger than
     // the viewport size as passed into resize().
     m_webView->setPageScaleFactor(0.5, WebPoint());
 
     SkBitmap bitmap;
@@ skipping 19 matching lines @@
 
 TEST_F(WebFrameTest, pageScaleFactorUpdatesScrollbars)
 {
     registerMockedHttpURLLoad("fixed_layout.html");
 
     FixedLayoutTestWebViewClient client;
     client.m_screenInfo.deviceScaleFactor = 1;
     int viewportWidth = 640;
     int viewportHeight = 480;
 
-    m_webView = FrameTestHelpers::createWebViewAndLoad(m_baseURL + "fixed_layout.html", true, 0, &client);
+    initializeWebViewAndLoad(m_baseURL + "fixed_layout.html", true, 0, &client);
     m_webView->enableFixedLayoutMode(true);
     m_webView->settings()->setViewportEnabled(true);
     m_webView->resize(WebSize(viewportWidth, viewportHeight));
     m_webView->layout();
 
     WebCore::FrameView* view = webViewImpl()->mainFrameImpl()->frameView();
     EXPECT_EQ(view->scrollSize(WebCore::HorizontalScrollbar), view->contentsSize().width() - view->visibleContentRect().width());
     EXPECT_EQ(view->scrollSize(WebCore::VerticalScrollbar), view->contentsSize().height() - view->visibleContentRect().height());
 
     m_webView->setPageScaleFactor(10, WebPoint());
 
     EXPECT_EQ(view->scrollSize(WebCore::HorizontalScrollbar), view->contentsSize().width() - view->visibleContentRect().width());
     EXPECT_EQ(view->scrollSize(WebCore::VerticalScrollbar), view->contentsSize().height() - view->visibleContentRect().height());
 }
 
 TEST_F(WebFrameTest, CanOverrideScaleLimits)
 {
     WebCore::Settings::setMockScrollbarsEnabled(true);
     WebCore::Settings::setUsesOverlayScrollbars(true);
 
     registerMockedHttpURLLoad("no_scale_for_you.html");
 
     FixedLayoutTestWebViewClient client;
     client.m_screenInfo.deviceScaleFactor = 1;
     int viewportWidth = 640;
     int viewportHeight = 480;
 
-    m_webView = FrameTestHelpers::createWebViewAndLoad(m_baseURL + "no_scale_for_you.html", true, 0, &client);
+    initializeWebViewAndLoad(m_baseURL + "no_scale_for_you.html", true, 0, &client);
     m_webView->enableFixedLayoutMode(true);
     m_webView->settings()->setViewportEnabled(true);
     m_webView->resize(WebSize(viewportWidth, viewportHeight));
 
     EXPECT_EQ(2.0f, m_webView->minimumPageScaleFactor());
     EXPECT_EQ(2.0f, m_webView->maximumPageScaleFactor());
 
     m_webView->setIgnoreViewportTagScaleLimits(true);
     m_webView->layout();
 
@@ skipping 41 matching lines @@
 }
 
 TEST_F(WebFrameTest, DivAutoZoomParamsTest)
 {
     registerMockedHttpURLLoad("get_scale_for_auto_zoom_into_div_test.html");
 
     const float deviceScaleFactor = 2.0f;
     int viewportWidth = 640 / deviceScaleFactor;
     int viewportHeight = 1280 / deviceScaleFactor;
     float doubleTapZoomAlreadyLegibleRatio = 1.2f;
-    m_webView = FrameTestHelpers::createWebViewAndLoad(m_baseURL + "get_scale_for_auto_zoom_into_div_test.html"); //
+    initializeWebViewAndLoad(m_baseURL + "get_scale_for_auto_zoom_into_div_test.html");
     m_webView->setDeviceScaleFactor(deviceScaleFactor);
     m_webView->setPageScaleFactorLimits(0.01f, 4);
     m_webView->setPageScaleFactor(0.5f, WebPoint(0, 0));
     m_webView->resize(WebSize(viewportWidth, viewportHeight));
     m_webView->enableFixedLayoutMode(true);
     m_webView->layout();
 
     WebRect wideDiv(200, 100, 400, 150);
     WebRect tallDiv(200, 300, 400, 800);
     WebRect doubleTapPointWide(wideDiv.x + 50, wideDiv.y + 50, touchPointPadding, touchPointPadding);
@@ skipping 59 matching lines @@
 }
 
 TEST_F(WebFrameTest, DivAutoZoomWideDivTest)
 {
     registerMockedHttpURLLoad("get_wide_div_for_auto_zoom_test.html");
 
     const float deviceScaleFactor = 2.0f;
     int viewportWidth = 640 / deviceScaleFactor;
     int viewportHeight = 1280 / deviceScaleFactor;
     float doubleTapZoomAlreadyLegibleRatio = 1.2f;
-    m_webView = FrameTestHelpers::createWebViewAndLoad(m_baseURL + "get_wide_div_for_auto_zoom_test.html");
+    initializeWebViewAndLoad(m_baseURL + "get_wide_div_for_auto_zoom_test.html");
     m_webView->enableFixedLayoutMode(true);
     m_webView->resize(WebSize(viewportWidth, viewportHeight));
     m_webView->setPageScaleFactorLimits(1.0f, 4);
     m_webView->setDeviceScaleFactor(deviceScaleFactor);
     m_webView->setPageScaleFactor(1.0f, WebPoint(0, 0));
     m_webView->layout();
 
     webViewImpl()->enableFakePageScaleAnimationForTesting(true);
 
     float doubleTapZoomAlreadyLegibleScale = webViewImpl()->minimumPageScaleFactor() * doubleTapZoomAlreadyLegibleRatio;
@@ skipping 10 matching lines @@
 }
 
 TEST_F(WebFrameTest, DivAutoZoomMultipleDivsTest)
 {
     registerMockedHttpURLLoad("get_multiple_divs_for_auto_zoom_test.html");
 
     const float deviceScaleFactor = 2.0f;
     int viewportWidth = 640 / deviceScaleFactor;
     int viewportHeight = 1280 / deviceScaleFactor;
     float doubleTapZoomAlreadyLegibleRatio = 1.2f;
-    m_webView = FrameTestHelpers::createWebViewAndLoad(m_baseURL + "get_multiple_divs_for_auto_zoom_test.html");
+    initializeWebViewAndLoad(m_baseURL + "get_multiple_divs_for_auto_zoom_test.html");
     m_webView->enableFixedLayoutMode(true);
     m_webView->resize(WebSize(viewportWidth, viewportHeight));
     m_webView->setPageScaleFactorLimits(0.5f, 4);
     m_webView->setDeviceScaleFactor(deviceScaleFactor);
     m_webView->setPageScaleFactor(0.5f, WebPoint(0, 0));
     m_webView->layout();
 
     webViewImpl()->enableFakePageScaleAnimationForTesting(true);
 
     WebRect topDiv(200, 100, 200, 150);
@@ skipping 27 matching lines @@
     EXPECT_FLOAT_EQ(webViewImpl()->minimumPageScaleFactor(), scale);
 }
 
 TEST_F(WebFrameTest, DivAutoZoomScaleBoundsTest)
 {
     registerMockedHttpURLLoad("get_scale_bounds_check_for_auto_zoom_test.html");
 
     int viewportWidth = 320;
     int viewportHeight = 480;
     float doubleTapZoomAlreadyLegibleRatio = 1.2f;
-    m_webView = FrameTestHelpers::createWebViewAndLoad(m_baseURL + "get_scale_bounds_check_for_auto_zoom_test.html");
+    initializeWebViewAndLoad(m_baseURL + "get_scale_bounds_check_for_auto_zoom_test.html");
     m_webView->enableFixedLayoutMode(true);
     m_webView->resize(WebSize(viewportWidth, viewportHeight));
     m_webView->setDeviceScaleFactor(1.5f);
     m_webView->layout();
 
     webViewImpl()->enableFakePageScaleAnimationForTesting(true);
 
     WebRect div(200, 100, 200, 150);
     WebPoint doubleTapPoint(div.x + 50, div.y + 50);
     float scale;
@@ skipping 41 matching lines @@
 }
 
 TEST_F(WebFrameTest, DivAutoZoomScaleFontScaleFactorTest)
 {
     registerMockedHttpURLLoad("get_scale_bounds_check_for_auto_zoom_test.html");
 
     int viewportWidth = 320;
     int viewportHeight = 480;
     float doubleTapZoomAlreadyLegibleRatio = 1.2f;
     float textAutosizingFontScaleFactor = 1.13f;
-    m_webView = FrameTestHelpers::createWebViewAndLoad(m_baseURL + "get_scale_bounds_check_for_auto_zoom_test.html");
+    initializeWebViewAndLoad(m_baseURL + "get_scale_bounds_check_for_auto_zoom_test.html");
     m_webView->enableFixedLayoutMode(true);
     m_webView->resize(WebSize(viewportWidth, viewportHeight));
     m_webView->layout();
 
     webViewImpl()->enableFakePageScaleAnimationForTesting(true);
     webViewImpl()->page()->settings().setTextAutosizingEnabled(true);
     webViewImpl()->page()->settings().setTextAutosizingFontScaleFactor(textAutosizingFontScaleFactor);
 
     WebRect div(200, 100, 200, 150);
     WebPoint doubleTapPoint(div.x + 50, div.y + 50);
@@ skipping 57 matching lines @@
 }
 
 TEST_F(WebFrameTest, DivMultipleTargetZoomMultipleDivsTest)
 {
     registerMockedHttpURLLoad("get_multiple_divs_for_auto_zoom_test.html");
 
     const float deviceScaleFactor = 2.0f;
     int viewportWidth = 640 / deviceScaleFactor;
     int viewportHeight = 1280 / deviceScaleFactor;
     float doubleTapZoomAlreadyLegibleRatio = 1.2f;
-    m_webView = FrameTestHelpers::createWebViewAndLoad(m_baseURL + "get_multiple_divs_for_auto_zoom_test.html");
+    initializeWebViewAndLoad(m_baseURL + "get_multiple_divs_for_auto_zoom_test.html");
     m_webView->enableFixedLayoutMode(true);
     m_webView->resize(WebSize(viewportWidth, viewportHeight));
     m_webView->setPageScaleFactorLimits(0.5f, 4);
     m_webView->setDeviceScaleFactor(deviceScaleFactor);
     m_webView->setPageScaleFactor(0.5f, WebPoint(0, 0));
     m_webView->layout();
 
     webViewImpl()->enableFakePageScaleAnimationForTesting(true);
 
     WebRect viewportRect(0, 0, viewportWidth, viewportHeight);
@@ skipping 15 matching lines @@
 
 TEST_F(WebFrameTest, DivScrollIntoEditableTest)
 {
     registerMockedHttpURLLoad("get_scale_for_zoom_into_editable_test.html");
 
     int viewportWidth = 450;
     int viewportHeight = 300;
     float leftBoxRatio = 0.3f;
     int caretPadding = 10;
     float minReadableCaretHeight = 18.0f;
-    m_webView = FrameTestHelpers::createWebViewAndLoad(m_baseURL + "get_scale_for_zoom_into_editable_test.html");
+    initializeWebViewAndLoad(m_baseURL + "get_scale_for_zoom_into_editable_test.html");
     m_webView->enableFixedLayoutMode(true);
     m_webView->resize(WebSize(viewportWidth, viewportHeight));
     m_webView->setPageScaleFactorLimits(1, 4);
     m_webView->layout();
     m_webView->setDeviceScaleFactor(1.5f);
     m_webView->settings()->setAutoZoomFocusedNodeToLegibleScale(true);
 
     webViewImpl()->enableFakePageScaleAnimationForTesting(true);
 
     WebRect editBoxWithText(200, 200, 250, 20);
@@ skipping 66 matching lines @@
     }
 };
 
 TEST_F(WebFrameTest, ReloadDoesntSetRedirect)
 {
     // Test for case in http://crbug.com/73104. Reloading a frame very quickly
     // would sometimes call decidePolicyForNavigation with isRedirect=true
     registerMockedHttpURLLoad("form.html");
 
     TestReloadDoesntRedirectWebFrameClient webFrameClient;
-    m_webView = FrameTestHelpers::createWebViewAndLoad(m_baseURL + "form.html", false, &webFrameClient);
+    initializeWebViewAndLoad(m_baseURL + "form.html", false, &webFrameClient);
 
     m_webView->mainFrame()->reload(true);
     // start reload before request is delivered.
     m_webView->mainFrame()->reload(true);
     Platform::current()->unitTestSupport()->serveAsynchronousMockedRequests();
 
     m_webView->close();
     m_webView = 0;
 }
 
 TEST_F(WebFrameTest, ReloadWithOverrideURLPreservesState)
 {
     const std::string firstURL = "find.html";
     const std::string secondURL = "form.html";
     const std::string thirdURL = "history.html";
     const float pageScaleFactor = 1.1684f;
     const int pageWidth = 640;
     const int pageHeight = 480;
 
     registerMockedHttpURLLoad(firstURL);
     registerMockedHttpURLLoad(secondURL);
     registerMockedHttpURLLoad(thirdURL);
 
-    m_webView = FrameTestHelpers::createWebViewAndLoad(m_baseURL + firstURL, true);
+    initializeWebViewAndLoad(m_baseURL + firstURL, true);
     webViewImpl()->resize(WebSize(pageWidth, pageHeight));
     webViewImpl()->mainFrame()->setScrollOffset(WebSize(pageWidth / 4, pageHeight / 4));
     webViewImpl()->setPageScaleFactorPreservingScrollOffset(pageScaleFactor);
 
     WebSize previousOffset = webViewImpl()->mainFrame()->scrollOffset();
     float previousScale = webViewImpl()->pageScaleFactor();
 
     // Reload the page using the cache.
     webViewImpl()->mainFrame()->reloadWithOverrideURL(toKURL(m_baseURL + secondURL), false);
     Platform::current()->unitTestSupport()->serveAsynchronousMockedRequests();
@@ skipping 10 matching lines @@
 class TestReloadWhileProvisionalFrameClient : public WebFrameClient {
 };
 
 TEST_F(WebFrameTest, ReloadWhileProvisional)
 {
     // Test that reloading while the previous load is still pending does not cause the initial
     // request to get lost.
     registerMockedHttpURLLoad("fixed_layout.html");
 
     TestReloadWhileProvisionalFrameClient webFrameClient;
-    m_webView = FrameTestHelpers::createWebView(false, &webFrameClient);
+    initializeWebView(false, &webFrameClient);
     FrameTestHelpers::loadFrame(m_webView->mainFrame(), m_baseURL + "fixed_layout.html");
     // start reload before first request is delivered.
     m_webView->mainFrame()->reload(true);
     Platform::current()->unitTestSupport()->serveAsynchronousMockedRequests();
     ASSERT_EQ(WebURL(toKURL(m_baseURL + "fixed_layout.html")),
         m_webView->mainFrame()->dataSource()->request().url());
 
     m_webView->close();
     m_webView = 0;
 }
 
 TEST_F(WebFrameTest, IframeRedirect)
 {
     registerMockedHttpURLLoad("iframe_redirect.html");
     registerMockedHttpURLLoad("visible_iframe.html");
 
-    m_webView = FrameTestHelpers::createWebViewAndLoad(m_baseURL + "iframe_redirect.html", true);
+    initializeWebViewAndLoad(m_baseURL + "iframe_redirect.html", true);
     Platform::current()->unitTestSupport()->serveAsynchronousMockedRequests(); // Load the iframe.
 
     WebFrame* iframe = m_webView->findFrameByName(WebString::fromUTF8("ifr"));
     ASSERT_TRUE(iframe);
     WebDataSource* iframeDataSource = iframe->dataSource();
     ASSERT_TRUE(iframeDataSource);
     WebVector<WebURL> redirects;
     iframeDataSource->redirectChain(redirects);
     ASSERT_EQ(2U, redirects.size());
     EXPECT_EQ(toKURL("about:blank"), toKURL(redirects[0].spec().data()));
     EXPECT_EQ(toKURL("http://www.test.com/visible_iframe.html"), toKURL(redirects[1].spec().data()));
 }
 
 TEST_F(WebFrameTest, ClearFocusedNodeTest)
 {
     registerMockedHttpURLLoad("iframe_clear_focused_node_test.html");
     registerMockedHttpURLLoad("autofocus_input_field_iframe.html");
 
-    m_webView = FrameTestHelpers::createWebViewAndLoad(m_baseURL + "iframe_clear_focused_node_test.html", true);
+    initializeWebViewAndLoad(m_baseURL + "iframe_clear_focused_node_test.html", true);
 
     // Clear the focused node.
     m_webView->clearFocusedNode();
 
     // Now retrieve the FocusedNode and test it should be null.
     EXPECT_EQ(0, webViewImpl()->focusedElement());
 }
 
 // Implementation of WebFrameClient that tracks the v8 contexts that are created
 // and destroyed for verification.
@@ skipping 58 matching lines @@
 // TODO(aa): Deflake this test.
 TEST_F(WebFrameTest, FLAKY_ContextNotificationsLoadUnload)
 {
     v8::HandleScope handleScope(v8::Isolate::GetCurrent());
 
     registerMockedHttpURLLoad("context_notifications_test.html");
     registerMockedHttpURLLoad("context_notifications_test_frame.html");
 
     // Load a frame with an iframe, make sure we get the right create notifications.
     ContextLifetimeTestWebFrameClient webFrameClient;
-    m_webView = FrameTestHelpers::createWebViewAndLoad(m_baseURL + "context_notifications_test.html", true, &webFrameClient);
+    initializeWebViewAndLoad(m_baseURL + "context_notifications_test.html", true, &webFrameClient);
 
     WebFrame* mainFrame = m_webView->mainFrame();
     WebFrame* childFrame = mainFrame->firstChild();
 
     ASSERT_EQ(2u, webFrameClient.createNotifications.size());
     EXPECT_EQ(0u, webFrameClient.releaseNotifications.size());
 
     ContextLifetimeTestWebFrameClient::Notification* firstCreateNotification = webFrameClient.createNotifications[0];
     ContextLifetimeTestWebFrameClient::Notification* secondCreateNotification = webFrameClient.createNotifications[1];
 
@@ skipping 18 matching lines @@
 }
 
 TEST_F(WebFrameTest, ContextNotificationsReload)
 {
     v8::HandleScope handleScope(v8::Isolate::GetCurrent());
 
     registerMockedHttpURLLoad("context_notifications_test.html");
     registerMockedHttpURLLoad("context_notifications_test_frame.html");
 
     ContextLifetimeTestWebFrameClient webFrameClient;
-    m_webView = FrameTestHelpers::createWebViewAndLoad(m_baseURL + "context_notifications_test.html", true, &webFrameClient);
+    initializeWebViewAndLoad(m_baseURL + "context_notifications_test.html", true, &webFrameClient);
 
     // Refresh, we should get two release notifications and two more create notifications.
     m_webView->mainFrame()->reload(false);
     Platform::current()->unitTestSupport()->serveAsynchronousMockedRequests();
     ASSERT_EQ(4u, webFrameClient.createNotifications.size());
     ASSERT_EQ(2u, webFrameClient.releaseNotifications.size());
 
     // The two release notifications we got should be exactly the same as the first two create notifications.
     for (size_t i = 0; i < webFrameClient.releaseNotifications.size(); ++i) {
       EXPECT_TRUE(webFrameClient.releaseNotifications[i]->Equals(
@@ skipping 20 matching lines @@
 
 TEST_F(WebFrameTest, ContextNotificationsIsolatedWorlds)
 {
     v8::Isolate* isolate = v8::Isolate::GetCurrent();
     v8::HandleScope handleScope(isolate);
 
     registerMockedHttpURLLoad("context_notifications_test.html");
     registerMockedHttpURLLoad("context_notifications_test_frame.html");
 
     ContextLifetimeTestWebFrameClient webFrameClient;
-    m_webView = FrameTestHelpers::createWebViewAndLoad(m_baseURL + "context_notifications_test.html", true, &webFrameClient);
+    initializeWebViewAndLoad(m_baseURL + "context_notifications_test.html", true, &webFrameClient);
 
     // Add an isolated world.
     webFrameClient.reset();
 
     int isolatedWorldId = 42;
     WebScriptSource scriptSource("hi!");
     int numSources = 1;
     int extensionGroup = 0;
     m_webView->mainFrame()->executeScriptInIsolatedWorld(isolatedWorldId, &scriptSource, numSources, extensionGroup);
 
@@ skipping 17 matching lines @@
     for (size_t i = 0; i < webFrameClient.releaseNotifications.size(); ++i) {
       if (webFrameClient.releaseNotifications[i]->Equals(webFrameClient.createNotifications[0]))
         ++matchCount;
     }
     EXPECT_EQ(1, matchCount);
 }
 
 TEST_F(WebFrameTest, FindInPage)
 {
     registerMockedHttpURLLoad("find.html");
-    m_webView = FrameTestHelpers::createWebViewAndLoad(m_baseURL + "find.html");
+    initializeWebViewAndLoad(m_baseURL + "find.html");
     WebFrame* frame = m_webView->mainFrame();
     const int findIdentifier = 12345;
     WebFindOptions options;
 
     // Find in a <div> element.
     EXPECT_TRUE(frame->find(findIdentifier, WebString::fromUTF8("bar1"), options, false, 0));
     frame->stopFinding(false);
     WebRange range = frame->selectionRange();
     EXPECT_EQ(5, range.startOffset());
     EXPECT_EQ(9, range.endOffset());
@@ skipping 34 matching lines @@
     EXPECT_FALSE(frame->find(findIdentifier, WebString::fromUTF8("bar5"), options, false, 0));
     // If there are any matches, stopFinding will set the selection on the found text.
     // However, we do not expect any matches, so check that the selection is null.
     frame->stopFinding(false);
     range = frame->selectionRange();
     ASSERT_TRUE(range.isNull());
 }
 
 TEST_F(WebFrameTest, GetContentAsPlainText)
 {
-    m_webView = FrameTestHelpers::createWebViewAndLoad("about:blank", true);
+    initializeWebViewAndLoad("about:blank", true);
     // We set the size because it impacts line wrapping, which changes the
     // resulting text value.
     m_webView->resize(WebSize(640, 480));
     WebFrame* frame = m_webView->mainFrame();
 
     // Generate a simple test case.
     const char simpleSource[] = "<div>Foo bar</div><div></div>baz";
     WebCore::KURL testURL = toKURL("about:blank");
     frame->loadHTMLString(simpleSource, testURL);
     runPendingTasks();
@@ skipping 23 matching lines @@
     EXPECT_EQ("Hello world\n\nsub\ntext", std::string(text.utf8().data()));
 
     // Get the frame text where the subframe separator falls on the boundary of
     // what we'll take. There used to be a crash in this case.
     text = frame->contentAsText(12);
     EXPECT_EQ("Hello world", std::string(text.utf8().data()));
 }
 
 TEST_F(WebFrameTest, GetFullHtmlOfPage)
 {
-    m_webView = FrameTestHelpers::createWebViewAndLoad("about:blank", true);
+    initializeWebViewAndLoad("about:blank", true);
     WebFrame* frame = m_webView->mainFrame();
 
     // Generate a simple test case.
     const char simpleSource[] = "<p>Hello</p><p>World</p>";
     WebCore::KURL testURL = toKURL("about:blank");
     frame->loadHTMLString(simpleSource, testURL);
     runPendingTasks();
 
     WebString text = frame->contentAsText(std::numeric_limits<size_t>::max());
     EXPECT_EQ("Hello\n\nWorld", std::string(text.utf8().data()));
@@ skipping 25 matching lines @@
     {
         frame->executeScript(WebScriptSource("window.history = 'replaced';"));
     }
 };
 
 TEST_F(WebFrameTest, ExecuteScriptDuringDidCreateScriptContext)
 {
     registerMockedHttpURLLoad("hello_world.html");
 
     TestExecuteScriptDuringDidCreateScriptContext webFrameClient;
-    m_webView = FrameTestHelpers::createWebViewAndLoad(m_baseURL + "hello_world.html", true, &webFrameClient);
+    initializeWebViewAndLoad(m_baseURL + "hello_world.html", true, &webFrameClient);
 
     m_webView->mainFrame()->reload();
     Platform::current()->unitTestSupport()->serveAsynchronousMockedRequests();
 
     m_webView->close();
     m_webView = 0;
 }
 
 class TestDidCreateFrameWebFrameClient : public WebFrameClient {
 public:
     TestDidCreateFrameWebFrameClient() : m_frameCount(0), m_parent(0)
     {
     }
 
-    virtual void didCreateFrame(WebFrame* parent, WebFrame* child)
+    virtual WebFrame* didCreateFrame(WebString name)
     {
         m_frameCount++;
+        /*
         if (!m_parent)
             m_parent = parent;
+            */
+        return 0;
     }
 
     int m_frameCount;
     WebFrame* m_parent;
 };
 
 TEST_F(WebFrameTest, DidCreateFrame)
 {
     registerMockedHttpURLLoad("iframes_test.html");
     registerMockedHttpURLLoad("visible_iframe.html");
     registerMockedHttpURLLoad("invisible_iframe.html");
     registerMockedHttpURLLoad("zero_sized_iframe.html");
 
     TestDidCreateFrameWebFrameClient webFrameClient;
-    m_webView = FrameTestHelpers::createWebViewAndLoad(m_baseURL + "iframes_test.html", false, &webFrameClient);
+    initializeWebViewAndLoad(m_baseURL + "iframes_test.html", false, &webFrameClient);
 
     EXPECT_EQ(webFrameClient.m_frameCount, 3);
     EXPECT_EQ(webFrameClient.m_parent, m_webView->mainFrame());
 
     m_webView->close();
     m_webView = 0;
 }
 
 class FindUpdateWebFrameClient : public WebFrameClient {
 public:
@@ skipping 22 matching lines @@
 #if OS(MACOSX)
 TEST_F(WebFrameTest, DISABLED_FindInPageMatchRects)
 #else
 TEST_F(WebFrameTest, FindInPageMatchRects)
 #endif
 {
     registerMockedHttpURLLoad("find_in_page.html");
     registerMockedHttpURLLoad("find_in_page_frame.html");
 
     FindUpdateWebFrameClient client;
-    m_webView = FrameTestHelpers::createWebViewAndLoad(m_baseURL + "find_in_page.html", true, &client);
+    initializeWebViewAndLoad(m_baseURL + "find_in_page.html", true, &client);
     m_webView->resize(WebSize(640, 480));
     m_webView->layout();
     runPendingTasks();
 
     // Note that the 'result 19' in the <select> element is not expected to produce a match.
     static const char* kFindString = "result";
     static const int kFindIdentifier = 12345;
     static const int kNumResults = 19;
 
     WebFindOptions options;
@@ skipping 99 matching lines @@
 
     m_webView->close();
     m_webView = 0;
 }
 
 TEST_F(WebFrameTest, FindInPageSkipsHiddenFrames)
 {
     registerMockedHttpURLLoad("find_in_hidden_frame.html");
 
     FindUpdateWebFrameClient client;
-    m_webView = FrameTestHelpers::createWebViewAndLoad(m_baseURL + "find_in_hidden_frame.html", true, &client);
+    initializeWebViewAndLoad(m_baseURL + "find_in_hidden_frame.html", true, &client);
     m_webView->resize(WebSize(640, 480));
     m_webView->layout();
     runPendingTasks();
 
     static const char* kFindString = "hello";
     static const int kFindIdentifier = 12345;
     static const int kNumResults = 1;
 
     WebFindOptions options;
     WebString searchText = WebString::fromUTF8(kFindString);
@@ skipping 12 matching lines @@
     m_webView->close();
     m_webView = 0;
 }
 
 TEST_F(WebFrameTest, FindOnDetachedFrame)
 {
     registerMockedHttpURLLoad("find_in_page.html");
     registerMockedHttpURLLoad("find_in_page_frame.html");
 
     FindUpdateWebFrameClient client;
-    m_webView = FrameTestHelpers::createWebViewAndLoad(m_baseURL + "find_in_page.html", true, &client);
+    initializeWebViewAndLoad(m_baseURL + "find_in_page.html", true, &client);
     m_webView->resize(WebSize(640, 480));
     m_webView->layout();
     runPendingTasks();
 
     static const char* kFindString = "result";
     static const int kFindIdentifier = 12345;
 
     WebFindOptions options;
     WebString searchText = WebString::fromUTF8(kFindString);
     WebFrameImpl* mainFrame = toWebFrameImpl(m_webView->mainFrame());
@@ skipping 22 matching lines @@
     m_webView->close();
     m_webView = 0;
 }
 
 TEST_F(WebFrameTest, FindDetachFrameBeforeScopeStrings)
 {
     registerMockedHttpURLLoad("find_in_page.html");
     registerMockedHttpURLLoad("find_in_page_frame.html");
 
     FindUpdateWebFrameClient client;
-    m_webView = FrameTestHelpers::createWebViewAndLoad(m_baseURL + "find_in_page.html", true, &client);
+    initializeWebViewAndLoad(m_baseURL + "find_in_page.html", true, &client);
     m_webView->resize(WebSize(640, 480));
     m_webView->layout();
     runPendingTasks();
 
     static const char* kFindString = "result";
     static const int kFindIdentifier = 12345;
 
     WebFindOptions options;
     WebString searchText = WebString::fromUTF8(kFindString);
     WebFrameImpl* mainFrame = toWebFrameImpl(m_webView->mainFrame());
@@ skipping 22 matching lines @@
     m_webView->close();
     m_webView = 0;
 }
 
 TEST_F(WebFrameTest, FindDetachFrameWhileScopingStrings)
 {
     registerMockedHttpURLLoad("find_in_page.html");
     registerMockedHttpURLLoad("find_in_page_frame.html");
 
     FindUpdateWebFrameClient client;
-    m_webView = FrameTestHelpers::createWebViewAndLoad(m_baseURL + "find_in_page.html", true, &client);
+    initializeWebViewAndLoad(m_baseURL + "find_in_page.html", true, &client);
     m_webView->resize(WebSize(640, 480));
     m_webView->layout();
     runPendingTasks();
 
     static const char* kFindString = "result";
     static const int kFindIdentifier = 12345;
 
     WebFindOptions options;
     WebString searchText = WebString::fromUTF8(kFindString);
     WebFrameImpl* mainFrame = toWebFrameImpl(m_webView->mainFrame());
@@ skipping 18 matching lines @@
     EXPECT_TRUE(client.findResultsAreReady());
 
     holdSecondFrame.release();
 
     m_webView->close();
     m_webView = 0;
 }
 
 static WebView* createWebViewForTextSelection(const std::string& url)
 {
-    WebView* webView = FrameTestHelpers::createWebViewAndLoad(url, true);
+    WebView* webView = createWebViewAndLoad(url, true);
     webView->settings()->setDefaultFontSize(12);
     webView->enableFixedLayoutMode(false);
     webView->resize(WebSize(640, 480));
     return webView;
 }
 
 static WebPoint topLeft(const WebRect& rect)
 {
     return WebPoint(rect.x, rect.y);
 }
@@ skipping 19 matching lines @@
 
 TEST_F(WebFrameTest, SelectRange)
 {
     WebFrame* frame;
     WebRect startWebRect;
     WebRect endWebRect;
 
     registerMockedHttpURLLoad("select_range_basic.html");
     registerMockedHttpURLLoad("select_range_scroll.html");
 
-    m_webView = createWebViewForTextSelection(m_baseURL + "select_range_basic.html");
+    initializeWebViewForTextSelection(m_baseURL + "select_range_basic.html");
     frame = m_webView->mainFrame();
     EXPECT_EQ("Some test text for testing.", selectionAsString(frame));
     m_webView->selectionBounds(startWebRect, endWebRect);
     frame->executeCommand(WebString::fromUTF8("Unselect"));
     EXPECT_EQ("", selectionAsString(frame));
     frame->selectRange(topLeft(startWebRect), bottomRightMinusOne(endWebRect));
     EXPECT_EQ("Some test text for testing.", selectionAsString(frame));
     m_webView->close();
     m_webView = 0;
 
-    m_webView = createWebViewForTextSelection(m_baseURL + "select_range_scroll.html");
+    initializeWebViewForTextSelection(m_baseURL + "select_range_scroll.html");
     frame = m_webView->mainFrame();
     EXPECT_EQ("Some offscreen test text for testing.", selectionAsString(frame));
     m_webView->selectionBounds(startWebRect, endWebRect);
     frame->executeCommand(WebString::fromUTF8("Unselect"));
     EXPECT_EQ("", selectionAsString(frame));
     frame->selectRange(topLeft(startWebRect), bottomRightMinusOne(endWebRect));
     EXPECT_EQ("Some offscreen test text for testing.", selectionAsString(frame));
     m_webView->close();
     m_webView = 0;
 }
 
 TEST_F(WebFrameTest, SelectRangeInIframe)
 {
     WebFrame* frame;
     WebRect startWebRect;
     WebRect endWebRect;
 
     registerMockedHttpURLLoad("select_range_iframe.html");
     registerMockedHttpURLLoad("select_range_basic.html");
 
-    m_webView = createWebViewForTextSelection(m_baseURL + "select_range_iframe.html");
+    initializeWebViewForTextSelection(m_baseURL + "select_range_iframe.html");
     frame = m_webView->mainFrame();
     WebFrame* subframe = frame->findChildByExpression(WebString::fromUTF8("/html/body/iframe"));
     EXPECT_EQ("Some test text for testing.", selectionAsString(subframe));
     m_webView->selectionBounds(startWebRect, endWebRect);
     subframe->executeCommand(WebString::fromUTF8("Unselect"));
     EXPECT_EQ("", selectionAsString(subframe));
     subframe->selectRange(topLeft(startWebRect), bottomRightMinusOne(endWebRect));
     EXPECT_EQ("Some test text for testing.", selectionAsString(subframe));
     m_webView->close();
     m_webView = 0;
 }
 
 TEST_F(WebFrameTest, SelectRangeDivContentEditable)
 {
     WebFrame* frame;
     WebRect startWebRect;
     WebRect endWebRect;
 
     registerMockedHttpURLLoad("select_range_div_editable.html");
 
     // Select the middle of an editable element, then try to extend the selection to the top of the document.
     // The selection range should be clipped to the bounds of the editable element.
-    m_webView = createWebViewForTextSelection(m_baseURL + "select_range_div_editable.html");
+    initializeWebViewForTextSelection(m_baseURL + "select_range_div_editable.html");
     frame = m_webView->mainFrame();
     EXPECT_EQ("This text is initially selected.", selectionAsString(frame));
     m_webView->selectionBounds(startWebRect, endWebRect);
 
     frame->selectRange(bottomRightMinusOne(endWebRect), WebPoint(0, 0));
     EXPECT_EQ("16-char header. This text is initially selected.", selectionAsString(frame));
     m_webView->close();
     m_webView = 0;
 
     // As above, but extending the selection to the bottom of the document.
-    m_webView = createWebViewForTextSelection(m_baseURL + "select_range_div_editable.html");
+    initializeWebViewForTextSelection(m_baseURL + "select_range_div_editable.html");
     frame = m_webView->mainFrame();
 
     m_webView->selectionBounds(startWebRect, endWebRect);
     frame->selectRange(topLeft(startWebRect), bottomRightMinusOne(endWebRect));
     EXPECT_EQ("This text is initially selected.", selectionAsString(frame));
     m_webView->selectionBounds(startWebRect, endWebRect);
 
     m_webView->selectionBounds(startWebRect, endWebRect);
     frame->selectRange(topLeft(startWebRect), WebPoint(640, 480));
     EXPECT_EQ("This text is initially selected. 16-char footer.", selectionAsString(frame));
     m_webView->close();
     m_webView = 0;
 }
 
 // positionForPoint returns the wrong values for contenteditable spans. See
 // http://crbug.com/238334.
 TEST_F(WebFrameTest, DISABLED_SelectRangeSpanContentEditable)
 {
     WebFrame* frame;
     WebRect startWebRect;
     WebRect endWebRect;
 
     registerMockedHttpURLLoad("select_range_span_editable.html");
 
     // Select the middle of an editable element, then try to extend the selection to the top of the document.
     // The selection range should be clipped to the bounds of the editable element.
-    m_webView = createWebViewForTextSelection(m_baseURL + "select_range_span_editable.html");
+    initializeWebViewForTextSelection(m_baseURL + "select_range_span_editable.html");
     frame = m_webView->mainFrame();
     EXPECT_EQ("This text is initially selected.", selectionAsString(frame));
     m_webView->selectionBounds(startWebRect, endWebRect);
 
     frame->selectRange(bottomRightMinusOne(endWebRect), WebPoint(0, 0));
     EXPECT_EQ("16-char header. This text is initially selected.", selectionAsString(frame));
     m_webView->close();
     m_webView = 0;
 
     // As above, but extending the selection to the bottom of the document.
-    m_webView = createWebViewForTextSelection(m_baseURL + "select_range_span_editable.html");
+    initializeWebViewForTextSelection(m_baseURL + "select_range_span_editable.html");
     frame = m_webView->mainFrame();
 
     m_webView->selectionBounds(startWebRect, endWebRect);
     frame->selectRange(topLeft(startWebRect), bottomRightMinusOne(endWebRect));
     EXPECT_EQ("This text is initially selected.", selectionAsString(frame));
     m_webView->selectionBounds(startWebRect, endWebRect);
 
     EXPECT_EQ("This text is initially selected.", selectionAsString(frame));
     m_webView->selectionBounds(startWebRect, endWebRect);
     frame->selectRange(topLeft(startWebRect), WebPoint(640, 480));
     EXPECT_EQ("This text is initially selected. 16-char footer.", selectionAsString(frame));
     m_webView->close();
     m_webView = 0;
 }
 
 TEST_F(WebFrameTest, SelectRangeCanMoveSelectionStart)
 {
     registerMockedHttpURLLoad("text_selection.html");
-    m_webView = createWebViewForTextSelection(m_baseURL + "text_selection.html");
+    initializeWebViewForTextSelection(m_baseURL + "text_selection.html");
     WebFrame* frame = m_webView->mainFrame();
 
     // Select second span. We can move the start to include the first span.
     frame->executeScript(WebScriptSource("selectElement('header_2');"));
     EXPECT_EQ("Header 2.", selectionAsString(frame));
     frame->selectRange(bottomRightMinusOne(elementBounds(frame, "header_2")), topLeft(elementBounds(frame, "header_1")));
     EXPECT_EQ("Header 1. Header 2.", selectionAsString(frame));
 
     // We can move the start and end together.
     frame->executeScript(WebScriptSource("selectElement('header_1');"));
@@ skipping 26 matching lines @@
     EXPECT_EQ("Editable 2.", selectionAsString(frame));
     frame->selectRange(bottomRightMinusOne(elementBounds(frame, "editable_2")), topLeft(elementBounds(frame, "header_2")));
     // positionForPoint returns the wrong values for contenteditable spans. See
     // http://crbug.com/238334.
     // EXPECT_EQ("[ Editable 1. Editable 2.", selectionAsString(frame));
 }
 
 TEST_F(WebFrameTest, SelectRangeCanMoveSelectionEnd)
 {
     registerMockedHttpURLLoad("text_selection.html");
-    m_webView = createWebViewForTextSelection(m_baseURL + "text_selection.html");
+    initializeWebViewForTextSelection(m_baseURL + "text_selection.html");
     WebFrame* frame = m_webView->mainFrame();
 
     // Select first span. We can move the end to include the second span.
     frame->executeScript(WebScriptSource("selectElement('header_1');"));
     EXPECT_EQ("Header 1.", selectionAsString(frame));
     frame->selectRange(topLeft(elementBounds(frame, "header_1")), bottomRightMinusOne(elementBounds(frame, "header_2")));
     EXPECT_EQ("Header 1. Header 2.", selectionAsString(frame));
 
     // We can move the start and end together.
     frame->executeScript(WebScriptSource("selectElement('header_2');"));
@@ skipping 33 matching lines @@
 static int computeOffset(WebCore::RenderObject* renderer, int x, int y)
 {
     return WebCore::VisiblePosition(renderer->positionForPoint(WebCore::LayoutPoint(x, y))).deepEquivalent().computeOffsetInContainerNode();
 }
 
 // positionForPoint returns the wrong values for contenteditable spans. See
 // http://crbug.com/238334.
 TEST_F(WebFrameTest, DISABLED_PositionForPointTest)
 {
     registerMockedHttpURLLoad("select_range_span_editable.html");
-    m_webView = createWebViewForTextSelection(m_baseURL + "select_range_span_editable.html");
+    initializeWebViewForTextSelection(m_baseURL + "select_range_span_editable.html");
     WebFrameImpl* mainFrame = toWebFrameImpl(m_webView->mainFrame());
     WebCore::RenderObject* renderer = mainFrame->frame()->selection().rootEditableElement()->renderer();
     EXPECT_EQ(0, computeOffset(renderer, -1, -1));
     EXPECT_EQ(64, computeOffset(renderer, 1000, 1000));
 
     registerMockedHttpURLLoad("select_range_div_editable.html");
-    m_webView = createWebViewForTextSelection(m_baseURL + "select_range_div_editable.html");
+    initializeWebViewForTextSelection(m_baseURL + "select_range_div_editable.html");
     mainFrame = toWebFrameImpl(m_webView->mainFrame());
     renderer = mainFrame->frame()->selection().rootEditableElement()->renderer();
     EXPECT_EQ(0, computeOffset(renderer, -1, -1));
     EXPECT_EQ(64, computeOffset(renderer, 1000, 1000));
 }
 
 #if !OS(MACOSX)
 TEST_F(WebFrameTest, SelectRangeStaysHorizontallyAlignedWhenMoved)
 {
     WebFrameImpl* frame;
     registerMockedHttpURLLoad("move_caret.html");
 
-    m_webView = createWebViewForTextSelection(m_baseURL + "move_caret.html");
+    initializeWebViewForTextSelection(m_baseURL + "move_caret.html");
     frame = (WebFrameImpl*)m_webView->mainFrame();
 
     WebRect initialStartRect;
     WebRect initialEndRect;
     WebRect startRect;
     WebRect endRect;
 
     frame->executeScript(WebScriptSource("selectRange();"));
     m_webView->selectionBounds(initialStartRect, initialEndRect);
     WebPoint movedStart(topLeft(initialStartRect));
@@ skipping 23 matching lines @@
     m_webView->selectionBounds(startRect, endRect);
     EXPECT_EQ(startRect, initialStartRect);
     EXPECT_EQ(endRect, initialEndRect);
 }
 
 TEST_F(WebFrameTest, MoveCaretStaysHorizontallyAlignedWhenMoved)
 {
     WebFrameImpl* frame;
     registerMockedHttpURLLoad("move_caret.html");
 
-    m_webView = createWebViewForTextSelection(m_baseURL + "move_caret.html");
+    initializeWebViewForTextSelection(m_baseURL + "move_caret.html");
     frame = (WebFrameImpl*)m_webView->mainFrame();
 
     WebRect initialStartRect;
     WebRect initialEndRect;
     WebRect startRect;
     WebRect endRect;
 
     frame->executeScript(WebScriptSource("selectCaret();"));
     m_webView->selectionBounds(initialStartRect, initialEndRect);
     WebPoint moveTo(topLeft(initialStartRect));
@@ skipping 39 matching lines @@
 
 TEST_F(WebFrameTest, DisambiguationPopup)
 {
     const std::string htmlFile = "disambiguation_popup.html";
     registerMockedHttpURLLoad(htmlFile);
 
     DisambiguationPopupTestWebViewClient client;
 
     // Make sure we initialize to minimum scale, even if the window size
     // only becomes available after the load begins.
-    m_webView = FrameTestHelpers::createWebViewAndLoad(m_baseURL + htmlFile, true, 0, &client);
+    initializeWebViewAndLoad(m_baseURL + htmlFile, true, 0, &client);
     m_webView->resize(WebSize(1000, 1000));
     m_webView->layout();
 
     client.resetTriggered();
     m_webView->handleInputEvent(fatTap(0, 0));
     EXPECT_FALSE(client.triggered());
 
     client.resetTriggered();
     m_webView->handleInputEvent(fatTap(200, 115));
     EXPECT_FALSE(client.triggered());
@@ skipping 26 matching lines @@
 }
 
 TEST_F(WebFrameTest, DisambiguationPopupNoContainer)
 {
     registerMockedHttpURLLoad("disambiguation_popup_no_container.html");
 
     DisambiguationPopupTestWebViewClient client;
 
     // Make sure we initialize to minimum scale, even if the window size
     // only becomes available after the load begins.
-    m_webView = FrameTestHelpers::createWebViewAndLoad(m_baseURL + "disambiguation_popup_no_container.html", true, 0, &client);
+    initializeWebViewAndLoad(m_baseURL + "disambiguation_popup_no_container.html", true, 0, &client);
     m_webView->resize(WebSize(1000, 1000));
     m_webView->layout();
 
     client.resetTriggered();
     m_webView->handleInputEvent(fatTap(50, 50));
     EXPECT_FALSE(client.triggered());
 
     m_webView->close();
     m_webView = 0;
 }
 
 TEST_F(WebFrameTest, DisambiguationPopupMobileSite)
 {
     const std::string htmlFile = "disambiguation_popup_mobile_site.html";
     registerMockedHttpURLLoad(htmlFile);
 
     DisambiguationPopupTestWebViewClient client;
 
     // Make sure we initialize to minimum scale, even if the window size
     // only becomes available after the load begins.
-    m_webView = FrameTestHelpers::createWebViewAndLoad(m_baseURL + htmlFile, true, 0, &client);
+    initializeWebViewAndLoad(m_baseURL + htmlFile, true, 0, &client);
     m_webView->enableFixedLayoutMode(true);
     m_webView->settings()->setViewportEnabled(true);
     m_webView->resize(WebSize(1000, 1000));
     m_webView->layout();
 
     client.resetTriggered();
     m_webView->handleInputEvent(fatTap(0, 0));
     EXPECT_FALSE(client.triggered());
 
     client.resetTriggered();
@@ skipping 18 matching lines @@
 
 TEST_F(WebFrameTest, DisambiguationPopupViewportSite)
 {
     const std::string htmlFile = "disambiguation_popup_viewport_site.html";
     registerMockedHttpURLLoad(htmlFile);
 
     DisambiguationPopupTestWebViewClient client;
 
     // Make sure we initialize to minimum scale, even if the window size
     // only becomes available after the load begins.
-    m_webView = FrameTestHelpers::createWebViewAndLoad(m_baseURL + htmlFile, true, 0, &client);
+    initializeWebViewAndLoad(m_baseURL + htmlFile, true, 0, &client);
     m_webView->enableFixedLayoutMode(true);
     m_webView->settings()->setViewportEnabled(true);
     m_webView->resize(WebSize(1000, 1000));
     m_webView->layout();
 
     client.resetTriggered();
     m_webView->handleInputEvent(fatTap(0, 0));
     EXPECT_FALSE(client.triggered());
 
     client.resetTriggered();
@@ skipping 21 matching lines @@
     const unsigned viewportWidth = 500;
     const unsigned viewportHeight = 1000;
     const unsigned divHeight = 100;
     const std::string htmlFile = "disambiguation_popup_blacklist.html";
     registerMockedHttpURLLoad(htmlFile);
 
     DisambiguationPopupTestWebViewClient client;
 
     // Make sure we initialize to minimum scale, even if the window size
     // only becomes available after the load begins.
-    m_webView = FrameTestHelpers::createWebViewAndLoad(m_baseURL + htmlFile, true, 0, &client);
+    initializeWebViewAndLoad(m_baseURL + htmlFile, true, 0, &client);
     m_webView->resize(WebSize(viewportWidth, viewportHeight));
     m_webView->layout();
 
     // Click somewhere where the popup shouldn't appear.
     client.resetTriggered();
     m_webView->handleInputEvent(fatTap(viewportWidth / 2, 0));
     EXPECT_FALSE(client.triggered());
 
     // Click directly in between two container divs with click handlers, with children that don't handle clicks.
     client.resetTriggered();
@@ skipping 10 matching lines @@
 }
 
 TEST_F(WebFrameTest, DisambiguationPopupPageScale)
 {
     registerMockedHttpURLLoad("disambiguation_popup_page_scale.html");
 
     DisambiguationPopupTestWebViewClient client;
 
     // Make sure we initialize to minimum scale, even if the window size
     // only becomes available after the load begins.
-    m_webView = FrameTestHelpers::createWebViewAndLoad(m_baseURL + "disambiguation_popup_page_scale.html", true, 0, &client);
+    initializeWebViewAndLoad(m_baseURL + "disambiguation_popup_page_scale.html", true, 0, &client);
     m_webView->resize(WebSize(1000, 1000));
     m_webView->layout();
 
     client.resetTriggered();
     m_webView->handleInputEvent(fatTap(80, 80));
     EXPECT_TRUE(client.triggered());
 
     client.resetTriggered();
     m_webView->handleInputEvent(fatTap(230, 190));
     EXPECT_TRUE(client.triggered());
@@ skipping 35 matching lines @@
     bool commitCalled() const { return m_commitCalled; }
 
 private:
     bool m_commitCalled;
 };
 
 TEST_F(WebFrameTest, ReplaceNavigationAfterHistoryNavigation)
 {
     TestSubstituteDataWebFrameClient webFrameClient;
 
-    m_webView = FrameTestHelpers::createWebViewAndLoad("about:blank", true, &webFrameClient);
+    initializeWebViewAndLoad("about:blank", true, &webFrameClient);
     runPendingTasks();
     WebFrame* frame = m_webView->mainFrame();
 
     // 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";
@@ skipping 43 matching lines @@
 
     int m_numBodies;
     bool m_didLoad;
 };
 
 TEST_F(WebFrameTest, HTMLDocument)
 {
     registerMockedHttpURLLoad("clipped-body.html");
 
     TestWillInsertBodyWebFrameClient webFrameClient;
-    m_webView = FrameTestHelpers::createWebViewAndLoad(m_baseURL + "clipped-body.html", false, &webFrameClient);
+    initializeWebViewAndLoad(m_baseURL + "clipped-body.html", false, &webFrameClient);
 
     EXPECT_TRUE(webFrameClient.m_didLoad);
     EXPECT_EQ(1, webFrameClient.m_numBodies);
 
     m_webView->close();
     m_webView = 0;
 }
 
 TEST_F(WebFrameTest, EmptyDocument)
 {
     registerMockedHttpURLLoad("pageserializer/green_rectangle.svg");
 
     TestWillInsertBodyWebFrameClient webFrameClient;
-    m_webView = FrameTestHelpers::createWebView(false, &webFrameClient);
+    initializeWebView(false, &webFrameClient);
 
     EXPECT_FALSE(webFrameClient.m_didLoad);
     EXPECT_EQ(1, webFrameClient.m_numBodies); // The empty document that a new frame starts with triggers this.
     m_webView->close();
     m_webView = 0;
 }
 
 TEST_F(WebFrameTest, MoveCaretSelectionTowardsWindowPointWithNoSelection)
 {
-    m_webView = FrameTestHelpers::createWebViewAndLoad("about:blank", true);
+    initializeWebViewAndLoad("about:blank", true);
     WebFrame* frame = m_webView->mainFrame();
 
     // This test passes if this doesn't crash.
     frame->moveCaretSelectionTowardsWindowPoint(WebPoint(0, 0));
 }
 
 class SpellCheckClient : public WebSpellCheckClient {
 public:
     explicit SpellCheckClient(uint32_t hash = 0) : m_numberOfTimesChecked(0), m_hash(hash) { }
     virtual ~SpellCheckClient() { }
     virtual void requestCheckingOfText(const WebKit::WebString&, const WebKit::WebVector<uint32_t>&, const WebKit::WebVector<unsigned>&, WebKit::WebTextCheckingCompletion* completion) OVERRIDE
     {
         ++m_numberOfTimesChecked;
         Vector<WebTextCheckingResult> results;
         const int misspellingStartOffset = 1;
         const int misspellingLength = 8;
         results.append(WebTextCheckingResult(WebTextCheckingTypeSpelling, misspellingStartOffset, misspellingLength, WebString(), m_hash));
         completion->didFinishCheckingText(results);
     }
     int numberOfTimesChecked() const { return m_numberOfTimesChecked; }
 private:
     int m_numberOfTimesChecked;
     uint32_t m_hash;
 };
 
 TEST_F(WebFrameTest, ReplaceMisspelledRange)
 {
     registerMockedHttpURLLoad("spell.html");
-    m_webView = FrameTestHelpers::createWebViewAndLoad(m_baseURL + "spell.html");
+    initializeWebViewAndLoad(m_baseURL + "spell.html");
     SpellCheckClient spellcheck;
     m_webView->setSpellCheckClient(&spellcheck);
 
     WebFrameImpl* frame = toWebFrameImpl(m_webView->mainFrame());
     Document* document = frame->frame()->document();
     Element* element = document->getElementById("data");
 
     m_webView->settings()->setAsynchronousSpellCheckingEnabled(true);
     m_webView->settings()->setUnifiedTextCheckerEnabled(true);
     m_webView->settings()->setEditingBehavior(WebSettings::EditingBehaviorWin);
@@ skipping 12 matching lines @@
     frame->replaceMisspelledRange("welcome");
     EXPECT_EQ("_welcome_.", std::string(frame->contentAsText(std::numeric_limits<size_t>::max()).utf8().data()));
 
     m_webView->close();
     m_webView = 0;
 }
 
 TEST_F(WebFrameTest, RemoveSpellingMarkers)
 {
     registerMockedHttpURLLoad("spell.html");
-    m_webView = FrameTestHelpers::createWebViewAndLoad(m_baseURL + "spell.html");
+    initializeWebViewAndLoad(m_baseURL + "spell.html");
     SpellCheckClient spellcheck;
     m_webView->setSpellCheckClient(&spellcheck);
 
     WebFrameImpl* frame = toWebFrameImpl(m_webView->mainFrame());
     Document* document = frame->frame()->document();
     Element* element = document->getElementById("data");
 
     m_webView->settings()->setAsynchronousSpellCheckingEnabled(true);
     m_webView->settings()->setUnifiedTextCheckerEnabled(true);
     m_webView->settings()->setEditingBehavior(WebSettings::EditingBehaviorWin);
 
     element->focus();
     document->execCommand("InsertText", false, "_wellcome_.");
 
     frame->removeSpellingMarkers();
 
     const int allTextBeginOffset = 0;
     const int allTextLength = 11;
     frame->selectRange(WebRange::fromDocumentRange(frame, allTextBeginOffset, allTextLength));
     RefPtr<Range> selectionRange = frame->frame()->selection().toNormalizedRange();
 
     EXPECT_EQ(0U, document->markers()->markersInRange(selectionRange.get(), DocumentMarker::Spelling).size());
 
     m_webView->close();
     m_webView = 0;
 }
 
 TEST_F(WebFrameTest, MarkerHashIdentifiers) {
     registerMockedHttpURLLoad("spell.html");
-    m_webView = FrameTestHelpers::createWebViewAndLoad(m_baseURL + "spell.html");
+    initializeWebViewAndLoad(m_baseURL + "spell.html");
 
     static const uint32_t kHash = 42;
     SpellCheckClient spellcheck(kHash);
     m_webView->setSpellCheckClient(&spellcheck);
 
     WebFrameImpl* frame = toWebFrameImpl(m_webView->mainFrame());
     Document* document = frame->frame()->document();
     Element* element = document->getElementById("data");
 
     m_webView->settings()->setAsynchronousSpellCheckingEnabled(true);
@@ skipping 38 matching lines @@
         m_completion = 0;
     }
 
 private:
     WebKit::WebTextCheckingCompletion* m_completion;
 };
 
 TEST_F(WebFrameTest, SlowSpellcheckMarkerPosition)
 {
     registerMockedHttpURLLoad("spell.html");
-    m_webView = FrameTestHelpers::createWebViewAndLoad(m_baseURL + "spell.html");
+    initializeWebViewAndLoad(m_baseURL + "spell.html");
 
     StubbornSpellCheckClient spellcheck;
     m_webView->setSpellCheckClient(&spellcheck);
 
     WebFrameImpl* frame = toWebFrameImpl(m_webView->mainFrame());
     WebInputElement webInputElement = frame->document().getElementById("data").to<WebInputElement>();
     Document* document = frame->frame()->document();
     Element* element = document->getElementById("data");
 
     m_webView->settings()->setAsynchronousSpellCheckingEnabled(true);
@@ skipping 13 matching lines @@
 
     m_webView->close();
     m_webView = 0;
 }
 
 // This test verifies that cancelling spelling request does not cause a
 // write-after-free when there's no spellcheck client set.
 TEST_F(WebFrameTest, CancelSpellingRequestCrash)
 {
     registerMockedHttpURLLoad("spell.html");
-    m_webView = FrameTestHelpers::createWebViewAndLoad(m_baseURL + "spell.html");
+    initializeWebViewAndLoad(m_baseURL + "spell.html");
     m_webView->setSpellCheckClient(0);
 
     WebFrameImpl* frame = toWebFrameImpl(m_webView->mainFrame());
     Document* document = frame->frame()->document();
     Element* element = document->getElementById("data");
 
     m_webView->settings()->setAsynchronousSpellCheckingEnabled(true);
     m_webView->settings()->setUnifiedTextCheckerEnabled(true);
     m_webView->settings()->setEditingBehavior(WebSettings::EditingBehaviorWin);
 
@@ skipping 16 matching lines @@
         EXPECT_TRUE(!m_didAccessInitialDocument);
         m_didAccessInitialDocument = true;
     }
 
     bool m_didAccessInitialDocument;
 };
 
 TEST_F(WebFrameTest, DidAccessInitialDocumentBody)
 {
     TestAccessInitialDocumentWebFrameClient webFrameClient;
-    m_webView = FrameTestHelpers::createWebView(true, &webFrameClient);
+    initializeWebView(true, &webFrameClient);
     runPendingTasks();
     EXPECT_FALSE(webFrameClient.m_didAccessInitialDocument);
 
     // Create another window that will try to access it.
     WebView* newView = FrameTestHelpers::createWebView(true);
     newView->mainFrame()->setOpener(m_webView->mainFrame());
     runPendingTasks();
     EXPECT_FALSE(webFrameClient.m_didAccessInitialDocument);
 
     // Access the initial document by modifying the body.
     newView->mainFrame()->executeScript(
         WebScriptSource("window.opener.document.body.innerHTML += 'Modified';"));
     runPendingTasks();
     EXPECT_TRUE(webFrameClient.m_didAccessInitialDocument);
 
     // Access the initial document again, to ensure we don't notify twice.
     newView->mainFrame()->executeScript(
         WebScriptSource("window.opener.document.body.innerHTML += 'Modified';"));
     runPendingTasks();
     EXPECT_TRUE(webFrameClient.m_didAccessInitialDocument);
 
     newView->close();
     m_webView->close();
     m_webView = 0;
 }
 
 TEST_F(WebFrameTest, DidAccessInitialDocumentNavigator)
 {
     TestAccessInitialDocumentWebFrameClient webFrameClient;
-    m_webView = FrameTestHelpers::createWebView(true, &webFrameClient);
+    initializeWebView(true, &webFrameClient);
     runPendingTasks();
     EXPECT_FALSE(webFrameClient.m_didAccessInitialDocument);
 
     // Create another window that will try to access it.
     WebView* newView = FrameTestHelpers::createWebView(true);
     newView->mainFrame()->setOpener(m_webView->mainFrame());
     runPendingTasks();
     EXPECT_FALSE(webFrameClient.m_didAccessInitialDocument);
 
     // Access the initial document to get to the navigator object.
     newView->mainFrame()->executeScript(
         WebScriptSource("console.log(window.opener.navigator);"));
     runPendingTasks();
     EXPECT_TRUE(webFrameClient.m_didAccessInitialDocument);
 
     newView->close();
     m_webView->close();
     m_webView = 0;
 }
 
 TEST_F(WebFrameTest, DidAccessInitialDocumentViaJavascriptUrl)
 {
     TestAccessInitialDocumentWebFrameClient webFrameClient;
-    m_webView = FrameTestHelpers::createWebView(true, &webFrameClient);
+    initializeWebView(true, &webFrameClient);
     runPendingTasks();
     EXPECT_FALSE(webFrameClient.m_didAccessInitialDocument);
 
     // Access the initial document from a javascript: URL.
     FrameTestHelpers::loadFrame(m_webView->mainFrame(), "javascript:document.body.appendChild(document.createTextNode('Modified'))");
     runPendingTasks();
     EXPECT_TRUE(webFrameClient.m_didAccessInitialDocument);
 
     m_webView->close();
     m_webView = 0;
 }
 
 TEST_F(WebFrameTest, DidAccessInitialDocumentBodyBeforeModalDialog)
 {
     TestAccessInitialDocumentWebFrameClient webFrameClient;
-    m_webView = FrameTestHelpers::createWebView(true, &webFrameClient);
+    initializeWebView(true, &webFrameClient);
     runPendingTasks();
     EXPECT_FALSE(webFrameClient.m_didAccessInitialDocument);
 
     // Create another window that will try to access it.
     WebView* newView = FrameTestHelpers::createWebView(true);
     newView->mainFrame()->setOpener(m_webView->mainFrame());
     runPendingTasks();
     EXPECT_FALSE(webFrameClient.m_didAccessInitialDocument);
 
     // Access the initial document by modifying the body. We normally set a
@@ skipping 47 matching lines @@
     bool m_wasProgrammaticScroll;
 };
 
 TEST_F(WebFrameTest, CompositorScrollIsUserScrollLongPage)
 {
     registerMockedHttpURLLoad("long_scroll.html");
     TestMainFrameUserOrProgrammaticScrollFrameClient client;
 
     // Make sure we initialize to minimum scale, even if the window size
     // only becomes available after the load begins.
-    m_webView = FrameTestHelpers::createWebViewAndLoad(m_baseURL + "long_scroll.html", true, &client);
+    initializeWebViewAndLoad(m_baseURL + "long_scroll.html", true, &client);
     m_webView->resize(WebSize(1000, 1000));
     m_webView->layout();
 
     EXPECT_FALSE(client.wasUserScroll());
     EXPECT_FALSE(client.wasProgrammaticScroll());
 
     // Do a compositor scroll, verify that this is counted as a user scroll.
     webViewImpl()->applyScrollAndScale(WebSize(0, 1), 1.1f);
     EXPECT_TRUE(client.wasUserScroll());
     client.reset();
@@ skipping 34 matching lines @@
     m_webView = 0;
 }
 
 TEST_F(WebFrameTest, CompositorScrollIsUserScrollShortPage)
 {
     registerMockedHttpURLLoad("short_scroll.html");
 
     TestMainFrameUserOrProgrammaticScrollFrameClient client;
 
     // Short page tests.
-    m_webView = FrameTestHelpers::createWebViewAndLoad(m_baseURL + "short_scroll.html", true, &client);
+    initializeWebViewAndLoad(m_baseURL + "short_scroll.html", true, &client);
 
     m_webView->resize(WebSize(1000, 1000));
     m_webView->layout();
 
     EXPECT_FALSE(client.wasUserScroll());
     EXPECT_FALSE(client.wasProgrammaticScroll());
 
     // Non zero page scale and scroll.
     webViewImpl()->applyScrollAndScale(WebSize(9, 13), 2.0f);
     EXPECT_FALSE(client.wasProgrammaticScroll());
@@ skipping 17 matching lines @@
     redirectResponse.setMIMEType("text/html");
     redirectResponse.setHTTPStatusCode(302);
     redirectResponse.setHTTPHeaderField("Location", redirect);
     Platform::current()->unitTestSupport()->registerMockedURL(testURL, redirectResponse, filePath);
 
     WebURLResponse finalResponse;
     finalResponse.initialize();
     finalResponse.setMIMEType("text/html");
     Platform::current()->unitTestSupport()->registerMockedURL(redirectURL, finalResponse, filePath);
 
-    m_webView = FrameTestHelpers::createWebViewAndLoad(m_baseURL + "first_party_redirect.html", true);
+    initializeWebViewAndLoad(m_baseURL + "first_party_redirect.html", true);
     EXPECT_TRUE(m_webView->mainFrame()->document().firstPartyForCookies() == redirectURL);
 
     m_webView->close();
     m_webView = 0;
 }
 
 class TestNavigationPolicyWebFrameClient : public WebFrameClient {
 public:
 
     virtual void didNavigateWithinPage(WebFrame*, bool)
     {
         EXPECT_TRUE(false);
     }
 };
 
 TEST_F(WebFrameTest, SimulateFragmentAnchorMiddleClick)
 {
     registerMockedHttpURLLoad("fragment_middle_click.html");
     TestNavigationPolicyWebFrameClient client;
-    m_webView = FrameTestHelpers::createWebViewAndLoad(m_baseURL + "fragment_middle_click.html", true, &client);
+    initializeWebViewAndLoad(m_baseURL + "fragment_middle_click.html", true, &client);
 
     WebCore::Document* document = webViewImpl()->page()->mainFrame()->document();
     WebCore::KURL destination = document->url();
     destination.setFragmentIdentifier("test");
 
     RefPtr<WebCore::Event> event = WebCore::MouseEvent::create(WebCore::eventNames().clickEvent, false, false,
         document->defaultView(), 0, 0, 0, 0, 0, 0, 0, false, false, false, false, 1, 0, 0);
     WebCore::FrameLoadRequest frameRequest(document->securityOrigin(), WebCore::ResourceRequest(destination));
     frameRequest.setTriggeringEvent(event);
     webViewImpl()->page()->mainFrame()->loader()->load(frameRequest);
 
     m_webView->close();
     m_webView = 0;
 }
 
 TEST_F(WebFrameTest, BackToReload)
 {
     registerMockedHttpURLLoad("fragment_middle_click.html");
-    m_webView = FrameTestHelpers::createWebViewAndLoad(m_baseURL + "fragment_middle_click.html", true);
+    initializeWebViewAndLoad(m_baseURL + "fragment_middle_click.html", true);
     WebFrame* frame = m_webView->mainFrame();
     WebHistoryItem firstItem = frame->currentHistoryItem();
     EXPECT_FALSE(firstItem.isNull());
 
     registerMockedHttpURLLoad("white-1x1.png");
     FrameTestHelpers::loadFrame(frame, m_baseURL + "white-1x1.png");
     Platform::current()->unitTestSupport()->serveAsynchronousMockedRequests();
     EXPECT_FALSE(frame->previousHistoryItem().isNull());
     EXPECT_EQ(firstItem.urlString(), frame->previousHistoryItem().urlString());
 
@@ skipping 25 matching lines @@
     bool frameLoadTypeSameSeen() const { return m_frameLoadTypeSameSeen; }
 
 private:
     bool m_frameLoadTypeSameSeen;
 };
 
 TEST_F(WebFrameTest, NavigateToSame)
 {
     registerMockedHttpURLLoad("navigate_to_same.html");
     TestSameDocumentWebFrameClient client;
-    m_webView = FrameTestHelpers::createWebViewAndLoad(m_baseURL + "navigate_to_same.html", true, &client);
+    initializeWebViewAndLoad(m_baseURL + "navigate_to_same.html", true, &client);
     EXPECT_FALSE(client.frameLoadTypeSameSeen());
 
     WebCore::FrameLoadRequest frameRequest(0, WebCore::ResourceRequest(webViewImpl()->page()->mainFrame()->document()->url()));
     webViewImpl()->page()->mainFrame()->loader()->load(frameRequest);
     Platform::current()->unitTestSupport()->serveAsynchronousMockedRequests();
 
     EXPECT_TRUE(client.frameLoadTypeSameSeen());
     m_webView->close();
     m_webView = 0;
 }
 
 TEST_F(WebFrameTest, WebNodeImageContents)
 {
-    m_webView = FrameTestHelpers::createWebViewAndLoad("about:blank", true);
+    initializeWebViewAndLoad("about:blank", true);
     WebFrame* frame = m_webView->mainFrame();
 
     static const char bluePNG[] = "<img src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAoAAAAKCAYAAACNMs+9AAAAGElEQVQYV2NkYPj/n4EIwDiqEF8oUT94AFIQE/cCn90IAAAAAElFTkSuQmCC\">";
 
     // Load up the image and test that we can extract the contents.
     WebCore::KURL testURL = toKURL("about:blank");
     frame->loadHTMLString(bluePNG, testURL);
     runPendingTasks();
 
     WebNode node = frame->document().body().firstChild();
@@ skipping 33 matching lines @@
 
 private:
     int m_startLoadingCount;
     int m_stopLoadingCount;
 };
 
 TEST_F(WebFrameTest, PushStateStartsAndStops)
 {
     registerMockedHttpURLLoad("push_state.html");
     TestStartStopCallbackWebViewClient client;
-    m_webView = FrameTestHelpers::createWebViewAndLoad(m_baseURL + "push_state.html", true, 0, &client);
+    initializeWebViewAndLoad(m_baseURL + "push_state.html", true, 0, &client);
     runPendingTasks();
 
     EXPECT_EQ(client.startLoadingCount(), 2);
     EXPECT_EQ(client.stopLoadingCount(), 2);
     m_webView->close();
     m_webView = 0;
 }
 
 } // namespace