Convert Settings::rootLayerScrolls to RuntimeEnabledFeatures

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

 /*
  * Copyright (C) 2010 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 67 matching lines @@
 #include "core/testing/NullExecutionContext.h"
 #include "modules/mediastream/MediaStream.h"
 #include "modules/mediastream/MediaStreamRegistry.h"
 #include "platform/DragImage.h"
 #include "platform/PlatformResourceLoader.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/UserGestureIndicator.h"
 #include "platform/geometry/FloatRect.h"
 #include "platform/network/ResourceError.h"
 #include "platform/scroll/ScrollbarTheme.h"
+#include "platform/testing/RuntimeEnabledFeaturesTestHelpers.h"
 #include "platform/testing/URLTestHelpers.h"
 #include "platform/testing/UnitTestHelpers.h"
 #include "platform/weborigin/KURLHash.h"
 #include "platform/weborigin/SchemeRegistry.h"
 #include "platform/weborigin/SecurityOrigin.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebCachePolicy.h"
 #include "public/platform/WebClipboard.h"
 #include "public/platform/WebFloatRect.h"
 #include "public/platform/WebMockClipboard.h"
@@ skipping 177 matching lines @@
         Element* element = frame->frame()->document()->getElementById(id);
         DCHECK(element);
         element->remove();
     }
 
     std::string m_baseURL;
     std::string m_notBaseURL;
     std::string m_chromeURL;
 };
 
+typedef bool TestParamRootLayerScrolling;
 class ParameterizedWebFrameTest
-    : public WebFrameTest
-    , public ::testing::WithParamInterface<FrameTestHelpers::SettingOverrideFunction>
-    , public FrameTestHelpers::SettingOverrider {
+    : public ::testing::WithParamInterface<TestParamRootLayerScrolling>
+    , private ScopedRootLayerScrollingForTest
+    , public WebFrameTest {
 public:
-
-    void overrideSettings(WebSettings *settings) override
-    {
-        GetParam()(settings);
-    }
+    ParameterizedWebFrameTest()
+        : ScopedRootLayerScrollingForTest(GetParam()) { }
 };
 
-INSTANTIATE_TEST_CASE_P(All, ParameterizedWebFrameTest, ::testing::Values(
-    FrameTestHelpers::DefaultSettingOverride,
-    FrameTestHelpers::RootLayerScrollsSettingOverride));
+INSTANTIATE_TEST_CASE_P(All, ParameterizedWebFrameTest, ::testing::Bool());
 
 TEST_P(ParameterizedWebFrameTest, ContentText)
 {
     registerMockedHttpURLLoad("iframes_test.html");
     registerMockedHttpURLLoad("visible_iframe.html");
     registerMockedHttpURLLoad("invisible_iframe.html");
     registerMockedHttpURLLoad("zero_sized_iframe.html");
 
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "iframes_test.html");
 
     // Now retrieve the frames text and test it only includes visible elements.
     std::string content = WebFrameContentDumper::dumpWebViewAsText(webViewHelper.webView(), 1024).utf8();
     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_P(ParameterizedWebFrameTest, FrameForEnteredContext)
 {
     registerMockedHttpURLLoad("iframes_test.html");
     registerMockedHttpURLLoad("visible_iframe.html");
     registerMockedHttpURLLoad("invisible_iframe.html");
     registerMockedHttpURLLoad("zero_sized_iframe.html");
 
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "iframes_test.html", true);
 
     v8::HandleScope scope(v8::Isolate::GetCurrent());
     EXPECT_EQ(webViewHelper.webView()->mainFrame(), WebLocalFrame::frameForContext(webViewHelper.webView()->mainFrame()->mainWorldScriptContext()));
     EXPECT_EQ(webViewHelper.webView()->mainFrame()->firstChild(), WebLocalFrame::frameForContext(webViewHelper.webView()->mainFrame()->firstChild()->mainWorldScriptContext()));
 }
 
 class ScriptExecutionCallbackHelper : public WebScriptExecutionCallback {
 public:
     explicit ScriptExecutionCallbackHelper(v8::Local<v8::Context> context)
@@ skipping 15 matching lines @@
 
     bool m_didComplete;
     String m_stringValue;
     v8::Local<v8::Context> m_context;
 };
 
 TEST_P(ParameterizedWebFrameTest, RequestExecuteScript)
 {
     registerMockedHttpURLLoad("foo.html");
 
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "foo.html", true);
 
     v8::HandleScope scope(v8::Isolate::GetCurrent());
     ScriptExecutionCallbackHelper callbackHelper(webViewHelper.webView()->mainFrame()->mainWorldScriptContext());
     webViewHelper.webView()->mainFrame()->toWebLocalFrame()->requestExecuteScriptAndReturnValue(WebScriptSource(WebString("'hello';")), false, &callbackHelper);
     runPendingTasks();
     EXPECT_TRUE(callbackHelper.didComplete());
     EXPECT_EQ("hello", callbackHelper.stringValue());
 }
 
 TEST_P(ParameterizedWebFrameTest, SuspendedRequestExecuteScript)
 {
     registerMockedHttpURLLoad("foo.html");
     registerMockedHttpURLLoad("bar.html");
 
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "foo.html", true);
 
     v8::HandleScope scope(v8::Isolate::GetCurrent());
     ScriptExecutionCallbackHelper callbackHelper(webViewHelper.webView()->mainFrame()->mainWorldScriptContext());
 
     // Suspend scheduled tasks so the script doesn't run.
     webViewHelper.webView()->mainFrameImpl()->frame()->document()->suspendScheduledTasks();
     webViewHelper.webView()->mainFrameImpl()->requestExecuteScriptAndReturnValue(WebScriptSource(WebString("'hello';")), false, &callbackHelper);
     runPendingTasks();
     EXPECT_FALSE(callbackHelper.didComplete());
 
     // If the frame navigates, pending scripts should be removed, but the callback should always be ran.
     FrameTestHelpers::loadFrame(webViewHelper.webView()->mainFrame(), m_baseURL + "bar.html");
     EXPECT_TRUE(callbackHelper.didComplete());
     EXPECT_EQ(String(), callbackHelper.stringValue());
 }
 
 TEST_P(ParameterizedWebFrameTest, IframeScriptRemovesSelf)
 {
     registerMockedHttpURLLoad("single_iframe.html");
     registerMockedHttpURLLoad("visible_iframe.html");
 
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "single_iframe.html", true);
 
     v8::HandleScope scope(v8::Isolate::GetCurrent());
     ScriptExecutionCallbackHelper callbackHelper(webViewHelper.webView()->mainFrame()->mainWorldScriptContext());
     webViewHelper.webView()->mainFrame()->firstChild()->toWebLocalFrame()->requestExecuteScriptAndReturnValue(WebScriptSource(WebString("var iframe = window.top.document.getElementsByTagName('iframe')[0]; window.top.document.body.removeChild(iframe); 'hello';")), false, &callbackHelper);
     runPendingTasks();
     EXPECT_TRUE(callbackHelper.didComplete());
     EXPECT_EQ(String(), callbackHelper.stringValue());
 }
 
 TEST_P(ParameterizedWebFrameTest, FormWithNullFrame)
 {
     registerMockedHttpURLLoad("form.html");
 
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "form.html");
 
     WebVector<WebFormElement> forms;
     webViewHelper.webView()->mainFrame()->document().forms(forms);
     webViewHelper.reset();
 
     EXPECT_EQ(forms.size(), 1U);
 
     // This test passes if this doesn't crash.
     WebSearchableFormData searchableDataForm(forms[0]);
 }
 
 TEST_P(ParameterizedWebFrameTest, ChromePageJavascript)
 {
     registerMockedChromeURLLoad("history.html");
 
     // Pass true to enable JavaScript.
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_chromeURL + "history.html", true);
 
     // Try to run JS against the chrome-style URL.
     FrameTestHelpers::loadFrame(webViewHelper.webView()->mainFrame(), "javascript:document.body.appendChild(document.createTextNode('Clobbered'))");
 
     // Now retrieve the frame's text and ensure it was modified by running javascript.
     std::string content = WebFrameContentDumper::dumpWebViewAsText(webViewHelper.webView(), 1024).utf8();
     EXPECT_NE(std::string::npos, content.find("Clobbered"));
 }
 
 TEST_P(ParameterizedWebFrameTest, ChromePageNoJavascript)
 {
     registerMockedChromeURLLoad("history.html");
 
     /// Pass true to enable JavaScript.
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_chromeURL + "history.html", true);
 
     // Try to run JS against the chrome-style URL after prohibiting it.
     WebSecurityPolicy::registerURLSchemeAsNotAllowingJavascriptURLs("chrome");
     FrameTestHelpers::loadFrame(webViewHelper.webView()->mainFrame(), "javascript:document.body.appendChild(document.createTextNode('Clobbered'))");
 
     // Now retrieve the frame's text and ensure it wasn't modified by running javascript.
     std::string content = WebFrameContentDumper::dumpWebViewAsText(webViewHelper.webView(), 1024).utf8();
     EXPECT_EQ(std::string::npos, content.find("Clobbered"));
 }
 
 TEST_P(ParameterizedWebFrameTest, LocationSetHostWithMissingPort)
 {
     std::string fileName = "print-location-href.html";
     registerMockedHttpURLLoad(fileName);
     URLTestHelpers::registerMockedURLLoad(toKURL("http://internal.test:0/" + fileName), WebString::fromUTF8(fileName));
 
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
 
     /// Pass true to enable JavaScript.
     webViewHelper.initializeAndLoad(m_baseURL + fileName, true);
 
     // Setting host to "hostname:" should be treated as "hostname:0".
     FrameTestHelpers::loadFrame(webViewHelper.webView()->mainFrame(), "javascript:location.host = 'internal.test:'; void 0;");
 
     FrameTestHelpers::loadFrame(webViewHelper.webView()->mainFrame(), "javascript:document.body.textContent = location.href; void 0;");
 
     std::string content = WebFrameContentDumper::dumpWebViewAsText(webViewHelper.webView(), 1024).utf8();
     EXPECT_EQ("http://internal.test:0/" + fileName, content);
 }
 
 TEST_P(ParameterizedWebFrameTest, LocationSetEmptyPort)
 {
     std::string fileName = "print-location-href.html";
     registerMockedHttpURLLoad(fileName);
     URLTestHelpers::registerMockedURLLoad(toKURL("http://internal.test:0/" + fileName), WebString::fromUTF8(fileName));
 
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
 
     /// Pass true to enable JavaScript.
     webViewHelper.initializeAndLoad(m_baseURL + fileName, true);
 
     FrameTestHelpers::loadFrame(webViewHelper.webView()->mainFrame(), "javascript:location.port = ''; void 0;");
 
     FrameTestHelpers::loadFrame(webViewHelper.webView()->mainFrame(), "javascript:document.body.textContent = location.href; void 0;");
 
     std::string content = WebFrameContentDumper::dumpWebViewAsText(webViewHelper.webView(), 1024).utf8();
     EXPECT_EQ("http://internal.test:0/" + fileName, content);
@@ skipping 13 matching lines @@
         m_executing = false;
     }
 
     bool m_executing;
     bool m_wasExecuted;
 };
 
 TEST_P(ParameterizedWebFrameTest, DidClearWindowObjectIsNotRecursive)
 {
     EvaluateOnLoadWebFrameClient webFrameClient;
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad("about:blank", true, &webFrameClient);
     EXPECT_TRUE(webFrameClient.m_wasExecuted);
 }
 
 class CSSCallbackWebFrameClient : public FrameTestHelpers::TestWebFrameClient {
 public:
     CSSCallbackWebFrameClient() : m_updateCount(0) { }
     void didMatchCSS(WebLocalFrame*, const WebVector<WebString>& newlyMatchingSelectors, const WebVector<WebString>& stoppedMatchingSelectors) override;
 
     std::map<WebLocalFrame*, std::set<std::string>> m_matchedSelectors;
@@ skipping 256 matching lines @@
     EXPECT_EQ(1, updateCount());
     EXPECT_THAT(matchedSelectors(), ElementsAre("span"))
         << "An invalid selector shouldn't prevent other selectors from matching.";
 }
 
 TEST_P(ParameterizedWebFrameTest, DispatchMessageEventWithOriginCheck)
 {
     registerMockedHttpURLLoad("postmessage_test.html");
 
     // Pass true to enable JavaScript.
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "postmessage_test.html", true);
 
     // Send a message with the correct origin.
     WebSecurityOrigin correctOrigin(WebSecurityOrigin::create(toKURL(m_baseURL)));
     WebDocument document = webViewHelper.webView()->mainFrame()->document();
     WebSerializedScriptValue data(WebSerializedScriptValue::fromString("foo"));
     WebDOMMessageEvent message(data, "http://origin.com");
     webViewHelper.webView()->mainFrame()->dispatchMessageEventWithOriginCheck(correctOrigin, message);
 
     // Send another message with incorrect origin.
     WebSecurityOrigin incorrectOrigin(WebSecurityOrigin::create(toKURL(m_chromeURL)));
     webViewHelper.webView()->mainFrame()->dispatchMessageEventWithOriginCheck(incorrectOrigin, message);
 
     // Verify that only the first addition is in the body of the page.
     std::string content = WebFrameContentDumper::dumpWebViewAsText(webViewHelper.webView(), 1024).utf8();
     EXPECT_NE(std::string::npos, content.find("Message 1."));
     EXPECT_EQ(std::string::npos, content.find("Message 2."));
 }
 
 TEST_P(ParameterizedWebFrameTest, PostMessageThenDetach)
 {
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad("about:blank");
 
     LocalFrame* frame = toLocalFrame(webViewHelper.webView()->page()->mainFrame());
     NonThrowableExceptionState exceptionState;
     MessagePortArray messagePorts;
     frame->domWindow()->postMessage(SerializedScriptValue::serialize("message"), messagePorts, "*", frame->localDOMWindow(), exceptionState);
     webViewHelper.reset();
     EXPECT_FALSE(exceptionState.hadException());
 
     // Success is not crashing.
@@ skipping 52 matching lines @@
 } // anonymous namespace
 
 TEST_P(ParameterizedWebFrameTest, ChangeInFixedLayoutResetsTextAutosizingMultipliers)
 {
     registerMockedHttpURLLoad("fixed_layout.html");
 
     FixedLayoutTestWebViewClient client;
     int viewportWidth = 640;
     int viewportHeight = 480;
 
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "fixed_layout.html", true, nullptr, &client, nullptr, enableViewportSettings);
 
     Document* document = toLocalFrame(webViewHelper.webView()->page()->mainFrame())->document();
     document->settings()->setTextAutosizingEnabled(true);
     EXPECT_TRUE(document->settings()->textAutosizingEnabled());
     webViewHelper.resize(WebSize(viewportWidth, viewportHeight));
 
     EXPECT_TRUE(setTextAutosizingMultiplier(document, 2));
 
     ViewportDescription description = document->viewportDescription();
     // Choose a width that's not going match the viewport width of the loaded document.
     description.minWidth = Length(100, blink::Fixed);
     description.maxWidth = Length(100, blink::Fixed);
     webViewHelper.webView()->updatePageDefinedViewportConstraints(description);
 
     EXPECT_TRUE(checkTextAutosizingMultiplier(document, 1));
 }
 
 TEST_P(ParameterizedWebFrameTest, WorkingTextAutosizingMultipliers_VirtualViewport)
 {
     const std::string htmlFile = "fixed_layout.html";
     registerMockedHttpURLLoad(htmlFile);
 
     FixedLayoutTestWebViewClient client;
 
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + htmlFile, true, nullptr, &client, nullptr, configureAndroid);
 
     Document* document = toLocalFrame(webViewHelper.webView()->page()->mainFrame())->document();
     document->settings()->setTextAutosizingEnabled(true);
     EXPECT_TRUE(document->settings()->textAutosizingEnabled());
 
     webViewHelper.resize(WebSize(490, 800));
 
     // Multiplier: 980 / 490 = 2.0
     EXPECT_TRUE(checkTextAutosizingMultiplier(document, 2.0));
 }
 
 TEST_P(ParameterizedWebFrameTest, VisualViewportSetSizeInvalidatesTextAutosizingMultipliers)
 {
     registerMockedHttpURLLoad("iframe_reload.html");
     registerMockedHttpURLLoad("visible_iframe.html");
 
     FixedLayoutTestWebViewClient client;
     int viewportWidth = 640;
     int viewportHeight = 480;
 
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "iframe_reload.html", true, nullptr, &client, nullptr, enableViewportSettings);
 
     LocalFrame* mainFrame = toLocalFrame(webViewHelper.webView()->page()->mainFrame());
     Document* document = mainFrame->document();
     FrameView* frameView = webViewHelper.webView()->mainFrameImpl()->frameView();
     document->settings()->setTextAutosizingEnabled(true);
     EXPECT_TRUE(document->settings()->textAutosizingEnabled());
     webViewHelper.resize(WebSize(viewportWidth, viewportHeight));
 
     for (Frame* frame = mainFrame; frame; frame = frame->tree().traverseNext()) {
@@ skipping 18 matching lines @@
     }
 }
 
 TEST_P(ParameterizedWebFrameTest, ZeroHeightPositiveWidthNotIgnored)
 {
     FixedLayoutTestWebViewClient client;
     client.m_screenInfo.deviceScaleFactor = 1;
     int viewportWidth = 1280;
     int viewportHeight = 0;
 
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initialize(true, nullptr, &client, nullptr, enableViewportSettings);
     webViewHelper.resize(WebSize(viewportWidth, viewportHeight));
 
     EXPECT_EQ(viewportWidth, webViewHelper.webView()->mainFrameImpl()->frameView()->layoutSize().width());
     EXPECT_EQ(viewportHeight, webViewHelper.webView()->mainFrameImpl()->frameView()->layoutSize().height());
 }
 
 TEST_P(ParameterizedWebFrameTest, DeviceScaleFactorUsesDefaultWithoutViewportTag)
 {
     registerMockedHttpURLLoad("no_viewport_tag.html");
 
     int viewportWidth = 640;
     int viewportHeight = 480;
 
     FixedLayoutTestWebViewClient client;
     client.m_screenInfo.deviceScaleFactor = 2;
 
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "no_viewport_tag.html", true, nullptr, &client, nullptr, enableViewportSettings);
 
     webViewHelper.resize(WebSize(viewportWidth, viewportHeight));
 
     EXPECT_EQ(2, webViewHelper.webView()->page()->deviceScaleFactor());
 
     // Device scale factor should be independent of page scale.
     webViewHelper.webView()->setDefaultPageScaleLimits(1, 2);
     webViewHelper.webView()->setPageScaleFactor(0.5);
     webViewHelper.webView()->updateAllLifecyclePhases();
     EXPECT_EQ(1, webViewHelper.webView()->pageScaleFactor());
 
     // Force the layout to happen before leaving the test.
     webViewHelper.webView()->updateAllLifecyclePhases();
 }
 
 TEST_P(ParameterizedWebFrameTest, FixedLayoutInitializeAtMinimumScale)
 {
     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.
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initialize(true, nullptr, &client, nullptr, enableViewportSettings);
     webViewHelper.webView()->setDefaultPageScaleLimits(0.25f, 5);
     FrameTestHelpers::loadFrame(webViewHelper.webView()->mainFrame(), m_baseURL + "fixed_layout.html");
     webViewHelper.resize(WebSize(viewportWidth, viewportHeight));
 
     int defaultFixedLayoutWidth = 980;
     float minimumPageScaleFactor = viewportWidth / (float) defaultFixedLayoutWidth;
     EXPECT_EQ(minimumPageScaleFactor, webViewHelper.webView()->pageScaleFactor());
     EXPECT_EQ(minimumPageScaleFactor, webViewHelper.webView()->minimumPageScaleFactor());
 
@@ skipping 16 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.
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initialize(true, nullptr, &client, nullptr, enableViewportSettings);
     webViewHelper.webView()->setDefaultPageScaleLimits(0.25f, 5);
     FrameTestHelpers::loadFrame(webViewHelper.webView()->mainFrame(), m_baseURL + "wide_document.html");
     webViewHelper.resize(WebSize(viewportWidth, viewportHeight));
 
     int wideDocumentWidth = 1500;
     float minimumPageScaleFactor = viewportWidth / (float) wideDocumentWidth;
     EXPECT_EQ(minimumPageScaleFactor, webViewHelper.webView()->pageScaleFactor());
     EXPECT_EQ(minimumPageScaleFactor, webViewHelper.webView()->minimumPageScaleFactor());
 
@@ skipping 14 matching lines @@
 
 TEST_P(ParameterizedWebFrameTest, DelayedViewportInitialScale)
 {
     registerMockedHttpURLLoad("viewport-auto-initial-scale.html");
 
     FixedLayoutTestWebViewClient client;
     client.m_screenInfo.deviceScaleFactor = 1;
     int viewportWidth = 640;
     int viewportHeight = 480;
 
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "viewport-auto-initial-scale.html", true, nullptr, &client, nullptr, enableViewportSettings);
     webViewHelper.resize(WebSize(viewportWidth, viewportHeight));
 
     EXPECT_EQ(0.25f, webViewHelper.webView()->pageScaleFactor());
 
     Document* document = toLocalFrame(webViewHelper.webView()->page()->mainFrame())->document();
     ViewportDescription description = document->viewportDescription();
     description.zoom = 2;
     document->setViewportDescription(description);
     webViewHelper.webView()->updateAllLifecyclePhases();
     EXPECT_EQ(2, webViewHelper.webView()->pageScaleFactor());
 }
 
 TEST_P(ParameterizedWebFrameTest, setLoadWithOverviewModeToFalse)
 {
     registerMockedHttpURLLoad("viewport-auto-initial-scale.html");
 
     FixedLayoutTestWebViewClient client;
     client.m_screenInfo.deviceScaleFactor = 1;
     int viewportWidth = 640;
     int viewportHeight = 480;
 
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "viewport-auto-initial-scale.html", true, nullptr, &client, nullptr, enableViewportSettings);
     webViewHelper.webView()->settings()->setWideViewportQuirkEnabled(true);
     webViewHelper.webView()->settings()->setLoadWithOverviewMode(false);
     webViewHelper.resize(WebSize(viewportWidth, viewportHeight));
 
     // The page must be displayed at 100% zoom.
     EXPECT_EQ(1.0f, webViewHelper.webView()->pageScaleFactor());
 }
 
 TEST_P(ParameterizedWebFrameTest, SetLoadWithOverviewModeToFalseAndNoWideViewport)
 {
     registerMockedHttpURLLoad("large-div.html");
 
     FixedLayoutTestWebViewClient client;
     client.m_screenInfo.deviceScaleFactor = 1;
     int viewportWidth = 640;
     int viewportHeight = 480;
 
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "large-div.html", true, nullptr, &client, nullptr, enableViewportSettings);
     webViewHelper.webView()->settings()->setLoadWithOverviewMode(false);
     webViewHelper.webView()->settings()->setWideViewportQuirkEnabled(true);
     webViewHelper.webView()->settings()->setUseWideViewport(false);
     webViewHelper.resize(WebSize(viewportWidth, viewportHeight));
 
     // The page must be displayed at 100% zoom, despite that it hosts a wide div element.
     EXPECT_EQ(1.0f, webViewHelper.webView()->pageScaleFactor());
 }
 
 TEST_P(ParameterizedWebFrameTest, NoWideViewportIgnoresPageViewportWidth)
 {
     registerMockedHttpURLLoad("viewport-auto-initial-scale.html");
 
     FixedLayoutTestWebViewClient client;
     client.m_screenInfo.deviceScaleFactor = 1;
     int viewportWidth = 640;
     int viewportHeight = 480;
 
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "viewport-auto-initial-scale.html", true, nullptr, &client, nullptr, enableViewportSettings);
     webViewHelper.webView()->settings()->setWideViewportQuirkEnabled(true);
     webViewHelper.webView()->settings()->setUseWideViewport(false);
     webViewHelper.resize(WebSize(viewportWidth, viewportHeight));
 
     // The page sets viewport width to 3000, but with UseWideViewport == false is must be ignored.
     EXPECT_EQ(viewportWidth, webViewHelper.webView()->mainFrameImpl()->frameView()->contentsSize().width());
     EXPECT_EQ(viewportHeight, webViewHelper.webView()->mainFrameImpl()->frameView()->contentsSize().height());
 }
 
 TEST_P(ParameterizedWebFrameTest, NoWideViewportIgnoresPageViewportWidthButAccountsScale)
 {
     registerMockedHttpURLLoad("viewport-wide-2x-initial-scale.html");
 
     FixedLayoutTestWebViewClient client;
     client.m_screenInfo.deviceScaleFactor = 1;
     int viewportWidth = 640;
     int viewportHeight = 480;
 
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "viewport-wide-2x-initial-scale.html", true, nullptr, &client, nullptr, enableViewportSettings);
     webViewHelper.webView()->settings()->setWideViewportQuirkEnabled(true);
     webViewHelper.webView()->settings()->setUseWideViewport(false);
     webViewHelper.resize(WebSize(viewportWidth, viewportHeight));
 
     // The page sets viewport width to 3000, but with UseWideViewport == false it must be ignored.
     // While the initial scale specified by the page must be accounted.
     EXPECT_EQ(viewportWidth / 2, webViewHelper.webView()->mainFrameImpl()->frameView()->contentsSize().width());
     EXPECT_EQ(viewportHeight / 2, webViewHelper.webView()->mainFrameImpl()->frameView()->contentsSize().height());
 }
 
 TEST_P(ParameterizedWebFrameTest, WideViewportSetsTo980WithoutViewportTag)
 {
     registerMockedHttpURLLoad("no_viewport_tag.html");
 
     FixedLayoutTestWebViewClient client;
     client.m_screenInfo.deviceScaleFactor = 1;
     int viewportWidth = 640;
     int viewportHeight = 480;
 
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "no_viewport_tag.html", true, nullptr, &client, nullptr, enableViewportSettings);
     applyViewportStyleOverride(&webViewHelper);
     webViewHelper.webView()->settings()->setWideViewportQuirkEnabled(true);
     webViewHelper.webView()->settings()->setUseWideViewport(true);
     webViewHelper.resize(WebSize(viewportWidth, viewportHeight));
 
     EXPECT_EQ(980, webViewHelper.webView()->mainFrameImpl()->frameView()->contentsSize().width());
     EXPECT_EQ(980.0 / viewportWidth * viewportHeight, webViewHelper.webView()->mainFrameImpl()->frameView()->contentsSize().height());
 }
 
 TEST_P(ParameterizedWebFrameTest, WideViewportSetsTo980WithXhtmlMp)
 {
     registerMockedHttpURLLoad("viewport/viewport-legacy-xhtmlmp.html");
 
     FixedLayoutTestWebViewClient client;
     client.m_screenInfo.deviceScaleFactor = 1;
     int viewportWidth = 640;
     int viewportHeight = 480;
 
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initialize(true, nullptr, &client, nullptr, enableViewportSettings);
     applyViewportStyleOverride(&webViewHelper);
     webViewHelper.webView()->settings()->setWideViewportQuirkEnabled(true);
     webViewHelper.webView()->settings()->setUseWideViewport(true);
     FrameTestHelpers::loadFrame(webViewHelper.webView()->mainFrame(), m_baseURL + "viewport/viewport-legacy-xhtmlmp.html");
 
     webViewHelper.resize(WebSize(viewportWidth, viewportHeight));
     EXPECT_EQ(viewportWidth, webViewHelper.webView()->mainFrameImpl()->frameView()->contentsSize().width());
     EXPECT_EQ(viewportHeight, webViewHelper.webView()->mainFrameImpl()->frameView()->contentsSize().height());
 }
 
 TEST_P(ParameterizedWebFrameTest, NoWideViewportAndHeightInMeta)
 {
     registerMockedHttpURLLoad("viewport-height-1000.html");
 
     FixedLayoutTestWebViewClient client;
     client.m_screenInfo.deviceScaleFactor = 1;
     int viewportWidth = 640;
     int viewportHeight = 480;
 
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "viewport-height-1000.html", true, nullptr, &client, nullptr, enableViewportSettings);
     webViewHelper.webView()->settings()->setWideViewportQuirkEnabled(true);
     webViewHelper.webView()->settings()->setUseWideViewport(false);
     webViewHelper.resize(WebSize(viewportWidth, viewportHeight));
 
     EXPECT_EQ(viewportWidth, webViewHelper.webView()->mainFrameImpl()->frameView()->contentsSize().width());
 }
 
 TEST_P(ParameterizedWebFrameTest, WideViewportSetsTo980WithAutoWidth)
 {
     registerMockedHttpURLLoad("viewport-2x-initial-scale.html");
 
     FixedLayoutTestWebViewClient client;
     client.m_screenInfo.deviceScaleFactor = 1;
     int viewportWidth = 640;
     int viewportHeight = 480;
 
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "viewport-2x-initial-scale.html", true, nullptr, &client, nullptr, enableViewportSettings);
     applyViewportStyleOverride(&webViewHelper);
     webViewHelper.webView()->settings()->setWideViewportQuirkEnabled(true);
     webViewHelper.webView()->settings()->setUseWideViewport(true);
     webViewHelper.resize(WebSize(viewportWidth, viewportHeight));
 
     EXPECT_EQ(980, webViewHelper.webView()->mainFrameImpl()->frameView()->contentsSize().width());
     EXPECT_EQ(980.0 / viewportWidth * viewportHeight, webViewHelper.webView()->mainFrameImpl()->frameView()->contentsSize().height());
 }
 
 TEST_P(ParameterizedWebFrameTest, PageViewportInitialScaleOverridesLoadWithOverviewMode)
 {
     registerMockedHttpURLLoad("viewport-wide-2x-initial-scale.html");
 
     FixedLayoutTestWebViewClient client;
     client.m_screenInfo.deviceScaleFactor = 1;
     int viewportWidth = 640;
     int viewportHeight = 480;
 
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "viewport-wide-2x-initial-scale.html", true, nullptr, &client, nullptr, enableViewportSettings);
     webViewHelper.webView()->settings()->setLoadWithOverviewMode(false);
     webViewHelper.resize(WebSize(viewportWidth, viewportHeight));
 
     // The page must be displayed at 200% zoom, as specified in its viewport meta tag.
     EXPECT_EQ(2.0f, webViewHelper.webView()->pageScaleFactor());
 }
 
 TEST_P(ParameterizedWebFrameTest, setInitialPageScaleFactorPermanently)
 {
     registerMockedHttpURLLoad("fixed_layout.html");
 
     FixedLayoutTestWebViewClient client;
     client.m_screenInfo.deviceScaleFactor = 1;
     float enforcedPageScaleFactor = 2.0f;
 
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "fixed_layout.html", true, nullptr, &client, nullptr, enableViewportSettings);
     applyViewportStyleOverride(&webViewHelper);
     webViewHelper.webView()->settings()->setWideViewportQuirkEnabled(true);
     webViewHelper.webView()->settings()->setLoadWithOverviewMode(false);
     webViewHelper.webView()->setInitialPageScaleOverride(enforcedPageScaleFactor);
     webViewHelper.webView()->updateAllLifecyclePhases();
 
     EXPECT_EQ(enforcedPageScaleFactor, webViewHelper.webView()->pageScaleFactor());
 
     int viewportWidth = 640;
@@ skipping 10 matching lines @@
 TEST_P(ParameterizedWebFrameTest, PermanentInitialPageScaleFactorOverridesLoadWithOverviewMode)
 {
     registerMockedHttpURLLoad("viewport-auto-initial-scale.html");
 
     FixedLayoutTestWebViewClient client;
     client.m_screenInfo.deviceScaleFactor = 1;
     int viewportWidth = 640;
     int viewportHeight = 480;
     float enforcedPageScaleFactor = 0.5f;
 
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "viewport-auto-initial-scale.html", true, nullptr, &client, nullptr, enableViewportSettings);
     webViewHelper.webView()->settings()->setLoadWithOverviewMode(false);
     webViewHelper.webView()->setInitialPageScaleOverride(enforcedPageScaleFactor);
     webViewHelper.resize(WebSize(viewportWidth, viewportHeight));
 
     EXPECT_EQ(enforcedPageScaleFactor, webViewHelper.webView()->pageScaleFactor());
 }
 
 TEST_P(ParameterizedWebFrameTest, PermanentInitialPageScaleFactorOverridesPageViewportInitialScale)
 {
     registerMockedHttpURLLoad("viewport-wide-2x-initial-scale.html");
 
     FixedLayoutTestWebViewClient client;
     client.m_screenInfo.deviceScaleFactor = 1;
     int viewportWidth = 640;
     int viewportHeight = 480;
     float enforcedPageScaleFactor = 0.5f;
 
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "viewport-wide-2x-initial-scale.html", true, nullptr, &client, nullptr, enableViewportSettings);
     webViewHelper.webView()->setInitialPageScaleOverride(enforcedPageScaleFactor);
     webViewHelper.resize(WebSize(viewportWidth, viewportHeight));
 
     EXPECT_EQ(enforcedPageScaleFactor, webViewHelper.webView()->pageScaleFactor());
 }
 
 TEST_P(ParameterizedWebFrameTest, SmallPermanentInitialPageScaleFactorIsClobbered)
 {
     const char* pages[] = {
         // These pages trigger the clobbering condition. There must be a matching item in "pageScaleFactors" array.
         "viewport-device-0.5x-initial-scale.html",
         "viewport-initial-scale-1.html",
         // These ones do not.
         "viewport-auto-initial-scale.html",
         "viewport-target-densitydpi-device-and-fixed-width.html"
     };
     float pageScaleFactors[] = { 0.5f, 1.0f };
     for (size_t i = 0; i < WTF_ARRAY_LENGTH(pages); ++i)
         registerMockedHttpURLLoad(pages[i]);
 
     FixedLayoutTestWebViewClient client;
     client.m_screenInfo.deviceScaleFactor = 1;
     int viewportWidth = 400;
     int viewportHeight = 300;
     float enforcedPageScaleFactor = 0.75f;
 
     for (size_t i = 0; i < WTF_ARRAY_LENGTH(pages); ++i) {
         for (int quirkEnabled = 0; quirkEnabled <= 1; ++quirkEnabled) {
-            FrameTestHelpers::WebViewHelper webViewHelper(this);
+            FrameTestHelpers::WebViewHelper webViewHelper;
             webViewHelper.initializeAndLoad(m_baseURL + pages[i], true, nullptr, &client, nullptr, enableViewportSettings);
             applyViewportStyleOverride(&webViewHelper);
             webViewHelper.webView()->settings()->setClobberUserAgentInitialScaleQuirk(quirkEnabled);
             webViewHelper.webView()->setInitialPageScaleOverride(enforcedPageScaleFactor);
             webViewHelper.resize(WebSize(viewportWidth, viewportHeight));
 
             float expectedPageScaleFactor = quirkEnabled && i < WTF_ARRAY_LENGTH(pageScaleFactors) ? pageScaleFactors[i] : enforcedPageScaleFactor;
             EXPECT_EQ(expectedPageScaleFactor, webViewHelper.webView()->pageScaleFactor());
         }
     }
 }
 
 TEST_P(ParameterizedWebFrameTest, PermanentInitialPageScaleFactorAffectsLayoutWidth)
 {
     FixedLayoutTestWebViewClient client;
     client.m_screenInfo.deviceScaleFactor = 1;
     int viewportWidth = 640;
     int viewportHeight = 480;
     float enforcedPageScaleFactor = 0.5;
 
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad("about:blank", true, nullptr, &client, nullptr, enableViewportSettings);
     webViewHelper.webView()->settings()->setWideViewportQuirkEnabled(true);
     webViewHelper.webView()->settings()->setUseWideViewport(false);
     webViewHelper.webView()->settings()->setLoadWithOverviewMode(false);
     webViewHelper.webView()->setInitialPageScaleOverride(enforcedPageScaleFactor);
     webViewHelper.resize(WebSize(viewportWidth, viewportHeight));
 
     EXPECT_EQ(viewportWidth / enforcedPageScaleFactor, webViewHelper.webView()->mainFrameImpl()->frameView()->contentsSize().width());
     EXPECT_EQ(enforcedPageScaleFactor, webViewHelper.webView()->pageScaleFactor());
 }
 
 TEST_P(ParameterizedWebFrameTest, DocumentElementClientHeightWorksWithWrapContentMode)
 {
     registerMockedHttpURLLoad("0-by-0.html");
 
     FixedLayoutTestWebViewClient client;
     client.m_screenInfo.deviceScaleFactor = 1;
     int viewportWidth = 640;
     int viewportHeight = 480;
 
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
 
     webViewHelper.initializeAndLoad(m_baseURL + "0-by-0.html", true, nullptr, &client, nullptr, configureAndroid);
     webViewHelper.webView()->settings()->setForceZeroLayoutHeight(true);
     webViewHelper.resize(WebSize(viewportWidth, viewportHeight));
 
     LocalFrame* frame = webViewHelper.webView()->mainFrameImpl()->frame();
     Document* document = frame->document();
     EXPECT_EQ(viewportHeight, document->documentElement()->clientHeight());
     EXPECT_EQ(viewportWidth, document->documentElement()->clientWidth());
 }
 
 TEST_P(ParameterizedWebFrameTest, SetForceZeroLayoutHeightWorksWithWrapContentMode)
 {
     registerMockedHttpURLLoad("0-by-0.html");
 
     FixedLayoutTestWebViewClient client;
     client.m_screenInfo.deviceScaleFactor = 1;
     int viewportWidth = 640;
     int viewportHeight = 480;
 
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
 
     webViewHelper.initializeAndLoad(m_baseURL + "0-by-0.html", true, nullptr, &client, nullptr, configureAndroid);
     webViewHelper.webView()->settings()->setForceZeroLayoutHeight(true);
     PaintLayerCompositor* compositor = webViewHelper.webView()->compositor();
     EXPECT_EQ(0, webViewHelper.webView()->mainFrameImpl()->frameView()->layoutSize().width());
     EXPECT_EQ(0, webViewHelper.webView()->mainFrameImpl()->frameView()->layoutSize().height());
     EXPECT_EQ(0.0, compositor->containerLayer()->size().width());
     EXPECT_EQ(0.0, compositor->containerLayer()->size().height());
 
     webViewHelper.resize(WebSize(viewportWidth, 0));
@@ skipping 21 matching lines @@
 
 TEST_P(ParameterizedWebFrameTest, SetForceZeroLayoutHeight)
 {
     registerMockedHttpURLLoad("200-by-300.html");
 
     FixedLayoutTestWebViewClient client;
     client.m_screenInfo.deviceScaleFactor = 1;
     int viewportWidth = 640;
     int viewportHeight = 480;
 
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
 
     webViewHelper.initializeAndLoad(m_baseURL + "200-by-300.html", true, nullptr, &client, nullptr, enableViewportSettings);
     webViewHelper.resize(WebSize(viewportWidth, viewportHeight));
 
     EXPECT_LE(viewportHeight, webViewHelper.webView()->mainFrameImpl()->frameView()->layoutSize().height());
     webViewHelper.webView()->settings()->setForceZeroLayoutHeight(true);
     EXPECT_TRUE(webViewHelper.webView()->mainFrameImpl()->frameView()->needsLayout());
 
     EXPECT_EQ(0, webViewHelper.webView()->mainFrameImpl()->frameView()->layoutSize().height());
 
@@ skipping 142 matching lines @@
 TEST_P(ParameterizedWebFrameTest, SetForceZeroLayoutHeightWorksAcrossNavigations)
 {
     registerMockedHttpURLLoad("200-by-300.html");
     registerMockedHttpURLLoad("large-div.html");
 
     FixedLayoutTestWebViewClient client;
     client.m_screenInfo.deviceScaleFactor = 1;
     int viewportWidth = 640;
     int viewportHeight = 480;
 
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
 
     webViewHelper.initializeAndLoad(m_baseURL + "200-by-300.html", true, nullptr, &client, nullptr, enableViewportSettings);
     webViewHelper.webView()->settings()->setForceZeroLayoutHeight(true);
     webViewHelper.resize(WebSize(viewportWidth, viewportHeight));
 
     FrameTestHelpers::loadFrame(webViewHelper.webView()->mainFrame(), m_baseURL + "large-div.html");
     webViewHelper.webView()->updateAllLifecyclePhases();
 
     EXPECT_EQ(0, webViewHelper.webView()->mainFrameImpl()->frameView()->layoutSize().height());
 }
 
 TEST_P(ParameterizedWebFrameTest, SetForceZeroLayoutHeightWithWideViewportQuirk)
 {
     registerMockedHttpURLLoad("200-by-300.html");
 
     FixedLayoutTestWebViewClient client;
     client.m_screenInfo.deviceScaleFactor = 1;
     int viewportWidth = 640;
     int viewportHeight = 480;
 
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
 
     webViewHelper.initializeAndLoad(m_baseURL + "200-by-300.html", true, nullptr, &client, nullptr, enableViewportSettings);
     webViewHelper.webView()->settings()->setWideViewportQuirkEnabled(true);
     webViewHelper.webView()->settings()->setUseWideViewport(true);
     webViewHelper.webView()->settings()->setForceZeroLayoutHeight(true);
     webViewHelper.resize(WebSize(viewportWidth, viewportHeight));
 
     EXPECT_EQ(0, webViewHelper.webView()->mainFrameImpl()->frameView()->layoutSize().height());
 }
 
 TEST_P(ParameterizedWebFrameTest, WideViewportAndWideContentWithInitialScale)
 {
     registerMockedHttpURLLoad("wide_document_width_viewport.html");
     registerMockedHttpURLLoad("white-1x1.png");
 
     FixedLayoutTestWebViewClient client;
     client.m_screenInfo.deviceScaleFactor = 1;
     int viewportWidth = 600;
     int viewportHeight = 800;
 
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad("about:blank", true, nullptr, &client, nullptr, enableViewportSettings);
     webViewHelper.webView()->settings()->setWideViewportQuirkEnabled(true);
     webViewHelper.webView()->settings()->setUseWideViewport(true);
     webViewHelper.webView()->settings()->setViewportMetaLayoutSizeQuirk(true);
     webViewHelper.resize(WebSize(viewportWidth, viewportHeight));
 
     FrameTestHelpers::loadFrame(webViewHelper.webView()->mainFrame(), m_baseURL + "wide_document_width_viewport.html");
     webViewHelper.resize(WebSize(viewportWidth, viewportHeight));
 
     int wideDocumentWidth = 800;
     float minimumPageScaleFactor = viewportWidth / (float) wideDocumentWidth;
     EXPECT_EQ(minimumPageScaleFactor, webViewHelper.webView()->pageScaleFactor());
     EXPECT_EQ(minimumPageScaleFactor, webViewHelper.webView()->minimumPageScaleFactor());
 }
 
 TEST_P(ParameterizedWebFrameTest, WideViewportQuirkClobbersHeight)
 {
     registerMockedHttpURLLoad("viewport-height-1000.html");
 
     FixedLayoutTestWebViewClient client;
     client.m_screenInfo.deviceScaleFactor = 1;
     int viewportWidth = 600;
     int viewportHeight = 800;
 
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad("about:blank", true, nullptr, &client, nullptr, enableViewportSettings);
     webViewHelper.webView()->settings()->setWideViewportQuirkEnabled(true);
     webViewHelper.webView()->settings()->setUseWideViewport(false);
     webViewHelper.webView()->settings()->setViewportMetaLayoutSizeQuirk(true);
     webViewHelper.resize(WebSize(viewportWidth, viewportHeight));
 
     FrameTestHelpers::loadFrame(webViewHelper.webView()->mainFrame(), m_baseURL + "viewport-height-1000.html");
     webViewHelper.resize(WebSize(viewportWidth, viewportHeight));
 
     EXPECT_EQ(800, webViewHelper.webView()->mainFrameImpl()->frameView()->layoutSize().height());
     EXPECT_EQ(1, webViewHelper.webView()->pageScaleFactor());
 }
 
 TEST_P(ParameterizedWebFrameTest, LayoutSize320Quirk)
 {
     registerMockedHttpURLLoad("viewport/viewport-30.html");
 
     FixedLayoutTestWebViewClient client;
     client.m_screenInfo.deviceScaleFactor = 1;
     int viewportWidth = 600;
     int viewportHeight = 800;
 
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad("about:blank", true, nullptr, &client, nullptr, enableViewportSettings);
     webViewHelper.webView()->settings()->setWideViewportQuirkEnabled(true);
     webViewHelper.webView()->settings()->setUseWideViewport(true);
     webViewHelper.webView()->settings()->setViewportMetaLayoutSizeQuirk(true);
     webViewHelper.resize(WebSize(viewportWidth, viewportHeight));
 
     FrameTestHelpers::loadFrame(webViewHelper.webView()->mainFrame(), m_baseURL + "viewport/viewport-30.html");
     webViewHelper.resize(WebSize(viewportWidth, viewportHeight));
 
     EXPECT_EQ(600, webViewHelper.webView()->mainFrameImpl()->frameView()->layoutSize().width());
@@ skipping 30 matching lines @@
 
 TEST_P(ParameterizedWebFrameTest, ZeroValuesQuirk)
 {
     registerMockedHttpURLLoad("viewport-zero-values.html");
 
     FixedLayoutTestWebViewClient client;
     client.m_screenInfo.deviceScaleFactor = 1;
     int viewportWidth = 640;
     int viewportHeight = 480;
 
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initialize(true, nullptr, &client, nullptr, enableViewportSettings);
     webViewHelper.webView()->settings()->setViewportMetaZeroValuesQuirk(true);
     webViewHelper.webView()->settings()->setWideViewportQuirkEnabled(true);
     webViewHelper.webView()->settings()->setViewportMetaLayoutSizeQuirk(true);
     FrameTestHelpers::loadFrame(webViewHelper.webView()->mainFrame(), m_baseURL + "viewport-zero-values.html");
     webViewHelper.resize(WebSize(viewportWidth, viewportHeight));
 
     EXPECT_EQ(viewportWidth, webViewHelper.webView()->mainFrameImpl()->frameView()->layoutSize().width());
     EXPECT_EQ(1.0f, webViewHelper.webView()->pageScaleFactor());
 
     webViewHelper.webView()->settings()->setUseWideViewport(true);
     webViewHelper.webView()->updateAllLifecyclePhases();
     EXPECT_EQ(viewportWidth, webViewHelper.webView()->mainFrameImpl()->frameView()->layoutSize().width());
     EXPECT_EQ(1.0f, webViewHelper.webView()->pageScaleFactor());
 }
 
 TEST_P(ParameterizedWebFrameTest, OverflowHiddenDisablesScrolling)
 {
     registerMockedHttpURLLoad("body-overflow-hidden.html");
 
     FixedLayoutTestWebViewClient client;
     client.m_screenInfo.deviceScaleFactor = 1;
     int viewportWidth = 640;
     int viewportHeight = 480;
 
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initialize(true, nullptr, &client, nullptr);
     FrameTestHelpers::loadFrame(webViewHelper.webView()->mainFrame(), m_baseURL + "body-overflow-hidden.html");
     webViewHelper.resize(WebSize(viewportWidth, viewportHeight));
 
     FrameView* view = webViewHelper.webView()->mainFrameImpl()->frameView();
     EXPECT_FALSE(view->userInputScrollable(VerticalScrollbar));
     EXPECT_FALSE(view->userInputScrollable(HorizontalScrollbar));
 }
 
 TEST_P(ParameterizedWebFrameTest, OverflowHiddenDisablesScrollingWithSetCanHaveScrollbars)
 {
     registerMockedHttpURLLoad("body-overflow-hidden-short.html");
 
     FixedLayoutTestWebViewClient client;
     client.m_screenInfo.deviceScaleFactor = 1;
     int viewportWidth = 640;
     int viewportHeight = 480;
 
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initialize(true, nullptr, &client, nullptr);
     FrameTestHelpers::loadFrame(webViewHelper.webView()->mainFrame(), m_baseURL + "body-overflow-hidden-short.html");
     webViewHelper.resize(WebSize(viewportWidth, viewportHeight));
 
     FrameView* view = webViewHelper.webView()->mainFrameImpl()->frameView();
     EXPECT_FALSE(view->userInputScrollable(VerticalScrollbar));
     EXPECT_FALSE(view->userInputScrollable(HorizontalScrollbar));
 
     webViewHelper.webView()->mainFrameImpl()->setCanHaveScrollbars(true);
     EXPECT_FALSE(view->userInputScrollable(VerticalScrollbar));
@@ skipping 22 matching lines @@
 TEST_P(ParameterizedWebFrameTest, NonZeroValuesNoQuirk)
 {
     registerMockedHttpURLLoad("viewport-nonzero-values.html");
 
     FixedLayoutTestWebViewClient client;
     client.m_screenInfo.deviceScaleFactor = 1;
     int viewportWidth = 640;
     int viewportHeight = 480;
     float expectedPageScaleFactor = 0.5f;
 
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initialize(true, nullptr, &client, nullptr, enableViewportSettings);
     webViewHelper.webView()->settings()->setViewportMetaZeroValuesQuirk(true);
     webViewHelper.webView()->settings()->setWideViewportQuirkEnabled(true);
     FrameTestHelpers::loadFrame(webViewHelper.webView()->mainFrame(), m_baseURL + "viewport-nonzero-values.html");
     webViewHelper.resize(WebSize(viewportWidth, viewportHeight));
 
     EXPECT_EQ(viewportWidth / expectedPageScaleFactor, webViewHelper.webView()->mainFrameImpl()->frameView()->layoutSize().width());
     EXPECT_EQ(expectedPageScaleFactor, webViewHelper.webView()->pageScaleFactor());
 
     webViewHelper.webView()->settings()->setUseWideViewport(true);
     webViewHelper.webView()->updateAllLifecyclePhases();
     EXPECT_EQ(viewportWidth / expectedPageScaleFactor, webViewHelper.webView()->mainFrameImpl()->frameView()->layoutSize().width());
     EXPECT_EQ(expectedPageScaleFactor, webViewHelper.webView()->pageScaleFactor());
 }
 
 TEST_P(ParameterizedWebFrameTest, 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;
 
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "fixed_layout.html", true, nullptr, &client, nullptr, enableViewportSettings);
     webViewHelper.resize(WebSize(viewportWidth, viewportHeight));
 
     int prevLayoutCount = webViewHelper.webView()->mainFrameImpl()->frameView()->layoutCount();
     webViewHelper.webView()->setPageScaleFactor(3);
     EXPECT_FALSE(webViewHelper.webView()->mainFrameImpl()->frameView()->needsLayout());
     EXPECT_EQ(prevLayoutCount, webViewHelper.webView()->mainFrameImpl()->frameView()->layoutCount());
 }
 
 TEST_P(ParameterizedWebFrameTest, setPageScaleFactorWithOverlayScrollbarsDoesNotLayout)
 {
     registerMockedHttpURLLoad("fixed_layout.html");
 
     FixedLayoutTestWebViewClient client;
     client.m_screenInfo.deviceScaleFactor = 1;
     int viewportWidth = 640;
     int viewportHeight = 480;
 
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "fixed_layout.html", true, nullptr, &client, nullptr, enableViewportSettings);
     webViewHelper.resize(WebSize(viewportWidth, viewportHeight));
 
     int prevLayoutCount = webViewHelper.webView()->mainFrameImpl()->frameView()->layoutCount();
     webViewHelper.webView()->setPageScaleFactor(30);
     EXPECT_FALSE(webViewHelper.webView()->mainFrameImpl()->frameView()->needsLayout());
     EXPECT_EQ(prevLayoutCount, webViewHelper.webView()->mainFrameImpl()->frameView()->layoutCount());
 
 }
 
 TEST_P(ParameterizedWebFrameTest, pageScaleFactorWrittenToHistoryItem)
 {
     registerMockedHttpURLLoad("fixed_layout.html");
 
     FixedLayoutTestWebViewClient client;
     client.m_screenInfo.deviceScaleFactor = 1;
     int viewportWidth = 640;
     int viewportHeight = 480;
 
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "fixed_layout.html", true, nullptr, &client, nullptr, enableViewportSettings);
     webViewHelper.resize(WebSize(viewportWidth, viewportHeight));
 
     webViewHelper.webView()->setPageScaleFactor(3);
     EXPECT_EQ(3, toLocalFrame(webViewHelper.webView()->page()->mainFrame())->loader().currentItem()->pageScaleFactor());
 }
 
 TEST_P(ParameterizedWebFrameTest, initialScaleWrittenToHistoryItem)
 {
     registerMockedHttpURLLoad("fixed_layout.html");
 
     FixedLayoutTestWebViewClient client;
     client.m_screenInfo.deviceScaleFactor = 1;
     int viewportWidth = 640;
     int viewportHeight = 480;
 
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initialize(true, nullptr, &client, nullptr, enableViewportSettings);
     webViewHelper.webView()->setDefaultPageScaleLimits(0.25f, 5);
     FrameTestHelpers::loadFrame(webViewHelper.webView()->mainFrame(), m_baseURL + "fixed_layout.html");
     webViewHelper.resize(WebSize(viewportWidth, viewportHeight));
 
     int defaultFixedLayoutWidth = 980;
     float minimumPageScaleFactor = viewportWidth / (float) defaultFixedLayoutWidth;
     EXPECT_EQ(minimumPageScaleFactor, toLocalFrame(webViewHelper.webView()->page()->mainFrame())->loader().currentItem()->pageScaleFactor());
 }
 
 TEST_P(ParameterizedWebFrameTest, pageScaleFactorDoesntShrinkFrameView)
 {
     registerMockedHttpURLLoad("large-div.html");
 
     FixedLayoutTestWebViewClient client;
     client.m_screenInfo.deviceScaleFactor = 1;
     // Small viewport to ensure there are always scrollbars.
     int viewportWidth = 64;
     int viewportHeight = 48;
 
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "large-div.html", true, nullptr, &client, nullptr, enableViewportSettings);
     webViewHelper.resize(WebSize(viewportWidth, viewportHeight));
 
     FrameView* view = webViewHelper.webView()->mainFrameImpl()->frameView();
     int viewportWidthMinusScrollbar = viewportWidth;
     int viewportHeightMinusScrollbar = viewportHeight;
 
     if (view->verticalScrollbar() && !view->verticalScrollbar()->isOverlayScrollbar())
         viewportWidthMinusScrollbar -= 15;
 
@@ skipping 17 matching lines @@
 
 TEST_P(ParameterizedWebFrameTest, pageScaleFactorDoesNotApplyCssTransform)
 {
     registerMockedHttpURLLoad("fixed_layout.html");
 
     FixedLayoutTestWebViewClient client;
     client.m_screenInfo.deviceScaleFactor = 1;
     int viewportWidth = 640;
     int viewportHeight = 480;
 
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "fixed_layout.html", true, nullptr, &client, nullptr, enableViewportSettings);
     webViewHelper.resize(WebSize(viewportWidth, viewportHeight));
 
     webViewHelper.webView()->setPageScaleFactor(2);
 
     EXPECT_EQ(980, toLocalFrame(webViewHelper.webView()->page()->mainFrame())->contentLayoutItem().documentRect().width());
     EXPECT_EQ(980, webViewHelper.webView()->mainFrameImpl()->frameView()->contentsSize().width());
 }
 
 TEST_P(ParameterizedWebFrameTest, targetDensityDpiHigh)
 {
     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 < WTF_ARRAY_LENGTH(deviceScaleFactors); ++i) {
         float deviceScaleFactor = deviceScaleFactors[i];
         float deviceDpi = deviceScaleFactor * 160.0f;
         client.m_screenInfo.deviceScaleFactor = deviceScaleFactor;
 
-        FrameTestHelpers::WebViewHelper webViewHelper(this);
+        FrameTestHelpers::WebViewHelper webViewHelper;
         webViewHelper.initializeAndLoad(m_baseURL + "viewport-target-densitydpi-high.html", true, nullptr, &client, nullptr, enableViewportSettings);
         webViewHelper.webView()->settings()->setWideViewportQuirkEnabled(true);
         webViewHelper.webView()->settings()->setSupportDeprecatedTargetDensityDPI(true);
         webViewHelper.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, webViewHelper.webView()->mainFrameImpl()->frameView()->layoutSize().width(), 1.0f);
         EXPECT_NEAR(viewportHeight * densityDpiScaleRatio, webViewHelper.webView()->mainFrameImpl()->frameView()->layoutSize().height(), 1.0f);
         EXPECT_NEAR(1.0f / densityDpiScaleRatio, webViewHelper.webView()->pageScaleFactor(), 0.01f);
     }
 }
 
 TEST_P(ParameterizedWebFrameTest, targetDensityDpiDevice)
 {
     registerMockedHttpURLLoad("viewport-target-densitydpi-device.html");
 
     float deviceScaleFactors[] = { 1.0f, 4.0f / 3.0f, 2.0f };
 
     FixedLayoutTestWebViewClient client;
     int viewportWidth = 640;
     int viewportHeight = 480;
 
     for (size_t i = 0; i < WTF_ARRAY_LENGTH(deviceScaleFactors); ++i) {
         client.m_screenInfo.deviceScaleFactor = deviceScaleFactors[i];
 
-        FrameTestHelpers::WebViewHelper webViewHelper(this);
+        FrameTestHelpers::WebViewHelper webViewHelper;
         webViewHelper.initializeAndLoad(m_baseURL + "viewport-target-densitydpi-device.html", true, nullptr, &client, nullptr, enableViewportSettings);
         webViewHelper.webView()->settings()->setWideViewportQuirkEnabled(true);
         webViewHelper.webView()->settings()->setSupportDeprecatedTargetDensityDPI(true);
         webViewHelper.resize(WebSize(viewportWidth, viewportHeight));
 
         EXPECT_NEAR(viewportWidth * client.m_screenInfo.deviceScaleFactor, webViewHelper.webView()->mainFrameImpl()->frameView()->layoutSize().width(), 1.0f);
         EXPECT_NEAR(viewportHeight * client.m_screenInfo.deviceScaleFactor, webViewHelper.webView()->mainFrameImpl()->frameView()->layoutSize().height(), 1.0f);
         EXPECT_NEAR(1.0f / client.m_screenInfo.deviceScaleFactor, webViewHelper.webView()->pageScaleFactor(), 0.01f);
     }
 }
 
 TEST_P(ParameterizedWebFrameTest, targetDensityDpiDeviceAndFixedWidth)
 {
     registerMockedHttpURLLoad("viewport-target-densitydpi-device-and-fixed-width.html");
 
     float deviceScaleFactors[] = { 1.0f, 4.0f / 3.0f, 2.0f };
 
     FixedLayoutTestWebViewClient client;
     int viewportWidth = 640;
     int viewportHeight = 480;
 
     for (size_t i = 0; i < WTF_ARRAY_LENGTH(deviceScaleFactors); ++i) {
         client.m_screenInfo.deviceScaleFactor = deviceScaleFactors[i];
 
-        FrameTestHelpers::WebViewHelper webViewHelper(this);
+        FrameTestHelpers::WebViewHelper webViewHelper;
         webViewHelper.initializeAndLoad(m_baseURL + "viewport-target-densitydpi-device-and-fixed-width.html", true, nullptr, &client, nullptr, enableViewportSettings);
         webViewHelper.webView()->settings()->setWideViewportQuirkEnabled(true);
         webViewHelper.webView()->settings()->setSupportDeprecatedTargetDensityDPI(true);
         webViewHelper.webView()->settings()->setUseWideViewport(true);
         webViewHelper.resize(WebSize(viewportWidth, viewportHeight));
 
         EXPECT_NEAR(viewportWidth, webViewHelper.webView()->mainFrameImpl()->frameView()->layoutSize().width(), 1.0f);
         EXPECT_NEAR(viewportHeight, webViewHelper.webView()->mainFrameImpl()->frameView()->layoutSize().height(), 1.0f);
         EXPECT_NEAR(1.0f, webViewHelper.webView()->pageScaleFactor(), 0.01f);
     }
 }
 
 TEST_P(ParameterizedWebFrameTest, NoWideViewportAndScaleLessThanOne)
 {
     registerMockedHttpURLLoad("viewport-initial-scale-less-than-1.html");
 
     FixedLayoutTestWebViewClient client;
     client.m_screenInfo.deviceScaleFactor = 1.33f;
     int viewportWidth = 640;
     int viewportHeight = 480;
 
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "viewport-initial-scale-less-than-1.html", true, nullptr, &client, nullptr, enableViewportSettings);
     webViewHelper.webView()->settings()->setSupportDeprecatedTargetDensityDPI(true);
     webViewHelper.webView()->settings()->setWideViewportQuirkEnabled(true);
     webViewHelper.webView()->settings()->setUseWideViewport(false);
     webViewHelper.resize(WebSize(viewportWidth, viewportHeight));
 
     EXPECT_NEAR(viewportWidth * client.m_screenInfo.deviceScaleFactor, webViewHelper.webView()->mainFrameImpl()->frameView()->layoutSize().width(), 1.0f);
     EXPECT_NEAR(viewportHeight * client.m_screenInfo.deviceScaleFactor, webViewHelper.webView()->mainFrameImpl()->frameView()->layoutSize().height(), 1.0f);
     EXPECT_NEAR(1.0f / client.m_screenInfo.deviceScaleFactor, webViewHelper.webView()->pageScaleFactor(), 0.01f);
 }
 
 TEST_P(ParameterizedWebFrameTest, NoWideViewportAndScaleLessThanOneWithDeviceWidth)
 {
     registerMockedHttpURLLoad("viewport-initial-scale-less-than-1-device-width.html");
 
     FixedLayoutTestWebViewClient client;
     client.m_screenInfo.deviceScaleFactor = 1.33f;
     int viewportWidth = 640;
     int viewportHeight = 480;
 
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "viewport-initial-scale-less-than-1-device-width.html", true, nullptr, &client, nullptr, enableViewportSettings);
     webViewHelper.webView()->settings()->setSupportDeprecatedTargetDensityDPI(true);
     webViewHelper.webView()->settings()->setWideViewportQuirkEnabled(true);
     webViewHelper.webView()->settings()->setUseWideViewport(false);
     webViewHelper.resize(WebSize(viewportWidth, viewportHeight));
 
     const float pageZoom = 0.25f;
     EXPECT_NEAR(viewportWidth * client.m_screenInfo.deviceScaleFactor / pageZoom, webViewHelper.webView()->mainFrameImpl()->frameView()->layoutSize().width(), 1.0f);
     EXPECT_NEAR(viewportHeight * client.m_screenInfo.deviceScaleFactor / pageZoom, webViewHelper.webView()->mainFrameImpl()->frameView()->layoutSize().height(), 1.0f);
     EXPECT_NEAR(1.0f / client.m_screenInfo.deviceScaleFactor, webViewHelper.webView()->pageScaleFactor(), 0.01f);
 }
 
 TEST_P(ParameterizedWebFrameTest, NoWideViewportAndNoViewportWithInitialPageScaleOverride)
 {
     registerMockedHttpURLLoad("large-div.html");
 
     FixedLayoutTestWebViewClient client;
     int viewportWidth = 640;
     int viewportHeight = 480;
     float enforcedPageScaleFactor = 5.0f;
 
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "large-div.html", true, nullptr, &client, nullptr, enableViewportSettings);
     webViewHelper.webView()->setDefaultPageScaleLimits(0.25f, 5);
     webViewHelper.webView()->settings()->setWideViewportQuirkEnabled(true);
     webViewHelper.webView()->settings()->setUseWideViewport(false);
     webViewHelper.webView()->setInitialPageScaleOverride(enforcedPageScaleFactor);
     webViewHelper.resize(WebSize(viewportWidth, viewportHeight));
 
     EXPECT_NEAR(viewportWidth / enforcedPageScaleFactor, webViewHelper.webView()->mainFrameImpl()->frameView()->layoutSize().width(), 1.0f);
     EXPECT_NEAR(viewportHeight / enforcedPageScaleFactor, webViewHelper.webView()->mainFrameImpl()->frameView()->layoutSize().height(), 1.0f);
     EXPECT_NEAR(enforcedPageScaleFactor, webViewHelper.webView()->pageScaleFactor(), 0.01f);
 }
 
 TEST_P(ParameterizedWebFrameTest, NoUserScalableQuirkIgnoresViewportScale)
 {
     registerMockedHttpURLLoad("viewport-initial-scale-and-user-scalable-no.html");
 
     FixedLayoutTestWebViewClient client;
     int viewportWidth = 640;
     int viewportHeight = 480;
 
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "viewport-initial-scale-and-user-scalable-no.html", true, nullptr, &client, nullptr, enableViewportSettings);
     webViewHelper.webView()->settings()->setViewportMetaNonUserScalableQuirk(true);
     webViewHelper.resize(WebSize(viewportWidth, viewportHeight));
 
     EXPECT_NEAR(viewportWidth, webViewHelper.webView()->mainFrameImpl()->frameView()->layoutSize().width(), 1.0f);
     EXPECT_NEAR(viewportHeight, webViewHelper.webView()->mainFrameImpl()->frameView()->layoutSize().height(), 1.0f);
     EXPECT_NEAR(1.0f, webViewHelper.webView()->pageScaleFactor(), 0.01f);
 }
 
 TEST_P(ParameterizedWebFrameTest, NoUserScalableQuirkIgnoresViewportScaleForNonWideViewport)
 {
     registerMockedHttpURLLoad("viewport-initial-scale-and-user-scalable-no.html");
 
     FixedLayoutTestWebViewClient client;
     client.m_screenInfo.deviceScaleFactor = 1.33f;
     int viewportWidth = 640;
     int viewportHeight = 480;
 
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "viewport-initial-scale-and-user-scalable-no.html", true, nullptr, &client, nullptr, enableViewportSettings);
     webViewHelper.webView()->settings()->setSupportDeprecatedTargetDensityDPI(true);
     webViewHelper.webView()->settings()->setViewportMetaNonUserScalableQuirk(true);
     webViewHelper.webView()->settings()->setWideViewportQuirkEnabled(true);
     webViewHelper.webView()->settings()->setUseWideViewport(false);
     webViewHelper.resize(WebSize(viewportWidth, viewportHeight));
 
     EXPECT_NEAR(viewportWidth * client.m_screenInfo.deviceScaleFactor, webViewHelper.webView()->mainFrameImpl()->frameView()->layoutSize().width(), 1.0f);
     EXPECT_NEAR(viewportHeight * client.m_screenInfo.deviceScaleFactor, webViewHelper.webView()->mainFrameImpl()->frameView()->layoutSize().height(), 1.0f);
     EXPECT_NEAR(1.0f / client.m_screenInfo.deviceScaleFactor, webViewHelper.webView()->pageScaleFactor(), 0.01f);
 }
 
 TEST_P(ParameterizedWebFrameTest, NoUserScalableQuirkIgnoresViewportScaleForWideViewport)
 {
     registerMockedHttpURLLoad("viewport-2x-initial-scale-non-user-scalable.html");
 
     FixedLayoutTestWebViewClient client;
     int viewportWidth = 640;
     int viewportHeight = 480;
 
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "viewport-2x-initial-scale-non-user-scalable.html", true, nullptr, &client, nullptr, enableViewportSettings);
     webViewHelper.webView()->settings()->setViewportMetaNonUserScalableQuirk(true);
     webViewHelper.webView()->settings()->setWideViewportQuirkEnabled(true);
     webViewHelper.webView()->settings()->setUseWideViewport(true);
     webViewHelper.resize(WebSize(viewportWidth, viewportHeight));
 
     EXPECT_NEAR(viewportWidth, webViewHelper.webView()->mainFrameImpl()->frameView()->layoutSize().width(), 1.0f);
     EXPECT_NEAR(viewportHeight, webViewHelper.webView()->mainFrameImpl()->frameView()->layoutSize().height(), 1.0f);
     EXPECT_NEAR(1.0f, webViewHelper.webView()->pageScaleFactor(), 0.01f);
 }
 
 TEST_P(ParameterizedWebFrameTest, DesktopPageCanBeZoomedInWhenWideViewportIsTurnedOff)
 {
     registerMockedHttpURLLoad("no_viewport_tag.html");
 
     FixedLayoutTestWebViewClient client;
     int viewportWidth = 640;
     int viewportHeight = 480;
 
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "no_viewport_tag.html", true, nullptr, &client, nullptr, enableViewportSettings);
     webViewHelper.webView()->setDefaultPageScaleLimits(0.25f, 5);
     webViewHelper.webView()->settings()->setWideViewportQuirkEnabled(true);
     webViewHelper.webView()->settings()->setUseWideViewport(false);
     webViewHelper.resize(WebSize(viewportWidth, viewportHeight));
 
     EXPECT_NEAR(1.0f, webViewHelper.webView()->pageScaleFactor(), 0.01f);
     EXPECT_NEAR(1.0f, webViewHelper.webView()->minimumPageScaleFactor(), 0.01f);
     EXPECT_NEAR(5.0f, webViewHelper.webView()->maximumPageScaleFactor(), 0.01f);
 }
@@ skipping 10 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;
 
-        FrameTestHelpers::WebViewHelper webViewHelper(this);
+        FrameTestHelpers::WebViewHelper webViewHelper;
         webViewHelper.initializeAndLoad(m_baseURL + url, true, nullptr, nullptr, nullptr, enableViewportSettings);
         webViewHelper.webView()->setDefaultPageScaleLimits(0.25f, 5);
 
         // Origin scrollOffsets preserved under resize.
         {
             webViewHelper.resize(WebSize(viewportSize.width, viewportSize.height));
             webViewHelper.webView()->setPageScaleFactor(initialPageScaleFactor);
             ASSERT_EQ(viewportSize, webViewHelper.webView()->size());
             ASSERT_EQ(initialPageScaleFactor, webViewHelper.webView()->pageScaleFactor());
             webViewHelper.resize(WebSize(viewportSize.height, viewportSize.width));
@@ skipping 12 matching lines @@
             webViewHelper.resize(WebSize(viewportSize.width, viewportSize.height * 0.8f));
             EXPECT_EQ(initialPageScaleFactor, webViewHelper.webView()->pageScaleFactor());
             EXPECT_EQ(expectedScrollOffset, webViewHelper.webView()->mainFrame()->scrollOffset());
             webViewHelper.resize(WebSize(viewportSize.width, viewportSize.height * 0.8f));
             EXPECT_EQ(initialPageScaleFactor, webViewHelper.webView()->pageScaleFactor());
             EXPECT_EQ(expectedScrollOffset, webViewHelper.webView()->mainFrame()->scrollOffset());
         }
     }
 };
 
-INSTANTIATE_TEST_CASE_P(All, WebFrameResizeTest, ::testing::Values(
-    FrameTestHelpers::DefaultSettingOverride,
-    FrameTestHelpers::RootLayerScrollsSettingOverride));
+INSTANTIATE_TEST_CASE_P(All, WebFrameResizeTest, ::testing::Bool());
 
 TEST_P(WebFrameResizeTest, ResizeYieldsCorrectScrollAndScaleForWidthEqualsDeviceWidth)
 {
     // With width=device-width, pageScaleFactor is preserved across resizes as
     // long as the content adjusts according to the device-width.
     const char* url = "resize_scroll_mobile.html";
     const float initialPageScaleFactor = 1;
     const WebSize scrollOffset(0, 50);
     const WebSize viewportSize(120, 160);
     const bool shouldScaleRelativeToViewportWidth = true;
@@ skipping 46 matching lines @@
 
 TEST_P(ParameterizedWebFrameTest, pageScaleFactorUpdatesScrollbars)
 {
     registerMockedHttpURLLoad("fixed_layout.html");
 
     FixedLayoutTestWebViewClient client;
     client.m_screenInfo.deviceScaleFactor = 1;
     int viewportWidth = 640;
     int viewportHeight = 480;
 
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "fixed_layout.html", true, nullptr, &client, nullptr, enableViewportSettings);
     webViewHelper.resize(WebSize(viewportWidth, viewportHeight));
 
     FrameView* view = webViewHelper.webView()->mainFrameImpl()->frameView();
     EXPECT_EQ(view->scrollSize(HorizontalScrollbar), view->contentsSize().width() - view->visibleContentRect().width());
     EXPECT_EQ(view->scrollSize(VerticalScrollbar), view->contentsSize().height() - view->visibleContentRect().height());
 
     webViewHelper.webView()->setPageScaleFactor(10);
 
     EXPECT_EQ(view->scrollSize(HorizontalScrollbar), view->contentsSize().width() - view->visibleContentRect().width());
     EXPECT_EQ(view->scrollSize(VerticalScrollbar), view->contentsSize().height() - view->visibleContentRect().height());
 }
 
 TEST_P(ParameterizedWebFrameTest, CanOverrideScaleLimits)
 {
     registerMockedHttpURLLoad("no_scale_for_you.html");
 
     FixedLayoutTestWebViewClient client;
     client.m_screenInfo.deviceScaleFactor = 1;
     int viewportWidth = 640;
     int viewportHeight = 480;
 
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "no_scale_for_you.html", true, nullptr, &client, nullptr, enableViewportSettings);
     webViewHelper.webView()->setDefaultPageScaleLimits(0.25f, 5);
     webViewHelper.resize(WebSize(viewportWidth, viewportHeight));
 
     EXPECT_EQ(2.0f, webViewHelper.webView()->minimumPageScaleFactor());
     EXPECT_EQ(2.0f, webViewHelper.webView()->maximumPageScaleFactor());
 
     webViewHelper.webView()->setIgnoreViewportTagScaleLimits(true);
     webViewHelper.webView()->updateAllLifecyclePhases();
 
@@ skipping 64 matching lines @@
 }
 
 TEST_P(ParameterizedWebFrameTest, 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;
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "get_scale_for_auto_zoom_into_div_test.html", false, nullptr, nullptr, nullptr, configureAndroid);
     webViewHelper.webView()->setDeviceScaleFactor(deviceScaleFactor);
     webViewHelper.webView()->setDefaultPageScaleLimits(0.01f, 4);
     webViewHelper.webView()->setPageScaleFactor(0.5f);
     webViewHelper.resize(WebSize(viewportWidth, viewportHeight));
 
     WebRect wideDiv(200, 100, 400, 150);
     WebRect tallDiv(200, 300, 400, 800);
     WebPoint doubleTapPointWide(wideDiv.x + 50, wideDiv.y + 50);
     WebPoint doubleTapPointTall(tallDiv.x + 50, tallDiv.y + 50);
@@ skipping 31 matching lines @@
 }
 
 TEST_P(ParameterizedWebFrameTest, 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;
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "get_wide_div_for_auto_zoom_test.html", false, nullptr, nullptr, nullptr, configureAndroid);
     webViewHelper.resize(WebSize(viewportWidth, viewportHeight));
     webViewHelper.webView()->setDeviceScaleFactor(deviceScaleFactor);
     webViewHelper.webView()->setPageScaleFactor(1.0f);
     webViewHelper.webView()->updateAllLifecyclePhases();
 
     webViewHelper.webView()->enableFakePageScaleAnimationForTesting(true);
 
     float doubleTapZoomAlreadyLegibleScale = webViewHelper.webView()->minimumPageScaleFactor() * doubleTapZoomAlreadyLegibleRatio;
 
@@ skipping 11 matching lines @@
 TEST_P(ParameterizedWebFrameTest, DivAutoZoomVeryTallTest)
 {
     // When a block is taller than the viewport and a zoom targets a lower part
     // of it, then we should keep the target point onscreen instead of snapping
     // back up the top of the block.
     registerMockedHttpURLLoad("very_tall_div.html");
 
     const float deviceScaleFactor = 2.0f;
     int viewportWidth = 640 / deviceScaleFactor;
     int viewportHeight = 1280 / deviceScaleFactor;
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "very_tall_div.html", true, nullptr, nullptr, nullptr, configureAndroid);
     webViewHelper.resize(WebSize(viewportWidth, viewportHeight));
     webViewHelper.webView()->setDeviceScaleFactor(deviceScaleFactor);
     webViewHelper.webView()->setPageScaleFactor(1.0f);
     webViewHelper.webView()->updateAllLifecyclePhases();
 
     WebRect div(200, 300, 400, 5000);
     WebPoint point(div.x + 50, div.y + 3000);
     float scale;
     WebPoint scroll;
@@ skipping 271 matching lines @@
     simulateDoubleTap(webViewHelper.webView(), doubleTapPoint, scale);
     EXPECT_FLOAT_EQ(webViewHelper.webView()->minimumPageScaleFactor(), scale);
     simulateDoubleTap(webViewHelper.webView(), doubleTapPoint, scale);
     EXPECT_FLOAT_EQ(legibleScale, scale);
 }
 
 TEST_P(ParameterizedWebFrameTest, BlockBoundTest)
 {
     registerMockedHttpURLLoad("block_bound.html");
 
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "block_bound.html", false, nullptr, nullptr, nullptr, configureAndroid);
 
     IntRect rectBack = IntRect(0, 0, 200, 200);
     IntRect rectLeftTop = IntRect(10, 10, 80, 80);
     IntRect rectRightBottom = IntRect(110, 110, 80, 80);
     IntRect blockBound;
 
     blockBound = IntRect(webViewHelper.webView()->computeBlockBound(WebPoint(9, 9), true));
     EXPECT_RECT_EQ(rectBack, blockBound);
 
@@ skipping 17 matching lines @@
 }
 
 TEST_P(ParameterizedWebFrameTest, 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;
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "get_multiple_divs_for_auto_zoom_test.html");
     webViewHelper.resize(WebSize(viewportWidth, viewportHeight));
     webViewHelper.webView()->setDefaultPageScaleLimits(0.5f, 4);
     webViewHelper.webView()->setDeviceScaleFactor(deviceScaleFactor);
     webViewHelper.webView()->setPageScaleFactor(0.5f);
     webViewHelper.webView()->setMaximumLegibleScale(1.f);
     webViewHelper.webView()->updateAllLifecyclePhases();
 
     webViewHelper.webView()->enableFakePageScaleAnimationForTesting(true);
 
@@ skipping 251 matching lines @@
 
     // There should be no change at all since the textbox is fully visible already.
     EXPECT_EQ(initialScale, scale);
     EXPECT_FALSE(needAnimation);
 }
 
 TEST_P(ParameterizedWebFrameTest, CharacterIndexAtPointWithPinchZoom)
 {
     registerMockedHttpURLLoad("sometext.html");
 
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "sometext.html");
     webViewHelper.resize(WebSize(640, 480));
 
     webViewHelper.webView()->setPageScaleFactor(2);
     webViewHelper.webView()->setVisualViewportOffset(WebFloatPoint(50, 60));
 
     WebRect baseRect;
     WebRect extentRect;
 
     WebLocalFrame* mainFrame = webViewHelper.webView()->mainFrame()->toWebLocalFrame();
     size_t ix = mainFrame->characterIndexForPoint(WebPoint(320, 388));
 
     EXPECT_EQ(2ul, ix);
 }
 
 TEST_P(ParameterizedWebFrameTest, FirstRectForCharacterRangeWithPinchZoom)
 {
     registerMockedHttpURLLoad("textbox.html");
 
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "textbox.html", true);
     webViewHelper.resize(WebSize(640, 480));
 
     WebLocalFrame* mainFrame = webViewHelper.webView()->mainFrame()->toWebLocalFrame();
     mainFrame->executeScript(WebScriptSource("selectRange();"));
 
     WebRect oldRect;
     mainFrame->firstRectForCharacterRange(0, 5, oldRect);
 
     WebFloatPoint visualOffset(100, 130);
@@ skipping 21 matching lines @@
     }
 };
 
 TEST_P(ParameterizedWebFrameTest, 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;
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "form.html", false, &webFrameClient);
 
     webViewHelper.webView()->mainFrame()->reload(WebFrameLoadType::ReloadBypassingCache);
     // start another reload before request is delivered.
     FrameTestHelpers::reloadFrameIgnoringCache(webViewHelper.webView()->mainFrame());
 }
 
 class ClearScrollStateOnCommitWebFrameClient : public FrameTestHelpers::TestWebFrameClient {
 public:
     void didCommitProvisionalLoad(WebLocalFrame* frame, const WebHistoryItem&, WebHistoryCommitType) override
@@ skipping 46 matching lines @@
     EXPECT_EQ(0, webViewHelper.webView()->mainFrame()->scrollOffset().height);
     EXPECT_EQ(1.0f, webViewHelper.webView()->pageScaleFactor());
 }
 
 TEST_P(ParameterizedWebFrameTest, ReloadWhileProvisional)
 {
     // Test that reloading while the previous load is still pending does not cause the initial
     // request to get lost.
     registerMockedHttpURLLoad("fixed_layout.html");
 
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initialize();
     WebURLRequest request;
     request.setURL(toKURL(m_baseURL + "fixed_layout.html"));
     request.setRequestorOrigin(WebSecurityOrigin::createUnique());
     webViewHelper.webView()->mainFrame()->loadRequest(request);
     // start reload before first request is delivered.
     FrameTestHelpers::reloadFrameIgnoringCache(webViewHelper.webView()->mainFrame());
 
     WebDataSource* dataSource = webViewHelper.webView()->mainFrame()->dataSource();
     ASSERT_TRUE(dataSource);
     EXPECT_EQ(toKURL(m_baseURL + "fixed_layout.html"), KURL(dataSource->request().url()));
 }
 
 TEST_P(ParameterizedWebFrameTest, AppendRedirects)
 {
     const std::string firstURL = "about:blank";
     const std::string secondURL = "http://internal.test";
 
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(firstURL, true);
 
     WebDataSource* dataSource = webViewHelper.webView()->mainFrame()->dataSource();
     ASSERT_TRUE(dataSource);
     dataSource->appendRedirect(toKURL(secondURL));
 
     WebVector<WebURL> redirects;
     dataSource->redirectChain(redirects);
     ASSERT_EQ(2U, redirects.size());
     EXPECT_EQ(toKURL(firstURL), KURL(redirects[0]));
     EXPECT_EQ(toKURL(secondURL), KURL(redirects[1]));
 }
 
 TEST_P(ParameterizedWebFrameTest, IframeRedirect)
 {
     registerMockedHttpURLLoad("iframe_redirect.html");
     registerMockedHttpURLLoad("visible_iframe.html");
 
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "iframe_redirect.html", true);
     // Pump pending requests one more time. The test page loads script that navigates.
     FrameTestHelpers::pumpPendingRequestsForFrameToLoad(webViewHelper.webView()->mainFrame());
 
     WebFrame* iframe = webViewHelper.webView()->findFrameByName(WebString::fromUTF8("ifr"), nullptr);
     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"), KURL(redirects[0]));
     EXPECT_EQ(toKURL("http://internal.test/visible_iframe.html"), KURL(redirects[1]));
 }
 
 TEST_P(ParameterizedWebFrameTest, ClearFocusedNodeTest)
 {
     registerMockedHttpURLLoad("iframe_clear_focused_node_test.html");
     registerMockedHttpURLLoad("autofocus_input_field_iframe.html");
 
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "iframe_clear_focused_node_test.html", true);
 
     // Clear the focused node.
     webViewHelper.webView()->clearFocusedElement();
 
     // Now retrieve the FocusedNode and test it should be null.
     EXPECT_EQ(0, webViewHelper.webView()->focusedElement());
 }
 
 // Implementation of WebFrameClient that tracks the v8 contexts that are created
@@ skipping 52 matching lines @@
 
 TEST_P(ParameterizedWebFrameTest, 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;
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "context_notifications_test.html", true, &webFrameClient);
 
     WebFrame* mainFrame = webViewHelper.webView()->mainFrame();
     WebFrame* childFrame = mainFrame->firstChild();
 
     ASSERT_EQ(2u, webFrameClient.createNotifications.size());
     EXPECT_EQ(0u, webFrameClient.releaseNotifications.size());
 
     auto& firstCreateNotification = webFrameClient.createNotifications[0];
     auto& secondCreateNotification = webFrameClient.createNotifications[1];
@@ skipping 18 matching lines @@
 }
 
 TEST_P(ParameterizedWebFrameTest, ContextNotificationsReload)
 {
     v8::HandleScope handleScope(v8::Isolate::GetCurrent());
 
     registerMockedHttpURLLoad("context_notifications_test.html");
     registerMockedHttpURLLoad("context_notifications_test_frame.html");
 
     ContextLifetimeTestWebFrameClient webFrameClient;
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "context_notifications_test.html", true, &webFrameClient);
 
     // Refresh, we should get two release notifications and two more create notifications.
     FrameTestHelpers::reloadFrame(webViewHelper.webView()->mainFrame());
     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 17 matching lines @@
 
 TEST_P(ParameterizedWebFrameTest, ContextNotificationsIsolatedWorlds)
 {
     v8::Isolate* isolate = v8::Isolate::GetCurrent();
     v8::HandleScope handleScope(isolate);
 
     registerMockedHttpURLLoad("context_notifications_test.html");
     registerMockedHttpURLLoad("context_notifications_test_frame.html");
 
     ContextLifetimeTestWebFrameClient webFrameClient;
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(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;
     webViewHelper.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].get()))
             ++matchCount;
     }
     EXPECT_EQ(1, matchCount);
 }
 
 TEST_P(ParameterizedWebFrameTest, FindInPage)
 {
     registerMockedHttpURLLoad("find.html");
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "find.html");
     ASSERT_TRUE(webViewHelper.webView()->mainFrameImpl());
     WebLocalFrame* frame = webViewHelper.webView()->mainFrameImpl();
     const int findIdentifier = 12345;
     WebFindOptions options;
 
     // Find in a <div> element.
     EXPECT_TRUE(frame->find(findIdentifier, WebString::fromUTF8("bar1"), options, false));
     frame->stopFinding(WebLocalFrame::StopFindActionKeepSelection);
     WebRange range = frame->selectionRange();
@@ skipping 36 matching lines @@
     EXPECT_FALSE(frame->find(findIdentifier, WebString::fromUTF8("bar5"), options, false));
     // 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(WebLocalFrame::StopFindActionKeepSelection);
     range = frame->selectionRange();
     ASSERT_TRUE(range.isNull());
 }
 
 TEST_P(ParameterizedWebFrameTest, GetContentAsPlainText)
 {
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad("about:blank", true);
     // We set the size because it impacts line wrapping, which changes the
     // resulting text value.
     webViewHelper.resize(WebSize(640, 480));
     WebFrame* frame = webViewHelper.webView()->mainFrame();
 
     // Generate a simple test case.
     const char simpleSource[] = "<div>Foo bar</div><div></div>baz";
     KURL testURL = toKURL("about:blank");
     FrameTestHelpers::loadHTMLString(frame, simpleSource, testURL);
@@ skipping 21 matching lines @@
     EXPECT_EQ("Hello world\n\nsub\ntext", text.utf8());
 
     // 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 = WebFrameContentDumper::dumpWebViewAsText(webViewHelper.webView(), 12);
     EXPECT_EQ("Hello world", text.utf8());
 }
 
 TEST_P(ParameterizedWebFrameTest, GetFullHtmlOfPage)
 {
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad("about:blank", true);
     WebLocalFrame* frame = webViewHelper.webView()->mainFrameImpl();
 
     // Generate a simple test case.
     const char simpleSource[] = "<p>Hello</p><p>World</p>";
     KURL testURL = toKURL("about:blank");
     FrameTestHelpers::loadHTMLString(frame, simpleSource, testURL);
 
     WebString text = WebFrameContentDumper::dumpWebViewAsText(webViewHelper.webView(), std::numeric_limits<size_t>::max());
     EXPECT_EQ("Hello\n\nWorld", text.utf8());
@@ skipping 24 matching lines @@
     {
         frame->executeScript(WebScriptSource("window.history = 'replaced';"));
     }
 };
 
 TEST_P(ParameterizedWebFrameTest, ExecuteScriptDuringDidCreateScriptContext)
 {
     registerMockedHttpURLLoad("hello_world.html");
 
     TestExecuteScriptDuringDidCreateScriptContext webFrameClient;
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "hello_world.html", true, &webFrameClient);
 
     FrameTestHelpers::reloadFrame(webViewHelper.webView()->mainFrame());
 }
 
 class FindUpdateWebFrameClient : public FrameTestHelpers::TestWebFrameClient {
 public:
     FindUpdateWebFrameClient()
         : m_findResultsAreReady(false)
         , m_count(-1)
@@ skipping 21 matching lines @@
     bool m_findResultsAreReady;
     int m_count;
     int m_activeIndex;
 };
 
 TEST_P(ParameterizedWebFrameTest, FindInPageMatchRects)
 {
     registerMockedHttpURLLoad("find_in_page_frame.html");
 
     FindUpdateWebFrameClient client;
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "find_in_page_frame.html", true, &client);
     webViewHelper.resize(WebSize(640, 480));
     webViewHelper.webView()->setMaximumLegibleScale(1.f);
     webViewHelper.webView()->updateAllLifecyclePhases();
     runPendingTasks();
 
     // Note that the 'result 19' in the <select> element is not expected to
     // produce a match. Also, results 00 and 01 are in a different frame that is
     // not included in this test.
     const char kFindString[] = "result";
@@ skipping 92 matching lines @@
     EXPECT_TRUE(client.findResultsAreReady());
     EXPECT_EQ(kActiveIndex, client.activeIndex());
 }
 
 TEST_P(ParameterizedWebFrameTest, FindOnDetachedFrame)
 {
     registerMockedHttpURLLoad("find_in_page.html");
     registerMockedHttpURLLoad("find_in_page_frame.html");
 
     FindUpdateWebFrameClient client;
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "find_in_page.html", true, &client);
     webViewHelper.resize(WebSize(640, 480));
     runPendingTasks();
 
     const char kFindString[] = "result";
     const int kFindIdentifier = 12345;
 
     WebFindOptions options;
     WebString searchText = WebString::fromUTF8(kFindString);
     WebLocalFrameImpl* mainFrame = webViewHelper.webView()->mainFrameImpl();
@@ skipping 16 matching lines @@
     runPendingTasks();
     EXPECT_TRUE(client.findResultsAreReady());
 }
 
 TEST_P(ParameterizedWebFrameTest, FindDetachFrameBeforeScopeStrings)
 {
     registerMockedHttpURLLoad("find_in_page.html");
     registerMockedHttpURLLoad("find_in_page_frame.html");
 
     FindUpdateWebFrameClient client;
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "find_in_page.html", true, &client);
     webViewHelper.resize(WebSize(640, 480));
     runPendingTasks();
 
     const char kFindString[] = "result";
     const int kFindIdentifier = 12345;
 
     WebFindOptions options;
     WebString searchText = WebString::fromUTF8(kFindString);
     WebLocalFrameImpl* mainFrame = webViewHelper.webView()->mainFrameImpl();
@@ skipping 15 matching lines @@
     runPendingTasks();
     EXPECT_TRUE(client.findResultsAreReady());
 }
 
 TEST_P(ParameterizedWebFrameTest, FindDetachFrameWhileScopingStrings)
 {
     registerMockedHttpURLLoad("find_in_page.html");
     registerMockedHttpURLLoad("find_in_page_frame.html");
 
     FindUpdateWebFrameClient client;
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "find_in_page.html", true, &client);
     webViewHelper.resize(WebSize(640, 480));
     runPendingTasks();
 
     const char kFindString[] = "result";
     const int kFindIdentifier = 12345;
 
     WebFindOptions options;
     WebString searchText = WebString::fromUTF8(kFindString);
     WebLocalFrameImpl* mainFrame = webViewHelper.webView()->mainFrameImpl();
@@ skipping 14 matching lines @@
 
     runPendingTasks();
     EXPECT_TRUE(client.findResultsAreReady());
 }
 
 TEST_P(ParameterizedWebFrameTest, ResetMatchCount)
 {
     registerMockedHttpURLLoad("find_in_generated_frame.html");
 
     FindUpdateWebFrameClient client;
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "find_in_generated_frame.html", true, &client);
     webViewHelper.resize(WebSize(640, 480));
     runPendingTasks();
 
     const char kFindString[] = "result";
     const int kFindIdentifier = 12345;
 
     WebFindOptions options;
     WebString searchText = WebString::fromUTF8(kFindString);
     WebLocalFrameImpl* mainFrame = webViewHelper.webView()->mainFrameImpl();
 
     // Check that child frame exists.
     EXPECT_TRUE(!!mainFrame->traverseNext(false));
 
     for (WebFrame* frame = mainFrame; frame; frame = frame->traverseNext(false))
         EXPECT_FALSE(frame->toWebLocalFrame()->find(kFindIdentifier, searchText, options, false));
 
     runPendingTasks();
     EXPECT_FALSE(client.findResultsAreReady());
 
     mainFrame->ensureTextFinder().resetMatchCount();
 }
 
 TEST_P(ParameterizedWebFrameTest, SetTickmarks)
 {
     registerMockedHttpURLLoad("find.html");
 
     FindUpdateWebFrameClient client;
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "find.html", true, &client);
     webViewHelper.resize(WebSize(640, 480));
     runPendingTasks();
 
     const char kFindString[] = "foo";
     const int kFindIdentifier = 12345;
 
     WebFindOptions options;
     WebString searchText = WebString::fromUTF8(kFindString);
     WebLocalFrameImpl* mainFrame = webViewHelper.webView()->mainFrameImpl();
@@ skipping 32 matching lines @@
     Vector<IntRect> originalTickmarksAfterReset;
     scrollbar->getTickmarks(originalTickmarksAfterReset);
     EXPECT_EQ(originalTickmarks, originalTickmarksAfterReset);
 }
 
 TEST_P(ParameterizedWebFrameTest, FindInPageJavaScriptUpdatesDOM)
 {
     registerMockedHttpURLLoad("find.html");
 
     FindUpdateWebFrameClient client;
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "find.html", true, &client);
     webViewHelper.resize(WebSize(640, 480));
     runPendingTasks();
 
     WebLocalFrameImpl* frame = webViewHelper.webView()->mainFrameImpl();
     const int findIdentifier = 12345;
     static const char* kFindString = "foo";
     WebString searchText = WebString::fromUTF8(kFindString);
     WebFindOptions options;
     bool activeNow;
@@ skipping 54 matching lines @@
 
 TEST_P(ParameterizedWebFrameTest, SelectRange)
 {
     WebLocalFrame* frame;
     WebRect startWebRect;
     WebRect endWebRect;
 
     registerMockedHttpURLLoad("select_range_basic.html");
     registerMockedHttpURLLoad("select_range_scroll.html");
 
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     initializeTextSelectionWebView(m_baseURL + "select_range_basic.html", &webViewHelper);
     frame = webViewHelper.webView()->mainFrameImpl();
     EXPECT_EQ("Some test text for testing.", selectionAsString(frame));
     webViewHelper.webView()->selectionBounds(startWebRect, endWebRect);
     frame->executeCommand(WebString::fromUTF8("Unselect"));
     EXPECT_EQ("", selectionAsString(frame));
     frame->selectRange(topLeft(startWebRect), bottomRightMinusOne(endWebRect));
     // On some devices, the above bottomRightMinusOne() causes the ending '.' not selected.
     std::string selectionString = selectionAsString(frame);
     EXPECT_TRUE(selectionString == "Some test text for testing."
@@ skipping 14 matching lines @@
 
 TEST_P(ParameterizedWebFrameTest, SelectRangeInIframe)
 {
     WebFrame* frame;
     WebRect startWebRect;
     WebRect endWebRect;
 
     registerMockedHttpURLLoad("select_range_iframe.html");
     registerMockedHttpURLLoad("select_range_basic.html");
 
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     initializeTextSelectionWebView(m_baseURL + "select_range_iframe.html", &webViewHelper);
     frame = webViewHelper.webView()->mainFrame();
     WebLocalFrame* subframe = frame->firstChild()->toWebLocalFrame();
     EXPECT_EQ("Some test text for testing.", selectionAsString(subframe));
     webViewHelper.webView()->selectionBounds(startWebRect, endWebRect);
     subframe->executeCommand(WebString::fromUTF8("Unselect"));
     EXPECT_EQ("", selectionAsString(subframe));
     subframe->selectRange(topLeft(startWebRect), bottomRightMinusOne(endWebRect));
     // On some devices, the above bottomRightMinusOne() causes the ending '.' not selected.
     std::string selectionString = selectionAsString(subframe);
     EXPECT_TRUE(selectionString == "Some test text for testing."
         || selectionString == "Some test text for testing");
 }
 
 TEST_P(ParameterizedWebFrameTest, SelectRangeDivContentEditable)
 {
     WebLocalFrame* 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.
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     initializeTextSelectionWebView(m_baseURL + "select_range_div_editable.html", &webViewHelper);
     frame = webViewHelper.webView()->mainFrameImpl();
     EXPECT_EQ("This text is initially selected.", selectionAsString(frame));
     webViewHelper.webView()->selectionBounds(startWebRect, endWebRect);
 
     frame->selectRange(bottomRightMinusOne(endWebRect), WebPoint(0, 0));
     EXPECT_EQ("16-char header. This text is initially selected.", selectionAsString(frame));
 
     // As above, but extending the selection to the bottom of the document.
     initializeTextSelectionWebView(m_baseURL + "select_range_div_editable.html", &webViewHelper);
@@ skipping 14 matching lines @@
 TEST_P(ParameterizedWebFrameTest, DISABLED_SelectRangeSpanContentEditable)
 {
     WebLocalFrame* 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.
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     initializeTextSelectionWebView(m_baseURL + "select_range_span_editable.html", &webViewHelper);
     frame = webViewHelper.webView()->mainFrameImpl();
     EXPECT_EQ("This text is initially selected.", selectionAsString(frame));
     webViewHelper.webView()->selectionBounds(startWebRect, endWebRect);
 
     frame->selectRange(bottomRightMinusOne(endWebRect), WebPoint(0, 0));
     EXPECT_EQ("16-char header. This text is initially selected.", selectionAsString(frame));
 
     // As above, but extending the selection to the bottom of the document.
     initializeTextSelectionWebView(m_baseURL + "select_range_span_editable.html", &webViewHelper);
     frame = webViewHelper.webView()->mainFrameImpl();
 
     webViewHelper.webView()->selectionBounds(startWebRect, endWebRect);
     frame->selectRange(topLeft(startWebRect), bottomRightMinusOne(endWebRect));
     EXPECT_EQ("This text is initially selected.", selectionAsString(frame));
     webViewHelper.webView()->selectionBounds(startWebRect, endWebRect);
 
     EXPECT_EQ("This text is initially selected.", selectionAsString(frame));
     webViewHelper.webView()->selectionBounds(startWebRect, endWebRect);
     frame->selectRange(topLeft(startWebRect), WebPoint(640, 480));
     EXPECT_EQ("This text is initially selected. 16-char footer.", selectionAsString(frame));
 }
 
 TEST_P(ParameterizedWebFrameTest, SelectRangeCanMoveSelectionStart)
 {
     registerMockedHttpURLLoad("text_selection.html");
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     initializeTextSelectionWebView(m_baseURL + "text_selection.html", &webViewHelper);
     WebLocalFrame* frame = webViewHelper.webView()->mainFrameImpl();
 
     // 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.
@@ skipping 27 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_P(ParameterizedWebFrameTest, SelectRangeCanMoveSelectionEnd)
 {
     registerMockedHttpURLLoad("text_selection.html");
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     initializeTextSelectionWebView(m_baseURL + "text_selection.html", &webViewHelper);
     WebLocalFrame* frame = webViewHelper.webView()->mainFrameImpl();
 
     // 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.
@@ skipping 32 matching lines @@
 }
 
 TEST_P(ParameterizedWebFrameTest, MoveRangeSelectionExtent)
 {
     WebLocalFrameImpl* frame;
     WebRect startWebRect;
     WebRect endWebRect;
 
     registerMockedHttpURLLoad("move_range_selection_extent.html");
 
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     initializeTextSelectionWebView(m_baseURL + "move_range_selection_extent.html", &webViewHelper);
     frame = webViewHelper.webView()->mainFrameImpl();
     EXPECT_EQ("This text is initially selected.", selectionAsString(frame));
     webViewHelper.webView()->selectionBounds(startWebRect, endWebRect);
 
     frame->moveRangeSelectionExtent(WebPoint(640, 480));
     EXPECT_EQ("This text is initially selected. 16-char footer.", selectionAsString(frame));
 
     frame->moveRangeSelectionExtent(WebPoint(0, 0));
     EXPECT_EQ("16-char header. ", selectionAsString(frame));
@@ skipping 13 matching lines @@
 }
 
 TEST_P(ParameterizedWebFrameTest, MoveRangeSelectionExtentCannotCollapse)
 {
     WebLocalFrameImpl* frame;
     WebRect startWebRect;
     WebRect endWebRect;
 
     registerMockedHttpURLLoad("move_range_selection_extent.html");
 
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     initializeTextSelectionWebView(m_baseURL + "move_range_selection_extent.html", &webViewHelper);
     frame = webViewHelper.webView()->mainFrameImpl();
     EXPECT_EQ("This text is initially selected.", selectionAsString(frame));
     webViewHelper.webView()->selectionBounds(startWebRect, endWebRect);
 
     frame->moveRangeSelectionExtent(bottomRightMinusOne(startWebRect));
     EXPECT_EQ("This text is initially selected.", selectionAsString(frame));
 
     // Reset with swapped base and extent.
     frame->selectRange(topLeft(endWebRect), bottomRightMinusOne(startWebRect));
     EXPECT_EQ("This text is initially selected.", selectionAsString(frame));
 
     frame->moveRangeSelectionExtent(bottomRightMinusOne(endWebRect));
     EXPECT_EQ("This text is initially selected.", selectionAsString(frame));
 }
 
 TEST_P(ParameterizedWebFrameTest, MoveRangeSelectionExtentScollsInputField)
 {
     WebLocalFrameImpl* frame;
     WebRect startWebRect;
     WebRect endWebRect;
 
     registerMockedHttpURLLoad("move_range_selection_extent_input_field.html");
 
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     initializeTextSelectionWebView(m_baseURL + "move_range_selection_extent_input_field.html", &webViewHelper);
     frame = webViewHelper.webView()->mainFrameImpl();
     EXPECT_EQ("Length", selectionAsString(frame));
     webViewHelper.webView()->selectionBounds(startWebRect, endWebRect);
 
     EXPECT_EQ(0, frame->frame()->selection().rootEditableElement()->scrollLeft());
     frame->moveRangeSelectionExtent(WebPoint(endWebRect.x + 500, endWebRect.y));
     EXPECT_GE(frame->frame()->selection().rootEditableElement()->scrollLeft(), 1);
     EXPECT_EQ("Lengthy text goes here.", selectionAsString(frame));
 }
 
 static int computeOffset(LayoutObject* layoutObject, int x, int y)
 {
     return createVisiblePosition(layoutObject->positionForPoint(LayoutPoint(x, y))).deepEquivalent().computeOffsetInContainerNode();
 }
 
 // positionForPoint returns the wrong values for contenteditable spans. See
 // http://crbug.com/238334.
 TEST_P(ParameterizedWebFrameTest, DISABLED_PositionForPointTest)
 {
     registerMockedHttpURLLoad("select_range_span_editable.html");
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     initializeTextSelectionWebView(m_baseURL + "select_range_span_editable.html", &webViewHelper);
     WebLocalFrameImpl* mainFrame = webViewHelper.webView()->mainFrameImpl();
     LayoutObject* layoutObject = mainFrame->frame()->selection().rootEditableElement()->layoutObject();
     EXPECT_EQ(0, computeOffset(layoutObject, -1, -1));
     EXPECT_EQ(64, computeOffset(layoutObject, 1000, 1000));
 
     registerMockedHttpURLLoad("select_range_div_editable.html");
     initializeTextSelectionWebView(m_baseURL + "select_range_div_editable.html", &webViewHelper);
     mainFrame = webViewHelper.webView()->mainFrameImpl();
     layoutObject = mainFrame->frame()->selection().rootEditableElement()->layoutObject();
     EXPECT_EQ(0, computeOffset(layoutObject, -1, -1));
     EXPECT_EQ(64, computeOffset(layoutObject, 1000, 1000));
 }
 
 #if !OS(MACOSX) && !OS(LINUX)
 TEST_P(ParameterizedWebFrameTest, SelectRangeStaysHorizontallyAlignedWhenMoved)
 {
     registerMockedHttpURLLoad("move_caret.html");
 
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     initializeTextSelectionWebView(m_baseURL + "move_caret.html", &webViewHelper);
     WebLocalFrameImpl* frame = webViewHelper.webView()->mainFrameImpl();
 
     WebRect initialStartRect;
     WebRect initialEndRect;
     WebRect startRect;
     WebRect endRect;
 
     frame->executeScript(WebScriptSource("selectRange();"));
     webViewHelper.webView()->selectionBounds(initialStartRect, initialEndRect);
@@ skipping 24 matching lines @@
     webViewHelper.webView()->selectionBounds(startRect, endRect);
     EXPECT_EQ(startRect, initialStartRect);
     EXPECT_EQ(endRect, initialEndRect);
 }
 
 TEST_P(ParameterizedWebFrameTest, MoveCaretStaysHorizontallyAlignedWhenMoved)
 {
     WebLocalFrameImpl* frame;
     registerMockedHttpURLLoad("move_caret.html");
 
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     initializeTextSelectionWebView(m_baseURL + "move_caret.html", &webViewHelper);
     frame = (WebLocalFrameImpl*)webViewHelper.webView()->mainFrame();
 
     WebRect initialStartRect;
     WebRect initialEndRect;
     WebRect startRect;
     WebRect endRect;
 
     frame->executeScript(WebScriptSource("selectCaret();"));
     webViewHelper.webView()->selectionBounds(initialStartRect, initialEndRect);
@@ skipping 175 matching lines @@
 
     registerMockedHttpURLLoad("select_range_basic.html");
     registerMockedHttpURLLoad("select_range_scroll.html");
 
     int viewWidth = 500;
     int viewHeight = 500;
 
     CompositedSelectionBoundsTestWebViewClient fakeSelectionWebViewClient;
     CompositedSelectionBoundsTestLayerTreeView& fakeSelectionLayerTreeView = fakeSelectionWebViewClient.selectionLayerTreeView();
 
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initialize(true, nullptr, &fakeSelectionWebViewClient, nullptr);
     webViewHelper.webView()->settings()->setDefaultFontSize(12);
     webViewHelper.webView()->setDefaultPageScaleLimits(1, 1);
     webViewHelper.resize(WebSize(viewWidth, viewHeight));
     webViewHelper.webView()->setFocus(true);
     FrameTestHelpers::loadFrame(webViewHelper.webView()->mainFrame(), m_baseURL + "select_range_basic.html");
 
     // The frame starts with no selection.
     WebLocalFrame* frame = webViewHelper.webView()->mainFrameImpl();
     ASSERT_TRUE(frame->hasSelection());
@@ skipping 61 matching lines @@
 
 TEST_P(ParameterizedWebFrameTest, 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.
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + htmlFile, true, 0, &client);
     webViewHelper.resize(WebSize(1000, 1000));
 
     client.resetTriggered();
     webViewHelper.webView()->handleInputEvent(fatTap(0, 0));
     EXPECT_FALSE(client.triggered());
 
     client.resetTriggered();
     webViewHelper.webView()->handleInputEvent(fatTap(200, 115));
     EXPECT_FALSE(client.triggered());
@@ skipping 32 matching lines @@
 }
 
 TEST_P(ParameterizedWebFrameTest, 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.
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "disambiguation_popup_no_container.html", true, 0, &client);
     webViewHelper.resize(WebSize(1000, 1000));
 
     client.resetTriggered();
     webViewHelper.webView()->handleInputEvent(fatTap(50, 50));
     EXPECT_FALSE(client.triggered());
 }
 
 TEST_P(ParameterizedWebFrameTest, 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.
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + htmlFile, true, nullptr, &client, nullptr, enableViewportSettings);
     webViewHelper.resize(WebSize(1000, 1000));
 
     client.resetTriggered();
     webViewHelper.webView()->handleInputEvent(fatTap(0, 0));
     EXPECT_FALSE(client.triggered());
 
     client.resetTriggered();
     webViewHelper.webView()->handleInputEvent(fatTap(200, 115));
     EXPECT_FALSE(client.triggered());
@@ skipping 13 matching lines @@
 
 TEST_P(ParameterizedWebFrameTest, 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.
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + htmlFile, true, nullptr, &client, nullptr, enableViewportSettings);
     webViewHelper.resize(WebSize(1000, 1000));
 
     client.resetTriggered();
     webViewHelper.webView()->handleInputEvent(fatTap(0, 0));
     EXPECT_FALSE(client.triggered());
 
     client.resetTriggered();
     webViewHelper.webView()->handleInputEvent(fatTap(200, 115));
     EXPECT_FALSE(client.triggered());
@@ skipping 66 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.
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + htmlFile, true, 0, &client);
     webViewHelper.resize(WebSize(viewportWidth, viewportHeight));
 
     // Click somewhere where the popup shouldn't appear.
     client.resetTriggered();
     webViewHelper.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();
     webViewHelper.webView()->handleInputEvent(fatTap(viewportWidth / 2, divHeight));
     EXPECT_TRUE(client.triggered());
 
     // The third div container should be blacklisted if you click on the link it contains.
     client.resetTriggered();
     webViewHelper.webView()->handleInputEvent(fatTap(viewportWidth / 2, divHeight * 3.25));
     EXPECT_FALSE(client.triggered());
 }
 
 TEST_P(ParameterizedWebFrameTest, 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.
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "disambiguation_popup_page_scale.html", true, 0, &client);
     webViewHelper.resize(WebSize(1000, 1000));
 
     client.resetTriggered();
     webViewHelper.webView()->handleInputEvent(fatTap(80, 80));
     EXPECT_TRUE(client.triggered());
 
     client.resetTriggered();
     webViewHelper.webView()->handleInputEvent(fatTap(230, 190));
     EXPECT_TRUE(client.triggered());
@@ skipping 31 matching lines @@
     bool commitCalled() const { return m_commitCalled; }
 
 private:
     bool m_commitCalled;
 };
 
 TEST_P(ParameterizedWebFrameTest, ReplaceNavigationAfterHistoryNavigation)
 {
     TestSubstituteDataWebFrameClient webFrameClient;
 
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad("about:blank", true, &webFrameClient);
     WebFrame* frame = webViewHelper.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 36 matching lines @@
 
     int m_numBodies;
     bool m_didLoad;
 };
 
 TEST_P(ParameterizedWebFrameTest, HTMLDocument)
 {
     registerMockedHttpURLLoad("clipped-body.html");
 
     TestWillInsertBodyWebFrameClient webFrameClient;
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "clipped-body.html", false, &webFrameClient);
 
     EXPECT_TRUE(webFrameClient.m_didLoad);
     EXPECT_EQ(1, webFrameClient.m_numBodies);
 }
 
 TEST_P(ParameterizedWebFrameTest, EmptyDocument)
 {
     registerMockedHttpURLLoad("frameserializer/svg/green_rectangle.svg");
 
     TestWillInsertBodyWebFrameClient webFrameClient;
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initialize(false, &webFrameClient);
 
     EXPECT_FALSE(webFrameClient.m_didLoad);
     EXPECT_EQ(1, webFrameClient.m_numBodies); // The empty document that a new frame starts with triggers this.
 }
 
 TEST_P(ParameterizedWebFrameTest, MoveCaretSelectionTowardsWindowPointWithNoSelection)
 {
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad("about:blank", true);
     WebFrame* frame = webViewHelper.webView()->mainFrame();
 
     // This test passes if this doesn't crash.
     frame->toWebLocalFrame()->moveCaretSelection(WebPoint(0, 0));
 }
 
 class SpellCheckClient : public WebSpellCheckClient {
 public:
     explicit SpellCheckClient(uint32_t hash = 0) : m_numberOfTimesChecked(0), m_hash(hash) { }
     virtual ~SpellCheckClient() { }
     void requestCheckingOfText(const WebString&, const WebVector<uint32_t>&, const WebVector<unsigned>&, WebTextCheckingCompletion* completion) override
     {
         ++m_numberOfTimesChecked;
         Vector<WebTextCheckingResult> results;
         const int misspellingStartOffset = 1;
         const int misspellingLength = 8;
         results.append(WebTextCheckingResult(WebTextDecorationTypeSpelling, misspellingStartOffset, misspellingLength, WebString(), m_hash));
         completion->didFinishCheckingText(results);
     }
     int numberOfTimesChecked() const { return m_numberOfTimesChecked; }
 private:
     int m_numberOfTimesChecked;
     uint32_t m_hash;
 };
 
 TEST_P(ParameterizedWebFrameTest, ReplaceMisspelledRange)
 {
     registerMockedHttpURLLoad("spell.html");
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "spell.html");
     SpellCheckClient spellcheck;
     webViewHelper.webView()->setSpellCheckClient(&spellcheck);
 
     WebLocalFrameImpl* frame = webViewHelper.webView()->mainFrameImpl();
     Document* document = frame->frame()->document();
     Element* element = document->getElementById("data");
 
     webViewHelper.webView()->settings()->setEditingBehavior(WebSettings::EditingBehaviorWin);
 
@@ skipping 10 matching lines @@
     EXPECT_EQ(1, spellcheck.numberOfTimesChecked());
     EXPECT_EQ(1U, document->markers().markersInRange(selectionRange, DocumentMarker::Spelling).size());
 
     frame->replaceMisspelledRange("welcome");
     EXPECT_EQ("_welcome_.", WebFrameContentDumper::dumpWebViewAsText(webViewHelper.webView(), std::numeric_limits<size_t>::max()).utf8());
 }
 
 TEST_P(ParameterizedWebFrameTest, RemoveSpellingMarkers)
 {
     registerMockedHttpURLLoad("spell.html");
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "spell.html");
     SpellCheckClient spellcheck;
     webViewHelper.webView()->setSpellCheckClient(&spellcheck);
 
     WebLocalFrameImpl* frame = webViewHelper.webView()->mainFrameImpl();
     Document* document = frame->frame()->document();
     Element* element = document->getElementById("data");
 
     webViewHelper.webView()->settings()->setEditingBehavior(WebSettings::EditingBehaviorWin);
 
     element->focus();
     NonThrowableExceptionState exceptionState;
     document->execCommand("InsertText", false, "_wellcome_.", exceptionState);
     EXPECT_FALSE(exceptionState.hadException());
 
     frame->removeSpellingMarkers();
 
     const int allTextBeginOffset = 0;
     const int allTextLength = 11;
     frame->selectRange(WebRange(allTextBeginOffset, allTextLength));
     EphemeralRange selectionRange = frame->frame()->selection().selection().toNormalizedEphemeralRange();
 
     EXPECT_EQ(0U, document->markers().markersInRange(selectionRange, DocumentMarker::Spelling).size());
 }
 
 TEST_P(ParameterizedWebFrameTest, RemoveSpellingMarkersUnderWords)
 {
     registerMockedHttpURLLoad("spell.html");
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "spell.html");
     SpellCheckClient spellcheck;
     webViewHelper.webView()->setSpellCheckClient(&spellcheck);
 
     LocalFrame* frame = webViewHelper.webView()->mainFrameImpl()->frame();
     Document* document = frame->document();
     Element* element = document->getElementById("data");
 
     webViewHelper.webView()->settings()->setEditingBehavior(WebSettings::EditingBehaviorWin);
 
@@ skipping 11 matching lines @@
     frame->removeSpellingMarkersUnderWords(words);
 
     WebVector<uint32_t> documentMarkers2;
     webViewHelper.webView()->spellingMarkers(&documentMarkers2);
     EXPECT_EQ(0U, documentMarkers2.size());
 }
 
 TEST_P(ParameterizedWebFrameTest, MarkerHashIdentifiers)
 {
     registerMockedHttpURLLoad("spell.html");
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "spell.html");
 
     static const uint32_t kHash = 42;
     SpellCheckClient spellcheck(kHash);
     webViewHelper.webView()->setSpellCheckClient(&spellcheck);
 
     WebLocalFrameImpl* frame = webViewHelper.webView()->mainFrameImpl();
     Document* document = frame->frame()->document();
     Element* element = document->getElementById("data");
 
@@ skipping 63 matching lines @@
         m_completion->didFinishCheckingText(results);
         m_completion = 0;
     }
 
     WebTextCheckingCompletion* m_completion;
 };
 
 TEST_P(ParameterizedWebFrameTest, SlowSpellcheckMarkerPosition)
 {
     registerMockedHttpURLLoad("spell.html");
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "spell.html");
 
     StubbornSpellCheckClient spellcheck;
     webViewHelper.webView()->setSpellCheckClient(&spellcheck);
 
     WebLocalFrameImpl* frame = webViewHelper.webView()->mainFrameImpl();
     Document* document = frame->frame()->document();
     Element* element = document->getElementById("data");
 
     webViewHelper.webView()->settings()->setEditingBehavior(WebSettings::EditingBehaviorWin);
@@ skipping 10 matching lines @@
     WebVector<uint32_t> documentMarkers;
     webViewHelper.webView()->spellingMarkers(&documentMarkers);
     EXPECT_EQ(0U, documentMarkers.size());
 }
 
 // This test verifies that cancelling spelling request does not cause a
 // write-after-free when there's no spellcheck client set.
 TEST_P(ParameterizedWebFrameTest, CancelSpellingRequestCrash)
 {
     registerMockedHttpURLLoad("spell.html");
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "spell.html");
     webViewHelper.webView()->setSpellCheckClient(0);
 
     WebLocalFrameImpl* frame = webViewHelper.webView()->mainFrameImpl();
     Document* document = frame->frame()->document();
     Element* element = document->getElementById("data");
 
     webViewHelper.webView()->settings()->setEditingBehavior(WebSettings::EditingBehaviorWin);
 
     element->focus();
     frame->frame()->editor().replaceSelectionWithText("A", false, false);
     frame->frame()->spellChecker().cancelCheck();
 }
 
 TEST_P(ParameterizedWebFrameTest, SpellcheckResultErasesMarkers)
 {
     registerMockedHttpURLLoad("spell.html");
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "spell.html");
 
     StubbornSpellCheckClient spellcheck;
     webViewHelper.webView()->setSpellCheckClient(&spellcheck);
 
     WebLocalFrameImpl* frame = webViewHelper.webView()->mainFrameImpl();
     Document* document = frame->frame()->document();
     Element* element = document->getElementById("data");
 
     webViewHelper.webView()->settings()->setEditingBehavior(WebSettings::EditingBehaviorWin);
@@ skipping 11 matching lines @@
     document->markers().addMarker(range.startPosition(), range.endPosition(), DocumentMarker::InvisibleSpellcheck);
     EXPECT_EQ(3U, document->markers().markers().size());
 
     spellcheck.kickNoResults();
     EXPECT_EQ(0U, document->markers().markers().size());
 }
 
 TEST_P(ParameterizedWebFrameTest, SpellcheckResultsSavedInDocument)
 {
     registerMockedHttpURLLoad("spell.html");
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "spell.html");
 
     StubbornSpellCheckClient spellcheck;
     webViewHelper.webView()->setSpellCheckClient(&spellcheck);
 
     WebLocalFrameImpl* frame = webViewHelper.webView()->mainFrameImpl();
     Document* document = frame->frame()->document();
     Element* element = document->getElementById("data");
 
     webViewHelper.webView()->settings()->setEditingBehavior(WebSettings::EditingBehaviorWin);
@@ skipping 40 matching lines @@
     bool m_didAccessInitialDocument;
 };
 
 TEST_P(ParameterizedWebFrameTest, DidAccessInitialDocumentBody)
 {
     // FIXME: Why is this local webViewClient needed instead of the default
     // WebViewHelper one? With out it there's some mysterious crash in the
     // WebViewHelper destructor.
     FrameTestHelpers::TestWebViewClient webViewClient;
     TestAccessInitialDocumentWebFrameClient webFrameClient;
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initialize(true, &webFrameClient, &webViewClient);
     runPendingTasks();
     EXPECT_FALSE(webFrameClient.m_didAccessInitialDocument);
 
     // Create another window that will try to access it.
-    FrameTestHelpers::WebViewHelper newWebViewHelper(this);
+    FrameTestHelpers::WebViewHelper newWebViewHelper;
     WebView* newView = newWebViewHelper.initializeWithOpener(webViewHelper.webView()->mainFrame(), true);
     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);
 }
 
 TEST_P(ParameterizedWebFrameTest, DidAccessInitialDocumentNavigator)
 {
     // FIXME: Why is this local webViewClient needed instead of the default
     // WebViewHelper one? With out it there's some mysterious crash in the
     // WebViewHelper destructor.
     FrameTestHelpers::TestWebViewClient webViewClient;
     TestAccessInitialDocumentWebFrameClient webFrameClient;
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initialize(true, &webFrameClient, &webViewClient);
     runPendingTasks();
     EXPECT_FALSE(webFrameClient.m_didAccessInitialDocument);
 
     // Create another window that will try to access it.
-    FrameTestHelpers::WebViewHelper newWebViewHelper(this);
+    FrameTestHelpers::WebViewHelper newWebViewHelper;
     WebView* newView = newWebViewHelper.initializeWithOpener(webViewHelper.webView()->mainFrame(), true);
     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);
 }
 
 TEST_P(ParameterizedWebFrameTest, DidAccessInitialDocumentViaJavascriptUrl)
 {
     TestAccessInitialDocumentWebFrameClient webFrameClient;
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initialize(true, &webFrameClient);
     runPendingTasks();
     EXPECT_FALSE(webFrameClient.m_didAccessInitialDocument);
 
     // Access the initial document from a javascript: URL.
     FrameTestHelpers::loadFrame(webViewHelper.webView()->mainFrame(), "javascript:document.body.appendChild(document.createTextNode('Modified'))");
     EXPECT_TRUE(webFrameClient.m_didAccessInitialDocument);
 }
 
 // Fails on the WebKit XP (deps) bot. http://crbug.com/312192
 #if OS(WIN)
 TEST_P(ParameterizedWebFrameTest, DISABLED_DidAccessInitialDocumentBodyBeforeModalDialog)
 #else
 TEST_P(ParameterizedWebFrameTest, DidAccessInitialDocumentBodyBeforeModalDialog)
 #endif
 {
     // FIXME: Why is this local webViewClient needed instead of the default
     // WebViewHelper one? With out it there's some mysterious crash in the
     // WebViewHelper destructor.
     FrameTestHelpers::TestWebViewClient webViewClient;
     TestAccessInitialDocumentWebFrameClient webFrameClient;
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initialize(true, &webFrameClient, &webViewClient);
     runPendingTasks();
     EXPECT_FALSE(webFrameClient.m_didAccessInitialDocument);
 
     // Create another window that will try to access it.
-    FrameTestHelpers::WebViewHelper newWebViewHelper(this);
+    FrameTestHelpers::WebViewHelper newWebViewHelper;
     WebView* newView = newWebViewHelper.initializeWithOpener(webViewHelper.webView()->mainFrame(), true);
     runPendingTasks();
     EXPECT_FALSE(webFrameClient.m_didAccessInitialDocument);
 
     // Access the initial document by modifying the body.
     newView->mainFrame()->executeScript(
         WebScriptSource("window.opener.document.body.innerHTML += 'Modified';"));
     EXPECT_TRUE(webFrameClient.m_didAccessInitialDocument);
 
     // Run a modal dialog, which used to run a nested message loop and require
@@ skipping 12 matching lines @@
 TEST_P(ParameterizedWebFrameTest, DISABLED_DidWriteToInitialDocumentBeforeModalDialog)
 #else
 TEST_P(ParameterizedWebFrameTest, DidWriteToInitialDocumentBeforeModalDialog)
 #endif
 {
     // FIXME: Why is this local webViewClient needed instead of the default
     // WebViewHelper one? With out it there's some mysterious crash in the
     // WebViewHelper destructor.
     FrameTestHelpers::TestWebViewClient webViewClient;
     TestAccessInitialDocumentWebFrameClient webFrameClient;
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initialize(true, &webFrameClient, &webViewClient);
     runPendingTasks();
     EXPECT_FALSE(webFrameClient.m_didAccessInitialDocument);
 
     // Create another window that will try to access it.
-    FrameTestHelpers::WebViewHelper newWebViewHelper(this);
+    FrameTestHelpers::WebViewHelper newWebViewHelper;
     WebView* newView = newWebViewHelper.initializeWithOpener(webViewHelper.webView()->mainFrame(), true);
     runPendingTasks();
     EXPECT_FALSE(webFrameClient.m_didAccessInitialDocument);
 
     // Access the initial document with document.write, which moves us past the
     // initial empty document state of the state machine.
     newView->mainFrame()->executeScript(
         WebScriptSource("window.opener.document.write('Modified'); window.opener.document.close();"));
     EXPECT_TRUE(webFrameClient.m_didAccessInitialDocument);
 
@@ skipping 27 matching lines @@
         // FrameView can be scrolled in FrameView::setFixedVisibleContentRect
         // which is called from LocalFrame::createView (before the frame is associated
         // with the the view).
         if (view)
             m_didScrollFrame = true;
     }
 private:
     bool m_didScrollFrame;
 };
 
-TEST_P(ParameterizedWebFrameTest, CompositorScrollIsUserScrollLongPage)
+TEST_F(WebFrameTest, CompositorScrollIsUserScrollLongPage)
 {
     registerMockedHttpURLLoad("long_scroll.html");
     TestScrolledFrameClient client;
 
     // Make sure we initialize to minimum scale, even if the window size
     // only becomes available after the load begins.
     FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "long_scroll.html", true, &client);
     webViewHelper.resize(WebSize(1000, 1000));
 
@@ skipping 64 matching lines @@
     WebURLResponse redirectResponse;
     redirectResponse.setMIMEType("text/html");
     redirectResponse.setHTTPStatusCode(302);
     redirectResponse.setHTTPHeaderField("Location", redirect);
     Platform::current()->getURLLoaderMockFactory()->registerURL(testURL, redirectResponse, filePath);
 
     WebURLResponse finalResponse;
     finalResponse.setMIMEType("text/html");
     Platform::current()->getURLLoaderMockFactory()->registerURL(redirectURL, finalResponse, filePath);
 
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "first_party_redirect.html", true);
     EXPECT_TRUE(webViewHelper.webView()->mainFrame()->document().firstPartyForCookies() == redirectURL);
 }
 
 class TestNavigationPolicyWebFrameClient : public FrameTestHelpers::TestWebFrameClient {
 public:
 
     void didNavigateWithinPage(WebLocalFrame*, const WebHistoryItem&, WebHistoryCommitType, bool) override
     {
         EXPECT_TRUE(false);
     }
 };
 
 TEST_P(ParameterizedWebFrameTest, SimulateFragmentAnchorMiddleClick)
 {
     registerMockedHttpURLLoad("fragment_middle_click.html");
     TestNavigationPolicyWebFrameClient client;
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "fragment_middle_click.html", true, &client);
 
     Document* document = toLocalFrame(webViewHelper.webView()->page()->mainFrame())->document();
     KURL destination = document->url();
     destination.setFragmentIdentifier("test");
 
     Event* event = MouseEvent::create(EventTypeNames::click, false, false,
         document->domWindow(), 0, 0, 0, 0, 0, 0, 0, PlatformEvent::NoModifiers, 1, 0, nullptr, 0,
         PlatformMouseEvent::RealOrIndistinguishable, String());
     FrameLoadRequest frameRequest(document, ResourceRequest(destination));
@@ skipping 29 matching lines @@
 private:
     int m_decidePolicyCallCount;
 };
 
 TEST_P(ParameterizedWebFrameTest, ModifiedClickNewWindow)
 {
     registerMockedHttpURLLoad("ctrl_click.html");
     registerMockedHttpURLLoad("hello_world.html");
     TestNewWindowWebViewClient webViewClient;
     TestNewWindowWebFrameClient webFrameClient;
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "ctrl_click.html", true, &webFrameClient, &webViewClient);
 
     Document* document = toLocalFrame(webViewHelper.webView()->page()->mainFrame())->document();
     KURL destination = toKURL(m_baseURL + "hello_world.html");
 
     // ctrl+click event
     Event* event = MouseEvent::create(EventTypeNames::click, false, false,
         document->domWindow(), 0, 0, 0, 0, 0, 0, 0, PlatformEvent::CtrlKey, 0, 0, nullptr, 0,
         PlatformMouseEvent::RealOrIndistinguishable, String());
     FrameLoadRequest frameRequest(document, ResourceRequest(destination));
     frameRequest.setTriggeringEvent(event);
     UserGestureIndicator gesture(DefinitelyProcessingUserGesture);
     toLocalFrame(webViewHelper.webView()->page()->mainFrame())->loader().load(frameRequest);
     FrameTestHelpers::pumpPendingRequestsForFrameToLoad(webViewHelper.webView()->mainFrame());
 
     // decidePolicyForNavigation should be called both for the original request and the ctrl+click.
     EXPECT_EQ(2, webFrameClient.decidePolicyCallCount());
 }
 
 TEST_P(ParameterizedWebFrameTest, BackToReload)
 {
     registerMockedHttpURLLoad("fragment_middle_click.html");
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "fragment_middle_click.html", true);
     WebFrame* frame = webViewHelper.webView()->mainFrame();
     const FrameLoader& mainFrameLoader = webViewHelper.webView()->mainFrameImpl()->frame()->loader();
     Persistent<HistoryItem> firstItem = mainFrameLoader.currentItem();
     EXPECT_TRUE(firstItem);
 
     registerMockedHttpURLLoad("white-1x1.png");
     FrameTestHelpers::loadFrame(frame, m_baseURL + "white-1x1.png");
     EXPECT_NE(firstItem.get(), mainFrameLoader.currentItem());
 
     FrameTestHelpers::loadHistoryItem(frame, WebHistoryItem(firstItem.get()), WebHistoryDifferentDocumentLoad, WebCachePolicy::UseProtocolCachePolicy);
     EXPECT_EQ(firstItem.get(), mainFrameLoader.currentItem());
 
     FrameTestHelpers::reloadFrame(frame);
     EXPECT_EQ(WebCachePolicy::ValidatingCacheData, frame->dataSource()->request().getCachePolicy());
 }
 
 TEST_P(ParameterizedWebFrameTest, BackDuringChildFrameReload)
 {
     registerMockedHttpURLLoad("page_with_blank_iframe.html");
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "page_with_blank_iframe.html", true);
     WebLocalFrame* mainFrame = webViewHelper.webView()->mainFrameImpl();
     const FrameLoader& mainFrameLoader = webViewHelper.webView()->mainFrameImpl()->frame()->loader();
     WebFrame* childFrame = mainFrame->firstChild();
     ASSERT_TRUE(childFrame);
 
     // Start a history navigation, then have a different frame commit a navigation.
     // In this case, reload an about:blank frame, which will commit synchronously.
     // After the history navigation completes, both the appropriate document url and
     // the current history item should reflect the history navigation.
     registerMockedHttpURLLoad("white-1x1.png");
     WebHistoryItem item;
     item.initialize();
     WebURL historyURL(toKURL(m_baseURL + "white-1x1.png"));
     item.setURLString(historyURL.string());
     WebURLRequest request = mainFrame->requestFromHistoryItem(item, WebCachePolicy::UseProtocolCachePolicy);
     mainFrame->load(request, WebFrameLoadType::BackForward, item);
 
     FrameTestHelpers::reloadFrame(childFrame);
     EXPECT_EQ(item.urlString(), mainFrame->document().url().string());
     EXPECT_EQ(item.urlString(), WebString(mainFrameLoader.currentItem()->urlString()));
 }
 
 TEST_P(ParameterizedWebFrameTest, ReloadPost)
 {
     registerMockedHttpURLLoad("reload_post.html");
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "reload_post.html", true);
     WebFrame* frame = webViewHelper.webView()->mainFrame();
 
     FrameTestHelpers::loadFrame(webViewHelper.webView()->mainFrame(), "javascript:document.forms[0].submit()");
     // Pump requests one more time after the javascript URL has executed to
     // trigger the actual POST load request.
     FrameTestHelpers::pumpPendingRequestsForFrameToLoad(webViewHelper.webView()->mainFrame());
     EXPECT_EQ(WebString::fromUTF8("POST"), frame->dataSource()->request().httpMethod());
 
     FrameTestHelpers::reloadFrame(frame);
     EXPECT_EQ(WebCachePolicy::ValidatingCacheData, frame->dataSource()->request().getCachePolicy());
     EXPECT_EQ(WebNavigationTypeFormResubmitted, frame->dataSource()->navigationType());
 }
 
 TEST_P(ParameterizedWebFrameTest, LoadHistoryItemReload)
 {
     registerMockedHttpURLLoad("fragment_middle_click.html");
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "fragment_middle_click.html", true);
     WebFrame* frame = webViewHelper.webView()->mainFrame();
     const FrameLoader& mainFrameLoader = webViewHelper.webView()->mainFrameImpl()->frame()->loader();
     Persistent<HistoryItem> firstItem = mainFrameLoader.currentItem();
     EXPECT_TRUE(firstItem);
 
     registerMockedHttpURLLoad("white-1x1.png");
     FrameTestHelpers::loadFrame(frame, m_baseURL + "white-1x1.png");
     EXPECT_NE(firstItem.get(), mainFrameLoader.currentItem());
 
@@ skipping 63 matching lines @@
 };
 
 TEST_P(ParameterizedWebFrameTest, ReloadIframe)
 {
     registerMockedHttpURLLoad("iframe_reload.html");
     registerMockedHttpURLLoad("visible_iframe.html");
     TestCachePolicyWebFrameClient mainClient(0);
     TestCachePolicyWebFrameClient childClient(&mainClient);
     mainClient.setChildWebFrameClient(&childClient);
 
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "iframe_reload.html", true, &mainClient);
 
     WebLocalFrameImpl* mainFrame = webViewHelper.webView()->mainFrameImpl();
     WebLocalFrameImpl* childFrame = toWebLocalFrameImpl(mainFrame->firstChild());
     ASSERT_EQ(childFrame->client(), &childClient);
     EXPECT_EQ(mainClient.childFrameCreationCount(), 1);
     EXPECT_EQ(childClient.willSendRequestCallCount(), 1);
     EXPECT_EQ(childClient.getCachePolicy(), WebCachePolicy::UseProtocolCachePolicy);
 
     FrameTestHelpers::reloadFrame(mainFrame);
@@ skipping 23 matching lines @@
     bool frameLoadTypeReloadMainResourceSeen() const { return m_frameLoadTypeReloadMainResourceSeen; }
 
 private:
     bool m_frameLoadTypeReloadMainResourceSeen;
 };
 
 TEST_P(ParameterizedWebFrameTest, NavigateToSame)
 {
     registerMockedHttpURLLoad("navigate_to_same.html");
     TestSameDocumentWebFrameClient client;
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "navigate_to_same.html", true, &client);
     EXPECT_FALSE(client.frameLoadTypeReloadMainResourceSeen());
 
     FrameLoadRequest frameRequest(0, ResourceRequest(toLocalFrame(webViewHelper.webView()->page()->mainFrame())->document()->url()));
     toLocalFrame(webViewHelper.webView()->page()->mainFrame())->loader().load(frameRequest);
     FrameTestHelpers::pumpPendingRequestsForFrameToLoad(webViewHelper.webView()->mainFrame());
 
     EXPECT_TRUE(client.frameLoadTypeReloadMainResourceSeen());
 }
 
@@ skipping 16 matching lines @@
 
 private:
     int m_numOfImageRequests;
 };
 
 TEST_P(ParameterizedWebFrameTest, NavigateToSameNoConditionalRequestForSubresource)
 {
     registerMockedHttpURLLoad("foo_with_image.html");
     registerMockedHttpURLLoad("white-1x1.png");
     TestSameDocumentWithImageWebFrameClient client;
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "foo_with_image.html", true, &client, nullptr, nullptr, &configureLoadsImagesAutomatically);
 
     WebCache::clear();
     FrameTestHelpers::loadFrame(webViewHelper.webView()->mainFrame(), m_baseURL + "foo_with_image.html");
 
     // 2 images are requested, and each triggers 2 willSendRequest() calls,
     // once for preloading and once for the real request.
     EXPECT_EQ(client.numOfImageRequests(), 4);
 }
 
 TEST_P(ParameterizedWebFrameTest, WebNodeImageContents)
 {
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad("about:blank", true);
     WebFrame* frame = webViewHelper.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.
     KURL testURL = toKURL("about:blank");
     FrameTestHelpers::loadHTMLString(frame, bluePNG, testURL);
 
     WebNode node = frame->document().body().firstChild();
@@ skipping 40 matching lines @@
 private:
     int m_startLoadingCount;
     int m_stopLoadingCount;
     int m_differentDocumentStartCount;
 };
 
 TEST_P(ParameterizedWebFrameTest, PushStateStartsAndStops)
 {
     registerMockedHttpURLLoad("push_state.html");
     TestStartStopCallbackWebFrameClient client;
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "push_state.html", true, &client);
 
     EXPECT_EQ(client.startLoadingCount(), 2);
     EXPECT_EQ(client.stopLoadingCount(), 2);
     EXPECT_EQ(client.differentDocumentStartCount(), 1);
 }
 
 class TestDidNavigateCommitTypeWebFrameClient : public FrameTestHelpers::TestWebFrameClient {
 public:
     TestDidNavigateCommitTypeWebFrameClient()
         : m_lastCommitType(WebHistoryInertCommit)
     {
     }
 
     void didNavigateWithinPage(WebLocalFrame*, const WebHistoryItem&, WebHistoryCommitType type, bool) override
     {
         m_lastCommitType = type;
     }
 
     WebHistoryCommitType lastCommitType() const { return m_lastCommitType; }
 
 private:
     WebHistoryCommitType m_lastCommitType;
 };
 
 TEST_P(ParameterizedWebFrameTest, SameDocumentHistoryNavigationCommitType)
 {
     registerMockedHttpURLLoad("push_state.html");
     TestDidNavigateCommitTypeWebFrameClient client;
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     WebViewImpl* webViewImpl = webViewHelper.initializeAndLoad(m_baseURL + "push_state.html", true, &client);
     Persistent<HistoryItem> item = toLocalFrame(webViewImpl->page()->mainFrame())->loader().currentItem();
     runPendingTasks();
 
     toLocalFrame(webViewImpl->page()->mainFrame())->loader().load(FrameLoadRequest(nullptr, FrameLoader::resourceRequestFromHistoryItem(item.get(), WebCachePolicy::UseProtocolCachePolicy)), FrameLoadTypeBackForward, item.get(), HistorySameDocumentLoad);
     EXPECT_EQ(WebBackForwardCommit, client.lastCommitType());
 }
 
 class TestHistoryWebFrameClient : public FrameTestHelpers::TestWebFrameClient {
 public:
@@ skipping 18 matching lines @@
     WebFrame* m_frame;
 };
 
 // Tests that the first navigation in an initially blank subframe will result in
 // a history entry being replaced and not a new one being added.
 TEST_P(ParameterizedWebFrameTest, FirstBlankSubframeNavigation)
 {
     registerMockedHttpURLLoad("history.html");
     registerMockedHttpURLLoad("find.html");
 
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     TestHistoryWebFrameClient client;
     webViewHelper.initializeAndLoad("about:blank", true, &client);
 
     WebFrame* frame = webViewHelper.webView()->mainFrame();
 
     frame->executeScript(WebScriptSource(WebString::fromUTF8(
         "document.body.appendChild(document.createElement('iframe'))")));
 
     WebFrame* iframe = frame->firstChild();
     ASSERT_EQ(&client, toWebLocalFrameImpl(iframe)->client());
@@ skipping 12 matching lines @@
     EXPECT_FALSE(client.replacesCurrentHistoryItem());
 }
 
 // Tests that a navigation in a frame with a non-blank initial URL will create
 // a new history item, unlike the case above.
 TEST_P(ParameterizedWebFrameTest, FirstNonBlankSubframeNavigation)
 {
     registerMockedHttpURLLoad("history.html");
     registerMockedHttpURLLoad("find.html");
 
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     TestHistoryWebFrameClient client;
     webViewHelper.initializeAndLoad("about:blank", true, &client);
 
     WebFrame* frame = webViewHelper.webView()->mainFrame();
 
     std::string url1 = m_baseURL + "history.html";
     FrameTestHelpers::loadFrame(frame,
         "javascript:var f = document.createElement('iframe'); "
         "f.src = '" + url1 + "';"
         "document.body.appendChild(f)");
@@ skipping 36 matching lines @@
     ASSERT_TRUE(webScrollLayer->userScrollableHorizontal());
     ASSERT_TRUE(webScrollLayer->userScrollableVertical());
 }
 
 // Test that currentHistoryItem reflects the current page, not the provisional load.
 TEST_P(ParameterizedWebFrameTest, CurrentHistoryItem)
 {
     registerMockedHttpURLLoad("fixed_layout.html");
     std::string url = m_baseURL + "fixed_layout.html";
 
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initialize();
     WebFrame* frame = webViewHelper.webView()->mainFrame();
     const FrameLoader& mainFrameLoader = webViewHelper.webView()->mainFrameImpl()->frame()->loader();
     WebURLRequest request;
     request.setURL(toKURL(url));
     request.setRequestorOrigin(WebSecurityOrigin::createUnique());
     frame->loadRequest(request);
 
     // Before commit, there is no history item.
     EXPECT_FALSE(mainFrameLoader.currentItem());
@@ skipping 20 matching lines @@
 
 private:
     int m_callCount;
 };
 
 // Test that we don't crash if WebFrameClient::createChildFrame() fails.
 TEST_P(ParameterizedWebFrameTest, CreateChildFrameFailure)
 {
     registerMockedHttpURLLoad("create_child_frame_fail.html");
     FailCreateChildFrame client;
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "create_child_frame_fail.html", true, &client);
 
     EXPECT_EQ(1, client.callCount());
 }
 
 TEST_P(ParameterizedWebFrameTest, fixedPositionInFixedViewport)
 {
     registerMockedHttpURLLoad("fixed-position-in-fixed-viewport.html");
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "fixed-position-in-fixed-viewport.html", true, nullptr, nullptr, nullptr, enableViewportSettings);
 
     WebViewImpl* webView = webViewHelper.webView();
     webViewHelper.resize(WebSize(100, 100));
 
     Document* document = webView->mainFrameImpl()->frame()->document();
     Element* bottomFixed = document->getElementById("bottom-fixed");
     Element* topBottomFixed = document->getElementById("top-bottom-fixed");
     Element* rightFixed = document->getElementById("right-fixed");
     Element* leftRightFixed = document->getElementById("left-right-fixed");
 
     // The layout viewport will hit the min-scale limit of 0.25, so it'll be 400x800.
     webViewHelper.resize(WebSize(100, 200));
     EXPECT_EQ(800, bottomFixed->offsetTop() + bottomFixed->offsetHeight());
     EXPECT_EQ(800, topBottomFixed->offsetHeight());
 
     // Now the layout viewport hits the content width limit of 500px so it'll be 500x500.
     webViewHelper.resize(WebSize(200, 200));
     EXPECT_EQ(500, rightFixed->offsetLeft() + rightFixed->offsetWidth());
     EXPECT_EQ(500, leftRightFixed->offsetWidth());
 }
 
 TEST_P(ParameterizedWebFrameTest, FrameViewMoveWithSetFrameRect)
 {
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad("about:blank");
     webViewHelper.resize(WebSize(200, 200));
     webViewHelper.webView()->updateAllLifecyclePhases();
 
     FrameView* frameView = webViewHelper.webView()->mainFrameImpl()->frameView();
     EXPECT_RECT_EQ(IntRect(0, 0, 200, 200), frameView->frameRect());
     frameView->setFrameRect(IntRect(100, 100, 200, 200));
     EXPECT_RECT_EQ(IntRect(100, 100, 200, 200), frameView->frameRect());
 }
 
@@ skipping 77 matching lines @@
     webViewHelper.webView()->updateAllLifecyclePhases();
 
     FrameView* frameView = webViewHelper.webView()->mainFrameImpl()->frameView();
     EXPECT_LT(frameView->maximumScrollPosition().x(), 0);
 }
 
 TEST_P(ParameterizedWebFrameTest, FullscreenLayerSize)
 {
     FakeCompositingWebViewClient client;
     registerMockedHttpURLLoad("fullscreen_div.html");
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     int viewportWidth = 640;
     int viewportHeight = 480;
     client.m_screenInfo.rect.width = viewportWidth;
     client.m_screenInfo.rect.height = viewportHeight;
     WebViewImpl* webViewImpl = webViewHelper.initializeAndLoad(m_baseURL + "fullscreen_div.html", true, nullptr, &client, nullptr, configureAndroid);
     webViewHelper.resize(WebSize(viewportWidth, viewportHeight));
     webViewImpl->updateAllLifecyclePhases();
 
     Document* document = webViewImpl->mainFrameImpl()->frame()->document();
     UserGestureIndicator gesture(DefinitelyProcessingUserGesture);
@@ skipping 52 matching lines @@
     ASSERT_TRUE(layoutViewportScrollLayer->userScrollableHorizontal());
     ASSERT_TRUE(layoutViewportScrollLayer->userScrollableVertical());
     ASSERT_TRUE(visualViewportScrollLayer->userScrollableHorizontal());
     ASSERT_TRUE(visualViewportScrollLayer->userScrollableVertical());
 }
 
 TEST_P(ParameterizedWebFrameTest, FullscreenMainFrame)
 {
     FakeCompositingWebViewClient client;
     registerMockedHttpURLLoad("fullscreen_div.html");
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     int viewportWidth = 640;
     int viewportHeight = 480;
     WebViewImpl* webViewImpl = webViewHelper.initializeAndLoad(m_baseURL + "fullscreen_div.html", true, nullptr, &client, nullptr, configureAndroid);
     webViewHelper.resize(WebSize(viewportWidth, viewportHeight));
     webViewImpl->updateAllLifecyclePhases();
 
     Document* document = webViewImpl->mainFrameImpl()->frame()->document();
     UserGestureIndicator gesture(DefinitelyProcessingUserGesture);
     Fullscreen::from(*document).requestFullscreen(*document->documentElement(), Fullscreen::PrefixedRequest);
     webViewImpl->didEnterFullscreen();
@@ skipping 11 matching lines @@
     ASSERT_TRUE(webScrollLayer->scrollable());
     ASSERT_TRUE(webScrollLayer->userScrollableHorizontal());
     ASSERT_TRUE(webScrollLayer->userScrollableVertical());
 }
 
 TEST_P(ParameterizedWebFrameTest, FullscreenSubframe)
 {
     FakeCompositingWebViewClient client;
     registerMockedHttpURLLoad("fullscreen_iframe.html");
     registerMockedHttpURLLoad("fullscreen_div.html");
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     WebViewImpl* webViewImpl = webViewHelper.initializeAndLoad(m_baseURL + "fullscreen_iframe.html", true, nullptr, &client, nullptr, configureAndroid);
     int viewportWidth = 640;
     int viewportHeight = 480;
     client.m_screenInfo.rect.width = viewportWidth;
     client.m_screenInfo.rect.height = viewportHeight;
     webViewHelper.resize(WebSize(viewportWidth, viewportHeight));
     webViewImpl->updateAllLifecyclePhases();
 
     Document* document = toWebLocalFrameImpl(webViewHelper.webView()->mainFrame()->firstChild())->frame()->document();
     UserGestureIndicator gesture(DefinitelyProcessingUserGesture);
@@ skipping 13 matching lines @@
     webViewHelper.resize(WebSize(viewportHeight, viewportWidth));
     webViewImpl->updateAllLifecyclePhases();
     EXPECT_EQ(viewportHeight, fullscreenLayoutObject->logicalWidth().toInt());
     EXPECT_EQ(viewportWidth, fullscreenLayoutObject->logicalHeight().toInt());
 }
 
 TEST_P(ParameterizedWebFrameTest, FullscreenWithTinyViewport)
 {
     FakeCompositingWebViewClient client;
     registerMockedHttpURLLoad("viewport-tiny.html");
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     WebViewImpl* webViewImpl = webViewHelper.initializeAndLoad(m_baseURL + "viewport-tiny.html", true, nullptr, &client, nullptr, configureAndroid);
     int viewportWidth = 384;
     int viewportHeight = 640;
     client.m_screenInfo.rect.width = viewportWidth;
     client.m_screenInfo.rect.height = viewportHeight;
     webViewHelper.resize(WebSize(viewportWidth, viewportHeight));
     webViewImpl->updateAllLifecyclePhases();
 
     LayoutViewItem layoutViewItem = webViewHelper.webView()->mainFrameImpl()->frameView()->layoutViewItem();
     EXPECT_EQ(320, layoutViewItem.logicalWidth().floor());
@@ skipping 19 matching lines @@
     EXPECT_EQ(533, layoutViewItem.logicalHeight().floor());
     EXPECT_FLOAT_EQ(1.2, webViewImpl->pageScaleFactor());
     EXPECT_FLOAT_EQ(1.2, webViewImpl->minimumPageScaleFactor());
     EXPECT_FLOAT_EQ(5.0, webViewImpl->maximumPageScaleFactor());
 }
 
 TEST_P(ParameterizedWebFrameTest, FullscreenResizeWithTinyViewport)
 {
     FakeCompositingWebViewClient client;
     registerMockedHttpURLLoad("viewport-tiny.html");
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     WebViewImpl* webViewImpl = webViewHelper.initializeAndLoad(m_baseURL + "viewport-tiny.html", true, nullptr, &client, nullptr, configureAndroid);
     int viewportWidth = 384;
     int viewportHeight = 640;
     client.m_screenInfo.rect.width = viewportWidth;
     client.m_screenInfo.rect.height = viewportHeight;
     webViewHelper.resize(WebSize(viewportWidth, viewportHeight));
     webViewImpl->updateAllLifecyclePhases();
 
     LayoutViewItem layoutViewItem = webViewHelper.webView()->mainFrameImpl()->frameView()->layoutViewItem();
     Document* document = webViewImpl->mainFrameImpl()->frame()->document();
@@ skipping 33 matching lines @@
     // The purpose of this test is to more precisely simulate the sequence of
     // resize and switching fullscreen state operations on WebView, with the
     // interference from Android status bars like a real device does.
     // This verifies we handle the transition and restore states correctly.
     WebSize screenSizeMinusStatusBarsMinusUrlBar(598, 303);
     WebSize screenSizeMinusStatusBars(598, 359);
     WebSize screenSize(640, 384);
 
     FakeCompositingWebViewClient client;
     registerMockedHttpURLLoad("fullscreen_restore_scale_factor.html");
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     WebViewImpl* webViewImpl = webViewHelper.initializeAndLoad(m_baseURL + "fullscreen_restore_scale_factor.html", true, nullptr, &client, nullptr, &configureAndroid);
     client.m_screenInfo.rect.width = screenSizeMinusStatusBarsMinusUrlBar.width;
     client.m_screenInfo.rect.height = screenSizeMinusStatusBarsMinusUrlBar.height;
     webViewHelper.resize(screenSizeMinusStatusBarsMinusUrlBar);
     LayoutViewItem layoutViewItem = webViewHelper.webView()->mainFrameImpl()->frameView()->layoutViewItem();
     EXPECT_EQ(screenSizeMinusStatusBarsMinusUrlBar.width, layoutViewItem.logicalWidth().floor());
     EXPECT_EQ(screenSizeMinusStatusBarsMinusUrlBar.height, layoutViewItem.logicalHeight().floor());
     EXPECT_FLOAT_EQ(1.0, webViewImpl->pageScaleFactor());
     EXPECT_FLOAT_EQ(1.0, webViewImpl->minimumPageScaleFactor());
     EXPECT_FLOAT_EQ(5.0, webViewImpl->maximumPageScaleFactor());
@@ skipping 31 matching lines @@
     EXPECT_FLOAT_EQ(1.0, webViewImpl->pageScaleFactor());
     EXPECT_FLOAT_EQ(1.0, webViewImpl->minimumPageScaleFactor());
     EXPECT_FLOAT_EQ(5.0, webViewImpl->maximumPageScaleFactor());
 }
 
 // Tests that leaving fullscreen by navigating to a new page resets the
 // fullscreen page scale constraints.
 TEST_P(ParameterizedWebFrameTest, ClearFullscreenConstraintsOnNavigation)
 {
     registerMockedHttpURLLoad("viewport-tiny.html");
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     int viewportWidth = 100;
     int viewportHeight = 200;
 
     WebViewImpl* webViewImpl =
         webViewHelper.initializeAndLoad(
             m_baseURL + "viewport-tiny.html",
             true,
             nullptr,
             nullptr,
             nullptr,
@@ skipping 42 matching lines @@
         webViewImpl->mainFrameImpl()->frameView()->layoutViewItem();
     EXPECT_EQ(200, layoutViewItem.logicalWidth().floor());
     EXPECT_EQ(400, layoutViewItem.logicalHeight().floor());
     EXPECT_FLOAT_EQ(0.5, webViewImpl->minimumPageScaleFactor());
     EXPECT_FLOAT_EQ(5.0, webViewImpl->maximumPageScaleFactor());
 }
 
 TEST_P(ParameterizedWebFrameTest, LayoutBlockPercentHeightDescendants)
 {
     registerMockedHttpURLLoad("percent-height-descendants.html");
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "percent-height-descendants.html");
 
     WebViewImpl* webView = webViewHelper.webView();
     webViewHelper.resize(WebSize(800, 800));
     webView->updateAllLifecyclePhases();
 
     Document* document = webView->mainFrameImpl()->frame()->document();
     LayoutBlock* container = toLayoutBlock(document->getElementById("container")->layoutObject());
     LayoutBox* percentHeightInAnonymous = toLayoutBox(document->getElementById("percent-height-in-anonymous")->layoutObject());
     LayoutBox* percentHeightDirectChild = toLayoutBox(document->getElementById("percent-height-direct-child")->layoutObject());
 
     EXPECT_TRUE(container->hasPercentHeightDescendant(percentHeightInAnonymous));
     EXPECT_TRUE(container->hasPercentHeightDescendant(percentHeightDirectChild));
 
     ASSERT_TRUE(container->percentHeightDescendants());
     ASSERT_TRUE(container->hasPercentHeightDescendants());
     EXPECT_EQ(2U, container->percentHeightDescendants()->size());
     EXPECT_TRUE(container->percentHeightDescendants()->contains(percentHeightInAnonymous));
     EXPECT_TRUE(container->percentHeightDescendants()->contains(percentHeightDirectChild));
 
     LayoutBlock* anonymousBlock = percentHeightInAnonymous->containingBlock();
     EXPECT_TRUE(anonymousBlock->isAnonymous());
     EXPECT_FALSE(anonymousBlock->hasPercentHeightDescendants());
 }
 
 TEST_P(ParameterizedWebFrameTest, HasVisibleContentOnVisibleFrames)
 {
     registerMockedHttpURLLoad("visible_frames.html");
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     WebViewImpl* webViewImpl = webViewHelper.initializeAndLoad(m_baseURL + "visible_frames.html");
     for (WebFrame* frame = webViewImpl->mainFrameImpl()->traverseNext(false); frame; frame = frame->traverseNext(false)) {
         EXPECT_TRUE(frame->hasVisibleContent());
     }
 }
 
 TEST_P(ParameterizedWebFrameTest, HasVisibleContentOnHiddenFrames)
 {
     registerMockedHttpURLLoad("hidden_frames.html");
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     WebViewImpl* webViewImpl = webViewHelper.initializeAndLoad(m_baseURL + "hidden_frames.html");
     for (WebFrame* frame = webViewImpl->mainFrameImpl()->traverseNext(false); frame; frame = frame->traverseNext(false)) {
         EXPECT_FALSE(frame->hasVisibleContent());
     }
 }
 
 class ManifestChangeWebFrameClient : public FrameTestHelpers::TestWebFrameClient {
 public:
     ManifestChangeWebFrameClient() : m_manifestChangeCount(0) { }
     void didChangeManifest() override
     {
         ++m_manifestChangeCount;
     }
 
     int manifestChangeCount() { return m_manifestChangeCount; }
 
 private:
     int m_manifestChangeCount;
 };
 
 TEST_P(ParameterizedWebFrameTest, NotifyManifestChange)
 {
     registerMockedHttpURLLoad("link-manifest-change.html");
 
     ManifestChangeWebFrameClient webFrameClient;
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "link-manifest-change.html", true, &webFrameClient);
 
     EXPECT_EQ(14, webFrameClient.manifestChangeCount());
 }
 
 static Resource* fetchManifest(Document* document, const KURL& url)
 {
     FetchRequest fetchRequest = FetchRequest(ResourceRequest(url), FetchInitiatorInfo());
     fetchRequest.mutableResourceRequest().setRequestContext(WebURLRequest::RequestContextManifest);
 
     return RawResource::fetchSynchronously(fetchRequest, document->fetcher());
 }
 
 TEST_P(ParameterizedWebFrameTest, ManifestFetch)
 {
     registerMockedHttpURLLoad("foo.html");
     registerMockedHttpURLLoad("link-manifest-fetch.json");
 
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "foo.html");
     Document* document = webViewHelper.webView()->mainFrameImpl()->frame()->document();
 
     Resource* resource = fetchManifest(document, toKURL(m_baseURL + "link-manifest-fetch.json"));
 
     EXPECT_TRUE(resource->isLoaded());
 }
 
 TEST_P(ParameterizedWebFrameTest, ManifestCSPFetchAllow)
 {
     URLTestHelpers::registerMockedURLLoad(toKURL(m_notBaseURL + "link-manifest-fetch.json"), "link-manifest-fetch.json");
     registerMockedHttpURLLoadWithCSP("foo.html", "manifest-src *");
 
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "foo.html");
     Document* document = webViewHelper.webView()->mainFrameImpl()->frame()->document();
 
     Resource* resource = fetchManifest(document, toKURL(m_notBaseURL + "link-manifest-fetch.json"));
 
     EXPECT_TRUE(resource->isLoaded());
 }
 
 TEST_P(ParameterizedWebFrameTest, ManifestCSPFetchSelf)
 {
     URLTestHelpers::registerMockedURLLoad(toKURL(m_notBaseURL + "link-manifest-fetch.json"), "link-manifest-fetch.json");
     registerMockedHttpURLLoadWithCSP("foo.html", "manifest-src 'self'");
 
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "foo.html");
     Document* document = webViewHelper.webView()->mainFrameImpl()->frame()->document();
 
     Resource* resource = fetchManifest(document, toKURL(m_notBaseURL + "link-manifest-fetch.json"));
 
     EXPECT_EQ(0, resource); // Fetching resource wasn't allowed.
 }
 
 TEST_P(ParameterizedWebFrameTest, ManifestCSPFetchSelfReportOnly)
 {
     URLTestHelpers::registerMockedURLLoad(toKURL(m_notBaseURL + "link-manifest-fetch.json"), "link-manifest-fetch.json");
     registerMockedHttpURLLoadWithCSP("foo.html", "manifest-src 'self'", /* report only */ true);
 
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "foo.html");
     Document* document = webViewHelper.webView()->mainFrameImpl()->frame()->document();
 
     Resource* resource = fetchManifest(document, toKURL(m_notBaseURL + "link-manifest-fetch.json"));
 
     EXPECT_TRUE(resource->isLoaded());
 }
 
 TEST_P(ParameterizedWebFrameTest, ReloadBypassingCache)
 {
     // Check that a reload ignoring cache on a frame will result in the cache
     // policy of the request being set to ReloadBypassingCache.
     registerMockedHttpURLLoad("foo.html");
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "foo.html", true);
     WebFrame* frame = webViewHelper.webView()->mainFrame();
     FrameTestHelpers::reloadFrameIgnoringCache(frame);
     EXPECT_EQ(WebCachePolicy::BypassingCache, frame->dataSource()->request().getCachePolicy());
 }
 
 static void nodeImageTestValidation(const IntSize& referenceBitmapSize, DragImage* dragImage)
 {
     // Prepare the reference bitmap.
     SkBitmap bitmap;
     bitmap.allocN32Pixels(referenceBitmapSize.width(), referenceBitmapSize.height());
     SkCanvas canvas(bitmap);
     canvas.drawColor(SK_ColorGREEN);
 
     EXPECT_EQ(referenceBitmapSize.width(), dragImage->size().width());
     EXPECT_EQ(referenceBitmapSize.height(), dragImage->size().height());
     const SkBitmap& dragBitmap = dragImage->bitmap();
     SkAutoLockPixels lockPixel(dragBitmap);
     EXPECT_EQ(0, memcmp(bitmap.getPixels(), dragBitmap.getPixels(), bitmap.getSize()));
 }
 
 TEST_P(ParameterizedWebFrameTest, NodeImageTestCSSTransformDescendant)
 {
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     std::unique_ptr<DragImage> dragImage = nodeImageTestSetup(&webViewHelper, std::string("case-css-3dtransform-descendant"));
     EXPECT_TRUE(dragImage);
 
     nodeImageTestValidation(IntSize(40, 40), dragImage.get());
 }
 
 TEST_P(ParameterizedWebFrameTest, NodeImageTestCSSTransform)
 {
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     std::unique_ptr<DragImage> dragImage = nodeImageTestSetup(&webViewHelper, std::string("case-css-transform"));
     EXPECT_TRUE(dragImage);
 
     nodeImageTestValidation(IntSize(40, 40), dragImage.get());
 }
 
 TEST_P(ParameterizedWebFrameTest, NodeImageTestCSS3DTransform)
 {
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     std::unique_ptr<DragImage> dragImage = nodeImageTestSetup(&webViewHelper, std::string("case-css-3dtransform"));
     EXPECT_TRUE(dragImage);
 
     nodeImageTestValidation(IntSize(40, 40), dragImage.get());
 }
 
 TEST_P(ParameterizedWebFrameTest, NodeImageTestInlineBlock)
 {
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     std::unique_ptr<DragImage> dragImage = nodeImageTestSetup(&webViewHelper, std::string("case-inlineblock"));
     EXPECT_TRUE(dragImage);
 
     nodeImageTestValidation(IntSize(40, 40), dragImage.get());
 }
 
 TEST_P(ParameterizedWebFrameTest, NodeImageTestFloatLeft)
 {
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     std::unique_ptr<DragImage> dragImage = nodeImageTestSetup(&webViewHelper, std::string("case-float-left-overflow-hidden"));
     EXPECT_TRUE(dragImage);
 
     nodeImageTestValidation(IntSize(40, 40), dragImage.get());
 }
 
 // Crashes on Android: http://crbug.com/403804
 #if OS(ANDROID)
 TEST_P(ParameterizedWebFrameTest, DISABLED_PrintingBasic)
 #else
 TEST_P(ParameterizedWebFrameTest, PrintingBasic)
 #endif
 {
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad("data:text/html,Hello, world.");
 
     WebFrame* frame = webViewHelper.webView()->mainFrame();
 
     WebPrintParams printParams;
     printParams.printContentArea.width = 500;
     printParams.printContentArea.height = 500;
 
     int pageCount = frame->printBegin(printParams);
     EXPECT_EQ(1, pageCount);
@@ skipping 22 matching lines @@
     {
         m_didNotify = true;
     }
 
     bool m_didNotify;
 };
 
 TEST_P(ParameterizedWebFrameTest, ThemeColor)
 {
     registerMockedHttpURLLoad("theme_color_test.html");
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     ThemeColorTestWebFrameClient client;
     webViewHelper.initializeAndLoad(m_baseURL + "theme_color_test.html", true, &client);
     EXPECT_TRUE(client.didNotify());
     WebLocalFrameImpl* frame = webViewHelper.webView()->mainFrameImpl();
     EXPECT_EQ(0xff0000ff, frame->document().themeColor());
     // Change color by rgb.
     client.reset();
     frame->executeScript(WebScriptSource("document.getElementById('tc1').setAttribute('content', 'rgb(0, 0, 0)');"));
     EXPECT_TRUE(client.didNotify());
     EXPECT_EQ(0xff000000, frame->document().themeColor());
@@ skipping 812 matching lines @@
     bool failed() { return m_failed; }
 
     bool m_failed;
 };
 
 // FIXME: This would be better as a unittest on DocumentThreadableLoader but it
 // requires spin-up of a frame. It may be possible to remove that requirement
 // and convert it to a unittest.
 TEST_P(ParameterizedWebFrameTest, LoaderOriginAccess)
 {
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad("about:blank");
 
     SchemeRegistry::registerURLSchemeAsDisplayIsolated("chrome");
 
     // Cross-origin request.
     KURL resourceUrl(ParsedURLString, "chrome://test.pdf");
     ResourceRequest request(resourceUrl);
     request.setRequestContext(WebURLRequest::RequestContextObject);
     registerMockedChromeURLLoad("test.pdf");
 
@@ skipping 38 matching lines @@
     }
 
     Vector<WebConsoleMessage> messages;
 };
 
 TEST_P(ParameterizedWebFrameTest, CrossDomainAccessErrorsUseCallingWindow)
 {
     registerMockedHttpURLLoad("hidden_frames.html");
     registerMockedChromeURLLoad("hello_world.html");
 
-    FrameTestHelpers::WebViewHelper webViewHelper(this);
+    FrameTestHelpers::WebViewHelper webViewHelper;
     TestConsoleMessageWebFrameClient webFrameClient;
     FrameTestHelpers::TestWebViewClient webViewClient;
     webViewHelper.initializeAndLoad(m_baseURL + "hidden_frames.html", true, &webFrameClient, &webViewClient);
 
     // Create another window with a cross-origin page, and point its opener to
     // first window.
-    FrameTestHelpers::WebViewHelper popupWebViewHelper(this);
+    FrameTestHelpers::WebViewHelper popupWebViewHelper;
     TestConsoleMessageWebFrameClient popupWebFrameClient;
     WebView* popupView = popupWebViewHelper.initializeAndLoad(m_chromeURL + "hello_world.html", true, &popupWebFrameClient);
     popupView->mainFrame()->setOpener(webViewHelper.webView()->mainFrame());
 
     // Attempt a blocked navigation of an opener's subframe, and ensure that
     // the error shows up on the popup (calling) window's console, rather than
     // the target window.
     popupView->mainFrame()->executeScript(WebScriptSource("opener.frames[1].location.href='data:text/html,foo'"));
     EXPECT_TRUE(webFrameClient.messages.isEmpty());
     ASSERT_EQ(1u, popupWebFrameClient.messages.size());
     EXPECT_TRUE(std::string::npos != popupWebFrameClient.messages[0].text.utf8().find("Unsafe JavaScript attempt to initiate navigation"));
 
     // Try setting a cross-origin iframe element's source to a javascript: URL,
     // and check that this error is also printed on the calling window.
     popupView->mainFrame()->executeScript(WebScriptSource("opener.document.querySelectorAll('iframe')[1].src='javascript:alert()'"));
     EXPECT_TRUE(webFrameClient.messages.isEmpty());
     ASSERT_EQ(2u, popupWebFrameClient.messages.size());
     EXPECT_TRUE(std::string::npos != popupWebFrameClient.messages[1].text.utf8().find("Blocked a frame"));
 
     // Manually reset to break WebViewHelpers' dependencies on the stack
     // allocated WebFrameClients.
     webViewHelper.reset();
     popupWebViewHelper.reset();
 }
 
 class DeviceEmulationTest : public ParameterizedWebFrameTest {
 protected:
     DeviceEmulationTest()
-        : m_webViewHelper(this)
     {
         registerMockedHttpURLLoad("device_emulation.html");
         m_client.m_screenInfo.deviceScaleFactor = 1;
         m_webViewHelper.initializeAndLoad(m_baseURL + "device_emulation.html", true, 0, &m_client);
     }
 
     void testResize(const WebSize size, const String& expectedSize)
     {
         m_client.m_screenInfo.rect = WebRect(0, 0, size.width, size.height);
         m_client.m_screenInfo.availableRect = m_client.m_screenInfo.rect;
         m_webViewHelper.resize(size);
         EXPECT_EQ(expectedSize, dumpSize("test"));
     }
 
     String dumpSize(const String& id)
     {
         String code = "dumpSize('" + id + "')";
         v8::HandleScope scope(v8::Isolate::GetCurrent());
         ScriptExecutionCallbackHelper callbackHelper(m_webViewHelper.webView()->mainFrame()->mainWorldScriptContext());
         m_webViewHelper.webView()->mainFrameImpl()->requestExecuteScriptAndReturnValue(WebScriptSource(WebString(code)), false, &callbackHelper);
         runPendingTasks();
         EXPECT_TRUE(callbackHelper.didComplete());
         return callbackHelper.stringValue();
     }
 
     FixedLayoutTestWebViewClient m_client;
     FrameTestHelpers::WebViewHelper m_webViewHelper;
 };
 
