WebFrameTest: rename Parametrized -> Parameterized.

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 224 matching lines @@
         ASSERT(frame);
         Element* element = frame->document()->getElementById(testcase.c_str());
         return frame->nodeImage(*element);
     }
 
     std::string m_baseURL;
     std::string m_notBaseURL;
     std::string m_chromeURL;
 };
 
-enum ParametrizedWebFrameTestConfig {
+enum ParameterizedWebFrameTestConfig {
     Default,
     RootLayerScrolls
 };
 
-class ParametrizedWebFrameTest
+class ParameterizedWebFrameTest
     : public WebFrameTest
-    , public ::testing::WithParamInterface<ParametrizedWebFrameTestConfig>
+    , public ::testing::WithParamInterface<ParameterizedWebFrameTestConfig>
     , public FrameTestHelpers::SettingOverrider {
 public:
 
     virtual void overrideSettings(WebSettings* settings)
     {
         switch (GetParam()) {
         case Default:
             break;
         case RootLayerScrolls:
             settings->setRootLayerScrolls(true);
             break;
         }
     }
 };
 
 // Friendly string for gtest failure messages.
-void PrintTo(ParametrizedWebFrameTestConfig config, ::std::ostream* os)
+void PrintTo(ParameterizedWebFrameTestConfig config, ::std::ostream* os)
 {
     switch (config) {
     case Default:
         *os << "Default";
         break;
     case RootLayerScrolls:
         *os << "RootLayerScrolls";
         break;
     }
 }
 
-INSTANTIATE_TEST_CASE_P(All, ParametrizedWebFrameTest, ::testing::Values(
-    ParametrizedWebFrameTestConfig::Default,
-    ParametrizedWebFrameTestConfig::RootLayerScrolls));
+INSTANTIATE_TEST_CASE_P(All, ParameterizedWebFrameTest, ::testing::Values(
+    ParameterizedWebFrameTestConfig::Default,
+    ParameterizedWebFrameTestConfig::RootLayerScrolls));
 
-TEST_P(ParametrizedWebFrameTest, ContentText)
+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);
     webViewHelper.initializeAndLoad(m_baseURL + "iframes_test.html");
 
     // Now retrieve the frames text and test it only includes visible elements.
     std::string content = webViewHelper.webView()->mainFrame()->contentAsText(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(ParametrizedWebFrameTest, FrameForEnteredContext)
+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);
     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()));
 }
 
-TEST_P(ParametrizedWebFrameTest, FormWithNullFrame)
+TEST_P(ParameterizedWebFrameTest, FormWithNullFrame)
 {
     registerMockedHttpURLLoad("form.html");
 
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     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(ParametrizedWebFrameTest, ChromePageJavascript)
+TEST_P(ParameterizedWebFrameTest, ChromePageJavascript)
 {
     registerMockedChromeURLLoad("history.html");
 
     // Pass true to enable JavaScript.
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     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'))");
 
     // Required to see any updates in contentAsText.
     webViewHelper.webView()->layout();
 
     // Now retrieve the frame's text and ensure it was modified by running javascript.
     std::string content = webViewHelper.webView()->mainFrame()->contentAsText(1024).utf8();
     EXPECT_NE(std::string::npos, content.find("Clobbered"));
 }
 
-TEST_P(ParametrizedWebFrameTest, ChromePageNoJavascript)
+TEST_P(ParameterizedWebFrameTest, ChromePageNoJavascript)
 {
     registerMockedChromeURLLoad("history.html");
 
     /// Pass true to enable JavaScript.
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     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'))");
 
     // Required to see any updates in contentAsText.
     webViewHelper.webView()->layout();
 
     // Now retrieve the frame's text and ensure it wasn't modified by running javascript.
     std::string content = webViewHelper.webView()->mainFrame()->contentAsText(1024).utf8();
     EXPECT_EQ(std::string::npos, content.find("Clobbered"));
 }
 
-TEST_P(ParametrizedWebFrameTest, LocationSetHostWithMissingPort)
+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);
 
     /// 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 = webViewHelper.webView()->mainFrame()->contentAsText(1024).utf8();
     EXPECT_EQ("http://internal.test:0/" + fileName, content);
 }
 
-TEST_P(ParametrizedWebFrameTest, LocationSetEmptyPort)
+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);
 
     /// Pass true to enable JavaScript.
     webViewHelper.initializeAndLoad(m_baseURL + fileName, true);
 
@@ skipping 16 matching lines @@
         m_executing = true;
         v8::HandleScope handleScope(v8::Isolate::GetCurrent());
         frame->executeScriptAndReturnValue(WebScriptSource(WebString("window.someProperty = 42;")));
         m_executing = false;
     }
 
     bool m_executing;
     bool m_wasExecuted;
 };
 
-TEST_P(ParametrizedWebFrameTest, DidClearWindowObjectIsNotRecursive)
+TEST_P(ParameterizedWebFrameTest, DidClearWindowObjectIsNotRecursive)
 {
     EvaluateOnLoadWebFrameClient webFrameClient;
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     webViewHelper.initializeAndLoad("about:blank", true, &webFrameClient);
     EXPECT_TRUE(webFrameClient.m_wasExecuted);
 }
 
 class CSSCallbackWebFrameClient : public FrameTestHelpers::TestWebFrameClient {
 public:
     CSSCallbackWebFrameClient() : m_updateCount(0) { }
@@ skipping 254 matching lines @@
     selectors.push_back(WebString::fromUTF8("p span")); // Not compound.
     doc().watchCSSSelectors(WebVector<WebString>(selectors));
     m_frame->view()->layout();
     runPendingTasks();
 
     EXPECT_EQ(1, updateCount());
     EXPECT_THAT(matchedSelectors(), ElementsAre("span"))
         << "An invalid selector shouldn't prevent other selectors from matching.";
 }
 
-TEST_P(ParametrizedWebFrameTest, DispatchMessageEventWithOriginCheck)
+TEST_P(ParameterizedWebFrameTest, DispatchMessageEventWithOriginCheck)
 {
     registerMockedHttpURLLoad("postmessage_test.html");
 
     // Pass true to enable JavaScript.
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     webViewHelper.initializeAndLoad(m_baseURL + "postmessage_test.html", true);
 
     // Send a message with the correct origin.
     WebSecurityOrigin correctOrigin(WebSecurityOrigin::create(toKURL(m_baseURL)));
     WebDOMEvent event = webViewHelper.webView()->mainFrame()->document().createEvent("MessageEvent");
     WebDOMMessageEvent message = event.to<WebDOMMessageEvent>();
     WebSerializedScriptValue data(WebSerializedScriptValue::fromString("foo"));
     message.initMessageEvent("message", false, false, data, "http://origin.com", 0, "");
     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);
 
     // Required to see any updates in contentAsText.
     webViewHelper.webView()->layout();
 
     // Verify that only the first addition is in the body of the page.
     std::string content = webViewHelper.webView()->mainFrame()->contentAsText(1024).utf8();
     EXPECT_NE(std::string::npos, content.find("Message 1."));
     EXPECT_EQ(std::string::npos, content.find("Message 2."));
 }
 
-TEST_P(ParametrizedWebFrameTest, PostMessageThenDetach)
+TEST_P(ParameterizedWebFrameTest, PostMessageThenDetach)
 {
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     webViewHelper.initializeAndLoad("about:blank");
 
     RefPtrWillBeRawPtr<LocalFrame> frame = toLocalFrame(webViewHelper.webViewImpl()->page()->mainFrame());
     NonThrowableExceptionState exceptionState;
     frame->domWindow()->postMessage(SerializedScriptValueFactory::instance().create("message"), 0, "*", frame->localDOMWindow(), exceptionState);
     webViewHelper.reset();
     EXPECT_FALSE(exceptionState.hadException());
 
@@ skipping 41 matching lines @@
     bool multiplierChecked = false;
     for (LayoutObject* layoutObject = document->layoutView(); layoutObject; layoutObject = layoutObject->nextInPreOrder()) {
         if (layoutObject->style() && layoutObject->isText()) {
             EXPECT_EQ(multiplier, layoutObject->style()->textAutosizingMultiplier());
             multiplierChecked = true;
         }
     }
     return multiplierChecked;
 }
 
-TEST_P(ParametrizedWebFrameTest, ChangeInFixedLayoutResetsTextAutosizingMultipliers)
+TEST_P(ParameterizedWebFrameTest, ChangeInFixedLayoutResetsTextAutosizingMultipliers)
 {
     UseMockScrollbarSettings mockScrollbarSettings;
     registerMockedHttpURLLoad("fixed_layout.html");
 
     FixedLayoutTestWebViewClient client;
     int viewportWidth = 640;
     int viewportHeight = 480;
 
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     webViewHelper.initializeAndLoad(m_baseURL + "fixed_layout.html", true, 0, &client, enableViewportSettings);
 
     Document* document = toLocalFrame(webViewHelper.webViewImpl()->page()->mainFrame())->document();
     document->settings()->setTextAutosizingEnabled(true);
     EXPECT_TRUE(document->settings()->textAutosizingEnabled());
     webViewHelper.webViewImpl()->resize(WebSize(viewportWidth, viewportHeight));
     webViewHelper.webViewImpl()->layout();
 
     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.webViewImpl()->updatePageDefinedViewportConstraints(description);
 
     EXPECT_TRUE(checkTextAutosizingMultiplier(document, 1));
 }
 
-TEST_P(ParametrizedWebFrameTest, WorkingTextAutosizingMultipliers_VirtualViewport)
+TEST_P(ParameterizedWebFrameTest, WorkingTextAutosizingMultipliers_VirtualViewport)
 {
     UseMockScrollbarSettings mockScrollbarSettings;
     const std::string htmlFile = "fixed_layout.html";
     registerMockedHttpURLLoad(htmlFile);
 
     FixedLayoutTestWebViewClient client;
 
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     webViewHelper.initializeAndLoad(m_baseURL + htmlFile, true, 0, &client, configureAndroid);
 
     Document* document = toLocalFrame(webViewHelper.webViewImpl()->page()->mainFrame())->document();
     document->settings()->setTextAutosizingEnabled(true);
     EXPECT_TRUE(document->settings()->textAutosizingEnabled());
 
     webViewHelper.webView()->resize(WebSize(490, 800));
 
     // Multiplier: 980 / 490 = 2.0
     EXPECT_TRUE(checkTextAutosizingMultiplier(document, 2.0));
 }
 
-TEST_P(ParametrizedWebFrameTest, PinchViewportSetSizeInvalidatesTextAutosizingMultipliers)
+TEST_P(ParameterizedWebFrameTest, PinchViewportSetSizeInvalidatesTextAutosizingMultipliers)
 {
     UseMockScrollbarSettings mockScrollbarSettings;
     registerMockedHttpURLLoad("iframe_reload.html");
     registerMockedHttpURLLoad("visible_iframe.html");
 
     FixedLayoutTestWebViewClient client;
     int viewportWidth = 640;
     int viewportHeight = 480;
 
     FrameTestHelpers::WebViewHelper webViewHelper(this);
@@ skipping 22 matching lines @@
     for (Frame* frame = mainFrame; frame; frame = frame->tree().traverseNext()) {
         if (!frame->isLocalFrame())
             continue;
         for (LayoutObject* layoutObject = toLocalFrame(frame)->document()->layoutView(); layoutObject; layoutObject = layoutObject->nextInPreOrder()) {
             if (layoutObject->isText())
                 EXPECT_TRUE(layoutObject->needsLayout());
         }
     }
 }
 
-TEST_P(ParametrizedWebFrameTest, ZeroHeightPositiveWidthNotIgnored)
+TEST_P(ParameterizedWebFrameTest, ZeroHeightPositiveWidthNotIgnored)
 {
     UseMockScrollbarSettings mockScrollbarSettings;
 
     FixedLayoutTestWebViewClient client;
     client.m_screenInfo.deviceScaleFactor = 1;
     int viewportWidth = 1280;
     int viewportHeight = 0;
 
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     webViewHelper.initialize(true, 0, &client, enableViewportSettings);
     webViewHelper.webView()->resize(WebSize(viewportWidth, viewportHeight));
 
     EXPECT_EQ(viewportWidth, webViewHelper.webViewImpl()->mainFrameImpl()->frameView()->layoutSize().width());
     EXPECT_EQ(viewportHeight, webViewHelper.webViewImpl()->mainFrameImpl()->frameView()->layoutSize().height());
 }
 
-TEST_P(ParametrizedWebFrameTest, DeviceScaleFactorUsesDefaultWithoutViewportTag)
+TEST_P(ParameterizedWebFrameTest, DeviceScaleFactorUsesDefaultWithoutViewportTag)
 {
     UseMockScrollbarSettings mockScrollbarSettings;
     registerMockedHttpURLLoad("no_viewport_tag.html");
 
     int viewportWidth = 640;
     int viewportHeight = 480;
 
     FixedLayoutTestWebViewClient client;
     client.m_screenInfo.deviceScaleFactor = 2;
 
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     webViewHelper.initializeAndLoad(m_baseURL + "no_viewport_tag.html", true, 0, &client, enableViewportSettings);
 
     webViewHelper.webView()->resize(WebSize(viewportWidth, viewportHeight));
     webViewHelper.webView()->layout();
 
     EXPECT_EQ(2, webViewHelper.webView()->deviceScaleFactor());
 
     // Device scale factor should be independent of page scale.
     webViewHelper.webView()->setDefaultPageScaleLimits(1, 2);
     webViewHelper.webView()->setPageScaleFactor(0.5);
     webViewHelper.webView()->layout();
     EXPECT_EQ(1, webViewHelper.webView()->pageScaleFactor());
 
     // Force the layout to happen before leaving the test.
     webViewHelper.webView()->mainFrame()->contentAsText(1024).utf8();
 }
 
-TEST_P(ParametrizedWebFrameTest, FixedLayoutInitializeAtMinimumScale)
+TEST_P(ParameterizedWebFrameTest, FixedLayoutInitializeAtMinimumScale)
 {
     UseMockScrollbarSettings mockScrollbarSettings;
 
     registerMockedHttpURLLoad("fixed_layout.html");
 
     FixedLayoutTestWebViewClient client;
     client.m_screenInfo.deviceScaleFactor = 1;
     int viewportWidth = 640;
     int viewportHeight = 480;
 
@@ skipping 18 matching lines @@
     // Make sure we don't reset to initial scale if the page continues to load.
     webViewHelper.webViewImpl()->didCommitLoad(false, false);
     webViewHelper.webViewImpl()->didChangeContentsSize();
     EXPECT_EQ(userPinchPageScaleFactor, webViewHelper.webView()->pageScaleFactor());
 
     // Make sure we don't reset to initial scale if the viewport size changes.
     webViewHelper.webView()->resize(WebSize(viewportWidth, viewportHeight + 100));
     EXPECT_EQ(userPinchPageScaleFactor, webViewHelper.webView()->pageScaleFactor());
 }
 
-TEST_P(ParametrizedWebFrameTest, WideDocumentInitializeAtMinimumScale)
+TEST_P(ParameterizedWebFrameTest, WideDocumentInitializeAtMinimumScale)
 {
     UseMockScrollbarSettings mockScrollbarSettings;
 
     registerMockedHttpURLLoad("wide_document.html");
 
     FixedLayoutTestWebViewClient client;
     client.m_screenInfo.deviceScaleFactor = 1;
     int viewportWidth = 640;
     int viewportHeight = 480;
 
@@ skipping 18 matching lines @@
     // Make sure we don't reset to initial scale if the page continues to load.
     webViewHelper.webViewImpl()->didCommitLoad(false, false);
     webViewHelper.webViewImpl()->didChangeContentsSize();
     EXPECT_EQ(userPinchPageScaleFactor, webViewHelper.webView()->pageScaleFactor());
 
     // Make sure we don't reset to initial scale if the viewport size changes.
     webViewHelper.webView()->resize(WebSize(viewportWidth, viewportHeight + 100));
     EXPECT_EQ(userPinchPageScaleFactor, webViewHelper.webView()->pageScaleFactor());
 }
 
-TEST_P(ParametrizedWebFrameTest, DelayedViewportInitialScale)
+TEST_P(ParameterizedWebFrameTest, DelayedViewportInitialScale)
 {
     UseMockScrollbarSettings mockScrollbarSettings;
     registerMockedHttpURLLoad("viewport-auto-initial-scale.html");
 
     FixedLayoutTestWebViewClient client;
     client.m_screenInfo.deviceScaleFactor = 1;
     int viewportWidth = 640;
     int viewportHeight = 480;
 
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     webViewHelper.initializeAndLoad(m_baseURL + "viewport-auto-initial-scale.html", true, 0, &client, enableViewportSettings);
     webViewHelper.webView()->resize(WebSize(viewportWidth, viewportHeight));
 
     EXPECT_EQ(0.25f, webViewHelper.webView()->pageScaleFactor());
 
     Document* document = toLocalFrame(webViewHelper.webViewImpl()->page()->mainFrame())->document();
     ViewportDescription description = document->viewportDescription();
     description.zoom = 2;
     document->setViewportDescription(description);
     webViewHelper.webView()->layout();
     EXPECT_EQ(2, webViewHelper.webView()->pageScaleFactor());
 }
 
-TEST_P(ParametrizedWebFrameTest, setLoadWithOverviewModeToFalse)
+TEST_P(ParameterizedWebFrameTest, setLoadWithOverviewModeToFalse)
 {
     UseMockScrollbarSettings mockScrollbarSettings;
     registerMockedHttpURLLoad("viewport-auto-initial-scale.html");
 
     FixedLayoutTestWebViewClient client;
     client.m_screenInfo.deviceScaleFactor = 1;
     int viewportWidth = 640;
     int viewportHeight = 480;
 
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     webViewHelper.initializeAndLoad(m_baseURL + "viewport-auto-initial-scale.html", true, 0, &client, enableViewportSettings);
     webViewHelper.webView()->settings()->setWideViewportQuirkEnabled(true);
     webViewHelper.webView()->settings()->setLoadWithOverviewMode(false);
     webViewHelper.webView()->resize(WebSize(viewportWidth, viewportHeight));
 
     // The page must be displayed at 100% zoom.
     EXPECT_EQ(1.0f, webViewHelper.webView()->pageScaleFactor());
 }
 
-TEST_P(ParametrizedWebFrameTest, SetLoadWithOverviewModeToFalseAndNoWideViewport)
+TEST_P(ParameterizedWebFrameTest, SetLoadWithOverviewModeToFalseAndNoWideViewport)
 {
     UseMockScrollbarSettings mockScrollbarSettings;
     registerMockedHttpURLLoad("large-div.html");
 
     FixedLayoutTestWebViewClient client;
     client.m_screenInfo.deviceScaleFactor = 1;
     int viewportWidth = 640;
     int viewportHeight = 480;
 
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     webViewHelper.initializeAndLoad(m_baseURL + "large-div.html", true, 0, &client, enableViewportSettings);
     webViewHelper.webView()->settings()->setLoadWithOverviewMode(false);
     webViewHelper.webView()->settings()->setWideViewportQuirkEnabled(true);
     webViewHelper.webView()->settings()->setUseWideViewport(false);
     webViewHelper.webView()->resize(WebSize(viewportWidth, viewportHeight));
 
     // The page must be displayed at 100% zoom, despite that it hosts a wide div element.
     EXPECT_EQ(1.0f, webViewHelper.webView()->pageScaleFactor());
 }
 
-TEST_P(ParametrizedWebFrameTest, NoWideViewportIgnoresPageViewportWidth)
+TEST_P(ParameterizedWebFrameTest, NoWideViewportIgnoresPageViewportWidth)
 {
     UseMockScrollbarSettings mockScrollbarSettings;
     registerMockedHttpURLLoad("viewport-auto-initial-scale.html");
 
     FixedLayoutTestWebViewClient client;
     client.m_screenInfo.deviceScaleFactor = 1;
     int viewportWidth = 640;
     int viewportHeight = 480;
 
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     webViewHelper.initializeAndLoad(m_baseURL + "viewport-auto-initial-scale.html", true, 0, &client, enableViewportSettings);
     webViewHelper.webView()->settings()->setWideViewportQuirkEnabled(true);
     webViewHelper.webView()->settings()->setUseWideViewport(false);
     webViewHelper.webView()->resize(WebSize(viewportWidth, viewportHeight));
 
     // The page sets viewport width to 3000, but with UseWideViewport == false is must be ignored.
     EXPECT_EQ(viewportWidth, webViewHelper.webViewImpl()->mainFrameImpl()->frameView()->contentsSize().width());
     EXPECT_EQ(viewportHeight, webViewHelper.webViewImpl()->mainFrameImpl()->frameView()->contentsSize().height());
 }
 
-TEST_P(ParametrizedWebFrameTest, NoWideViewportIgnoresPageViewportWidthButAccountsScale)
+TEST_P(ParameterizedWebFrameTest, NoWideViewportIgnoresPageViewportWidthButAccountsScale)
 {
     UseMockScrollbarSettings mockScrollbarSettings;
     registerMockedHttpURLLoad("viewport-wide-2x-initial-scale.html");
 
     FixedLayoutTestWebViewClient client;
     client.m_screenInfo.deviceScaleFactor = 1;
     int viewportWidth = 640;
     int viewportHeight = 480;
 
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     webViewHelper.initializeAndLoad(m_baseURL + "viewport-wide-2x-initial-scale.html", true, 0, &client, enableViewportSettings);
     webViewHelper.webView()->settings()->setWideViewportQuirkEnabled(true);
     webViewHelper.webView()->settings()->setUseWideViewport(false);
     webViewHelper.webView()->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.webViewImpl()->mainFrameImpl()->frameView()->contentsSize().width());
     EXPECT_EQ(viewportHeight / 2, webViewHelper.webViewImpl()->mainFrameImpl()->frameView()->contentsSize().height());
 }
 
-TEST_P(ParametrizedWebFrameTest, WideViewportSetsTo980WithoutViewportTag)
+TEST_P(ParameterizedWebFrameTest, WideViewportSetsTo980WithoutViewportTag)
 {
     UseMockScrollbarSettings mockScrollbarSettings;
     registerMockedHttpURLLoad("no_viewport_tag.html");
 
     FixedLayoutTestWebViewClient client;
     client.m_screenInfo.deviceScaleFactor = 1;
     int viewportWidth = 640;
     int viewportHeight = 480;
 
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     webViewHelper.initializeAndLoad(m_baseURL + "no_viewport_tag.html", true, 0, &client, enableViewportSettings);
     applyViewportStyleOverride(&webViewHelper);
     webViewHelper.webView()->settings()->setWideViewportQuirkEnabled(true);
     webViewHelper.webView()->settings()->setUseWideViewport(true);
     webViewHelper.webView()->resize(WebSize(viewportWidth, viewportHeight));
 
     EXPECT_EQ(980, webViewHelper.webViewImpl()->mainFrameImpl()->frameView()->contentsSize().width());
     EXPECT_EQ(980.0 / viewportWidth * viewportHeight, webViewHelper.webViewImpl()->mainFrameImpl()->frameView()->contentsSize().height());
 }
 
-TEST_P(ParametrizedWebFrameTest, WideViewportSetsTo980WithXhtmlMp)
+TEST_P(ParameterizedWebFrameTest, WideViewportSetsTo980WithXhtmlMp)
 {
     UseMockScrollbarSettings mockScrollbarSettings;
     registerMockedHttpURLLoad("viewport/viewport-legacy-xhtmlmp.html");
 
     FixedLayoutTestWebViewClient client;
     client.m_screenInfo.deviceScaleFactor = 1;
     int viewportWidth = 640;
     int viewportHeight = 480;
 
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     webViewHelper.initialize(true, 0, &client, 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.webView()->resize(WebSize(viewportWidth, viewportHeight));
     EXPECT_EQ(viewportWidth, webViewHelper.webViewImpl()->mainFrameImpl()->frameView()->contentsSize().width());
     EXPECT_EQ(viewportHeight, webViewHelper.webViewImpl()->mainFrameImpl()->frameView()->contentsSize().height());
 }
 
-TEST_P(ParametrizedWebFrameTest, NoWideViewportAndHeightInMeta)
+TEST_P(ParameterizedWebFrameTest, NoWideViewportAndHeightInMeta)
 {
     UseMockScrollbarSettings mockScrollbarSettings;
     registerMockedHttpURLLoad("viewport-height-1000.html");
 
     FixedLayoutTestWebViewClient client;
     client.m_screenInfo.deviceScaleFactor = 1;
     int viewportWidth = 640;
     int viewportHeight = 480;
 
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     webViewHelper.initializeAndLoad(m_baseURL + "viewport-height-1000.html", true, 0, &client, enableViewportSettings);
     webViewHelper.webView()->settings()->setWideViewportQuirkEnabled(true);
     webViewHelper.webView()->settings()->setUseWideViewport(false);
     webViewHelper.webView()->resize(WebSize(viewportWidth, viewportHeight));
 
     EXPECT_EQ(viewportWidth, webViewHelper.webViewImpl()->mainFrameImpl()->frameView()->contentsSize().width());
 }
 
-TEST_P(ParametrizedWebFrameTest, WideViewportSetsTo980WithAutoWidth)
+TEST_P(ParameterizedWebFrameTest, WideViewportSetsTo980WithAutoWidth)
 {
     UseMockScrollbarSettings mockScrollbarSettings;
     registerMockedHttpURLLoad("viewport-2x-initial-scale.html");
 
     FixedLayoutTestWebViewClient client;
     client.m_screenInfo.deviceScaleFactor = 1;
     int viewportWidth = 640;
     int viewportHeight = 480;
 
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     webViewHelper.initializeAndLoad(m_baseURL + "viewport-2x-initial-scale.html", true, 0, &client, enableViewportSettings);
     applyViewportStyleOverride(&webViewHelper);
     webViewHelper.webView()->settings()->setWideViewportQuirkEnabled(true);
     webViewHelper.webView()->settings()->setUseWideViewport(true);
     webViewHelper.webView()->resize(WebSize(viewportWidth, viewportHeight));
 
     EXPECT_EQ(980, webViewHelper.webViewImpl()->mainFrameImpl()->frameView()->contentsSize().width());
     EXPECT_EQ(980.0 / viewportWidth * viewportHeight, webViewHelper.webViewImpl()->mainFrameImpl()->frameView()->contentsSize().height());
 }
 
-TEST_P(ParametrizedWebFrameTest, PageViewportInitialScaleOverridesLoadWithOverviewMode)
+TEST_P(ParameterizedWebFrameTest, PageViewportInitialScaleOverridesLoadWithOverviewMode)
 {
     UseMockScrollbarSettings mockScrollbarSettings;
     registerMockedHttpURLLoad("viewport-wide-2x-initial-scale.html");
 
     FixedLayoutTestWebViewClient client;
     client.m_screenInfo.deviceScaleFactor = 1;
     int viewportWidth = 640;
     int viewportHeight = 480;
 
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     webViewHelper.initializeAndLoad(m_baseURL + "viewport-wide-2x-initial-scale.html", true, 0, &client, enableViewportSettings);
     webViewHelper.webView()->settings()->setLoadWithOverviewMode(false);
     webViewHelper.webView()->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(ParametrizedWebFrameTest, setInitialPageScaleFactorPermanently)
+TEST_P(ParameterizedWebFrameTest, setInitialPageScaleFactorPermanently)
 {
     UseMockScrollbarSettings mockScrollbarSettings;
 
     registerMockedHttpURLLoad("fixed_layout.html");
 
     FixedLayoutTestWebViewClient client;
     client.m_screenInfo.deviceScaleFactor = 1;
     float enforcedPageScaleFactor = 2.0f;
 
     FrameTestHelpers::WebViewHelper webViewHelper(this);
@@ skipping 11 matching lines @@
     webViewHelper.webView()->resize(WebSize(viewportWidth, viewportHeight));
     webViewHelper.webView()->layout();
 
     EXPECT_EQ(enforcedPageScaleFactor, webViewHelper.webView()->pageScaleFactor());
 
     webViewHelper.webView()->setInitialPageScaleOverride(-1);
     webViewHelper.webView()->layout();
     EXPECT_EQ(1.0, webViewHelper.webView()->pageScaleFactor());
 }
 
-TEST_P(ParametrizedWebFrameTest, PermanentInitialPageScaleFactorOverridesLoadWithOverviewMode)
+TEST_P(ParameterizedWebFrameTest, PermanentInitialPageScaleFactorOverridesLoadWithOverviewMode)
 {
     UseMockScrollbarSettings mockScrollbarSettings;
     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);
     webViewHelper.initializeAndLoad(m_baseURL + "viewport-auto-initial-scale.html", true, 0, &client, enableViewportSettings);
     webViewHelper.webView()->settings()->setLoadWithOverviewMode(false);
     webViewHelper.webView()->setInitialPageScaleOverride(enforcedPageScaleFactor);
     webViewHelper.webView()->resize(WebSize(viewportWidth, viewportHeight));
 
     EXPECT_EQ(enforcedPageScaleFactor, webViewHelper.webView()->pageScaleFactor());
 }
 
-TEST_P(ParametrizedWebFrameTest, PermanentInitialPageScaleFactorOverridesPageViewportInitialScale)
+TEST_P(ParameterizedWebFrameTest, PermanentInitialPageScaleFactorOverridesPageViewportInitialScale)
 {
     UseMockScrollbarSettings mockScrollbarSettings;
     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);
     webViewHelper.initializeAndLoad(m_baseURL + "viewport-wide-2x-initial-scale.html", true, 0, &client, enableViewportSettings);
     webViewHelper.webView()->setInitialPageScaleOverride(enforcedPageScaleFactor);
     webViewHelper.webView()->resize(WebSize(viewportWidth, viewportHeight));
 
     EXPECT_EQ(enforcedPageScaleFactor, webViewHelper.webView()->pageScaleFactor());
 }
 
-TEST_P(ParametrizedWebFrameTest, SmallPermanentInitialPageScaleFactorIsClobbered)
+TEST_P(ParameterizedWebFrameTest, SmallPermanentInitialPageScaleFactorIsClobbered)
 {
     UseMockScrollbarSettings mockScrollbarSettings;
     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"
     };
@@ skipping 15 matching lines @@
             webViewHelper.webView()->settings()->setClobberUserAgentInitialScaleQuirk(quirkEnabled);
             webViewHelper.webView()->setInitialPageScaleOverride(enforcedPageScaleFactor);
             webViewHelper.webView()->resize(WebSize(viewportWidth, viewportHeight));
 
             float expectedPageScaleFactor = quirkEnabled && i < ARRAY_SIZE(pageScaleFactors) ? pageScaleFactors[i] : enforcedPageScaleFactor;
             EXPECT_EQ(expectedPageScaleFactor, webViewHelper.webView()->pageScaleFactor());
         }
     }
 }
 
-TEST_P(ParametrizedWebFrameTest, PermanentInitialPageScaleFactorAffectsLayoutWidth)
+TEST_P(ParameterizedWebFrameTest, PermanentInitialPageScaleFactorAffectsLayoutWidth)
 {
     UseMockScrollbarSettings mockScrollbarSettings;
 
     FixedLayoutTestWebViewClient client;
     client.m_screenInfo.deviceScaleFactor = 1;
     int viewportWidth = 640;
     int viewportHeight = 480;
     float enforcedPageScaleFactor = 0.5;
 
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     webViewHelper.initializeAndLoad("about:blank", true, 0, &client, enableViewportSettings);
     webViewHelper.webView()->settings()->setWideViewportQuirkEnabled(true);
     webViewHelper.webView()->settings()->setUseWideViewport(false);
     webViewHelper.webView()->settings()->setLoadWithOverviewMode(false);
     webViewHelper.webView()->setInitialPageScaleOverride(enforcedPageScaleFactor);
     webViewHelper.webView()->resize(WebSize(viewportWidth, viewportHeight));
 
     EXPECT_EQ(viewportWidth / enforcedPageScaleFactor, webViewHelper.webViewImpl()->mainFrameImpl()->frameView()->contentsSize().width());
     EXPECT_EQ(enforcedPageScaleFactor, webViewHelper.webView()->pageScaleFactor());
 }
 
-TEST_P(ParametrizedWebFrameTest, DocumentElementClientHeightWorksWithWrapContentMode)
+TEST_P(ParameterizedWebFrameTest, DocumentElementClientHeightWorksWithWrapContentMode)
 {
     UseMockScrollbarSettings mockScrollbarSettings;
     registerMockedHttpURLLoad("0-by-0.html");
 
     FixedLayoutTestWebViewClient client;
     client.m_screenInfo.deviceScaleFactor = 1;
     int viewportWidth = 640;
     int viewportHeight = 480;
 
     FrameTestHelpers::WebViewHelper webViewHelper(this);
 
     webViewHelper.initializeAndLoad(m_baseURL + "0-by-0.html", true, 0, &client, configureAndroid);
     webViewHelper.webView()->settings()->setForceZeroLayoutHeight(true);
     webViewHelper.webView()->resize(WebSize(viewportWidth, viewportHeight));
 
     LocalFrame* frame = webViewHelper.webViewImpl()->mainFrameImpl()->frame();
     Document* document = frame->document();
     EXPECT_EQ(viewportHeight, document->documentElement()->clientHeight());
     EXPECT_EQ(viewportWidth, document->documentElement()->clientWidth());
 }
 
-TEST_P(ParametrizedWebFrameTest, SetForceZeroLayoutHeightWorksWithWrapContentMode)
+TEST_P(ParameterizedWebFrameTest, SetForceZeroLayoutHeightWorksWithWrapContentMode)
 {
     UseMockScrollbarSettings mockScrollbarSettings;
     registerMockedHttpURLLoad("0-by-0.html");
 
     FixedLayoutTestWebViewClient client;
     client.m_screenInfo.deviceScaleFactor = 1;
     int viewportWidth = 640;
     int viewportHeight = 480;
 
     FrameTestHelpers::WebViewHelper webViewHelper(this);
@@ skipping 22 matching lines @@
     EXPECT_EQ(viewportWidth, compositor->containerLayer()->size().width());
     EXPECT_EQ(viewportHeight, compositor->containerLayer()->size().height());
 
     LocalFrame* frame = webViewHelper.webViewImpl()->mainFrameImpl()->frame();
     PinchViewport& pinchViewport = frame->page()->frameHost().pinchViewport();
     EXPECT_EQ(viewportHeight, pinchViewport.containerLayer()->size().height());
     EXPECT_TRUE(pinchViewport.containerLayer()->platformLayer()->masksToBounds());
     EXPECT_FALSE(compositor->containerLayer()->platformLayer()->masksToBounds());
 }
 
-TEST_P(ParametrizedWebFrameTest, SetForceZeroLayoutHeight)
+TEST_P(ParameterizedWebFrameTest, SetForceZeroLayoutHeight)
 {
     UseMockScrollbarSettings mockScrollbarSettings;
     registerMockedHttpURLLoad("200-by-300.html");
 
     FixedLayoutTestWebViewClient client;
     client.m_screenInfo.deviceScaleFactor = 1;
     int viewportWidth = 640;
     int viewportHeight = 480;
 
     FrameTestHelpers::WebViewHelper webViewHelper(this);
@@ skipping 56 matching lines @@
 
     ASSERT_NE(nullptr, element);
     EXPECT_EQ(String("oldValue"), element->innerText());
 
     PlatformGestureEvent gestureEvent(PlatformEvent::Type::GestureTap, hitPoint, hitPoint, IntSize(0, 0), 0, false, false, false, false);
     webViewHelper.webViewImpl()->mainFrameImpl()->frame()->eventHandler().handleGestureEvent(gestureEvent);
     // when pressed, the button changes its own text to "updatedValue"
     EXPECT_EQ(String("updatedValue"), element->innerText());
 }
 
-TEST_P(ParametrizedWebFrameTest, SetForceZeroLayoutHeightWorksAcrossNavigations)
+TEST_P(ParameterizedWebFrameTest, SetForceZeroLayoutHeightWorksAcrossNavigations)
 {
     UseMockScrollbarSettings mockScrollbarSettings;
     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);
 
     webViewHelper.initializeAndLoad(m_baseURL + "200-by-300.html", true, 0, &client, enableViewportSettings);
     webViewHelper.webView()->settings()->setForceZeroLayoutHeight(true);
     webViewHelper.webView()->resize(WebSize(viewportWidth, viewportHeight));
     webViewHelper.webView()->layout();
 
     FrameTestHelpers::loadFrame(webViewHelper.webView()->mainFrame(), m_baseURL + "large-div.html");
     webViewHelper.webView()->layout();
 
     EXPECT_EQ(0, webViewHelper.webViewImpl()->mainFrameImpl()->frameView()->layoutSize().height());
 }
 
-TEST_P(ParametrizedWebFrameTest, SetForceZeroLayoutHeightWithWideViewportQuirk)
+TEST_P(ParameterizedWebFrameTest, SetForceZeroLayoutHeightWithWideViewportQuirk)
 {
     UseMockScrollbarSettings mockScrollbarSettings;
     registerMockedHttpURLLoad("200-by-300.html");
 
     FixedLayoutTestWebViewClient client;
     client.m_screenInfo.deviceScaleFactor = 1;
     int viewportWidth = 640;
     int viewportHeight = 480;
 
     FrameTestHelpers::WebViewHelper webViewHelper(this);
 
     webViewHelper.initializeAndLoad(m_baseURL + "200-by-300.html", true, 0, &client, enableViewportSettings);
     webViewHelper.webView()->settings()->setWideViewportQuirkEnabled(true);
     webViewHelper.webView()->settings()->setUseWideViewport(true);
     webViewHelper.webView()->settings()->setForceZeroLayoutHeight(true);
     webViewHelper.webView()->resize(WebSize(viewportWidth, viewportHeight));
     webViewHelper.webView()->layout();
 
     EXPECT_EQ(0, webViewHelper.webViewImpl()->mainFrameImpl()->frameView()->layoutSize().height());
 }
 
-TEST_P(ParametrizedWebFrameTest, WideViewportAndWideContentWithInitialScale)
+TEST_P(ParameterizedWebFrameTest, WideViewportAndWideContentWithInitialScale)
 {
     UseMockScrollbarSettings mockScrollbarSettings;
     registerMockedHttpURLLoad("wide_document_width_viewport.html");
 
     FixedLayoutTestWebViewClient client;
     client.m_screenInfo.deviceScaleFactor = 1;
     int viewportWidth = 600;
     int viewportHeight = 800;
 
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     webViewHelper.initializeAndLoad("about:blank", true, 0, &client, enableViewportSettings);
     webViewHelper.webView()->settings()->setWideViewportQuirkEnabled(true);
     webViewHelper.webView()->settings()->setUseWideViewport(true);
     webViewHelper.webView()->settings()->setViewportMetaLayoutSizeQuirk(true);
     webViewHelper.webView()->resize(WebSize(viewportWidth, viewportHeight));
 
     FrameTestHelpers::loadFrame(webViewHelper.webView()->mainFrame(), m_baseURL + "wide_document_width_viewport.html");
     webViewHelper.webView()->resize(WebSize(viewportWidth, viewportHeight));
 
     int wideDocumentWidth = 800;
     float minimumPageScaleFactor = viewportWidth / (float) wideDocumentWidth;
     EXPECT_EQ(minimumPageScaleFactor, webViewHelper.webViewImpl()->pageScaleFactor());
     EXPECT_EQ(minimumPageScaleFactor, webViewHelper.webViewImpl()->minimumPageScaleFactor());
 }
 