-INSTANTIATE_TEST_CASE_P(All, DeviceEmulationTest, ::testing::Values(
-    FrameTestHelpers::DefaultSettingOverride,
-    FrameTestHelpers::RootLayerScrollsSettingOverride));
+INSTANTIATE_TEST_CASE_P(All, DeviceEmulationTest, ::testing::Bool());
 
 TEST_P(DeviceEmulationTest, DeviceSizeInvalidatedOnResize)
 {
     WebDeviceEmulationParams params;
     params.screenPosition = WebDeviceEmulationParams::Mobile;
     m_webViewHelper.webView()->enableDeviceEmulation(params);
 
     testResize(WebSize(700, 500), "300x300");
     testResize(WebSize(710, 500), "400x300");
     testResize(WebSize(690, 500), "200x300");
@@ skipping 907 matching lines @@
     client.addExpectedRequest(toKURL("http://internal.test/priorities/injected.js"), WebURLRequest::PriorityLow);
     client.addExpectedRequest(toKURL("http://internal.test/priorities/injected-async.js"), WebURLRequest::PriorityLow);
     client.addExpectedRequest(toKURL("http://internal.test/priorities/body.js"), WebURLRequest::PriorityHigh);
 
     FrameTestHelpers::WebViewHelper helper;
     helper.initializeAndLoad(m_baseURL + "script_priority.html", true, &client);
     client.verifyAllRequests();
 }
 
 } // namespace blink