-TEST_P(ParametrizedWebFrameTest, WideViewportQuirkClobbersHeight)
+TEST_P(ParameterizedWebFrameTest, WideViewportQuirkClobbersHeight)
 {
     UseMockScrollbarSettings mockScrollbarSettings;
     registerMockedHttpURLLoad("viewport-height-1000.html");
 
     FixedLayoutTestWebViewClient client;
     client.m_screenInfo.deviceScaleFactor = 1;
     int viewportWidth = 600;
     int viewportHeight = 800;
 
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     webViewHelper.initializeAndLoad("about:blank", true, 0, &client, enableViewportSettings);
     webViewHelper.webView()->settings()->setWideViewportQuirkEnabled(true);
     webViewHelper.webView()->settings()->setUseWideViewport(false);
     webViewHelper.webView()->settings()->setViewportMetaLayoutSizeQuirk(true);
     webViewHelper.webView()->resize(WebSize(viewportWidth, viewportHeight));
 
     FrameTestHelpers::loadFrame(webViewHelper.webView()->mainFrame(), m_baseURL + "viewport-height-1000.html");
     webViewHelper.webView()->resize(WebSize(viewportWidth, viewportHeight));
 
     EXPECT_EQ(800, webViewHelper.webViewImpl()->mainFrameImpl()->frameView()->layoutSize().height());
     EXPECT_EQ(1, webViewHelper.webView()->pageScaleFactor());
 }
 
-TEST_P(ParametrizedWebFrameTest, LayoutSize320Quirk)
+TEST_P(ParameterizedWebFrameTest, LayoutSize320Quirk)
 {
     UseMockScrollbarSettings mockScrollbarSettings;
     registerMockedHttpURLLoad("viewport/viewport-30.html");
 
     FixedLayoutTestWebViewClient client;
     client.m_screenInfo.deviceScaleFactor = 1;
     int viewportWidth = 600;
     int viewportHeight = 800;
 
     FrameTestHelpers::WebViewHelper webViewHelper(this);
@@ skipping 31 matching lines @@
     document->setViewportDescription(description);
     webViewHelper.webView()->layout();
     EXPECT_EQ(1000, webViewHelper.webViewImpl()->mainFrameImpl()->frameView()->layoutSize().height());
 
     description.maxHeight = Length(320, blink::Fixed);
     document->setViewportDescription(description);
     webViewHelper.webView()->layout();
     EXPECT_EQ(800, webViewHelper.webViewImpl()->mainFrameImpl()->frameView()->layoutSize().height());
 }
 
-TEST_P(ParametrizedWebFrameTest, ZeroValuesQuirk)
+TEST_P(ParameterizedWebFrameTest, ZeroValuesQuirk)
 {
     UseMockScrollbarSettings mockScrollbarSettings;
     registerMockedHttpURLLoad("viewport-zero-values.html");
 
     FixedLayoutTestWebViewClient client;
     client.m_screenInfo.deviceScaleFactor = 1;
     int viewportWidth = 640;
     int viewportHeight = 480;
 
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     webViewHelper.initialize(true, 0, &client, 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.webView()->resize(WebSize(viewportWidth, viewportHeight));
 
     EXPECT_EQ(viewportWidth, webViewHelper.webViewImpl()->mainFrameImpl()->frameView()->layoutSize().width());
     EXPECT_EQ(1.0f, webViewHelper.webView()->pageScaleFactor());
 
     webViewHelper.webView()->settings()->setUseWideViewport(true);
     webViewHelper.webView()->layout();
     EXPECT_EQ(viewportWidth, webViewHelper.webViewImpl()->mainFrameImpl()->frameView()->layoutSize().width());
     EXPECT_EQ(1.0f, webViewHelper.webView()->pageScaleFactor());
 }
 
-TEST_P(ParametrizedWebFrameTest, OverflowHiddenDisablesScrolling)
+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);
     webViewHelper.initialize(true, 0, &client);
     FrameTestHelpers::loadFrame(webViewHelper.webView()->mainFrame(), m_baseURL + "body-overflow-hidden.html");
     webViewHelper.webView()->resize(WebSize(viewportWidth, viewportHeight));
 
     FrameView* view = webViewHelper.webViewImpl()->mainFrameImpl()->frameView();
     EXPECT_FALSE(view->userInputScrollable(VerticalScrollbar));
     EXPECT_FALSE(view->userInputScrollable(HorizontalScrollbar));
 }
 
-TEST_P(ParametrizedWebFrameTest, OverflowHiddenDisablesScrollingWithSetCanHaveScrollbars)
+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);
     webViewHelper.initialize(true, 0, &client);
@@ skipping 21 matching lines @@
     FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initialize(true, 0, &client);
     webViewHelper.webView()->settings()->setIgnoreMainFrameOverflowHiddenQuirk(true);
     FrameTestHelpers::loadFrame(webViewHelper.webView()->mainFrame(), m_baseURL + "body-overflow-hidden.html");
     webViewHelper.webView()->resize(WebSize(viewportWidth, viewportHeight));
 
     FrameView* view = webViewHelper.webViewImpl()->mainFrameImpl()->frameView();
     EXPECT_TRUE(view->userInputScrollable(VerticalScrollbar));
 }
 
-TEST_P(ParametrizedWebFrameTest, NonZeroValuesNoQuirk)
+TEST_P(ParameterizedWebFrameTest, NonZeroValuesNoQuirk)
 {
     UseMockScrollbarSettings mockScrollbarSettings;
     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);
     webViewHelper.initialize(true, 0, &client, enableViewportSettings);
     webViewHelper.webView()->settings()->setViewportMetaZeroValuesQuirk(true);
     webViewHelper.webView()->settings()->setWideViewportQuirkEnabled(true);
     FrameTestHelpers::loadFrame(webViewHelper.webView()->mainFrame(), m_baseURL + "viewport-nonzero-values.html");
     webViewHelper.webView()->resize(WebSize(viewportWidth, viewportHeight));
 
     EXPECT_EQ(viewportWidth / expectedPageScaleFactor, webViewHelper.webViewImpl()->mainFrameImpl()->frameView()->layoutSize().width());
     EXPECT_EQ(expectedPageScaleFactor, webViewHelper.webView()->pageScaleFactor());
 
     webViewHelper.webView()->settings()->setUseWideViewport(true);
     webViewHelper.webView()->layout();
     EXPECT_EQ(viewportWidth / expectedPageScaleFactor, webViewHelper.webViewImpl()->mainFrameImpl()->frameView()->layoutSize().width());
     EXPECT_EQ(expectedPageScaleFactor, webViewHelper.webView()->pageScaleFactor());
 }
 
-TEST_P(ParametrizedWebFrameTest, setPageScaleFactorDoesNotLayout)
+TEST_P(ParameterizedWebFrameTest, setPageScaleFactorDoesNotLayout)
 {
     UseMockScrollbarSettings mockScrollbarSettings;
     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);
     webViewHelper.initializeAndLoad(m_baseURL + "fixed_layout.html", true, 0, &client, enableViewportSettings);
     webViewHelper.webView()->resize(WebSize(viewportWidth, viewportHeight));
     webViewHelper.webView()->layout();
 
     int prevLayoutCount = webViewHelper.webViewImpl()->mainFrameImpl()->frameView()->layoutCount();
     webViewHelper.webViewImpl()->setPageScaleFactor(3);
     EXPECT_FALSE(webViewHelper.webViewImpl()->mainFrameImpl()->frameView()->needsLayout());
     EXPECT_EQ(prevLayoutCount, webViewHelper.webViewImpl()->mainFrameImpl()->frameView()->layoutCount());
 }
 
-TEST_P(ParametrizedWebFrameTest, setPageScaleFactorWithOverlayScrollbarsDoesNotLayout)
+TEST_P(ParameterizedWebFrameTest, setPageScaleFactorWithOverlayScrollbarsDoesNotLayout)
 {
     UseMockScrollbarSettings mockScrollbarSettings;
 
     registerMockedHttpURLLoad("fixed_layout.html");
 
     FixedLayoutTestWebViewClient client;
     client.m_screenInfo.deviceScaleFactor = 1;
     int viewportWidth = 640;
     int viewportHeight = 480;
 
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     webViewHelper.initializeAndLoad(m_baseURL + "fixed_layout.html", true, 0, &client, enableViewportSettings);
     webViewHelper.webView()->resize(WebSize(viewportWidth, viewportHeight));
     webViewHelper.webView()->layout();
 
     int prevLayoutCount = webViewHelper.webViewImpl()->mainFrameImpl()->frameView()->layoutCount();
     webViewHelper.webViewImpl()->setPageScaleFactor(30);
     EXPECT_FALSE(webViewHelper.webViewImpl()->mainFrameImpl()->frameView()->needsLayout());
     EXPECT_EQ(prevLayoutCount, webViewHelper.webViewImpl()->mainFrameImpl()->frameView()->layoutCount());
 
 }
 
-TEST_P(ParametrizedWebFrameTest, pageScaleFactorWrittenToHistoryItem)
+TEST_P(ParameterizedWebFrameTest, pageScaleFactorWrittenToHistoryItem)
 {
     UseMockScrollbarSettings mockScrollbarSettings;
     registerMockedHttpURLLoad("fixed_layout.html");
 
     FixedLayoutTestWebViewClient client;
     client.m_screenInfo.deviceScaleFactor = 1;
     int viewportWidth = 640;
     int viewportHeight = 480;
 
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     webViewHelper.initializeAndLoad(m_baseURL + "fixed_layout.html", true, 0, &client, enableViewportSettings);
     webViewHelper.webView()->resize(WebSize(viewportWidth, viewportHeight));
     webViewHelper.webView()->layout();
 
     webViewHelper.webView()->setPageScaleFactor(3);
     EXPECT_EQ(3, toLocalFrame(webViewHelper.webViewImpl()->page()->mainFrame())->loader().currentItem()->pageScaleFactor());
 }
 
-TEST_P(ParametrizedWebFrameTest, initialScaleWrittenToHistoryItem)
+TEST_P(ParameterizedWebFrameTest, initialScaleWrittenToHistoryItem)
 {
     UseMockScrollbarSettings mockScrollbarSettings;
     registerMockedHttpURLLoad("fixed_layout.html");
 
     FixedLayoutTestWebViewClient client;
     client.m_screenInfo.deviceScaleFactor = 1;
     int viewportWidth = 640;
     int viewportHeight = 480;
 
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     webViewHelper.initialize(true, 0, &client, enableViewportSettings);
     webViewHelper.webView()->setDefaultPageScaleLimits(0.25f, 5);
     FrameTestHelpers::loadFrame(webViewHelper.webView()->mainFrame(), m_baseURL + "fixed_layout.html");
     webViewHelper.webView()->resize(WebSize(viewportWidth, viewportHeight));
     webViewHelper.webView()->layout();
 
     int defaultFixedLayoutWidth = 980;
     float minimumPageScaleFactor = viewportWidth / (float) defaultFixedLayoutWidth;
     EXPECT_EQ(minimumPageScaleFactor, toLocalFrame(webViewHelper.webViewImpl()->page()->mainFrame())->loader().currentItem()->pageScaleFactor());
 }
 
-TEST_P(ParametrizedWebFrameTest, pageScaleFactorDoesntShrinkFrameView)
+TEST_P(ParameterizedWebFrameTest, pageScaleFactorDoesntShrinkFrameView)
 {
     UseMockScrollbarSettings mockScrollbarSettings;
     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;
 
@@ skipping 20 matching lines @@
 
     IntSize unscaledSizeMinusScrollbar = view->visibleContentSize(ExcludeScrollbars);
     EXPECT_EQ(viewportWidthMinusScrollbar, unscaledSizeMinusScrollbar.width());
     EXPECT_EQ(viewportHeightMinusScrollbar, unscaledSizeMinusScrollbar.height());
 
     IntSize frameViewSize = view->visibleContentRect().size();
     EXPECT_EQ(viewportWidthMinusScrollbar, frameViewSize.width());
     EXPECT_EQ(viewportHeightMinusScrollbar, frameViewSize.height());
 }
 
-TEST_P(ParametrizedWebFrameTest, pageScaleFactorDoesNotApplyCssTransform)
+TEST_P(ParameterizedWebFrameTest, pageScaleFactorDoesNotApplyCssTransform)
 {
     UseMockScrollbarSettings mockScrollbarSettings;
     registerMockedHttpURLLoad("fixed_layout.html");
 
     FixedLayoutTestWebViewClient client;
     client.m_screenInfo.deviceScaleFactor = 1;
     int viewportWidth = 640;
     int viewportHeight = 480;
 
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     webViewHelper.initializeAndLoad(m_baseURL + "fixed_layout.html", true, 0, &client, enableViewportSettings);
     webViewHelper.webView()->resize(WebSize(viewportWidth, viewportHeight));
     webViewHelper.webView()->layout();
 
     webViewHelper.webView()->setPageScaleFactor(2);
 
     EXPECT_EQ(980, toLocalFrame(webViewHelper.webViewImpl()->page()->mainFrame())->contentLayoutObject()->unscaledDocumentRect().width());
     EXPECT_EQ(980, webViewHelper.webViewImpl()->mainFrameImpl()->frameView()->contentsSize().width());
 }
 
-TEST_P(ParametrizedWebFrameTest, targetDensityDpiHigh)
+TEST_P(ParameterizedWebFrameTest, targetDensityDpiHigh)
 {
     UseMockScrollbarSettings mockScrollbarSettings;
     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;
@@ skipping 11 matching lines @@
 
         // 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.webViewImpl()->mainFrameImpl()->frameView()->layoutSize().width(), 1.0f);
         EXPECT_NEAR(viewportHeight * densityDpiScaleRatio, webViewHelper.webViewImpl()->mainFrameImpl()->frameView()->layoutSize().height(), 1.0f);
         EXPECT_NEAR(1.0f / densityDpiScaleRatio, webViewHelper.webView()->pageScaleFactor(), 0.01f);
     }
 }
 
-TEST_P(ParametrizedWebFrameTest, targetDensityDpiDevice)
+TEST_P(ParameterizedWebFrameTest, targetDensityDpiDevice)
 {
     UseMockScrollbarSettings mockScrollbarSettings;
     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 < ARRAY_SIZE(deviceScaleFactors); ++i) {
         client.m_screenInfo.deviceScaleFactor = deviceScaleFactors[i];
 
         FrameTestHelpers::WebViewHelper webViewHelper(this);
         webViewHelper.initializeAndLoad(m_baseURL + "viewport-target-densitydpi-device.html", true, 0, &client, enableViewportSettings);
         webViewHelper.webView()->settings()->setWideViewportQuirkEnabled(true);
         webViewHelper.webView()->settings()->setSupportDeprecatedTargetDensityDPI(true);
         webViewHelper.webView()->resize(WebSize(viewportWidth, viewportHeight));
 
         EXPECT_NEAR(viewportWidth * client.m_screenInfo.deviceScaleFactor, webViewHelper.webViewImpl()->mainFrameImpl()->frameView()->layoutSize().width(), 1.0f);
         EXPECT_NEAR(viewportHeight * client.m_screenInfo.deviceScaleFactor, webViewHelper.webViewImpl()->mainFrameImpl()->frameView()->layoutSize().height(), 1.0f);
         EXPECT_NEAR(1.0f / client.m_screenInfo.deviceScaleFactor, webViewHelper.webView()->pageScaleFactor(), 0.01f);
     }
 }
 
-TEST_P(ParametrizedWebFrameTest, targetDensityDpiDeviceAndFixedWidth)
+TEST_P(ParameterizedWebFrameTest, targetDensityDpiDeviceAndFixedWidth)
 {
     UseMockScrollbarSettings mockScrollbarSettings;
     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 < ARRAY_SIZE(deviceScaleFactors); ++i) {
         client.m_screenInfo.deviceScaleFactor = deviceScaleFactors[i];
 
         FrameTestHelpers::WebViewHelper webViewHelper(this);
         webViewHelper.initializeAndLoad(m_baseURL + "viewport-target-densitydpi-device-and-fixed-width.html", true, 0, &client, enableViewportSettings);
         webViewHelper.webView()->settings()->setWideViewportQuirkEnabled(true);
         webViewHelper.webView()->settings()->setSupportDeprecatedTargetDensityDPI(true);
         webViewHelper.webView()->settings()->setUseWideViewport(true);
         webViewHelper.webView()->resize(WebSize(viewportWidth, viewportHeight));
 
         EXPECT_NEAR(viewportWidth, webViewHelper.webViewImpl()->mainFrameImpl()->frameView()->layoutSize().width(), 1.0f);
         EXPECT_NEAR(viewportHeight, webViewHelper.webViewImpl()->mainFrameImpl()->frameView()->layoutSize().height(), 1.0f);
         EXPECT_NEAR(1.0f, webViewHelper.webView()->pageScaleFactor(), 0.01f);
     }
 }
 
-TEST_P(ParametrizedWebFrameTest, NoWideViewportAndScaleLessThanOne)
+TEST_P(ParameterizedWebFrameTest, NoWideViewportAndScaleLessThanOne)
 {
     UseMockScrollbarSettings mockScrollbarSettings;
     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);
     webViewHelper.initializeAndLoad(m_baseURL + "viewport-initial-scale-less-than-1.html", true, 0, &client, enableViewportSettings);
     webViewHelper.webView()->settings()->setSupportDeprecatedTargetDensityDPI(true);
     webViewHelper.webView()->settings()->setWideViewportQuirkEnabled(true);
     webViewHelper.webView()->settings()->setUseWideViewport(false);
     webViewHelper.webView()->resize(WebSize(viewportWidth, viewportHeight));
     webViewHelper.webView()->layout();
 
     EXPECT_NEAR(viewportWidth * client.m_screenInfo.deviceScaleFactor, webViewHelper.webViewImpl()->mainFrameImpl()->frameView()->layoutSize().width(), 1.0f);
     EXPECT_NEAR(viewportHeight * client.m_screenInfo.deviceScaleFactor, webViewHelper.webViewImpl()->mainFrameImpl()->frameView()->layoutSize().height(), 1.0f);
     EXPECT_NEAR(1.0f / client.m_screenInfo.deviceScaleFactor, webViewHelper.webView()->pageScaleFactor(), 0.01f);
 }
 
-TEST_P(ParametrizedWebFrameTest, NoWideViewportAndScaleLessThanOneWithDeviceWidth)
+TEST_P(ParameterizedWebFrameTest, NoWideViewportAndScaleLessThanOneWithDeviceWidth)
 {
     UseMockScrollbarSettings mockScrollbarSettings;
     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);
     webViewHelper.initializeAndLoad(m_baseURL + "viewport-initial-scale-less-than-1-device-width.html", true, 0, &client, enableViewportSettings);
     webViewHelper.webView()->settings()->setSupportDeprecatedTargetDensityDPI(true);
     webViewHelper.webView()->settings()->setWideViewportQuirkEnabled(true);
     webViewHelper.webView()->settings()->setUseWideViewport(false);
     webViewHelper.webView()->resize(WebSize(viewportWidth, viewportHeight));
     webViewHelper.webView()->layout();
 
     const float pageZoom = 0.25f;
     EXPECT_NEAR(viewportWidth * client.m_screenInfo.deviceScaleFactor / pageZoom, webViewHelper.webViewImpl()->mainFrameImpl()->frameView()->layoutSize().width(), 1.0f);
     EXPECT_NEAR(viewportHeight * client.m_screenInfo.deviceScaleFactor / pageZoom, webViewHelper.webViewImpl()->mainFrameImpl()->frameView()->layoutSize().height(), 1.0f);
     EXPECT_NEAR(1.0f / client.m_screenInfo.deviceScaleFactor, webViewHelper.webView()->pageScaleFactor(), 0.01f);
 }
 
-TEST_P(ParametrizedWebFrameTest, NoWideViewportAndNoViewportWithInitialPageScaleOverride)
+TEST_P(ParameterizedWebFrameTest, NoWideViewportAndNoViewportWithInitialPageScaleOverride)
 {
     UseMockScrollbarSettings mockScrollbarSettings;
     registerMockedHttpURLLoad("large-div.html");
 
     FixedLayoutTestWebViewClient client;
     int viewportWidth = 640;
     int viewportHeight = 480;
     float enforcedPageScaleFactor = 5.0f;
 
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     webViewHelper.initializeAndLoad(m_baseURL + "large-div.html", true, 0, &client, enableViewportSettings);
     webViewHelper.webView()->setDefaultPageScaleLimits(0.25f, 5);
     webViewHelper.webView()->settings()->setWideViewportQuirkEnabled(true);
     webViewHelper.webView()->settings()->setUseWideViewport(false);
     webViewHelper.webView()->setInitialPageScaleOverride(enforcedPageScaleFactor);
     webViewHelper.webView()->resize(WebSize(viewportWidth, viewportHeight));
     webViewHelper.webView()->layout();
 
     EXPECT_NEAR(viewportWidth / enforcedPageScaleFactor, webViewHelper.webViewImpl()->mainFrameImpl()->frameView()->layoutSize().width(), 1.0f);
     EXPECT_NEAR(viewportHeight / enforcedPageScaleFactor, webViewHelper.webViewImpl()->mainFrameImpl()->frameView()->layoutSize().height(), 1.0f);
     EXPECT_NEAR(enforcedPageScaleFactor, webViewHelper.webView()->pageScaleFactor(), 0.01f);
 }
 
-TEST_P(ParametrizedWebFrameTest, NoUserScalableQuirkIgnoresViewportScale)
+TEST_P(ParameterizedWebFrameTest, NoUserScalableQuirkIgnoresViewportScale)
 {
     UseMockScrollbarSettings mockScrollbarSettings;
     registerMockedHttpURLLoad("viewport-initial-scale-and-user-scalable-no.html");
 
     FixedLayoutTestWebViewClient client;
     int viewportWidth = 640;
     int viewportHeight = 480;
 
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     webViewHelper.initializeAndLoad(m_baseURL + "viewport-initial-scale-and-user-scalable-no.html", true, 0, &client, enableViewportSettings);
     webViewHelper.webView()->settings()->setViewportMetaNonUserScalableQuirk(true);
     webViewHelper.webView()->resize(WebSize(viewportWidth, viewportHeight));
     webViewHelper.webView()->layout();
 
     EXPECT_NEAR(viewportWidth, webViewHelper.webViewImpl()->mainFrameImpl()->frameView()->layoutSize().width(), 1.0f);
     EXPECT_NEAR(viewportHeight, webViewHelper.webViewImpl()->mainFrameImpl()->frameView()->layoutSize().height(), 1.0f);
     EXPECT_NEAR(1.0f, webViewHelper.webView()->pageScaleFactor(), 0.01f);
 }
 
-TEST_P(ParametrizedWebFrameTest, NoUserScalableQuirkIgnoresViewportScaleForNonWideViewport)
+TEST_P(ParameterizedWebFrameTest, NoUserScalableQuirkIgnoresViewportScaleForNonWideViewport)
 {
     UseMockScrollbarSettings mockScrollbarSettings;
     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);
     webViewHelper.initializeAndLoad(m_baseURL + "viewport-initial-scale-and-user-scalable-no.html", true, 0, &client, enableViewportSettings);
     webViewHelper.webView()->settings()->setSupportDeprecatedTargetDensityDPI(true);
     webViewHelper.webView()->settings()->setViewportMetaNonUserScalableQuirk(true);
     webViewHelper.webView()->settings()->setWideViewportQuirkEnabled(true);
     webViewHelper.webView()->settings()->setUseWideViewport(false);
     webViewHelper.webView()->resize(WebSize(viewportWidth, viewportHeight));
     webViewHelper.webView()->layout();
 
     EXPECT_NEAR(viewportWidth * client.m_screenInfo.deviceScaleFactor, webViewHelper.webViewImpl()->mainFrameImpl()->frameView()->layoutSize().width(), 1.0f);
     EXPECT_NEAR(viewportHeight * client.m_screenInfo.deviceScaleFactor, webViewHelper.webViewImpl()->mainFrameImpl()->frameView()->layoutSize().height(), 1.0f);
     EXPECT_NEAR(1.0f / client.m_screenInfo.deviceScaleFactor, webViewHelper.webView()->pageScaleFactor(), 0.01f);
 }
 
-TEST_P(ParametrizedWebFrameTest, NoUserScalableQuirkIgnoresViewportScaleForWideViewport)
+TEST_P(ParameterizedWebFrameTest, NoUserScalableQuirkIgnoresViewportScaleForWideViewport)
 {
     UseMockScrollbarSettings mockScrollbarSettings;
     registerMockedHttpURLLoad("viewport-2x-initial-scale-non-user-scalable.html");
 
     FixedLayoutTestWebViewClient client;
     int viewportWidth = 640;
     int viewportHeight = 480;
 
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     webViewHelper.initializeAndLoad(m_baseURL + "viewport-2x-initial-scale-non-user-scalable.html", true, 0, &client, enableViewportSettings);
     webViewHelper.webView()->settings()->setViewportMetaNonUserScalableQuirk(true);
     webViewHelper.webView()->settings()->setWideViewportQuirkEnabled(true);
     webViewHelper.webView()->settings()->setUseWideViewport(true);
     webViewHelper.webView()->resize(WebSize(viewportWidth, viewportHeight));
 
     EXPECT_NEAR(viewportWidth, webViewHelper.webViewImpl()->mainFrameImpl()->frameView()->layoutSize().width(), 1.0f);
     EXPECT_NEAR(viewportHeight, webViewHelper.webViewImpl()->mainFrameImpl()->frameView()->layoutSize().height(), 1.0f);
     EXPECT_NEAR(1.0f, webViewHelper.webView()->pageScaleFactor(), 0.01f);
 }
 
-TEST_P(ParametrizedWebFrameTest, DesktopPageCanBeZoomedInWhenWideViewportIsTurnedOff)
+TEST_P(ParameterizedWebFrameTest, DesktopPageCanBeZoomedInWhenWideViewportIsTurnedOff)
 {
     UseMockScrollbarSettings mockScrollbarSettings;
     registerMockedHttpURLLoad("no_viewport_tag.html");
 
     FixedLayoutTestWebViewClient client;
     int viewportWidth = 640;
     int viewportHeight = 480;
 
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     webViewHelper.initializeAndLoad(m_baseURL + "no_viewport_tag.html", true, 0, &client, enableViewportSettings);
@@ skipping 109 matching lines @@
     const char* url = "resize_scroll_fixed_layout.html";
     const float initialPageScaleFactor = 2;
     const WebSize scrollOffset(200, 400);
     const WebSize viewportSize(320, 240);
     const bool shouldScaleRelativeToViewportWidth = true;
 
     testResizeYieldsCorrectScrollAndScale(
         url, initialPageScaleFactor, scrollOffset, viewportSize, shouldScaleRelativeToViewportWidth);
 }
 
-TEST_P(ParametrizedWebFrameTest, pageScaleFactorUpdatesScrollbars)
+TEST_P(ParameterizedWebFrameTest, pageScaleFactorUpdatesScrollbars)
 {
     UseMockScrollbarSettings mockScrollbarSettings;
     registerMockedHttpURLLoad("fixed_layout.html");
 
     FixedLayoutTestWebViewClient client;
     client.m_screenInfo.deviceScaleFactor = 1;
     int viewportWidth = 640;
     int viewportHeight = 480;
 
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     webViewHelper.initializeAndLoad(m_baseURL + "fixed_layout.html", true, 0, &client, enableViewportSettings);
     webViewHelper.webView()->resize(WebSize(viewportWidth, viewportHeight));
     webViewHelper.webView()->layout();
 
     FrameView* view = webViewHelper.webViewImpl()->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(ParametrizedWebFrameTest, CanOverrideScaleLimits)
+TEST_P(ParameterizedWebFrameTest, CanOverrideScaleLimits)
 {
     UseMockScrollbarSettings mockScrollbarSettings;
 
     registerMockedHttpURLLoad("no_scale_for_you.html");
 
     FixedLayoutTestWebViewClient client;
     client.m_screenInfo.deviceScaleFactor = 1;
     int viewportWidth = 640;
     int viewportHeight = 480;
 
@@ skipping 70 matching lines @@
         simulatePageScale(webViewImpl, scale);
 }
 
 void simulateDoubleTap(WebViewImpl* webViewImpl, WebPoint& point, float& scale)
 {
     webViewImpl->animateDoubleTapZoom(point);
     EXPECT_TRUE(webViewImpl->fakeDoubleTapAnimationPendingForTesting());
     simulatePageScale(webViewImpl, scale);
 }
 
-TEST_P(ParametrizedWebFrameTest, DivAutoZoomParamsTest)
+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);
     webViewHelper.initializeAndLoad(m_baseURL + "get_scale_for_auto_zoom_into_div_test.html", false, 0, 0, configureAndroid);
     webViewHelper.webView()->setDeviceScaleFactor(deviceScaleFactor);
@@ skipping 32 matching lines @@
 
     // Test double-tap zooming into tall div.
     WebRect tallBlockBound = webViewHelper.webViewImpl()->computeBlockBound(doubleTapPointTall, false);
     webViewHelper.webViewImpl()->computeScaleAndScrollForBlockRect(WebPoint(doubleTapPointTall.x, doubleTapPointTall.y), tallBlockBound, touchPointPadding, doubleTapZoomAlreadyLegibleScale, scale, scroll);
     // The div should start at the top left of the viewport.
     EXPECT_NEAR(viewportWidth / (float) tallDiv.width, scale, 0.1);
     EXPECT_NEAR(tallDiv.x, scroll.x, 20);
     EXPECT_NEAR(tallDiv.y, scroll.y, 20);
 }
 
-TEST_P(ParametrizedWebFrameTest, DivAutoZoomWideDivTest)
+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);
     webViewHelper.initializeAndLoad(m_baseURL + "get_wide_div_for_auto_zoom_test.html", false, 0, 0, configureAndroid);
     webViewHelper.webView()->resize(WebSize(viewportWidth, viewportHeight));
     webViewHelper.webView()->setDeviceScaleFactor(deviceScaleFactor);
     webViewHelper.webView()->setPageScaleFactor(1.0f);
     webViewHelper.webView()->layout();
 
     webViewHelper.webViewImpl()->enableFakePageScaleAnimationForTesting(true);
 
     float doubleTapZoomAlreadyLegibleScale = webViewHelper.webViewImpl()->minimumPageScaleFactor() * doubleTapZoomAlreadyLegibleRatio;
 
     WebRect div(0, 100, viewportWidth, 150);
     WebPoint point(div.x + 50, div.y + 50);
     float scale;
     setScaleAndScrollAndLayout(webViewHelper.webViewImpl(), WebPoint(0, 0), (webViewHelper.webViewImpl()->minimumPageScaleFactor()) * (1 + doubleTapZoomAlreadyLegibleRatio) / 2);
 
     simulateDoubleTap(webViewHelper.webViewImpl(), point, scale);
     EXPECT_FLOAT_EQ(doubleTapZoomAlreadyLegibleScale, scale);
     simulateDoubleTap(webViewHelper.webViewImpl(), point, scale);
     EXPECT_FLOAT_EQ(webViewHelper.webViewImpl()->minimumPageScaleFactor(), scale);
 }
 
-TEST_P(ParametrizedWebFrameTest, DivAutoZoomVeryTallTest)
+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);
@@ skipping 277 matching lines @@
     doubleTapZoomAlreadyLegibleScale = webViewHelper.webViewImpl()->minimumPageScaleFactor() * doubleTapZoomAlreadyLegibleRatio;
     setScaleAndScrollAndLayout(webViewHelper.webViewImpl(), WebPoint(0, 0), (webViewHelper.webViewImpl()->minimumPageScaleFactor()) * (1 + doubleTapZoomAlreadyLegibleRatio) / 2);
     simulateDoubleTap(webViewHelper.webViewImpl(), doubleTapPoint, scale);
     EXPECT_FLOAT_EQ(legibleScale, scale);
     simulateDoubleTap(webViewHelper.webViewImpl(), doubleTapPoint, scale);
     EXPECT_FLOAT_EQ(webViewHelper.webViewImpl()->minimumPageScaleFactor(), scale);
     simulateDoubleTap(webViewHelper.webViewImpl(), doubleTapPoint, scale);
     EXPECT_FLOAT_EQ(legibleScale, scale);
 }
 
-TEST_P(ParametrizedWebFrameTest, BlockBoundTest)
+TEST_P(ParameterizedWebFrameTest, BlockBoundTest)
 {
     registerMockedHttpURLLoad("block_bound.html");
 
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     webViewHelper.initializeAndLoad(m_baseURL + "block_bound.html", false, 0, 0, configureAndroid);
 
     IntRect rectBack = IntRect(0, 0, 200, 200);
     IntRect rectLeftTop = IntRect(10, 10, 80, 80);
     IntRect rectRightBottom = IntRect(110, 110, 80, 80);
     IntRect blockBound;
@@ skipping 13 matching lines @@
     blockBound = IntRect(webViewHelper.webViewImpl()->computeBlockBound(WebPoint(90, 90), true));
     EXPECT_RECT_EQ(rectBack, blockBound);
 
     blockBound = IntRect(webViewHelper.webViewImpl()->computeBlockBound(WebPoint(109, 109), true));
     EXPECT_RECT_EQ(rectBack, blockBound);
 
     blockBound = IntRect(webViewHelper.webViewImpl()->computeBlockBound(WebPoint(110, 110), true));
     EXPECT_RECT_EQ(rectRightBottom, blockBound);
 }
 
-TEST_P(ParametrizedWebFrameTest, DivMultipleTargetZoomMultipleDivsTest)
+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);
     webViewHelper.initializeAndLoad(m_baseURL + "get_multiple_divs_for_auto_zoom_test.html");
     webViewHelper.webView()->resize(WebSize(viewportWidth, viewportHeight));
@@ skipping 99 matching lines @@
     // Zoom out slightly.
     const float withinToleranceScale = scale * 0.9f;
     setScaleAndScrollAndLayout(webViewHelper.webViewImpl(), scroll, withinToleranceScale);
     // Move focus back to the second edit box.
     webViewHelper.webView()->advanceFocus(false);
     webViewHelper.webViewImpl()->computeScaleAndScrollForFocusedNode(webViewHelper.webViewImpl()->focusedElement(), scale, scroll, needAnimation);
     // The scale should not be adjusted as the zoomed out scale was sufficiently close to the previously focused scale.
     EXPECT_FALSE(needAnimation);
 }
 
-TEST_P(ParametrizedWebFrameTest, CharacterIndexAtPointWithPinchZoom)
+TEST_P(ParameterizedWebFrameTest, CharacterIndexAtPointWithPinchZoom)
 {
     registerMockedHttpURLLoad("sometext.html");
 
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     webViewHelper.initializeAndLoad(m_baseURL + "sometext.html");
     webViewHelper.webViewImpl()->resize(WebSize(640, 480));
     webViewHelper.webViewImpl()->layout();
 
 
     webViewHelper.webViewImpl()->setPageScaleFactor(2);
     webViewHelper.webViewImpl()->setPinchViewportOffset(WebFloatPoint(50, 60));
 
     WebRect baseRect;
     WebRect extentRect;
 
     WebFrame* mainFrame = webViewHelper.webViewImpl()->mainFrame();
     size_t ix = mainFrame->characterIndexForPoint(WebPoint(320, 388));
 
     EXPECT_EQ(2ul, ix);
 }
 
-TEST_P(ParametrizedWebFrameTest, FirstRectForCharacterRangeWithPinchZoom)
+TEST_P(ParameterizedWebFrameTest, FirstRectForCharacterRangeWithPinchZoom)
 {
     registerMockedHttpURLLoad("textbox.html");
 
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     webViewHelper.initializeAndLoad(m_baseURL + "textbox.html", true);
     webViewHelper.webViewImpl()->resize(WebSize(640, 480));
 
     WebFrame* mainFrame = webViewHelper.webViewImpl()->mainFrame();
     mainFrame->executeScript(WebScriptSource("selectRange();"));
 
@@ skipping 75 matching lines @@
 
 class TestReloadDoesntRedirectWebFrameClient : public FrameTestHelpers::TestWebFrameClient {
 public:
     virtual WebNavigationPolicy decidePolicyForNavigation(const NavigationPolicyInfo& info) override
     {
         EXPECT_FALSE(info.isRedirect);
         return WebNavigationPolicyCurrentTab;
     }
 };
 
-TEST_P(ParametrizedWebFrameTest, ReloadDoesntSetRedirect)
+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);
     webViewHelper.initializeAndLoad(m_baseURL + "form.html", false, &webFrameClient);
 
     webViewHelper.webView()->mainFrame()->reload(true);
@@ skipping 68 matching lines @@
 
     // Reload the page while ignoring the cache. State should not be propagated.
     Platform::current()->currentThread()->postTask(
         FROM_HERE, new ReloadWithOverrideURLTask(webViewHelper.webViewImpl()->mainFrame(), toKURL(m_baseURL + thirdURL), true));
     FrameTestHelpers::pumpPendingRequestsDoNotUse(webViewHelper.webViewImpl()->mainFrame());
     EXPECT_EQ(0, webViewHelper.webViewImpl()->mainFrame()->scrollOffset().width);
     EXPECT_EQ(0, webViewHelper.webViewImpl()->mainFrame()->scrollOffset().height);
     EXPECT_EQ(1.0f, webViewHelper.webViewImpl()->pageScaleFactor());
 }
 
-TEST_P(ParametrizedWebFrameTest, ReloadWhileProvisional)
+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);
     webViewHelper.initialize();
     WebURLRequest request;
     request.initialize();
     request.setURL(toKURL(m_baseURL + "fixed_layout.html"));
     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"), toKURL(dataSource->request().url().spec()));
 }
 
-TEST_P(ParametrizedWebFrameTest, AppendRedirects)
+TEST_P(ParameterizedWebFrameTest, AppendRedirects)
 {
     const std::string firstURL = "about:blank";
     const std::string secondURL = "http://internal.test";
 
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     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), toKURL(redirects[0].spec().data()));
     EXPECT_EQ(toKURL(secondURL), toKURL(redirects[1].spec().data()));
 }
 
-TEST_P(ParametrizedWebFrameTest, IframeRedirect)
+TEST_P(ParameterizedWebFrameTest, IframeRedirect)
 {
     registerMockedHttpURLLoad("iframe_redirect.html");
     registerMockedHttpURLLoad("visible_iframe.html");
 
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     webViewHelper.initializeAndLoad(m_baseURL + "iframe_redirect.html", true);
     // Pump pending requests one more time. The test page loads script that navigates.
     FrameTestHelpers::pumpPendingRequestsDoNotUse(webViewHelper.webView()->mainFrame());
 
     WebFrame* iframe = webViewHelper.webView()->findFrameByName(WebString::fromUTF8("ifr"));
     ASSERT_TRUE(iframe);
     WebDataSource* iframeDataSource = iframe->dataSource();
     ASSERT_TRUE(iframeDataSource);
     WebVector<WebURL> redirects;
     iframeDataSource->redirectChain(redirects);
     ASSERT_EQ(2U, redirects.size());
     EXPECT_EQ(toKURL("about:blank"), toKURL(redirects[0].spec().data()));
     EXPECT_EQ(toKURL("http://internal.test/visible_iframe.html"), toKURL(redirects[1].spec().data()));
 }
 
-TEST_P(ParametrizedWebFrameTest, ClearFocusedNodeTest)
+TEST_P(ParameterizedWebFrameTest, ClearFocusedNodeTest)
 {
     registerMockedHttpURLLoad("iframe_clear_focused_node_test.html");
     registerMockedHttpURLLoad("autofocus_input_field_iframe.html");
 
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     webViewHelper.initializeAndLoad(m_baseURL + "iframe_clear_focused_node_test.html", true);
 
     // Clear the focused node.
     webViewHelper.webView()->clearFocusedElement();
 
@@ skipping 55 matching lines @@
         createNotifications.push_back(new Notification(frame, context, worldId));
     }
 
     virtual void willReleaseScriptContext(WebLocalFrame* frame, v8::Local<v8::Context> context, int worldId) override
     {
         releaseNotifications.push_back(new Notification(frame, context, worldId));
     }
 };
 
 // TODO(aa): Deflake this test.
-TEST_P(ParametrizedWebFrameTest, FLAKY_ContextNotificationsLoadUnload)
+TEST_P(ParameterizedWebFrameTest, FLAKY_ContextNotificationsLoadUnload)
 {
     v8::HandleScope handleScope(v8::Isolate::GetCurrent());
 
     registerMockedHttpURLLoad("context_notifications_test.html");
     registerMockedHttpURLLoad("context_notifications_test_frame.html");
 
     // Load a frame with an iframe, make sure we get the right create notifications.
     ContextLifetimeTestWebFrameClient webFrameClient;
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     webViewHelper.initializeAndLoad(m_baseURL + "context_notifications_test.html", true, &webFrameClient);
@@ skipping 19 matching lines @@
     webViewHelper.reset();
 
     ASSERT_EQ(2u, webFrameClient.releaseNotifications.size());
     ContextLifetimeTestWebFrameClient::Notification* firstReleaseNotification = webFrameClient.releaseNotifications[0];
     ContextLifetimeTestWebFrameClient::Notification* secondReleaseNotification = webFrameClient.releaseNotifications[1];
 
     ASSERT_TRUE(firstCreateNotification->Equals(secondReleaseNotification));
     ASSERT_TRUE(secondCreateNotification->Equals(firstReleaseNotification));
 }
 
-TEST_P(ParametrizedWebFrameTest, ContextNotificationsReload)
+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);
     webViewHelper.initializeAndLoad(m_baseURL + "context_notifications_test.html", true, &webFrameClient);
 
@@ skipping 16 matching lines @@
 
     EXPECT_EQ(mainFrame, firstRefreshNotification->frame);
     EXPECT_EQ(mainFrame->mainWorldScriptContext(), firstRefreshNotification->context);
     EXPECT_EQ(0, firstRefreshNotification->worldId);
 
     EXPECT_EQ(childFrame, secondRefreshNotification->frame);
     EXPECT_EQ(childFrame->mainWorldScriptContext(), secondRefreshNotification->context);
     EXPECT_EQ(0, secondRefreshNotification->worldId);
 }
 
-TEST_P(ParametrizedWebFrameTest, ContextNotificationsIsolatedWorlds)
+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);
     webViewHelper.initializeAndLoad(m_baseURL + "context_notifications_test.html", true, &webFrameClient);
@@ skipping 23 matching lines @@
 
     // And one of them should be exactly the same as the create notification for the isolated context.
     int matchCount = 0;
     for (size_t i = 0; i < webFrameClient.releaseNotifications.size(); ++i) {
       if (webFrameClient.releaseNotifications[i]->Equals(webFrameClient.createNotifications[0]))
         ++matchCount;
     }
     EXPECT_EQ(1, matchCount);
 }
 
-TEST_P(ParametrizedWebFrameTest, FindInPage)
+TEST_P(ParameterizedWebFrameTest, FindInPage)
 {
     registerMockedHttpURLLoad("find.html");
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     webViewHelper.initializeAndLoad(m_baseURL + "find.html");
     WebFrame* frame = webViewHelper.webView()->mainFrame();
     const int findIdentifier = 12345;
     WebFindOptions options;
 
     // Find in a <div> element.
     EXPECT_TRUE(frame->find(findIdentifier, WebString::fromUTF8("bar1"), options, false, 0));
@@ skipping 36 matching lines @@
 
     // Find in <select> content.
     EXPECT_FALSE(frame->find(findIdentifier, WebString::fromUTF8("bar5"), options, false, 0));
     // If there are any matches, stopFinding will set the selection on the found text.
     // However, we do not expect any matches, so check that the selection is null.
     frame->stopFinding(false);
     range = frame->selectionRange();
     ASSERT_TRUE(range.isNull());
 }
 
-TEST_P(ParametrizedWebFrameTest, GetContentAsPlainText)
+TEST_P(ParameterizedWebFrameTest, GetContentAsPlainText)
 {
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     webViewHelper.initializeAndLoad("about:blank", true);
     // We set the size because it impacts line wrapping, which changes the
     // resulting text value.
     webViewHelper.webView()->resize(WebSize(640, 480));
     WebFrame* frame = webViewHelper.webView()->mainFrame();
 
     // Generate a simple test case.
     const char simpleSource[] = "<div>Foo bar</div><div></div>baz";
@@ skipping 21 matching lines @@
 
     text = frame->contentAsText(std::numeric_limits<size_t>::max());
     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 = frame->contentAsText(12);
     EXPECT_EQ("Hello world", text.utf8());
 }
 
-TEST_P(ParametrizedWebFrameTest, GetFullHtmlOfPage)
+TEST_P(ParameterizedWebFrameTest, GetFullHtmlOfPage)
 {
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     webViewHelper.initializeAndLoad("about:blank", true);
     WebFrame* frame = webViewHelper.webView()->mainFrame();
 
     // Generate a simple test case.
     const char simpleSource[] = "<p>Hello</p><p>World</p>";
     KURL testURL = toKURL("about:blank");
     FrameTestHelpers::loadHTMLString(frame, simpleSource, testURL);
 
@@ skipping 21 matching lines @@
 }
 
 class TestExecuteScriptDuringDidCreateScriptContext : public FrameTestHelpers::TestWebFrameClient {
 public:
     virtual void didCreateScriptContext(WebLocalFrame* frame, v8::Local<v8::Context> context, int extensionGroup, int worldId) override
     {
         frame->executeScript(WebScriptSource("window.history = 'replaced';"));
     }
 };
 
-TEST_P(ParametrizedWebFrameTest, ExecuteScriptDuringDidCreateScriptContext)
+TEST_P(ParameterizedWebFrameTest, ExecuteScriptDuringDidCreateScriptContext)
 {
     registerMockedHttpURLLoad("hello_world.html");
 
     TestExecuteScriptDuringDidCreateScriptContext webFrameClient;
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     webViewHelper.initializeAndLoad(m_baseURL + "hello_world.html", true, &webFrameClient);
 
     FrameTestHelpers::reloadFrame(webViewHelper.webView()->mainFrame());
 }
 
@@ skipping 13 matching lines @@
     }
 
     bool findResultsAreReady() const { return m_findResultsAreReady; }
     int count() const { return m_count; }
 
 private:
     bool m_findResultsAreReady;
     int m_count;
 };
 
-TEST_P(ParametrizedWebFrameTest, FindInPageMatchRects)
+TEST_P(ParameterizedWebFrameTest, FindInPageMatchRects)
 {
     registerMockedHttpURLLoad("find_in_page.html");
     registerMockedHttpURLLoad("find_in_page_frame.html");
 
     FindUpdateWebFrameClient client;
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     webViewHelper.initializeAndLoad(m_baseURL + "find_in_page.html", true, &client);
     webViewHelper.webView()->resize(WebSize(640, 480));
     webViewHelper.webView()->setMaximumLegibleScale(1.f);
     webViewHelper.webView()->layout();
@@ skipping 100 matching lines @@
     // immediate containing div. Consequently, result 18 should be above result 17.
     EXPECT_TRUE(webMatchRects[17].y > webMatchRects[18].y);
 
     // Resizing should update the rects version.
     webViewHelper.webView()->resize(WebSize(800, 600));
     webViewHelper.webView()->layout();
     runPendingTasks();
     EXPECT_TRUE(mainFrame->findMatchMarkersVersion() != rectsVersion);
 }
 
-TEST_P(ParametrizedWebFrameTest, FindInPageSkipsHiddenFrames)
+TEST_P(ParameterizedWebFrameTest, FindInPageSkipsHiddenFrames)
 {
     registerMockedHttpURLLoad("find_in_hidden_frame.html");
 
     FindUpdateWebFrameClient client;
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     webViewHelper.initializeAndLoad(m_baseURL + "find_in_hidden_frame.html", true, &client);
     webViewHelper.webView()->resize(WebSize(640, 480));
     webViewHelper.webView()->layout();
     runPendingTasks();
 
     static const char* kFindString = "hello";
     static const int kFindIdentifier = 12345;
     static const int kNumResults = 1;
 
     WebFindOptions options;
     WebString searchText = WebString::fromUTF8(kFindString);
     WebLocalFrameImpl* mainFrame = toWebLocalFrameImpl(webViewHelper.webView()->mainFrame());
     EXPECT_TRUE(mainFrame->find(kFindIdentifier, searchText, options, false, 0));
 
     mainFrame->resetMatchCount();
 
     for (WebFrame* frame = mainFrame; frame; frame = frame->traverseNext(false))
         frame->scopeStringMatches(kFindIdentifier, searchText, options, true);
 
     runPendingTasks();
     EXPECT_TRUE(client.findResultsAreReady());
     EXPECT_EQ(kNumResults, client.count());
 }
 
-TEST_P(ParametrizedWebFrameTest, FindOnDetachedFrame)
+TEST_P(ParameterizedWebFrameTest, FindOnDetachedFrame)
 {
     registerMockedHttpURLLoad("find_in_page.html");
     registerMockedHttpURLLoad("find_in_page_frame.html");
 
     FindUpdateWebFrameClient client;
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     webViewHelper.initializeAndLoad(m_baseURL + "find_in_page.html", true, &client);
     webViewHelper.webView()->resize(WebSize(640, 480));
     webViewHelper.webView()->layout();
     runPendingTasks();
@@ skipping 18 matching lines @@
 
     mainFrame->resetMatchCount();
 
     for (WebFrame* frame = mainFrame; frame; frame = frame->traverseNext(false))
         frame->scopeStringMatches(kFindIdentifier, searchText, options, true);
 
     runPendingTasks();
     EXPECT_TRUE(client.findResultsAreReady());
 }
 
-TEST_P(ParametrizedWebFrameTest, FindDetachFrameBeforeScopeStrings)
+TEST_P(ParameterizedWebFrameTest, FindDetachFrameBeforeScopeStrings)
 {
     registerMockedHttpURLLoad("find_in_page.html");
     registerMockedHttpURLLoad("find_in_page_frame.html");
 
     FindUpdateWebFrameClient client;
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     webViewHelper.initializeAndLoad(m_baseURL + "find_in_page.html", true, &client);
     webViewHelper.webView()->resize(WebSize(640, 480));
     webViewHelper.webView()->layout();
     runPendingTasks();
@@ skipping 18 matching lines @@
 
     mainFrame->resetMatchCount();
 
     for (WebFrame* frame = mainFrame; frame; frame = frame->traverseNext(false))
         frame->scopeStringMatches(kFindIdentifier, searchText, options, true);
 
     runPendingTasks();
     EXPECT_TRUE(client.findResultsAreReady());
 }
 
-TEST_P(ParametrizedWebFrameTest, FindDetachFrameWhileScopingStrings)
+TEST_P(ParameterizedWebFrameTest, FindDetachFrameWhileScopingStrings)
 {
     registerMockedHttpURLLoad("find_in_page.html");
     registerMockedHttpURLLoad("find_in_page_frame.html");
 
     FindUpdateWebFrameClient client;
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     webViewHelper.initializeAndLoad(m_baseURL + "find_in_page.html", true, &client);
     webViewHelper.webView()->resize(WebSize(640, 480));
     webViewHelper.webView()->layout();
     runPendingTasks();
@@ skipping 18 matching lines @@
     for (WebFrame* frame = mainFrame; frame; frame = frame->traverseNext(false))
         frame->scopeStringMatches(kFindIdentifier, searchText, options, true);
 
     // The first scopeStringMatches will have reset the state. Detach before it actually scopes.
     EXPECT_TRUE(mainFrame->document().getElementById("frame").remove());
 
     runPendingTasks();
     EXPECT_TRUE(client.findResultsAreReady());
 }
 
-TEST_P(ParametrizedWebFrameTest, ResetMatchCount)
+TEST_P(ParameterizedWebFrameTest, ResetMatchCount)
 {
     registerMockedHttpURLLoad("find_in_generated_frame.html");
 
     FindUpdateWebFrameClient client;
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     webViewHelper.initializeAndLoad(m_baseURL + "find_in_generated_frame.html", true, &client);
     webViewHelper.webView()->resize(WebSize(640, 480));
     webViewHelper.webView()->layout();
     runPendingTasks();
 
@@ skipping 10 matching lines @@
     for (WebFrame* frame = mainFrame; frame; frame = frame->traverseNext(false)) {
         EXPECT_FALSE(frame->find(kFindIdentifier, searchText, options, false, 0));
     }
 
     runPendingTasks();
     EXPECT_FALSE(client.findResultsAreReady());
 
     mainFrame->resetMatchCount();
 }
 
-TEST_P(ParametrizedWebFrameTest, SetTickmarks)
+TEST_P(ParameterizedWebFrameTest, SetTickmarks)
 {
     registerMockedHttpURLLoad("find.html");
 
     FindUpdateWebFrameClient client;
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     webViewHelper.initializeAndLoad(m_baseURL + "find.html", true, &client);
     webViewHelper.webView()->resize(WebSize(640, 480));
     webViewHelper.webView()->layout();
     runPendingTasks();
 
@@ skipping 57 matching lines @@
 static WebRect elementBounds(WebFrame* frame, const WebString& id)
 {
     return frame->document().getElementById(id).boundsInViewportSpace();
 }
 
 static std::string selectionAsString(WebFrame* frame)
 {
     return frame->selectionAsText().utf8();
 }
 
-TEST_P(ParametrizedWebFrameTest, SelectRange)
+TEST_P(ParameterizedWebFrameTest, SelectRange)
 {
     WebFrame* frame;
     WebRect startWebRect;
     WebRect endWebRect;
 
     registerMockedHttpURLLoad("select_range_basic.html");
     registerMockedHttpURLLoad("select_range_scroll.html");
 
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     initializeTextSelectionWebView(m_baseURL + "select_range_basic.html", &webViewHelper);
     frame = webViewHelper.webView()->mainFrame();
     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));
     EXPECT_EQ("Some test text for testing.", selectionAsString(frame));
 
     initializeTextSelectionWebView(m_baseURL + "select_range_scroll.html", &webViewHelper);
     frame = webViewHelper.webView()->mainFrame();
     EXPECT_EQ("Some offscreen 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));
     EXPECT_EQ("Some offscreen test text for testing.", selectionAsString(frame));
 }
 
-TEST_P(ParametrizedWebFrameTest, SelectRangeInIframe)
+TEST_P(ParameterizedWebFrameTest, SelectRangeInIframe)
 {
     WebFrame* frame;
     WebRect startWebRect;
     WebRect endWebRect;
 
     registerMockedHttpURLLoad("select_range_iframe.html");
     registerMockedHttpURLLoad("select_range_basic.html");
 
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     initializeTextSelectionWebView(m_baseURL + "select_range_iframe.html", &webViewHelper);
     frame = webViewHelper.webView()->mainFrame();
     WebFrame* subframe = frame->firstChild();
     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));
     EXPECT_EQ("Some test text for testing.", selectionAsString(subframe));
 }
 
-TEST_P(ParametrizedWebFrameTest, SelectRangeDivContentEditable)
+TEST_P(ParameterizedWebFrameTest, SelectRangeDivContentEditable)
 {
     WebFrame* frame;
     WebRect startWebRect;
     WebRect endWebRect;
 
     registerMockedHttpURLLoad("select_range_div_editable.html");
 
     // Select the middle of an editable element, then try to extend the selection to the top of the document.
     // The selection range should be clipped to the bounds of the editable element.
     FrameTestHelpers::WebViewHelper webViewHelper(this);
@@ skipping 14 matching lines @@
     EXPECT_EQ("This text is initially selected.", selectionAsString(frame));
     webViewHelper.webView()->selectionBounds(startWebRect, endWebRect);
 
     webViewHelper.webView()->selectionBounds(startWebRect, endWebRect);
     frame->selectRange(topLeft(startWebRect), WebPoint(640, 480));
     EXPECT_EQ("This text is initially selected. 16-char footer.", selectionAsString(frame));
 }
 
 // positionForPoint returns the wrong values for contenteditable spans. See
 // http://crbug.com/238334.
-TEST_P(ParametrizedWebFrameTest, DISABLED_SelectRangeSpanContentEditable)
+TEST_P(ParameterizedWebFrameTest, DISABLED_SelectRangeSpanContentEditable)
 {
     WebFrame* frame;
     WebRect startWebRect;
     WebRect endWebRect;
 
     registerMockedHttpURLLoad("select_range_span_editable.html");
 
     // Select the middle of an editable element, then try to extend the selection to the top of the document.
     // The selection range should be clipped to the bounds of the editable element.
     FrameTestHelpers::WebViewHelper webViewHelper(this);
@@ skipping 13 matching lines @@
     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(ParametrizedWebFrameTest, SelectRangeCanMoveSelectionStart)
+TEST_P(ParameterizedWebFrameTest, SelectRangeCanMoveSelectionStart)
 {
     registerMockedHttpURLLoad("text_selection.html");
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     initializeTextSelectionWebView(m_baseURL + "text_selection.html", &webViewHelper);
     WebFrame* frame = webViewHelper.webView()->mainFrame();
 
     // Select second span. We can move the start to include the first span.
     frame->executeScript(WebScriptSource("selectElement('header_2');"));
     EXPECT_EQ("Header 2.", selectionAsString(frame));
     frame->selectRange(bottomRightMinusOne(elementBounds(frame, "header_2")), topLeft(elementBounds(frame, "header_1")));
@@ skipping 27 matching lines @@
 
     // If the selection is editable text, we can't extend it into non-editable text.
     frame->executeScript(WebScriptSource("selectElement('editable_2');"));
     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(ParametrizedWebFrameTest, SelectRangeCanMoveSelectionEnd)
+TEST_P(ParameterizedWebFrameTest, SelectRangeCanMoveSelectionEnd)
 {
     registerMockedHttpURLLoad("text_selection.html");
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     initializeTextSelectionWebView(m_baseURL + "text_selection.html", &webViewHelper);
     WebFrame* frame = webViewHelper.webView()->mainFrame();
 
     // Select first span. We can move the end to include the second span.
     frame->executeScript(WebScriptSource("selectElement('header_1');"));
     EXPECT_EQ("Header 1.", selectionAsString(frame));
     frame->selectRange(topLeft(elementBounds(frame, "header_1")), bottomRightMinusOne(elementBounds(frame, "header_2")));
@@ skipping 27 matching lines @@
 
     // If the selection is editable text, we can't extend it into non-editable text.
     frame->executeScript(WebScriptSource("selectElement('editable_1');"));
     EXPECT_EQ("Editable 1.", selectionAsString(frame));
     frame->selectRange(topLeft(elementBounds(frame, "editable_1")), bottomRightMinusOne(elementBounds(frame, "footer_1")));
     // positionForPoint returns the wrong values for contenteditable spans. See
     // http://crbug.com/238334.
     // EXPECT_EQ("Editable 1. Editable 2. ]", selectionAsString(frame));
 }
 
-TEST_P(ParametrizedWebFrameTest, MoveRangeSelectionExtent)
+TEST_P(ParameterizedWebFrameTest, MoveRangeSelectionExtent)
 {
     WebLocalFrameImpl* frame;
     WebRect startWebRect;
     WebRect endWebRect;
 
     registerMockedHttpURLLoad("move_range_selection_extent.html");
 
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     initializeTextSelectionWebView(m_baseURL + "move_range_selection_extent.html", &webViewHelper);
     frame = toWebLocalFrameImpl(webViewHelper.webView()->mainFrame());
@@ skipping 13 matching lines @@
     frame->moveRangeSelectionExtent(WebPoint(640, 480));
     EXPECT_EQ(" 16-char footer.", selectionAsString(frame));
 
     frame->moveRangeSelectionExtent(WebPoint(0, 0));
     EXPECT_EQ("16-char header. This text is initially selected.", selectionAsString(frame));
 
     frame->executeCommand(WebString::fromUTF8("Unselect"));
     EXPECT_EQ("", selectionAsString(frame));
 }
 
-TEST_P(ParametrizedWebFrameTest, MoveRangeSelectionExtentCannotCollapse)
+TEST_P(ParameterizedWebFrameTest, MoveRangeSelectionExtentCannotCollapse)
 {
     WebLocalFrameImpl* frame;
     WebRect startWebRect;
     WebRect endWebRect;
 
     registerMockedHttpURLLoad("move_range_selection_extent.html");
 
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     initializeTextSelectionWebView(m_baseURL + "move_range_selection_extent.html", &webViewHelper);
     frame = toWebLocalFrameImpl(webViewHelper.webView()->mainFrame());
     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(ParametrizedWebFrameTest, MoveRangeSelectionExtentScollsInputField)
+TEST_P(ParameterizedWebFrameTest, MoveRangeSelectionExtentScollsInputField)
 {
     WebLocalFrameImpl* frame;
     WebRect startWebRect;
     WebRect endWebRect;
 
     registerMockedHttpURLLoad("move_range_selection_extent_input_field.html");
 
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     initializeTextSelectionWebView(m_baseURL + "move_range_selection_extent_input_field.html", &webViewHelper);
     frame = toWebLocalFrameImpl(webViewHelper.webView()->mainFrame());
     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 VisiblePosition(layoutObject->positionForPoint(LayoutPoint(x, y))).deepEquivalent().computeOffsetInContainerNode();
 }
 
 // positionForPoint returns the wrong values for contenteditable spans. See
 // http://crbug.com/238334.
-TEST_P(ParametrizedWebFrameTest, DISABLED_PositionForPointTest)
+TEST_P(ParameterizedWebFrameTest, DISABLED_PositionForPointTest)
 {
     registerMockedHttpURLLoad("select_range_span_editable.html");
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     initializeTextSelectionWebView(m_baseURL + "select_range_span_editable.html", &webViewHelper);
     WebLocalFrameImpl* mainFrame = toWebLocalFrameImpl(webViewHelper.webView()->mainFrame());
     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 = toWebLocalFrameImpl(webViewHelper.webView()->mainFrame());
     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(ParametrizedWebFrameTest, SelectRangeStaysHorizontallyAlignedWhenMoved)
+TEST_P(ParameterizedWebFrameTest, SelectRangeStaysHorizontallyAlignedWhenMoved)
 {
     registerMockedHttpURLLoad("move_caret.html");
 
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     initializeTextSelectionWebView(m_baseURL + "move_caret.html", &webViewHelper);
     WebLocalFrameImpl* frame = toWebLocalFrameImpl(webViewHelper.webView()->mainFrame());
 
     WebRect initialStartRect;
     WebRect initialEndRect;
     WebRect startRect;
@@ skipping 23 matching lines @@
     EXPECT_EQ(startRect, initialStartRect);
     EXPECT_EQ(endRect, initialEndRect);
 
     movedEnd.y -= 80;
     frame->selectRange(topLeft(initialStartRect), movedEnd);
     webViewHelper.webView()->selectionBounds(startRect, endRect);
     EXPECT_EQ(startRect, initialStartRect);
     EXPECT_EQ(endRect, initialEndRect);
 }
 
-TEST_P(ParametrizedWebFrameTest, MoveCaretStaysHorizontallyAlignedWhenMoved)
+TEST_P(ParameterizedWebFrameTest, MoveCaretStaysHorizontallyAlignedWhenMoved)
 {
     WebLocalFrameImpl* frame;
     registerMockedHttpURLLoad("move_caret.html");
 
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     initializeTextSelectionWebView(m_baseURL + "move_caret.html", &webViewHelper);
     frame = (WebLocalFrameImpl*)webViewHelper.webView()->mainFrame();
 
     WebRect initialStartRect;
     WebRect initialEndRect;
@@ skipping 172 matching lines @@
 TEST_F(CompositedSelectionBoundsTest, Transformed) { runTest("composited_selection_bounds_transformed.html"); }
 TEST_F(CompositedSelectionBoundsTest, SplitLayer) { runTest("composited_selection_bounds_split_layer.html"); }
 TEST_F(CompositedSelectionBoundsTest, EmptyLayer) { runTest("composited_selection_bounds_empty_layer.html"); }
 TEST_F(CompositedSelectionBoundsTest, Iframe) { runTestWithMultipleFiles("composited_selection_bounds_iframe.html", "composited_selection_bounds_basic.html", nullptr); }
 TEST_F(CompositedSelectionBoundsTest, DetachedFrame) { runTest("composited_selection_bounds_detached_frame.html"); }
 TEST_F(CompositedSelectionBoundsTest, Editable) { runTest("composited_selection_bounds_editable.html"); }
 TEST_F(CompositedSelectionBoundsTest, EditableDiv) { runTest("composited_selection_bounds_editable_div.html"); }
 TEST_F(CompositedSelectionBoundsTest, EmptyEditableInput) { runTest("composited_selection_bounds_empty_editable_input.html"); }
 TEST_F(CompositedSelectionBoundsTest, EmptyEditableArea) { runTest("composited_selection_bounds_empty_editable_area.html"); }
 
-TEST_P(ParametrizedWebFrameTest, CompositedSelectionBoundsCleared)
+TEST_P(ParameterizedWebFrameTest, CompositedSelectionBoundsCleared)
 {
     RuntimeEnabledFeatures::setCompositedSelectionUpdateEnabled(true);
 
     registerMockedHttpURLLoad("select_range_basic.html");
     registerMockedHttpURLLoad("select_range_scroll.html");
 
     int viewWidth = 500;
     int viewHeight = 500;
 
     CompositedSelectionBoundsTestWebViewClient fakeSelectionWebViewClient;
@@ skipping 63 matching lines @@
 {
     WebGestureEvent event;
     event.type = WebInputEvent::GestureTap;
     event.x = x;
     event.y = y;
     event.data.tap.width = 50;
     event.data.tap.height = 50;
     return event;
 }
 
-TEST_P(ParametrizedWebFrameTest, DisambiguationPopup)
+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);
     webViewHelper.initializeAndLoad(m_baseURL + htmlFile, true, 0, &client);
@@ skipping 34 matching lines @@
     // multi-target-tap.
     webViewHelper.webView()->settings()->setMultiTargetTapNotificationEnabled(false);
 
     for (int i = 0; i <= 46; i++) {
         client.resetTriggered();
         webViewHelper.webView()->handleInputEvent(fatTap(10 + i * 5, 590));
         EXPECT_FALSE(client.triggered());
     }
 }
 
-TEST_P(ParametrizedWebFrameTest, DisambiguationPopupNoContainer)
+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);
     webViewHelper.initializeAndLoad(m_baseURL + "disambiguation_popup_no_container.html", true, 0, &client);
     webViewHelper.webView()->resize(WebSize(1000, 1000));
     webViewHelper.webView()->layout();
 
     client.resetTriggered();
     webViewHelper.webView()->handleInputEvent(fatTap(50, 50));
     EXPECT_FALSE(client.triggered());
 }
 
-TEST_P(ParametrizedWebFrameTest, DisambiguationPopupMobileSite)
+TEST_P(ParameterizedWebFrameTest, DisambiguationPopupMobileSite)
 {
     UseMockScrollbarSettings mockScrollbarSettings;
     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);
@@ skipping 15 matching lines @@
         EXPECT_FALSE(client.triggered());
     }
 
     for (int i = 0; i <= 46; i++) {
         client.resetTriggered();
         webViewHelper.webView()->handleInputEvent(fatTap(10 + i * 5, 590));
         EXPECT_FALSE(client.triggered());
     }
 }
 
-TEST_P(ParametrizedWebFrameTest, DisambiguationPopupViewportSite)
+TEST_P(ParameterizedWebFrameTest, DisambiguationPopupViewportSite)
 {
     UseMockScrollbarSettings mockScrollbarSettings;
     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);
@@ skipping 66 matching lines @@
     EXPECT_TRUE(client.triggered());
 
     // The same tap shouldn't trigger didTapMultipleTargets() after disabling the notification for
     // multi-target-tap.
     webViewHelper.webView()->settings()->setMultiTargetTapNotificationEnabled(false);
     client.resetTriggered();
     webViewHelper.webView()->handleInputEvent(fatTap(10, 60));
     EXPECT_FALSE(client.triggered());
 }
 
-TEST_P(ParametrizedWebFrameTest, DisambiguationPopupBlacklist)
+TEST_P(ParameterizedWebFrameTest, DisambiguationPopupBlacklist)
 {
     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
@@ skipping 12 matching lines @@
     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(ParametrizedWebFrameTest, DisambiguationPopupPageScale)
+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);
     webViewHelper.initializeAndLoad(m_baseURL + "disambiguation_popup_page_scale.html", true, 0, &client);
     webViewHelper.webView()->resize(WebSize(1000, 1000));
@@ skipping 36 matching lines @@
         if (frame->dataSource()->response().url() != WebURL(URLTestHelpers::toKURL("about:blank")))
             m_commitCalled = true;
     }
 
     bool commitCalled() const { return m_commitCalled; }
 
 private:
     bool m_commitCalled;
 };
 
-TEST_P(ParametrizedWebFrameTest, ReplaceNavigationAfterHistoryNavigation)
+TEST_P(ParameterizedWebFrameTest, ReplaceNavigationAfterHistoryNavigation)
 {
     TestSubstituteDataWebFrameClient webFrameClient;
 
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     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
@@ skipping 37 matching lines @@
 
     virtual void willInsertBody(WebLocalFrame*) override
     {
         m_numBodies++;
     }
 
     int m_numBodies;
     bool m_didLoad;
 };
 
-TEST_P(ParametrizedWebFrameTest, HTMLDocument)
+TEST_P(ParameterizedWebFrameTest, HTMLDocument)
 {
     registerMockedHttpURLLoad("clipped-body.html");
 
     TestWillInsertBodyWebFrameClient webFrameClient;
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     webViewHelper.initializeAndLoad(m_baseURL + "clipped-body.html", false, &webFrameClient);
 
     EXPECT_TRUE(webFrameClient.m_didLoad);
     EXPECT_EQ(1, webFrameClient.m_numBodies);
 }
 
-TEST_P(ParametrizedWebFrameTest, EmptyDocument)
+TEST_P(ParameterizedWebFrameTest, EmptyDocument)
 {
     registerMockedHttpURLLoad("pageserializer/green_rectangle.svg");
 
     TestWillInsertBodyWebFrameClient webFrameClient;
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     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(ParametrizedWebFrameTest, MoveCaretSelectionTowardsWindowPointWithNoSelection)
+TEST_P(ParameterizedWebFrameTest, MoveCaretSelectionTowardsWindowPointWithNoSelection)
 {
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     webViewHelper.initializeAndLoad("about:blank", true);
     WebFrame* frame = webViewHelper.webView()->mainFrame();
 
     // This test passes if this doesn't crash.
     frame->moveCaretSelection(WebPoint(0, 0));
 }
 
 class SpellCheckClient : public WebSpellCheckClient {
 public:
     explicit SpellCheckClient(uint32_t hash = 0) : m_numberOfTimesChecked(0), m_hash(hash) { }
     virtual ~SpellCheckClient() { }
     virtual void requestCheckingOfText(const 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(ParametrizedWebFrameTest, ReplaceMisspelledRange)
+TEST_P(ParameterizedWebFrameTest, ReplaceMisspelledRange)
 {
     registerMockedHttpURLLoad("spell.html");
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     webViewHelper.initializeAndLoad(m_baseURL + "spell.html");
     SpellCheckClient spellcheck;
     webViewHelper.webView()->setSpellCheckClient(&spellcheck);
 
     WebLocalFrameImpl* frame = toWebLocalFrameImpl(webViewHelper.webView()->mainFrame());
     Document* document = frame->frame()->document();
     Element* element = document->getElementById("data");
@@ skipping 10 matching lines @@
     frame->selectRange(WebRange::fromDocumentRange(frame, allTextBeginOffset, allTextLength));
     RefPtrWillBeRawPtr<Range> selectionRange = frame->frame()->selection().toNormalizedRange();
 
     EXPECT_EQ(1, spellcheck.numberOfTimesChecked());
     EXPECT_EQ(1U, document->markers().markersInRange(selectionRange.get(), DocumentMarker::Spelling).size());
 
     frame->replaceMisspelledRange("welcome");
     EXPECT_EQ("_welcome_.", frame->contentAsText(std::numeric_limits<size_t>::max()).utf8());
 }
 
-TEST_P(ParametrizedWebFrameTest, RemoveSpellingMarkers)
+TEST_P(ParameterizedWebFrameTest, RemoveSpellingMarkers)
 {
     registerMockedHttpURLLoad("spell.html");
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     webViewHelper.initializeAndLoad(m_baseURL + "spell.html");
     SpellCheckClient spellcheck;
     webViewHelper.webView()->setSpellCheckClient(&spellcheck);
 
     WebLocalFrameImpl* frame = toWebLocalFrameImpl(webViewHelper.webView()->mainFrame());
     Document* document = frame->frame()->document();
     Element* element = document->getElementById("data");
 
     webViewHelper.webView()->settings()->setAsynchronousSpellCheckingEnabled(true);
     webViewHelper.webView()->settings()->setUnifiedTextCheckerEnabled(true);
     webViewHelper.webView()->settings()->setEditingBehavior(WebSettings::EditingBehaviorWin);
 
     element->focus();
     document->execCommand("InsertText", false, "_wellcome_.");
 
     frame->removeSpellingMarkers();
 
     const int allTextBeginOffset = 0;
     const int allTextLength = 11;
     frame->selectRange(WebRange::fromDocumentRange(frame, allTextBeginOffset, allTextLength));
     RefPtrWillBeRawPtr<Range> selectionRange = frame->frame()->selection().toNormalizedRange();
 
     EXPECT_EQ(0U, document->markers().markersInRange(selectionRange.get(), DocumentMarker::Spelling).size());
 }
 
-TEST_P(ParametrizedWebFrameTest, RemoveSpellingMarkersUnderWords)
+TEST_P(ParameterizedWebFrameTest, RemoveSpellingMarkersUnderWords)
 {
     registerMockedHttpURLLoad("spell.html");
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     webViewHelper.initializeAndLoad(m_baseURL + "spell.html");
     SpellCheckClient spellcheck;
     webViewHelper.webView()->setSpellCheckClient(&spellcheck);
 
     LocalFrame* frame = toWebLocalFrameImpl(webViewHelper.webView()->mainFrame())->frame();
     Document* document = frame->document();
     Element* element = document->getElementById("data");
@@ skipping 11 matching lines @@
 
     Vector<String> words;
     words.append("wellcome");
     frame->removeSpellingMarkersUnderWords(words);
 
     WebVector<uint32_t> documentMarkers2;
     webViewHelper.webView()->spellingMarkers(&documentMarkers2);
     EXPECT_EQ(0U, documentMarkers2.size());
 }
 
-TEST_P(ParametrizedWebFrameTest, MarkerHashIdentifiers)
+TEST_P(ParameterizedWebFrameTest, MarkerHashIdentifiers)
 {
     registerMockedHttpURLLoad("spell.html");
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     webViewHelper.initializeAndLoad(m_baseURL + "spell.html");
 
     static const uint32_t kHash = 42;
     SpellCheckClient spellcheck(kHash);
     webViewHelper.webView()->setSpellCheckClient(&spellcheck);
 
     WebLocalFrameImpl* frame = toWebLocalFrameImpl(webViewHelper.webView()->mainFrame());
@@ skipping 55 matching lines @@
         Vector<WebTextCheckingResult> results;
         if (misspellingStartOffset >= 0 && misspellingLength > 0)
             results.append(WebTextCheckingResult(type, misspellingStartOffset, misspellingLength));
         m_completion->didFinishCheckingText(results);
         m_completion = 0;
     }
 
     WebTextCheckingCompletion* m_completion;
 };
 
-TEST_P(ParametrizedWebFrameTest, SlowSpellcheckMarkerPosition)
+TEST_P(ParameterizedWebFrameTest, SlowSpellcheckMarkerPosition)
 {
     registerMockedHttpURLLoad("spell.html");
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     webViewHelper.initializeAndLoad(m_baseURL + "spell.html");
 
     StubbornSpellCheckClient spellcheck;
     webViewHelper.webView()->setSpellCheckClient(&spellcheck);
 
     WebLocalFrameImpl* frame = toWebLocalFrameImpl(webViewHelper.webView()->mainFrame());
     WebInputElement webInputElement = frame->document().getElementById("data").to<WebInputElement>();
@@ skipping 11 matching lines @@
 
     spellcheck.kick();
 
     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(ParametrizedWebFrameTest, CancelSpellingRequestCrash)
+TEST_P(ParameterizedWebFrameTest, CancelSpellingRequestCrash)
 {
     registerMockedHttpURLLoad("spell.html");
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     webViewHelper.initializeAndLoad(m_baseURL + "spell.html");
     webViewHelper.webView()->setSpellCheckClient(0);
 
     WebLocalFrameImpl* frame = toWebLocalFrameImpl(webViewHelper.webView()->mainFrame());
     Document* document = frame->frame()->document();
     Element* element = document->getElementById("data");
 
     webViewHelper.webView()->settings()->setAsynchronousSpellCheckingEnabled(true);
     webViewHelper.webView()->settings()->setUnifiedTextCheckerEnabled(true);
     webViewHelper.webView()->settings()->setEditingBehavior(WebSettings::EditingBehaviorWin);
 
     element->focus();
     frame->frame()->editor().replaceSelectionWithText("A", false, false);
     frame->frame()->spellChecker().cancelCheck();
 }
 
-TEST_P(ParametrizedWebFrameTest, SpellcheckResultErasesMarkers)
+TEST_P(ParameterizedWebFrameTest, SpellcheckResultErasesMarkers)
 {
     registerMockedHttpURLLoad("spell.html");
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     webViewHelper.initializeAndLoad(m_baseURL + "spell.html");
 
     StubbornSpellCheckClient spellcheck;
     webViewHelper.webView()->setSpellCheckClient(&spellcheck);
 
     WebLocalFrameImpl* frame = toWebLocalFrameImpl(webViewHelper.webView()->mainFrame());
     WebInputElement webInputElement = frame->document().getElementById("data").to<WebInputElement>();
     Document* document = frame->frame()->document();
     Element* element = document->getElementById("data");
 
     webViewHelper.webView()->settings()->setAsynchronousSpellCheckingEnabled(true);
     webViewHelper.webView()->settings()->setUnifiedTextCheckerEnabled(true);
     webViewHelper.webView()->settings()->setEditingBehavior(WebSettings::EditingBehaviorWin);
 
     element->focus();
     document->execCommand("InsertText", false, "welcome ");
     document->markers().addMarker(rangeOfContents(element->toNode()).get(), DocumentMarker::Spelling);
     document->markers().addMarker(rangeOfContents(element->toNode()).get(), DocumentMarker::Grammar);
     document->markers().addMarker(rangeOfContents(element->toNode()).get(), DocumentMarker::InvisibleSpellcheck);
     EXPECT_EQ(3U, document->markers().markers().size());
 
     spellcheck.kickNoResults();
     EXPECT_EQ(0U, document->markers().markers().size());
 }
 
-TEST_P(ParametrizedWebFrameTest, SpellcheckResultsSavedInDocument)
+TEST_P(ParameterizedWebFrameTest, SpellcheckResultsSavedInDocument)
 {
     registerMockedHttpURLLoad("spell.html");
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     webViewHelper.initializeAndLoad(m_baseURL + "spell.html");
 
     StubbornSpellCheckClient spellcheck;
     webViewHelper.webView()->setSpellCheckClient(&spellcheck);
 
     WebLocalFrameImpl* frame = toWebLocalFrameImpl(webViewHelper.webView()->mainFrame());
     WebInputElement webInputElement = frame->document().getElementById("data").to<WebInputElement>();
@@ skipping 35 matching lines @@
 
     virtual void didAccessInitialDocument(WebLocalFrame* frame)
     {
         EXPECT_TRUE(!m_didAccessInitialDocument);
         m_didAccessInitialDocument = true;
     }
 
     bool m_didAccessInitialDocument;
 };
 
-TEST_P(ParametrizedWebFrameTest, DidAccessInitialDocumentBody)
+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);
     webViewHelper.initialize(true, &webFrameClient, &webViewClient);
     runPendingTasks();
     EXPECT_FALSE(webFrameClient.m_didAccessInitialDocument);
@@ skipping 11 matching lines @@
     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(ParametrizedWebFrameTest, DidAccessInitialDocumentNavigator)
+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);
     webViewHelper.initialize(true, &webFrameClient, &webViewClient);
     runPendingTasks();
     EXPECT_FALSE(webFrameClient.m_didAccessInitialDocument);
 
     // Create another window that will try to access it.
     FrameTestHelpers::WebViewHelper newWebViewHelper(this);
     WebView* newView = newWebViewHelper.initialize(true);
     newView->mainFrame()->setOpener(webViewHelper.webView()->mainFrame());
     runPendingTasks();
     EXPECT_FALSE(webFrameClient.m_didAccessInitialDocument);
 
     // Access the initial document to get to the navigator object.
     newView->mainFrame()->executeScript(
         WebScriptSource("console.log(window.opener.navigator);"));
     runPendingTasks();
     EXPECT_TRUE(webFrameClient.m_didAccessInitialDocument);
 }
 
-TEST_P(ParametrizedWebFrameTest, DidAccessInitialDocumentViaJavascriptUrl)
+TEST_P(ParameterizedWebFrameTest, DidAccessInitialDocumentViaJavascriptUrl)
 {
     TestAccessInitialDocumentWebFrameClient webFrameClient;
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     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(ParametrizedWebFrameTest, DISABLED_DidAccessInitialDocumentBodyBeforeModalDialog)
+TEST_P(ParameterizedWebFrameTest, DISABLED_DidAccessInitialDocumentBodyBeforeModalDialog)
 #else
-TEST_P(ParametrizedWebFrameTest, DidAccessInitialDocumentBodyBeforeModalDialog)
+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);
     webViewHelper.initialize(true, &webFrameClient, &webViewClient);
     runPendingTasks();
@@ skipping 17 matching lines @@
         WebScriptSource("window.opener.confirm('Modal');"));
     EXPECT_TRUE(webFrameClient.m_didAccessInitialDocument);
 
     // Ensure that we don't notify again later.
     runPendingTasks();
     EXPECT_TRUE(webFrameClient.m_didAccessInitialDocument);
 }
 
 // Fails on the WebKit XP (deps) bot. http://crbug.com/312192
 #if OS(WIN)
-TEST_P(ParametrizedWebFrameTest, DISABLED_DidWriteToInitialDocumentBeforeModalDialog)
+TEST_P(ParameterizedWebFrameTest, DISABLED_DidWriteToInitialDocumentBeforeModalDialog)
 #else
-TEST_P(ParametrizedWebFrameTest, DidWriteToInitialDocumentBeforeModalDialog)
+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);
     webViewHelper.initialize(true, &webFrameClient, &webViewClient);
     runPendingTasks();
@@ skipping 101 matching lines @@
     EXPECT_FALSE(view->wasScrolledByUser());
     client.reset();
 
     // Programmatic scroll to same offset. No scroll event should be generated.
     frameImpl->executeScript(WebScriptSource("window.scrollTo(0, 20);"));
     EXPECT_FALSE(client.wasFrameScrolled());
     EXPECT_FALSE(view->wasScrolledByUser());
     client.reset();
 }
 
-TEST_P(ParametrizedWebFrameTest, FirstPartyForCookiesForRedirect)
+TEST_P(ParameterizedWebFrameTest, FirstPartyForCookiesForRedirect)
 {
     WTF::String filePath = Platform::current()->unitTestSupport()->webKitRootDir();
     filePath.append("/Source/web/tests/data/first_party.html");
 
     WebURL testURL(toKURL("http://internal.test/first_party_redirect.html"));
     char redirect[] = "http://internal.test/first_party.html";
     WebURL redirectURL(toKURL(redirect));
     WebURLResponse redirectResponse;
     redirectResponse.initialize();
     redirectResponse.setMIMEType("text/html");
@@ skipping 13 matching lines @@
 
 class TestNavigationPolicyWebFrameClient : public FrameTestHelpers::TestWebFrameClient {
 public:
 
     virtual void didNavigateWithinPage(WebLocalFrame*, const WebHistoryItem&, WebHistoryCommitType) override
     {
         EXPECT_TRUE(false);
     }
 };
 
-TEST_P(ParametrizedWebFrameTest, SimulateFragmentAnchorMiddleClick)
+TEST_P(ParameterizedWebFrameTest, SimulateFragmentAnchorMiddleClick)
 {
     registerMockedHttpURLLoad("fragment_middle_click.html");
     TestNavigationPolicyWebFrameClient client;
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     webViewHelper.initializeAndLoad(m_baseURL + "fragment_middle_click.html", true, &client);
 
     Document* document = toLocalFrame(webViewHelper.webViewImpl()->page()->mainFrame())->document();
     KURL destination = document->url();
     destination.setFragmentIdentifier("test");
 
@@ skipping 26 matching lines @@
         m_decidePolicyCallCount++;
         return info.defaultPolicy;
     }
 
     int decidePolicyCallCount() const { return m_decidePolicyCallCount; }
 
 private:
     int m_decidePolicyCallCount;
 };
 
-TEST_P(ParametrizedWebFrameTest, ModifiedClickNewWindow)
+TEST_P(ParameterizedWebFrameTest, ModifiedClickNewWindow)
 {
     registerMockedHttpURLLoad("ctrl_click.html");
     registerMockedHttpURLLoad("hello_world.html");
     TestNewWindowWebViewClient webViewClient;
     TestNewWindowWebFrameClient webFrameClient;
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     webViewHelper.initializeAndLoad(m_baseURL + "ctrl_click.html", true, &webFrameClient, &webViewClient);
 
     Document* document = toLocalFrame(webViewHelper.webViewImpl()->page()->mainFrame())->document();
     KURL destination = toKURL(m_baseURL + "hello_world.html");
 
     // ctrl+click event
     RefPtrWillBeRawPtr<Event> event = MouseEvent::create(EventTypeNames::click, false, false,
         document->domWindow(), 0, 0, 0, 0, 0, 0, 0, true, false, false, false, 0, 0, nullptr, nullptr);
     FrameLoadRequest frameRequest(document, ResourceRequest(destination));
     frameRequest.setTriggeringEvent(event);
     UserGestureIndicator gesture(DefinitelyProcessingUserGesture);
     toLocalFrame(webViewHelper.webViewImpl()->page()->mainFrame())->loader().load(frameRequest);
     FrameTestHelpers::pumpPendingRequestsDoNotUse(webViewHelper.webView()->mainFrame());
 
     // decidePolicyForNavigation should be called both for the original request and the ctrl+click.
     EXPECT_EQ(2, webFrameClient.decidePolicyCallCount());
 }
 
-TEST_P(ParametrizedWebFrameTest, BackToReload)
+TEST_P(ParameterizedWebFrameTest, BackToReload)
 {
     registerMockedHttpURLLoad("fragment_middle_click.html");
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     webViewHelper.initializeAndLoad(m_baseURL + "fragment_middle_click.html", true);
     WebFrame* frame = webViewHelper.webView()->mainFrame();
     const FrameLoader& mainFrameLoader = webViewHelper.webViewImpl()->mainFrameImpl()->frame()->loader();
     RefPtrWillBePersistent<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, WebURLRequest::UseProtocolCachePolicy);
     EXPECT_EQ(firstItem.get(), mainFrameLoader.currentItem());
 
     FrameTestHelpers::reloadFrame(frame);
     EXPECT_EQ(WebURLRequest::ReloadIgnoringCacheData, frame->dataSource()->request().cachePolicy());
 }
 
-TEST_P(ParametrizedWebFrameTest, BackDuringChildFrameReload)
+TEST_P(ParameterizedWebFrameTest, BackDuringChildFrameReload)
 {
     registerMockedHttpURLLoad("page_with_blank_iframe.html");
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     webViewHelper.initializeAndLoad(m_baseURL + "page_with_blank_iframe.html", true);
     WebFrame* mainFrame = webViewHelper.webView()->mainFrame();
     const FrameLoader& mainFrameLoader = webViewHelper.webViewImpl()->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());
     mainFrame->loadHistoryItem(item, WebHistoryDifferentDocumentLoad, WebURLRequest::UseProtocolCachePolicy);
 
     FrameTestHelpers::reloadFrame(childFrame);
     EXPECT_EQ(item.urlString(), mainFrame->document().url().string());
     EXPECT_EQ(item.urlString(), WebString(mainFrameLoader.currentItem()->urlString()));
 }
 
-TEST_P(ParametrizedWebFrameTest, ReloadPost)
+TEST_P(ParameterizedWebFrameTest, ReloadPost)
 {
     registerMockedHttpURLLoad("reload_post.html");
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     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::pumpPendingRequestsDoNotUse(webViewHelper.webView()->mainFrame());
     EXPECT_EQ(WebString::fromUTF8("POST"), frame->dataSource()->request().httpMethod());
 
     FrameTestHelpers::reloadFrame(frame);
     EXPECT_EQ(WebURLRequest::ReloadIgnoringCacheData, frame->dataSource()->request().cachePolicy());
     EXPECT_EQ(WebNavigationTypeFormResubmitted, frame->dataSource()->navigationType());
 }
 
-TEST_P(ParametrizedWebFrameTest, LoadHistoryItemReload)
+TEST_P(ParameterizedWebFrameTest, LoadHistoryItemReload)
 {
     registerMockedHttpURLLoad("fragment_middle_click.html");
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     webViewHelper.initializeAndLoad(m_baseURL + "fragment_middle_click.html", true);
     WebFrame* frame = webViewHelper.webView()->mainFrame();
     const FrameLoader& mainFrameLoader = webViewHelper.webViewImpl()->mainFrameImpl()->frame()->loader();
     RefPtrWillBePersistent<HistoryItem> firstItem = mainFrameLoader.currentItem();
     EXPECT_TRUE(firstItem);
 
     registerMockedHttpURLLoad("white-1x1.png");
@@ skipping 58 matching lines @@
 
 private:
     TestCachePolicyWebFrameClient* m_parentClient;
 
     WebURLRequest::CachePolicy m_policy;
     TestCachePolicyWebFrameClient* m_childClient;
     int m_willSendRequestCallCount;
     int m_childFrameCreationCount;
 };
 
-TEST_P(ParametrizedWebFrameTest, ReloadIframe)
+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);
     webViewHelper.initializeAndLoad(m_baseURL + "iframe_reload.html", true, &mainClient);
 
@@ skipping 27 matching lines @@
         if (toWebLocalFrameImpl(frame)->frame()->loader().loadType() == FrameLoadTypeSame)
             m_frameLoadTypeSameSeen = true;
     }
 
     bool frameLoadTypeSameSeen() const { return m_frameLoadTypeSameSeen; }
 
 private:
     bool m_frameLoadTypeSameSeen;
 };
 
-TEST_P(ParametrizedWebFrameTest, NavigateToSame)
+TEST_P(ParameterizedWebFrameTest, NavigateToSame)
 {
     registerMockedHttpURLLoad("navigate_to_same.html");
     TestSameDocumentWebFrameClient client;
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     webViewHelper.initializeAndLoad(m_baseURL + "navigate_to_same.html", true, &client);
     EXPECT_FALSE(client.frameLoadTypeSameSeen());
 
     FrameLoadRequest frameRequest(0, ResourceRequest(toLocalFrame(webViewHelper.webViewImpl()->page()->mainFrame())->document()->url()));
     toLocalFrame(webViewHelper.webViewImpl()->page()->mainFrame())->loader().load(frameRequest);
     FrameTestHelpers::pumpPendingRequestsDoNotUse(webViewHelper.webView()->mainFrame());
@@ skipping 15 matching lines @@
             EXPECT_EQ(WebURLRequest::UseProtocolCachePolicy, request.cachePolicy());
         }
     }
 
     int numOfImageRequests() const { return m_numOfImageRequests; }
 
 private:
     int m_numOfImageRequests;
 };
 
-TEST_P(ParametrizedWebFrameTest, NavigateToSameNoConditionalRequestForSubresource)
+TEST_P(ParameterizedWebFrameTest, NavigateToSameNoConditionalRequestForSubresource)
 {
     registerMockedHttpURLLoad("foo_with_image.html");
     registerMockedHttpURLLoad("white-1x1.png");
     TestSameDocumentWithImageWebFrameClient client;
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     webViewHelper.initializeAndLoad(m_baseURL + "foo_with_image.html", true, &client, 0, &configureLoadsImagesAutomatically);
 
     WebCache::clear();
     FrameTestHelpers::loadFrame(webViewHelper.webView()->mainFrame(), m_baseURL + "foo_with_image.html");
 
     EXPECT_EQ(client.numOfImageRequests(), 2);
 }
 
-TEST_P(ParametrizedWebFrameTest, WebNodeImageContents)
+TEST_P(ParameterizedWebFrameTest, WebNodeImageContents)
 {
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     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);
@@ skipping 38 matching lines @@
     int startLoadingCount() const { return m_startLoadingCount; }
     int stopLoadingCount() const { return m_stopLoadingCount; }
     int differentDocumentStartCount() const { return m_differentDocumentStartCount; }
 
 private:
     int m_startLoadingCount;
     int m_stopLoadingCount;
     int m_differentDocumentStartCount;
 };
 
-TEST_P(ParametrizedWebFrameTest, PushStateStartsAndStops)
+TEST_P(ParameterizedWebFrameTest, PushStateStartsAndStops)
 {
     registerMockedHttpURLLoad("push_state.html");
     TestStartStopCallbackWebFrameClient client;
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     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)
     {
     }
 
     virtual void didNavigateWithinPage(WebLocalFrame*, const WebHistoryItem&, WebHistoryCommitType type) override
     {
         m_lastCommitType = type;
     }
 
     WebHistoryCommitType lastCommitType() const { return m_lastCommitType; }
 
 private:
     WebHistoryCommitType m_lastCommitType;
 };
 
-TEST_P(ParametrizedWebFrameTest, SameDocumentHistoryNavigationCommitType)
+TEST_P(ParameterizedWebFrameTest, SameDocumentHistoryNavigationCommitType)
 {
     registerMockedHttpURLLoad("push_state.html");
     TestDidNavigateCommitTypeWebFrameClient client;
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     WebViewImpl* webViewImpl = webViewHelper.initializeAndLoad(m_baseURL + "push_state.html", true, &client);
     RefPtrWillBePersistent<HistoryItem> item = toLocalFrame(webViewImpl->page()->mainFrame())->loader().currentItem();
     runPendingTasks();
 
     toLocalFrame(webViewImpl->page()->mainFrame())->loader().loadHistoryItem(item.get(), FrameLoadTypeBackForward, HistorySameDocumentLoad);
     EXPECT_EQ(WebBackForwardCommit, client.lastCommitType());
@@ skipping 17 matching lines @@
     bool replacesCurrentHistoryItem() { return m_replacesCurrentHistoryItem; }
     WebFrame* frame() { return m_frame; }
 
 private:
     bool m_replacesCurrentHistoryItem;
     WebFrame* m_frame;
 };
 
 // Test which ensures that the first navigation in a subframe will always
 // result in history entry being replaced and not a new one added.
-TEST_P(ParametrizedWebFrameTest, DISABLED_FirstFrameNavigationReplacesHistory)
+TEST_P(ParameterizedWebFrameTest, DISABLED_FirstFrameNavigationReplacesHistory)
 {
     registerMockedHttpURLLoad("history.html");
     registerMockedHttpURLLoad("find.html");
 
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     TestHistoryWebFrameClient client;
     webViewHelper.initializeAndLoad("about:blank", true, &client);
     EXPECT_TRUE(client.replacesCurrentHistoryItem());
 
     WebFrame* frame = webViewHelper.webView()->mainFrame();
@@ skipping 53 matching lines @@
 
     // Call javascript to make the layer scrollable, and verify it.
     WebLocalFrameImpl* frame = (WebLocalFrameImpl*)webViewHelper.webView()->mainFrame();
     frame->executeScript(WebScriptSource("allowScroll();"));
     webViewHelper.webView()->layout();
     ASSERT_TRUE(webScrollLayer->userScrollableHorizontal());
     ASSERT_TRUE(webScrollLayer->userScrollableVertical());
 }
 
 // Test that currentHistoryItem reflects the current page, not the provisional load.
-TEST_P(ParametrizedWebFrameTest, CurrentHistoryItem)
+TEST_P(ParameterizedWebFrameTest, CurrentHistoryItem)
 {
     registerMockedHttpURLLoad("fixed_layout.html");
     std::string url = m_baseURL + "fixed_layout.html";
 
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     webViewHelper.initialize();
     WebFrame* frame = webViewHelper.webView()->mainFrame();
     const FrameLoader& mainFrameLoader = webViewHelper.webViewImpl()->mainFrameImpl()->frame()->loader();
     WebURLRequest request;
     request.initialize();
@@ skipping 21 matching lines @@
         return 0;
     }
 
     int callCount() const { return m_callCount; }
 
 private:
     int m_callCount;
 };
 
 // Test that we don't crash if WebFrameClient::createChildFrame() fails.
-TEST_P(ParametrizedWebFrameTest, CreateChildFrameFailure)
+TEST_P(ParameterizedWebFrameTest, CreateChildFrameFailure)
 {
     registerMockedHttpURLLoad("create_child_frame_fail.html");
     FailCreateChildFrame client;
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     webViewHelper.initializeAndLoad(m_baseURL + "create_child_frame_fail.html", true, &client);
 
     EXPECT_EQ(1, client.callCount());
 }
 
-TEST_P(ParametrizedWebFrameTest, fixedPositionInFixedViewport)
+TEST_P(ParameterizedWebFrameTest, fixedPositionInFixedViewport)
 {
     UseMockScrollbarSettings mockScrollbarSettings;
     registerMockedHttpURLLoad("fixed-position-in-fixed-viewport.html");
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     webViewHelper.initializeAndLoad(m_baseURL + "fixed-position-in-fixed-viewport.html", true, 0, 0, enableViewportSettings);
 
     WebView* webView = webViewHelper.webView();
     webView->resize(WebSize(100, 100));
 
     Document* document = toWebLocalFrameImpl(webView->mainFrame())->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.
     webView->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.
     webView->resize(WebSize(200, 200));
     EXPECT_EQ(500, rightFixed->offsetLeft() + rightFixed->offsetWidth());
     EXPECT_EQ(500, leftRightFixed->offsetWidth());
 }
 
-TEST_P(ParametrizedWebFrameTest, FrameViewMoveWithSetFrameRect)
+TEST_P(ParameterizedWebFrameTest, FrameViewMoveWithSetFrameRect)
 {
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     webViewHelper.initializeAndLoad("about:blank");
     webViewHelper.webViewImpl()->resize(WebSize(200, 200));
     webViewHelper.webViewImpl()->layout();
 
     FrameView* frameView = webViewHelper.webViewImpl()->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 57 matching lines @@
     // should allow an extra 0.5px of scrolling in the pinch viewport. Make
     // sure we're not losing any pixels when applying the adjustment on the
     // main frame.
     webView->applyViewportDeltas(WebFloatSize(), WebFloatSize(), WebFloatSize(), 1.0f, 1.0f / topControlsHeight);
     EXPECT_POINT_EQ(IntPoint(0, 1901), frameView->maximumScrollPosition());
 
     webView->applyViewportDeltas(WebFloatSize(), WebFloatSize(), WebFloatSize(), 1.0f, 2.0f / topControlsHeight);
     EXPECT_POINT_EQ(IntPoint(0, 1903), frameView->maximumScrollPosition());
 }
 
-TEST_P(ParametrizedWebFrameTest, FullscreenLayerSize)
+TEST_P(ParameterizedWebFrameTest, FullscreenLayerSize)
 {
     FakeCompositingWebViewClient client;
     registerMockedHttpURLLoad("fullscreen_div.html");
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     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, 0, &client, configureAndroid);
     webViewImpl->resize(WebSize(viewportWidth, viewportHeight));
@@ skipping 47 matching lines @@
 
     // Verify that the main frame is scrollable upon exiting fullscreen.
     webViewImpl->didExitFullScreen();
     webViewImpl->layout();
     ASSERT_FALSE(Fullscreen::isFullScreen(*document));
     webScrollLayer = webViewImpl->compositor()->scrollLayer()->platformLayer();
     ASSERT_TRUE(webScrollLayer->userScrollableHorizontal());
     ASSERT_TRUE(webScrollLayer->userScrollableVertical());
 }
 
-TEST_P(ParametrizedWebFrameTest, FullscreenMainFrame)
+TEST_P(ParameterizedWebFrameTest, FullscreenMainFrame)
 {
     FakeCompositingWebViewClient client;
     registerMockedHttpURLLoad("fullscreen_div.html");
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     int viewportWidth = 640;
     int viewportHeight = 480;
     WebViewImpl* webViewImpl = webViewHelper.initializeAndLoad(m_baseURL + "fullscreen_div.html", true, 0, &client, configureAndroid);
     webViewImpl->resize(WebSize(viewportWidth, viewportHeight));
     webViewImpl->layout();
 
@@ skipping 10 matching lines @@
     ASSERT_TRUE(webScrollLayer->userScrollableHorizontal());
     ASSERT_TRUE(webScrollLayer->userScrollableVertical());
 
     // Verify the main frame still behaves correctly after a resize.
     webViewImpl->resize(WebSize(viewportHeight, viewportWidth));
     ASSERT_TRUE(webScrollLayer->scrollable());
     ASSERT_TRUE(webScrollLayer->userScrollableHorizontal());
     ASSERT_TRUE(webScrollLayer->userScrollableVertical());
 }
 
-TEST_P(ParametrizedWebFrameTest, FullscreenSubframe)
+TEST_P(ParameterizedWebFrameTest, FullscreenSubframe)
 {
     FakeCompositingWebViewClient client;
     registerMockedHttpURLLoad("fullscreen_iframe.html");
     registerMockedHttpURLLoad("fullscreen_div.html");
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     WebViewImpl* webViewImpl = webViewHelper.initializeAndLoad(m_baseURL + "fullscreen_iframe.html", true, 0, &client, configureAndroid);
     int viewportWidth = 640;
     int viewportHeight = 480;
     client.m_screenInfo.rect.width = viewportWidth;
     client.m_screenInfo.rect.height = viewportHeight;
@@ skipping 45 matching lines @@
     webViewImpl->didEnterFullScreen();
     webViewImpl->layout();
 
     // Verify that the video layer is visible in fullscreen.
     DeprecatedPaintLayer* paintLayer =  videoFullscreen->layoutObject()->enclosingLayer();
     GraphicsLayer* graphicsLayer = paintLayer->graphicsLayerBacking();
     EXPECT_TRUE(graphicsLayer->contentsAreVisible());
     context->notifyContextDestroyed();
 }
 
-TEST_P(ParametrizedWebFrameTest, FullscreenWithTinyViewport)
+TEST_P(ParameterizedWebFrameTest, FullscreenWithTinyViewport)
 {
     FakeCompositingWebViewClient client;
     registerMockedHttpURLLoad("viewport-tiny.html");
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     WebViewImpl* webViewImpl = webViewHelper.initializeAndLoad(m_baseURL + "viewport-tiny.html", true, 0, &client, configureAndroid);
     int viewportWidth = 384;
     int viewportHeight = 640;
     client.m_screenInfo.rect.width = viewportWidth;
     client.m_screenInfo.rect.height = viewportHeight;
     webViewImpl->resize(WebSize(viewportWidth, viewportHeight));
@@ skipping 19 matching lines @@
 
     webViewImpl->didExitFullScreen();
     webViewImpl->layout();
     EXPECT_EQ(320, layoutView->logicalWidth().floor());
     EXPECT_EQ(533, layoutView->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(ParametrizedWebFrameTest, FullscreenResizeWithTinyViewport)
+TEST_P(ParameterizedWebFrameTest, FullscreenResizeWithTinyViewport)
 {
     FakeCompositingWebViewClient client;
     registerMockedHttpURLLoad("viewport-tiny.html");
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     WebViewImpl* webViewImpl = webViewHelper.initializeAndLoad(m_baseURL + "viewport-tiny.html", true, 0, &client, configureAndroid);
     int viewportWidth = 384;
     int viewportHeight = 640;
     client.m_screenInfo.rect.width = viewportWidth;
     client.m_screenInfo.rect.height = viewportHeight;
     webViewImpl->resize(WebSize(viewportWidth, viewportHeight));
@@ skipping 25 matching lines @@
 
     webViewImpl->didExitFullScreen();
     webViewImpl->layout();
     EXPECT_EQ(320, layoutView->logicalWidth().floor());
     EXPECT_EQ(192, layoutView->logicalHeight().floor());
     EXPECT_FLOAT_EQ(2, webViewImpl->pageScaleFactor());
     EXPECT_FLOAT_EQ(2, webViewImpl->minimumPageScaleFactor());
     EXPECT_FLOAT_EQ(5.0, webViewImpl->maximumPageScaleFactor());
 }
 
-TEST_P(ParametrizedWebFrameTest, LayoutBlockPercentHeightDescendants)
+TEST_P(ParameterizedWebFrameTest, LayoutBlockPercentHeightDescendants)
 {
     registerMockedHttpURLLoad("percent-height-descendants.html");
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     webViewHelper.initializeAndLoad(m_baseURL + "percent-height-descendants.html");
 
     WebView* webView = webViewHelper.webView();
     webView->resize(WebSize(800, 800));
     webView->layout();
 
     Document* document = toWebLocalFrameImpl(webView->mainFrame())->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(LayoutBlock::hasPercentHeightDescendant(percentHeightInAnonymous));
     EXPECT_TRUE(LayoutBlock::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(ParametrizedWebFrameTest, HasVisibleContentOnVisibleFrames)
+TEST_P(ParameterizedWebFrameTest, HasVisibleContentOnVisibleFrames)
 {
     registerMockedHttpURLLoad("visible_frames.html");
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     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(ParametrizedWebFrameTest, HasVisibleContentOnHiddenFrames)
+TEST_P(ParameterizedWebFrameTest, HasVisibleContentOnHiddenFrames)
 {
     registerMockedHttpURLLoad("hidden_frames.html");
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     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) { }
     virtual void didChangeManifest(WebLocalFrame*) override
     {
         ++m_manifestChangeCount;
     }
 
     int manifestChangeCount() { return m_manifestChangeCount; }
 
 private:
     int m_manifestChangeCount;
 };
 
-TEST_P(ParametrizedWebFrameTest, NotifyManifestChange)
+TEST_P(ParameterizedWebFrameTest, NotifyManifestChange)
 {
     registerMockedHttpURLLoad("link-manifest-change.html");
 
     ManifestChangeWebFrameClient webFrameClient;
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     webViewHelper.initializeAndLoad(m_baseURL + "link-manifest-change.html", true, &webFrameClient);
 
     EXPECT_EQ(14, webFrameClient.manifestChangeCount());
 }
 
 static ResourcePtr<Resource> fetchManifest(Document* document, const KURL& url)
 {
     FetchRequest fetchRequest = FetchRequest(ResourceRequest(url), FetchInitiatorInfo());
     fetchRequest.mutableResourceRequest().setRequestContext(WebURLRequest::RequestContextManifest);
 
     return document->fetcher()->fetchSynchronously(fetchRequest);
 }
 
-TEST_P(ParametrizedWebFrameTest, ManifestFetch)
+TEST_P(ParameterizedWebFrameTest, ManifestFetch)
 {
     registerMockedHttpURLLoad("foo.html");
     registerMockedHttpURLLoad("link-manifest-fetch.json");
 
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     webViewHelper.initializeAndLoad(m_baseURL + "foo.html");
     Document* document = toWebLocalFrameImpl(webViewHelper.webViewImpl()->mainFrame())->frame()->document();
 
     ResourcePtr<Resource> resource = fetchManifest(document, toKURL(m_baseURL + "link-manifest-fetch.json"));
 
     EXPECT_TRUE(resource->isLoaded());
 }
 
-TEST_P(ParametrizedWebFrameTest, ManifestCSPFetchAllow)
+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);
     webViewHelper.initializeAndLoad(m_baseURL + "foo.html");
     Document* document = toWebLocalFrameImpl(webViewHelper.webViewImpl()->mainFrame())->frame()->document();
 
     ResourcePtr<Resource> resource = fetchManifest(document, toKURL(m_notBaseURL + "link-manifest-fetch.json"));
 
     EXPECT_TRUE(resource->isLoaded());
 }
 
-TEST_P(ParametrizedWebFrameTest, ManifestCSPFetchSelf)
+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);
     webViewHelper.initializeAndLoad(m_baseURL + "foo.html");
     Document* document = toWebLocalFrameImpl(webViewHelper.webViewImpl()->mainFrame())->frame()->document();
 
     ResourcePtr<Resource> resource = fetchManifest(document, toKURL(m_notBaseURL + "link-manifest-fetch.json"));
 
     EXPECT_EQ(0, resource.get()); // Fetching resource wasn't allowed.
 }
 
-TEST_P(ParametrizedWebFrameTest, ManifestCSPFetchSelfReportOnly)
+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);
     webViewHelper.initializeAndLoad(m_baseURL + "foo.html");
     Document* document = toWebLocalFrameImpl(webViewHelper.webViewImpl()->mainFrame())->frame()->document();
 
     ResourcePtr<Resource> resource = fetchManifest(document, toKURL(m_notBaseURL + "link-manifest-fetch.json"));
 
     EXPECT_TRUE(resource->isLoaded());
 }
 
 
 class DefaultPresentationChangeWebFrameClient : public FrameTestHelpers::TestWebFrameClient {
 public:
     DefaultPresentationChangeWebFrameClient() : m_defaultPresentationChangeCount(0) { }
     virtual void didChangeDefaultPresentation(WebLocalFrame*) override
     {
         ++m_defaultPresentationChangeCount;
     }
 
     int defaultPresentationChangeCount() { return m_defaultPresentationChangeCount; }
 
 private:
     int m_defaultPresentationChangeCount;
 };
 
-TEST_P(ParametrizedWebFrameTest, NotifyDefaultPresentationChange)
+TEST_P(ParameterizedWebFrameTest, NotifyDefaultPresentationChange)
 {
     registerMockedHttpURLLoad("link-presentation-url-change.html");
 
     DefaultPresentationChangeWebFrameClient webFrameClient;
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     webViewHelper.initializeAndLoad(m_baseURL + "link-presentation-url-change.html", true, &webFrameClient);
 
     EXPECT_EQ(14, webFrameClient.defaultPresentationChangeCount());
 }
 
 
-TEST_P(ParametrizedWebFrameTest, ReloadBypassingCache)
+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);
     webViewHelper.initializeAndLoad(m_baseURL + "foo.html", true);
     WebFrame* frame = webViewHelper.webView()->mainFrame();
     FrameTestHelpers::reloadFrameIgnoringCache(frame);
     EXPECT_EQ(WebURLRequest::ReloadBypassingCache, frame->dataSource()->request().cachePolicy());
 }
 
 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(ParametrizedWebFrameTest, NodeImageTestCSSTransform)
+TEST_P(ParameterizedWebFrameTest, NodeImageTestCSSTransform)
 {
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     OwnPtr<DragImage> dragImage = nodeImageTestSetup(&webViewHelper, std::string("case-css-transform"));
     EXPECT_TRUE(dragImage);
 
     nodeImageTestValidation(IntSize(40, 40), dragImage.get());
 }
 
-TEST_P(ParametrizedWebFrameTest, NodeImageTestCSS3DTransform)
+TEST_P(ParameterizedWebFrameTest, NodeImageTestCSS3DTransform)
 {
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     OwnPtr<DragImage> dragImage = nodeImageTestSetup(&webViewHelper, std::string("case-css-3dtransform"));
     EXPECT_TRUE(dragImage);
 
     nodeImageTestValidation(IntSize(20, 40), dragImage.get());
 }
 
-TEST_P(ParametrizedWebFrameTest, NodeImageTestInlineBlock)
+TEST_P(ParameterizedWebFrameTest, NodeImageTestInlineBlock)
 {
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     OwnPtr<DragImage> dragImage = nodeImageTestSetup(&webViewHelper, std::string("case-inlineblock"));
     EXPECT_TRUE(dragImage);
 
     nodeImageTestValidation(IntSize(40, 40), dragImage.get());
 }
 
-TEST_P(ParametrizedWebFrameTest, NodeImageTestFloatLeft)
+TEST_P(ParameterizedWebFrameTest, NodeImageTestFloatLeft)
 {
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     OwnPtr<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(ParametrizedWebFrameTest, DISABLED_PrintingBasic)
+TEST_P(ParameterizedWebFrameTest, DISABLED_PrintingBasic)
 #else
-TEST_P(ParametrizedWebFrameTest, PrintingBasic)
+TEST_P(ParameterizedWebFrameTest, PrintingBasic)
 #endif
 {
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     webViewHelper.initializeAndLoad("data:text/html,Hello, world.");
 
     WebFrame* frame = webViewHelper.webView()->mainFrame();
 
     WebPrintParams printParams;
     printParams.printContentArea.width = 500;
     printParams.printContentArea.height = 500;
@@ skipping 22 matching lines @@
 
 private:
     virtual void didChangeThemeColor()
     {
         m_didNotify = true;
     }
 
     bool m_didNotify;
 };
 
-TEST_P(ParametrizedWebFrameTest, ThemeColor)
+TEST_P(ParameterizedWebFrameTest, ThemeColor)
 {
     registerMockedHttpURLLoad("theme_color_test.html");
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     ThemeColorTestWebFrameClient client;
     webViewHelper.initializeAndLoad(m_baseURL + "theme_color_test.html", true, &client);
     EXPECT_TRUE(client.didNotify());
     WebLocalFrameImpl* frame = webViewHelper.webViewImpl()->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());
     // Change color by hsl.
     client.reset();
     frame->executeScript(WebScriptSource("document.getElementById('tc1').setAttribute('content', 'hsl(240,100%, 50%)');"));
     EXPECT_TRUE(client.didNotify());
     EXPECT_EQ(0xff0000ff, frame->document().themeColor());
     // Change of second theme-color meta tag will not change frame's theme
     // color.
     client.reset();
     frame->executeScript(WebScriptSource("document.getElementById('tc2').setAttribute('content', '#00FF00');"));
     EXPECT_TRUE(client.didNotify());
     EXPECT_EQ(0xff0000ff, frame->document().themeColor());
 }
 
 // Make sure that an embedder-triggered detach with a remote frame parent
 // doesn't leave behind dangling pointers.
-TEST_P(ParametrizedWebFrameTest, EmbedderTriggeredDetachWithRemoteMainFrame)
+TEST_P(ParameterizedWebFrameTest, EmbedderTriggeredDetachWithRemoteMainFrame)
 {
     // FIXME: Refactor some of this logic into WebViewHelper to make it easier to
     // write tests with a top-level remote frame.
     FrameTestHelpers::TestWebViewClient viewClient;
     FrameTestHelpers::TestWebRemoteFrameClient remoteClient;
     WebView* view = WebView::create(&viewClient);
     view->setMainFrame(remoteClient.frame());
     FrameTestHelpers::TestWebFrameClient childFrameClient;
     WebLocalFrame* childFrame = view->mainFrame()->toWebRemoteFrame()->createLocalChild(WebTreeScopeType::Document, "", WebSandboxFlags::None, &childFrameClient, nullptr);
 
@@ skipping 513 matching lines @@
     {
         m_historyCommitType = historyCommitType;
     }
 
     WebHistoryCommitType historyCommitType() const { return m_historyCommitType; }
 
 private:
     WebHistoryCommitType m_historyCommitType;
 };
 
-TEST_P(ParametrizedWebFrameTest, RemoteFrameInitialCommitType)
+TEST_P(ParameterizedWebFrameTest, RemoteFrameInitialCommitType)
 {
     FrameTestHelpers::TestWebViewClient viewClient;
     FrameTestHelpers::TestWebRemoteFrameClient remoteClient;
     WebView* view = WebView::create(&viewClient);
     view->setMainFrame(remoteClient.frame());
     toRemoteFrame(toCoreFrame(view->mainFrame()))->securityContext()->setReplicatedOrigin(SecurityOrigin::create(toKURL(m_baseURL)));
 
     // If an iframe has a remote main frame, ensure the inital commit is correctly identified as WebInitialCommitInChildFrame.
     CommitTypeWebFrameClient childFrameClient;
     WebLocalFrame* childFrame = view->mainFrame()->toWebRemoteFrame()->createLocalChild(WebTreeScopeType::Document, "", WebSandboxFlags::None, &childFrameClient, nullptr);
@@ skipping 10 matching lines @@
 
     void reset() { m_failed = false; }
     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(ParametrizedWebFrameTest, LoaderOriginAccess)
+TEST_P(ParameterizedWebFrameTest, LoaderOriginAccess)
 {
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     webViewHelper.initializeAndLoad("about:blank");
 
     SchemeRegistry::registerURLSchemeAsDisplayIsolated("chrome");
 
     // Cross-origin request.
     KURL resourceUrl(ParsedURLString, "chrome://test.pdf");
     registerMockedChromeURLLoad("test.pdf");
 
@@ skipping 10 matching lines @@
     EXPECT_TRUE(client.failed());
 
     client.reset();
     // Try to load the request with cross origin access. Should succeed.
     options.crossOriginRequestPolicy = AllowCrossOriginRequests;
     DocumentThreadableLoader::loadResourceSynchronously(
         *frame->document(), ResourceRequest(resourceUrl), client, options, resourceLoaderOptions);
     EXPECT_FALSE(client.failed());
 }
 
-TEST_P(ParametrizedWebFrameTest, DetachRemoteFrame)
+TEST_P(ParameterizedWebFrameTest, DetachRemoteFrame)
 {
     FrameTestHelpers::TestWebViewClient viewClient;
     FrameTestHelpers::TestWebRemoteFrameClient remoteClient;
     WebView* view = WebView::create(&viewClient);
     view->setMainFrame(remoteClient.frame());
     FrameTestHelpers::TestWebRemoteFrameClient childFrameClient;
     WebRemoteFrame* childFrame = view->mainFrame()->toWebRemoteFrame()->createRemoteChild(WebTreeScopeType::Document, "", WebSandboxFlags::None, &childFrameClient);
     childFrame->detach();
     view->close();
 }
 
 class TestConsoleMessageWebFrameClient : public FrameTestHelpers::TestWebFrameClient {
 public:
     virtual void didAddMessageToConsole(const WebConsoleMessage& message, const WebString& sourceName, unsigned sourceLine, const WebString& stackTrace)
     {
         messages.push_back(message);
     }
 
     std::vector<WebConsoleMessage> messages;
 };
 
-TEST_P(ParametrizedWebFrameTest, CrossDomainAccessErrorsUseCallingWindow)
+TEST_P(ParameterizedWebFrameTest, CrossDomainAccessErrorsUseCallingWindow)
 {
     registerMockedHttpURLLoad("hidden_frames.html");
     registerMockedChromeURLLoad("hello_world.html");
 
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     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
@@ skipping 17 matching lines @@
     EXPECT_TRUE(webFrameClient.messages.empty());
     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();
 }
 
-TEST_P(ParametrizedWebFrameTest, CreateLocalChildWithPreviousSibling)
+TEST_P(ParameterizedWebFrameTest, CreateLocalChildWithPreviousSibling)
 {
     FrameTestHelpers::TestWebViewClient viewClient;
     FrameTestHelpers::TestWebRemoteFrameClient remoteClient;
     WebView* view = WebView::create(&viewClient);
     view->setMainFrame(remoteClient.frame());
     WebRemoteFrame* parent = view->mainFrame()->toWebRemoteFrame();
 
     WebLocalFrame* secondFrame = parent->createLocalChild(WebTreeScopeType::Document, "", WebSandboxFlags::None, nullptr, nullptr);
     WebLocalFrame* fourthFrame = parent->createLocalChild(WebTreeScopeType::Document, "", WebSandboxFlags::None, nullptr, secondFrame);
     WebLocalFrame* thirdFrame = parent->createLocalChild(WebTreeScopeType::Document, "", WebSandboxFlags::None, nullptr, secondFrame);
@@ skipping 15 matching lines @@
 
     EXPECT_EQ(parent, firstFrame->parent());
     EXPECT_EQ(parent, secondFrame->parent());
     EXPECT_EQ(parent, thirdFrame->parent());
     EXPECT_EQ(parent, fourthFrame->parent());
 
     view->close();
 }
 
 } // namespace blink