reflow comments in web/tests

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

 /*
  * Copyright (C) 2010 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 387 matching lines @@
   webViewHelper.webView()
       ->mainFrameImpl()
       ->frame()
       ->document()
       ->suspendScheduledTasks();
   webViewHelper.webView()->mainFrameImpl()->requestExecuteScriptAndReturnValue(
       WebScriptSource(WebString("'hello';")), false, &callbackHelper);
   runPendingTasks();
   EXPECT_FALSE(callbackHelper.didComplete());
 
-  // If the frame navigates, pending scripts should be removed, but the callback should always be ran.
+  // If the frame navigates, pending scripts should be removed, but the callback
+  // should always be ran.
   FrameTestHelpers::loadFrame(webViewHelper.webView()->mainFrame(),
                               m_baseURL + "bar.html");
   EXPECT_TRUE(callbackHelper.didComplete());
   EXPECT_EQ(String(), callbackHelper.stringValue());
 }
 
 TEST_P(ParameterizedWebFrameTest, IframeScriptRemovesSelf) {
   registerMockedHttpURLLoad("single_iframe.html");
   registerMockedHttpURLLoad("visible_iframe.html");
 
@@ skipping 39 matching lines @@
 
   // Pass true to enable JavaScript.
   FrameTestHelpers::WebViewHelper webViewHelper;
   webViewHelper.initializeAndLoad(m_chromeURL + "history.html", true);
 
   // Try to run JS against the chrome-style URL.
   FrameTestHelpers::loadFrame(webViewHelper.webView()->mainFrame(),
                               "javascript:document.body.appendChild(document."
                               "createTextNode('Clobbered'))");
 
-  // Now retrieve the frame's text and ensure it was modified by running javascript.
+  // Now retrieve the frame's text and ensure it was modified by running
+  // javascript.
   std::string content =
       WebFrameContentDumper::dumpWebViewAsText(webViewHelper.webView(), 1024)
           .utf8();
   EXPECT_NE(std::string::npos, content.find("Clobbered"));
 }
 
 TEST_P(ParameterizedWebFrameTest, ChromePageNoJavascript) {
   registerMockedChromeURLLoad("history.html");
 
   /// Pass true to enable JavaScript.
   FrameTestHelpers::WebViewHelper webViewHelper;
   webViewHelper.initializeAndLoad(m_chromeURL + "history.html", true);
 
   // Try to run JS against the chrome-style URL after prohibiting it.
   WebSecurityPolicy::registerURLSchemeAsNotAllowingJavascriptURLs("chrome");
   FrameTestHelpers::loadFrame(webViewHelper.webView()->mainFrame(),
                               "javascript:document.body.appendChild(document."
                               "createTextNode('Clobbered'))");
 
-  // Now retrieve the frame's text and ensure it wasn't modified by running javascript.
+  // Now retrieve the frame's text and ensure it wasn't modified by running
+  // javascript.
   std::string content =
       WebFrameContentDumper::dumpWebViewAsText(webViewHelper.webView(), 1024)
           .utf8();
   EXPECT_EQ(std::string::npos, content.find("Clobbered"));
 }
 
 TEST_P(ParameterizedWebFrameTest, LocationSetHostWithMissingPort) {
   std::string fileName = "print-location-href.html";
   registerMockedHttpURLLoad(fileName);
   URLTestHelpers::registerMockedURLLoad(
@@ skipping 446 matching lines @@
 
   Document* document =
       toLocalFrame(webViewHelper.webView()->page()->mainFrame())->document();
   document->settings()->setTextAutosizingEnabled(true);
   EXPECT_TRUE(document->settings()->textAutosizingEnabled());
   webViewHelper.resize(WebSize(viewportWidth, viewportHeight));
 
   EXPECT_TRUE(setTextAutosizingMultiplier(document, 2));
 
   ViewportDescription description = document->viewportDescription();
-  // Choose a width that's not going match the viewport width of the loaded document.
+  // Choose a width that's not going match the viewport width of the loaded
+  // document.
   description.minWidth = Length(100, blink::Fixed);
   description.maxWidth = Length(100, blink::Fixed);
   webViewHelper.webView()->updatePageDefinedViewportConstraints(description);
 
   EXPECT_TRUE(checkTextAutosizingMultiplier(document, 1));
 }
 
 TEST_P(ParameterizedWebFrameTest,
        WorkingTextAutosizingMultipliers_VirtualViewport) {
   const std::string htmlFile = "fixed_layout.html";
@@ skipping 254 matching lines @@
   int viewportHeight = 480;
 
   FrameTestHelpers::WebViewHelper webViewHelper;
   webViewHelper.initializeAndLoad(m_baseURL + "large-div.html", true, nullptr,
                                   &client, nullptr, enableViewportSettings);
   webViewHelper.webView()->settings()->setLoadWithOverviewMode(false);
   webViewHelper.webView()->settings()->setWideViewportQuirkEnabled(true);
   webViewHelper.webView()->settings()->setUseWideViewport(false);
   webViewHelper.resize(WebSize(viewportWidth, viewportHeight));
 
-  // The page must be displayed at 100% zoom, despite that it hosts a wide div element.
+  // The page must be displayed at 100% zoom, despite that it hosts a wide div
+  // element.
   EXPECT_EQ(1.0f, webViewHelper.webView()->pageScaleFactor());
 }
 
 TEST_P(ParameterizedWebFrameTest, NoWideViewportIgnoresPageViewportWidth) {
   registerMockedHttpURLLoad("viewport-auto-initial-scale.html");
 
   FixedLayoutTestWebViewClient client;
   client.m_screenInfo.deviceScaleFactor = 1;
   int viewportWidth = 640;
   int viewportHeight = 480;
 
   FrameTestHelpers::WebViewHelper webViewHelper;
   webViewHelper.initializeAndLoad(
       m_baseURL + "viewport-auto-initial-scale.html", true, nullptr, &client,
       nullptr, enableViewportSettings);
   webViewHelper.webView()->settings()->setWideViewportQuirkEnabled(true);
   webViewHelper.webView()->settings()->setUseWideViewport(false);
   webViewHelper.resize(WebSize(viewportWidth, viewportHeight));
 
-  // The page sets viewport width to 3000, but with UseWideViewport == false is must be ignored.
+  // The page sets viewport width to 3000, but with UseWideViewport == false is
+  // must be ignored.
   EXPECT_EQ(viewportWidth, webViewHelper.webView()
                                ->mainFrameImpl()
                                ->frameView()
                                ->contentsSize()
                                .width());
   EXPECT_EQ(viewportHeight, webViewHelper.webView()
                                 ->mainFrameImpl()
                                 ->frameView()
                                 ->contentsSize()
                                 .height());
 }
 
 TEST_P(ParameterizedWebFrameTest,
        NoWideViewportIgnoresPageViewportWidthButAccountsScale) {
   registerMockedHttpURLLoad("viewport-wide-2x-initial-scale.html");
 
   FixedLayoutTestWebViewClient client;
   client.m_screenInfo.deviceScaleFactor = 1;
   int viewportWidth = 640;
   int viewportHeight = 480;
 
   FrameTestHelpers::WebViewHelper webViewHelper;
   webViewHelper.initializeAndLoad(
       m_baseURL + "viewport-wide-2x-initial-scale.html", true, nullptr, &client,
       nullptr, enableViewportSettings);
   webViewHelper.webView()->settings()->setWideViewportQuirkEnabled(true);
   webViewHelper.webView()->settings()->setUseWideViewport(false);
   webViewHelper.resize(WebSize(viewportWidth, viewportHeight));
 
-  // The page sets viewport width to 3000, but with UseWideViewport == false it must be ignored.
-  // While the initial scale specified by the page must be accounted.
+  // The page sets viewport width to 3000, but with UseWideViewport == false it
+  // must be ignored while the initial scale specified by the page must be
+  // accounted.
   EXPECT_EQ(viewportWidth / 2, webViewHelper.webView()
                                    ->mainFrameImpl()
                                    ->frameView()
                                    ->contentsSize()
                                    .width());
   EXPECT_EQ(viewportHeight / 2, webViewHelper.webView()
                                     ->mainFrameImpl()
                                     ->frameView()
                                     ->contentsSize()
                                     .height());
@@ skipping 120 matching lines @@
   int viewportWidth = 640;
   int viewportHeight = 480;
 
   FrameTestHelpers::WebViewHelper webViewHelper;
   webViewHelper.initializeAndLoad(
       m_baseURL + "viewport-wide-2x-initial-scale.html", true, nullptr, &client,
       nullptr, enableViewportSettings);
   webViewHelper.webView()->settings()->setLoadWithOverviewMode(false);
   webViewHelper.resize(WebSize(viewportWidth, viewportHeight));
 
-  // The page must be displayed at 200% zoom, as specified in its viewport meta tag.
+  // The page must be displayed at 200% zoom, as specified in its viewport meta
+  // tag.
   EXPECT_EQ(2.0f, webViewHelper.webView()->pageScaleFactor());
 }
 
 TEST_P(ParameterizedWebFrameTest, setInitialPageScaleFactorPermanently) {
   registerMockedHttpURLLoad("fixed_layout.html");
 
   FixedLayoutTestWebViewClient client;
   client.m_screenInfo.deviceScaleFactor = 1;
   float enforcedPageScaleFactor = 2.0f;
 
@@ skipping 61 matching lines @@
   webViewHelper.webView()->setInitialPageScaleOverride(enforcedPageScaleFactor);
   webViewHelper.resize(WebSize(viewportWidth, viewportHeight));
 
   EXPECT_EQ(enforcedPageScaleFactor,
             webViewHelper.webView()->pageScaleFactor());
 }
 
 TEST_P(ParameterizedWebFrameTest,
        SmallPermanentInitialPageScaleFactorIsClobbered) {
   const char* pages[] = {
-      // These pages trigger the clobbering condition. There must be a matching item in "pageScaleFactors" array.
+      // These pages trigger the clobbering condition. There must be a matching
+      // item in "pageScaleFactors" array.
       "viewport-device-0.5x-initial-scale.html",
       "viewport-initial-scale-1.html",
       // These ones do not.
       "viewport-auto-initial-scale.html",
       "viewport-target-densitydpi-device-and-fixed-width.html"};
   float pageScaleFactors[] = {0.5f, 1.0f};
   for (size_t i = 0; i < WTF_ARRAY_LENGTH(pages); ++i)
     registerMockedHttpURLLoad(pages[i]);
 
   FixedLayoutTestWebViewClient client;
@@ skipping 109 matching lines @@
   EXPECT_EQ(0, webViewHelper.webView()
                    ->mainFrameImpl()
                    ->frameView()
                    ->layoutSize()
                    .height());
   EXPECT_EQ(viewportWidth, compositor->containerLayer()->size().width());
   EXPECT_EQ(0.0, compositor->containerLayer()->size().height());
 
   // The flag ForceZeroLayoutHeight will cause the following resize of viewport
   // height to be ignored by the outer viewport (the container layer of
-  // LayerCompositor). The height of the visualViewport, however, is not affected.
+  // LayerCompositor). The height of the visualViewport, however, is not
+  // affected.
   webViewHelper.resize(WebSize(viewportWidth, viewportHeight));
   EXPECT_FALSE(
       webViewHelper.webView()->mainFrameImpl()->frameView()->needsLayout());
   EXPECT_EQ(viewportWidth, webViewHelper.webView()
                                ->mainFrameImpl()
                                ->frameView()
                                ->layoutSize()
                                .width());
   EXPECT_EQ(0, webViewHelper.webView()
                    ->mainFrameImpl()
@@ skipping 712 matching lines @@
 
     FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(
         m_baseURL + "viewport-target-densitydpi-high.html", true, nullptr,
         &client, nullptr, enableViewportSettings);
     webViewHelper.webView()->settings()->setWideViewportQuirkEnabled(true);
     webViewHelper.webView()->settings()->setSupportDeprecatedTargetDensityDPI(
         true);
     webViewHelper.resize(WebSize(viewportWidth, viewportHeight));
 
-    // We need to account for the fact that logical pixels are unconditionally multiplied by deviceScaleFactor to produce
-    // physical pixels.
+    // We need to account for the fact that logical pixels are unconditionally
+    // multiplied by deviceScaleFactor to produce physical pixels.
     float densityDpiScaleRatio = deviceScaleFactor * targetDpi / deviceDpi;
     EXPECT_NEAR(viewportWidth * densityDpiScaleRatio, webViewHelper.webView()
                                                           ->mainFrameImpl()
                                                           ->frameView()
                                                           ->layoutSize()
                                                           .width(),
                 1.0f);
     EXPECT_NEAR(viewportHeight * densityDpiScaleRatio, webViewHelper.webView()
                                                            ->mainFrameImpl()
                                                            ->frameView()
@@ skipping 353 matching lines @@
       webViewHelper.resize(WebSize(viewportSize.height, viewportSize.width));
       float expectedPageScaleFactor =
           initialPageScaleFactor *
           (shouldScaleRelativeToViewportWidth ? 1 / aspectRatio : 1);
       EXPECT_NEAR(expectedPageScaleFactor,
                   webViewHelper.webView()->pageScaleFactor(), 0.05f);
       EXPECT_EQ(WebSize(),
                 webViewHelper.webView()->mainFrame()->scrollOffset());
     }
 
-    // Resizing just the height should not affect pageScaleFactor or scrollOffset.
+    // Resizing just the height should not affect pageScaleFactor or
+    // scrollOffset.
     {
       webViewHelper.resize(WebSize(viewportSize.width, viewportSize.height));
       webViewHelper.webView()->setPageScaleFactor(initialPageScaleFactor);
       webViewHelper.webView()->mainFrame()->setScrollOffset(scrollOffset);
       webViewHelper.webView()->updateAllLifecyclePhases();
       const WebSize expectedScrollOffset =
           webViewHelper.webView()->mainFrame()->scrollOffset();
       webViewHelper.resize(
           WebSize(viewportSize.width, viewportSize.height * 0.8f));
       EXPECT_EQ(initialPageScaleFactor,
@@ skipping 37 matching lines @@
   const WebSize scrollOffset(0, 0);
   const WebSize viewportSize(240, 320);
   const bool shouldScaleRelativeToViewportWidth = false;
 
   testResizeYieldsCorrectScrollAndScale(url, initialPageScaleFactor,
                                         scrollOffset, viewportSize,
                                         shouldScaleRelativeToViewportWidth);
 }
 
 TEST_P(WebFrameResizeTest, ResizeYieldsCorrectScrollAndScaleForFixedWidth) {
-  // With a fixed width, pageScaleFactor scales by the relative change in viewport width.
+  // With a fixed width, pageScaleFactor scales by the relative change in
+  // viewport width.
   const char* url = "resize_scroll_fixed_width.html";
   const float initialPageScaleFactor = 2;
   const WebSize scrollOffset(0, 200);
   const WebSize viewportSize(240, 320);
   const bool shouldScaleRelativeToViewportWidth = true;
 
   testResizeYieldsCorrectScrollAndScale(url, initialPageScaleFactor,
                                         scrollOffset, viewportSize,
                                         shouldScaleRelativeToViewportWidth);
 }
 
 TEST_P(WebFrameResizeTest, ResizeYieldsCorrectScrollAndScaleForFixedLayout) {
-  // With a fixed layout, pageScaleFactor scales by the relative change in viewport width.
+  // With a fixed layout, pageScaleFactor scales by the relative change in
+  // viewport width.
   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);
 }
@@ skipping 279 matching lines @@
   WebRect topDiv(200, 100, 200, 150);
   WebRect bottomDiv(200, 300, 200, 150);
   WebPoint topPoint(topDiv.x + 50, topDiv.y + 50);
   WebPoint bottomPoint(bottomDiv.x + 50, bottomDiv.y + 50);
   float scale;
   setScaleAndScrollAndLayout(
       webViewHelper.webView(), WebPoint(0, 0),
       (webViewHelper.webView()->minimumPageScaleFactor()) *
           (1 + doubleTapZoomAlreadyLegibleRatio) / 2);
 
-  // Test double tap on two different divs
-  // After first zoom, we should go back to minimum page scale with a second double tap.
+  // Test double tap on two different divs.  After first zoom, we should go back
+  // to minimum page scale with a second double tap.
   simulateDoubleTap(webViewHelper.webView(), topPoint, scale);
   EXPECT_FLOAT_EQ(1, scale);
   simulateDoubleTap(webViewHelper.webView(), bottomPoint, scale);
   EXPECT_FLOAT_EQ(webViewHelper.webView()->minimumPageScaleFactor(), scale);
 
-  // If the user pinch zooms after double tap, a second double tap should zoom back to the div.
+  // If the user pinch zooms after double tap, a second double tap should zoom
+  // back to the div.
   simulateDoubleTap(webViewHelper.webView(), topPoint, scale);
   EXPECT_FLOAT_EQ(1, scale);
   webViewHelper.webView()->applyViewportDeltas(WebFloatSize(), WebFloatSize(),
                                                WebFloatSize(), 0.6f, 0);
   simulateDoubleTap(webViewHelper.webView(), bottomPoint, scale);
   EXPECT_FLOAT_EQ(1, scale);
   simulateDoubleTap(webViewHelper.webView(), bottomPoint, scale);
   EXPECT_FLOAT_EQ(webViewHelper.webView()->minimumPageScaleFactor(), scale);
 
-  // If we didn't yet get an auto-zoom update and a second double-tap arrives, should go back to minimum scale.
+  // If we didn't yet get an auto-zoom update and a second double-tap arrives,
+  // should go back to minimum scale.
   webViewHelper.webView()->applyViewportDeltas(WebFloatSize(), WebFloatSize(),
                                                WebFloatSize(), 1.1f, 0);
   webViewHelper.webView()->animateDoubleTapZoom(topPoint);
   EXPECT_TRUE(
       webViewHelper.webView()->fakeDoubleTapAnimationPendingForTesting());
   simulateDoubleTap(webViewHelper.webView(), bottomPoint, scale);
   EXPECT_FLOAT_EQ(webViewHelper.webView()->minimumPageScaleFactor(), scale);
 }
 
 TEST_F(WebFrameTest, DivAutoZoomScaleBoundsTest) {
@@ skipping 92 matching lines @@
   webViewHelper.webView()->updateAllLifecyclePhases();
 
   webViewHelper.webView()->enableFakePageScaleAnimationForTesting(true);
   webViewHelper.webView()->page()->settings().setTextAutosizingEnabled(true);
 
   WebRect div(200, 100, 200, 150);
   WebPoint doubleTapPoint(div.x + 50, div.y + 50);
   float scale;
 
   // Test double tap scale bounds.
-  // minimumPageScale < doubleTapZoomAlreadyLegibleScale < 1 < maximumLegibleScaleFactor
+  // minimumPageScale < doubleTapZoomAlreadyLegibleScale < 1 <
+  //     maximumLegibleScaleFactor
   float legibleScale = maximumLegibleScaleFactor;
   setScaleAndScrollAndLayout(
       webViewHelper.webView(), WebPoint(0, 0),
       (webViewHelper.webView()->minimumPageScaleFactor()) *
           (1 + doubleTapZoomAlreadyLegibleRatio) / 2);
   float doubleTapZoomAlreadyLegibleScale =
       webViewHelper.webView()->minimumPageScaleFactor() *
       doubleTapZoomAlreadyLegibleRatio;
   webViewHelper.webView()->setDefaultPageScaleLimits(0.5f, 4);
   webViewHelper.webView()->updateAllLifecyclePhases();
   simulateDoubleTap(webViewHelper.webView(), doubleTapPoint, scale);
   EXPECT_FLOAT_EQ(legibleScale, scale);
   simulateDoubleTap(webViewHelper.webView(), doubleTapPoint, scale);
   EXPECT_FLOAT_EQ(webViewHelper.webView()->minimumPageScaleFactor(), scale);
   simulateDoubleTap(webViewHelper.webView(), doubleTapPoint, scale);
   EXPECT_FLOAT_EQ(legibleScale, scale);
 
   // Zoom in to reset double_tap_zoom_in_effect flag.
   webViewHelper.webView()->applyViewportDeltas(WebFloatSize(), WebFloatSize(),
                                                WebFloatSize(), 1.1f, 0);
-  // 1 < maximumLegibleScaleFactor < minimumPageScale < doubleTapZoomAlreadyLegibleScale
+  // 1 < maximumLegibleScaleFactor < minimumPageScale <
+  //     doubleTapZoomAlreadyLegibleScale
   webViewHelper.webView()->setDefaultPageScaleLimits(1.0f, 4);
   webViewHelper.webView()->updateAllLifecyclePhases();
   doubleTapZoomAlreadyLegibleScale =
       webViewHelper.webView()->minimumPageScaleFactor() *
       doubleTapZoomAlreadyLegibleRatio;
   setScaleAndScrollAndLayout(
       webViewHelper.webView(), WebPoint(0, 0),
       (webViewHelper.webView()->minimumPageScaleFactor()) *
           (1 + doubleTapZoomAlreadyLegibleRatio) / 2);
   simulateDoubleTap(webViewHelper.webView(), doubleTapPoint, scale);
   EXPECT_FLOAT_EQ(doubleTapZoomAlreadyLegibleScale, scale);
   simulateDoubleTap(webViewHelper.webView(), doubleTapPoint, scale);
   EXPECT_FLOAT_EQ(webViewHelper.webView()->minimumPageScaleFactor(), scale);
   simulateDoubleTap(webViewHelper.webView(), doubleTapPoint, scale);
   EXPECT_FLOAT_EQ(doubleTapZoomAlreadyLegibleScale, scale);
 
   // Zoom in to reset double_tap_zoom_in_effect flag.
   webViewHelper.webView()->applyViewportDeltas(WebFloatSize(), WebFloatSize(),
                                                WebFloatSize(), 1.1f, 0);
-  // minimumPageScale < 1 < maximumLegibleScaleFactor < doubleTapZoomAlreadyLegibleScale
+  // minimumPageScale < 1 < maximumLegibleScaleFactor <
+  //     doubleTapZoomAlreadyLegibleScale
   webViewHelper.webView()->setDefaultPageScaleLimits(0.95f, 4);
   webViewHelper.webView()->updateAllLifecyclePhases();
   doubleTapZoomAlreadyLegibleScale =
       webViewHelper.webView()->minimumPageScaleFactor() *
       doubleTapZoomAlreadyLegibleRatio;
   setScaleAndScrollAndLayout(
       webViewHelper.webView(), WebPoint(0, 0),
       (webViewHelper.webView()->minimumPageScaleFactor()) *
           (1 + doubleTapZoomAlreadyLegibleRatio) / 2);
   simulateDoubleTap(webViewHelper.webView(), doubleTapPoint, scale);
   EXPECT_FLOAT_EQ(doubleTapZoomAlreadyLegibleScale, scale);
   simulateDoubleTap(webViewHelper.webView(), doubleTapPoint, scale);
   EXPECT_FLOAT_EQ(webViewHelper.webView()->minimumPageScaleFactor(), scale);
   simulateDoubleTap(webViewHelper.webView(), doubleTapPoint, scale);
   EXPECT_FLOAT_EQ(doubleTapZoomAlreadyLegibleScale, scale);
 
   // Zoom in to reset double_tap_zoom_in_effect flag.
   webViewHelper.webView()->applyViewportDeltas(WebFloatSize(), WebFloatSize(),
                                                WebFloatSize(), 1.1f, 0);
-  // minimumPageScale < 1 < doubleTapZoomAlreadyLegibleScale < maximumLegibleScaleFactor
+  // minimumPageScale < 1 < doubleTapZoomAlreadyLegibleScale <
+  //     maximumLegibleScaleFactor
   webViewHelper.webView()->setDefaultPageScaleLimits(0.9f, 4);
   webViewHelper.webView()->updateAllLifecyclePhases();
   doubleTapZoomAlreadyLegibleScale =
       webViewHelper.webView()->minimumPageScaleFactor() *
       doubleTapZoomAlreadyLegibleRatio;
   setScaleAndScrollAndLayout(
       webViewHelper.webView(), WebPoint(0, 0),
       (webViewHelper.webView()->minimumPageScaleFactor()) *
           (1 + doubleTapZoomAlreadyLegibleRatio) / 2);
   simulateDoubleTap(webViewHelper.webView(), doubleTapPoint, scale);
@@ skipping 22 matching lines @@
   webViewHelper.webView()->enableFakePageScaleAnimationForTesting(true);
   webViewHelper.webView()->page()->settings().setTextAutosizingEnabled(true);
   webViewHelper.webView()->page()->settings().setAccessibilityFontScaleFactor(
       accessibilityFontScaleFactor);
 
   WebRect div(200, 100, 200, 150);
   WebPoint doubleTapPoint(div.x + 50, div.y + 50);
   float scale;
 
   // Test double tap scale bounds.
-  // minimumPageScale < doubleTapZoomAlreadyLegibleScale < 1 < accessibilityFontScaleFactor
+  // minimumPageScale < doubleTapZoomAlreadyLegibleScale < 1 <
+  //     accessibilityFontScaleFactor
   float legibleScale = accessibilityFontScaleFactor;
   setScaleAndScrollAndLayout(
       webViewHelper.webView(), WebPoint(0, 0),
       (webViewHelper.webView()->minimumPageScaleFactor()) *
           (1 + doubleTapZoomAlreadyLegibleRatio) / 2);
   float doubleTapZoomAlreadyLegibleScale =
       webViewHelper.webView()->minimumPageScaleFactor() *
       doubleTapZoomAlreadyLegibleRatio;
   webViewHelper.webView()->setDefaultPageScaleLimits(0.5f, 4);
   webViewHelper.webView()->updateAllLifecyclePhases();
   simulateDoubleTap(webViewHelper.webView(), doubleTapPoint, scale);
   EXPECT_FLOAT_EQ(legibleScale, scale);
   simulateDoubleTap(webViewHelper.webView(), doubleTapPoint, scale);
   EXPECT_FLOAT_EQ(webViewHelper.webView()->minimumPageScaleFactor(), scale);
   simulateDoubleTap(webViewHelper.webView(), doubleTapPoint, scale);
   EXPECT_FLOAT_EQ(legibleScale, scale);
 
   // Zoom in to reset double_tap_zoom_in_effect flag.
   webViewHelper.webView()->applyViewportDeltas(WebFloatSize(), WebFloatSize(),
                                                WebFloatSize(), 1.1f, 0);
-  // 1 < accessibilityFontScaleFactor < minimumPageScale < doubleTapZoomAlreadyLegibleScale
+  // 1 < accessibilityFontScaleFactor < minimumPageScale <
+  //     doubleTapZoomAlreadyLegibleScale
   webViewHelper.webView()->setDefaultPageScaleLimits(1.0f, 4);
   webViewHelper.webView()->updateAllLifecyclePhases();
   doubleTapZoomAlreadyLegibleScale =
       webViewHelper.webView()->minimumPageScaleFactor() *
       doubleTapZoomAlreadyLegibleRatio;
   setScaleAndScrollAndLayout(
       webViewHelper.webView(), WebPoint(0, 0),
       (webViewHelper.webView()->minimumPageScaleFactor()) *
           (1 + doubleTapZoomAlreadyLegibleRatio) / 2);
   simulateDoubleTap(webViewHelper.webView(), doubleTapPoint, scale);
   EXPECT_FLOAT_EQ(doubleTapZoomAlreadyLegibleScale, scale);
   simulateDoubleTap(webViewHelper.webView(), doubleTapPoint, scale);
   EXPECT_FLOAT_EQ(webViewHelper.webView()->minimumPageScaleFactor(), scale);
   simulateDoubleTap(webViewHelper.webView(), doubleTapPoint, scale);
   EXPECT_FLOAT_EQ(doubleTapZoomAlreadyLegibleScale, scale);
 
   // Zoom in to reset double_tap_zoom_in_effect flag.
   webViewHelper.webView()->applyViewportDeltas(WebFloatSize(), WebFloatSize(),
                                                WebFloatSize(), 1.1f, 0);
-  // minimumPageScale < 1 < accessibilityFontScaleFactor < doubleTapZoomAlreadyLegibleScale
+  // minimumPageScale < 1 < accessibilityFontScaleFactor <
+  //     doubleTapZoomAlreadyLegibleScale
   webViewHelper.webView()->setDefaultPageScaleLimits(0.95f, 4);
   webViewHelper.webView()->updateAllLifecyclePhases();
   doubleTapZoomAlreadyLegibleScale =
       webViewHelper.webView()->minimumPageScaleFactor() *
       doubleTapZoomAlreadyLegibleRatio;
   setScaleAndScrollAndLayout(
       webViewHelper.webView(), WebPoint(0, 0),
       (webViewHelper.webView()->minimumPageScaleFactor()) *
           (1 + doubleTapZoomAlreadyLegibleRatio) / 2);
   simulateDoubleTap(webViewHelper.webView(), doubleTapPoint, scale);
   EXPECT_FLOAT_EQ(doubleTapZoomAlreadyLegibleScale, scale);
   simulateDoubleTap(webViewHelper.webView(), doubleTapPoint, scale);
   EXPECT_FLOAT_EQ(webViewHelper.webView()->minimumPageScaleFactor(), scale);
   simulateDoubleTap(webViewHelper.webView(), doubleTapPoint, scale);
   EXPECT_FLOAT_EQ(doubleTapZoomAlreadyLegibleScale, scale);
 
   // Zoom in to reset double_tap_zoom_in_effect flag.
   webViewHelper.webView()->applyViewportDeltas(WebFloatSize(), WebFloatSize(),
                                                WebFloatSize(), 1.1f, 0);
-  // minimumPageScale < 1 < doubleTapZoomAlreadyLegibleScale < accessibilityFontScaleFactor
+  // minimumPageScale < 1 < doubleTapZoomAlreadyLegibleScale <
+  //     accessibilityFontScaleFactor
   webViewHelper.webView()->setDefaultPageScaleLimits(0.9f, 4);
   webViewHelper.webView()->updateAllLifecyclePhases();
   doubleTapZoomAlreadyLegibleScale =
       webViewHelper.webView()->minimumPageScaleFactor() *
       doubleTapZoomAlreadyLegibleRatio;
   setScaleAndScrollAndLayout(
       webViewHelper.webView(), WebPoint(0, 0),
       (webViewHelper.webView()->minimumPageScaleFactor()) *
           (1 + doubleTapZoomAlreadyLegibleRatio) / 2);
   simulateDoubleTap(webViewHelper.webView(), doubleTapPoint, scale);
@@ skipping 193 matching lines @@
   // The edit box is wider than the viewport when legible.
   viewportWidth = 200;
   viewportHeight = 150;
   webViewHelper.resize(WebSize(viewportWidth, viewportHeight));
   setScaleAndScrollAndLayout(webViewHelper.webView(), WebPoint(0, 0),
                              initialScale);
   webViewHelper.webView()->computeScaleAndScrollForFocusedNode(
       webViewHelper.webView()->focusedElement(), autoZoomToLegibleScale, scale,
       scroll, needAnimation);
   EXPECT_TRUE(needAnimation);
-  // The caret should be right aligned since the caret would be offscreen when the edit box is left aligned.
+  // The caret should be right aligned since the caret would be offscreen when
+  // the edit box is left aligned.
   hScroll = caret.x + caret.width + caretPadding - viewportWidth / scale;
   EXPECT_NEAR(hScroll, scroll.x(), 2);
   EXPECT_NEAR(minReadableCaretHeight / caret.height, scale, 0.1);
 
   setScaleAndScrollAndLayout(webViewHelper.webView(), WebPoint(0, 0),
                              initialScale);
   // Move focus to edit box with text.
   webViewHelper.webView()->advanceFocus(false);
   webViewHelper.webView()->computeScaleAndScrollForFocusedNode(
       webViewHelper.webView()->focusedElement(), autoZoomToLegibleScale, scale,
@@ skipping 11 matching lines @@
   webViewHelper.webView()->advanceFocus(true);
   // Zoom out slightly.
   const float withinToleranceScale = scale * 0.9f;
   setScaleAndScrollAndLayout(webViewHelper.webView(), scroll,
                              withinToleranceScale);
   // Move focus back to the second edit box.
   webViewHelper.webView()->advanceFocus(false);
   webViewHelper.webView()->computeScaleAndScrollForFocusedNode(
       webViewHelper.webView()->focusedElement(), autoZoomToLegibleScale, scale,
       scroll, needAnimation);
-  // The scale should not be adjusted as the zoomed out scale was sufficiently close to the previously focused scale.
+  // The scale should not be adjusted as the zoomed out scale was sufficiently
+  // close to the previously focused scale.
   EXPECT_FALSE(needAnimation);
 }
 
 TEST_F(WebFrameTest, DivScrollIntoEditablePreservePageScaleTest) {
   registerMockedHttpURLLoad("get_scale_for_zoom_into_editable_test.html");
 
   const bool autoZoomToLegibleScale = true;
   const int viewportWidth = 450;
   const int viewportHeight = 300;
   const float minReadableCaretHeight = 16.0f;
@@ skipping 49 matching lines @@
   EXPECT_TRUE(needAnimation);
   // Horizontal scroll have to be the same
   EXPECT_NEAR(hScroll, scroll.x(), 1);
   vScroll =
       editBoxWithText.y - (viewportHeight / scale - editBoxWithText.height) / 2;
   EXPECT_NEAR(vScroll, scroll.y(), 1);
   // Page scale have to be unchanged
   EXPECT_EQ(newScale, scale);
 }
 
-// Tests the scroll into view functionality when autoZoomeFocusedNodeToLegibleScale set
-// to false. i.e. The path non-Android platforms take.
+// Tests the scroll into view functionality when
+// autoZoomeFocusedNodeToLegibleScale set to false. i.e. The path non-Android
+// platforms take.
 TEST_F(WebFrameTest, DivScrollIntoEditableTestZoomToLegibleScaleDisabled) {
   registerMockedHttpURLLoad("get_scale_for_zoom_into_editable_test.html");
 
   const bool autoZoomToLegibleScale = false;
   int viewportWidth = 100;
   int viewportHeight = 100;
   float leftBoxRatio = 0.3f;
   FrameTestHelpers::WebViewHelper webViewHelper;
   webViewHelper.initializeAndLoad(m_baseURL +
                                   "get_scale_for_zoom_into_editable_test.html");
   webViewHelper.webView()->page()->settings().setTextAutosizingEnabled(false);
   webViewHelper.resize(WebSize(viewportWidth, viewportHeight));
   webViewHelper.webView()->setDefaultPageScaleLimits(0.25f, 4);
 
   webViewHelper.webView()->enableFakePageScaleAnimationForTesting(true);
 
   WebRect editBoxWithText(200, 200, 250, 20);
   WebRect editBoxWithNoText(200, 250, 250, 20);
 
   // Test scrolling the focused node
-  // Since we're zoomed out, the caret is considered too small to be legible and so we'd
-  // normally zoom in. Make sure we don't change scale since the auto-zoom setting is off.
+  // Since we're zoomed out, the caret is considered too small to be legible and
+  // so we'd normally zoom in. Make sure we don't change scale since the
+  // auto-zoom setting is off.
 
   // Focus the second empty textbox.
   webViewHelper.webView()->advanceFocus(false);
   webViewHelper.webView()->advanceFocus(false);
 
   // Set the page scale to be smaller than the minimal readable scale.
   float initialScale = 0.25f;
   setScaleAndScrollAndLayout(webViewHelper.webView(), WebPoint(0, 0),
                              initialScale);
 
@@ skipping 17 matching lines @@
   setScaleAndScrollAndLayout(webViewHelper.webView(), scroll, scale);
 
   // Select the first textbox.
   webViewHelper.webView()->advanceFocus(true);
   WebRect rect, caret;
   webViewHelper.webView()->selectionBounds(caret, rect);
   webViewHelper.webView()->computeScaleAndScrollForFocusedNode(
       webViewHelper.webView()->focusedElement(), autoZoomToLegibleScale, scale,
       scroll, needAnimation);
 
-  // There should be no change at all since the textbox is fully visible already.
+  // There should be no change at all since the textbox is fully visible
+  // already.
   EXPECT_EQ(initialScale, scale);
   EXPECT_FALSE(needAnimation);
 }
 
 TEST_P(ParameterizedWebFrameTest, CharacterIndexAtPointWithPinchZoom) {
   registerMockedHttpURLLoad("sometext.html");
 
   FrameTestHelpers::WebViewHelper webViewHelper;
   webViewHelper.initializeAndLoad(m_baseURL + "sometext.html");
   webViewHelper.resize(WebSize(640, 480));
@@ skipping 125 matching lines @@
   webViewHelper.webView()->mainFrame()->reloadWithOverrideURL(
       toKURL(m_baseURL + thirdURL), WebFrameLoadType::ReloadBypassingCache);
   FrameTestHelpers::pumpPendingRequestsForFrameToLoad(
       webViewHelper.webView()->mainFrame());
   EXPECT_EQ(0, webViewHelper.webView()->mainFrame()->scrollOffset().width);
   EXPECT_EQ(0, webViewHelper.webView()->mainFrame()->scrollOffset().height);
   EXPECT_EQ(1.0f, webViewHelper.webView()->pageScaleFactor());
 }
 
 TEST_P(ParameterizedWebFrameTest, ReloadWhileProvisional) {
-  // Test that reloading while the previous load is still pending does not cause the initial
-  // request to get lost.
+  // 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;
   webViewHelper.initialize();
   WebURLRequest request;
   request.setURL(toKURL(m_baseURL + "fixed_layout.html"));
   request.setRequestorOrigin(WebSecurityOrigin::createUnique());
   webViewHelper.webView()->mainFrame()->loadRequest(request);
   // start reload before first request is delivered.
   FrameTestHelpers::reloadFrameIgnoringCache(
@@ skipping 24 matching lines @@
   EXPECT_EQ(toKURL(firstURL), KURL(redirects[0]));
   EXPECT_EQ(toKURL(secondURL), KURL(redirects[1]));
 }
 
 TEST_P(ParameterizedWebFrameTest, IframeRedirect) {
   registerMockedHttpURLLoad("iframe_redirect.html");
   registerMockedHttpURLLoad("visible_iframe.html");
 
   FrameTestHelpers::WebViewHelper webViewHelper;
   webViewHelper.initializeAndLoad(m_baseURL + "iframe_redirect.html", true);
-  // Pump pending requests one more time. The test page loads script that navigates.
+  // Pump pending requests one more time. The test page loads script that
+  // navigates.
   FrameTestHelpers::pumpPendingRequestsForFrameToLoad(
       webViewHelper.webView()->mainFrame());
 
   WebFrame* iframe = webViewHelper.webView()->findFrameByName(
       WebString::fromUTF8("ifr"), nullptr);
   ASSERT_TRUE(iframe);
   WebDataSource* iframeDataSource = iframe->dataSource();
   ASSERT_TRUE(iframeDataSource);
   WebVector<WebURL> redirects;
   iframeDataSource->redirectChain(redirects);
@@ skipping 70 matching lines @@
         wrapUnique(new Notification(frame, context, worldId)));
   }
 };
 
 TEST_P(ParameterizedWebFrameTest, ContextNotificationsLoadUnload) {
   v8::HandleScope handleScope(v8::Isolate::GetCurrent());
 
   registerMockedHttpURLLoad("context_notifications_test.html");
   registerMockedHttpURLLoad("context_notifications_test_frame.html");
 
-  // Load a frame with an iframe, make sure we get the right create notifications.
+  // Load a frame with an iframe, make sure we get the right create
+  // notifications.
   ContextLifetimeTestWebFrameClient webFrameClient;
   FrameTestHelpers::WebViewHelper webViewHelper;
   webViewHelper.initializeAndLoad(m_baseURL + "context_notifications_test.html",
                                   true, &webFrameClient);
 
   WebFrame* mainFrame = webViewHelper.webView()->mainFrame();
   WebFrame* childFrame = mainFrame->firstChild();
 
   ASSERT_EQ(2u, webFrameClient.createNotifications.size());
   EXPECT_EQ(0u, webFrameClient.releaseNotifications.size());
 
   auto& firstCreateNotification = webFrameClient.createNotifications[0];
   auto& secondCreateNotification = webFrameClient.createNotifications[1];
 
   EXPECT_EQ(mainFrame, firstCreateNotification->frame);
   EXPECT_EQ(mainFrame->mainWorldScriptContext(),
             firstCreateNotification->context);
   EXPECT_EQ(0, firstCreateNotification->worldId);
 
   EXPECT_EQ(childFrame, secondCreateNotification->frame);
   EXPECT_EQ(childFrame->mainWorldScriptContext(),
             secondCreateNotification->context);
   EXPECT_EQ(0, secondCreateNotification->worldId);
 
-  // Close the view. We should get two release notifications that are exactly the same as the create ones, in reverse order.
+  // Close the view. We should get two release notifications that are exactly
+  // the same as the create ones, in reverse order.
   webViewHelper.reset();
 
   ASSERT_EQ(2u, webFrameClient.releaseNotifications.size());
   auto& firstReleaseNotification = webFrameClient.releaseNotifications[0];
   auto& secondReleaseNotification = webFrameClient.releaseNotifications[1];
 
   ASSERT_TRUE(firstCreateNotification->Equals(secondReleaseNotification.get()));
   ASSERT_TRUE(secondCreateNotification->Equals(firstReleaseNotification.get()));
 }
 
 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;
   webViewHelper.initializeAndLoad(m_baseURL + "context_notifications_test.html",
                                   true, &webFrameClient);
 
-  // Refresh, we should get two release notifications and two more create notifications.
+  // Refresh, we should get two release notifications and two more create
+  // notifications.
   FrameTestHelpers::reloadFrame(webViewHelper.webView()->mainFrame());
   ASSERT_EQ(4u, webFrameClient.createNotifications.size());
   ASSERT_EQ(2u, webFrameClient.releaseNotifications.size());
 
-  // The two release notifications we got should be exactly the same as the first two create notifications.
+  // The two release notifications we got should be exactly the same as the
+  // first two create notifications.
   for (size_t i = 0; i < webFrameClient.releaseNotifications.size(); ++i) {
     EXPECT_TRUE(webFrameClient.releaseNotifications[i]->Equals(
         webFrameClient
             .createNotifications[webFrameClient.createNotifications.size() - 3 -
                                  i]
             .get()));
   }
 
-  // The last two create notifications should be for the current frames and context.
+  // The last two create notifications should be for the current frames and
+  // context.
   WebFrame* mainFrame = webViewHelper.webView()->mainFrame();
   WebFrame* childFrame = mainFrame->firstChild();
   auto& firstRefreshNotification = webFrameClient.createNotifications[2];
   auto& secondRefreshNotification = webFrameClient.createNotifications[3];
 
   EXPECT_EQ(mainFrame, firstRefreshNotification->frame);
   EXPECT_EQ(mainFrame->mainWorldScriptContext(),
             firstRefreshNotification->context);
   EXPECT_EQ(0, firstRefreshNotification->worldId);
 
@@ skipping 24 matching lines @@
   int extensionGroup = 0;
   webViewHelper.webView()->mainFrame()->executeScriptInIsolatedWorld(
       isolatedWorldId, &scriptSource, numSources, extensionGroup);
 
   // We should now have a new create notification.
   ASSERT_EQ(1u, webFrameClient.createNotifications.size());
   auto& notification = webFrameClient.createNotifications[0];
   ASSERT_EQ(isolatedWorldId, notification->worldId);
   ASSERT_EQ(webViewHelper.webView()->mainFrame(), notification->frame);
 
-  // We don't have an API to enumarate isolated worlds for a frame, but we can at least assert that the context we got is *not* the main world's context.
+  // We don't have an API to enumarate isolated worlds for a frame, but we can
+  // at least assert that the context we got is *not* the main world's context.
   ASSERT_NE(webViewHelper.webView()->mainFrame()->mainWorldScriptContext(),
             v8::Local<v8::Context>::New(isolate, notification->context));
 
   webViewHelper.reset();
 
-  // We should have gotten three release notifications (one for each of the frames, plus one for the isolated context).
+  // We should have gotten three release notifications (one for each of the
+  // frames, plus one for the isolated context).
   ASSERT_EQ(3u, webFrameClient.releaseNotifications.size());
 
-  // And one of them should be exactly the same as the create notification for the isolated context.
+  // 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].get()))
       ++matchCount;
   }
   EXPECT_EQ(1, matchCount);
 }
 
 TEST_P(ParameterizedWebFrameTest, FindInPage) {
@@ skipping 10 matching lines @@
       frame->find(findIdentifier, WebString::fromUTF8("bar1"), options, false));
   frame->stopFinding(WebLocalFrame::StopFindActionKeepSelection);
   WebRange range = frame->selectionRange();
   EXPECT_EQ(5, range.startOffset());
   EXPECT_EQ(9, range.endOffset());
   EXPECT_TRUE(frame->document().focusedElement().isNull());
 
   // Find in an <input> value.
   EXPECT_TRUE(
       frame->find(findIdentifier, WebString::fromUTF8("bar2"), options, false));
-  // Confirm stopFinding(WebLocalFrame::StopFindActionKeepSelection) sets the selection on the found text.
+  // Confirm stopFinding(WebLocalFrame::StopFindActionKeepSelection) sets the
+  // selection on the found text.
   frame->stopFinding(WebLocalFrame::StopFindActionKeepSelection);
   range = frame->selectionRange();
   ASSERT_FALSE(range.isNull());
   EXPECT_EQ(5, range.startOffset());
   EXPECT_EQ(9, range.endOffset());
   EXPECT_TRUE(frame->document().focusedElement().hasHTMLTagName("input"));
 
   // Find in a <textarea> content.
   EXPECT_TRUE(
       frame->find(findIdentifier, WebString::fromUTF8("bar3"), options, false));
-  // Confirm stopFinding(WebLocalFrame::StopFindActionKeepSelection) sets the selection on the found text.
+  // Confirm stopFinding(WebLocalFrame::StopFindActionKeepSelection) sets the
+  // selection on the found text.
   frame->stopFinding(WebLocalFrame::StopFindActionKeepSelection);
   range = frame->selectionRange();
   ASSERT_FALSE(range.isNull());
   EXPECT_EQ(5, range.startOffset());
   EXPECT_EQ(9, range.endOffset());
   EXPECT_TRUE(frame->document().focusedElement().hasHTMLTagName("textarea"));
 
   // Find in a contentEditable element.
   EXPECT_TRUE(
       frame->find(findIdentifier, WebString::fromUTF8("bar4"), options, false));
-  // Confirm stopFinding(WebLocalFrame::StopFindActionKeepSelection) sets the selection on the found text.
+  // Confirm stopFinding(WebLocalFrame::StopFindActionKeepSelection) sets the
+  // selection on the found text.
   frame->stopFinding(WebLocalFrame::StopFindActionKeepSelection);
   range = frame->selectionRange();
   ASSERT_FALSE(range.isNull());
   EXPECT_EQ(0, range.startOffset());
   EXPECT_EQ(4, range.endOffset());
-  // "bar4" is surrounded by <span>, but the focusable node should be the parent <div>.
+  // "bar4" is surrounded by <span>, but the focusable node should be the parent
+  // <div>.
   EXPECT_TRUE(frame->document().focusedElement().hasHTMLTagName("div"));
 
   // Find in <select> content.
   EXPECT_FALSE(
       frame->find(findIdentifier, WebString::fromUTF8("bar5"), options, false));
-  // If there are any matches, stopFinding will set the selection on the found text.
-  // However, we do not expect any matches, so check that the selection is null.
+  // If there are any matches, stopFinding will set the selection on the found
+  // text.  However, we do not expect any matches, so check that the selection
+  // is null.
   frame->stopFinding(WebLocalFrame::StopFindActionKeepSelection);
   range = frame->selectionRange();
   ASSERT_TRUE(range.isNull());
 }
 
 TEST_P(ParameterizedWebFrameTest, GetContentAsPlainText) {
   FrameTestHelpers::WebViewHelper webViewHelper;
   webViewHelper.initializeAndLoad("about:blank", true);
   // We set the size because it impacts line wrapping, which changes the
   // resulting text value.
@@ skipping 166 matching lines @@
     EXPECT_EQ(mainFrame->selectNearestFindMatch(resultRect.center(), 0),
               resultIndex + 1);
 
     // Check that the find result ordering matches with our expectations.
     Range* result = mainFrame->textFinder()->activeMatch();
     ASSERT_TRUE(result);
     result->setEnd(result->endContainer(), result->endOffset() + 3);
     EXPECT_EQ(result->text(),
               String::format("%s %02d", kFindString, resultIndex + 2));
 
-    // Verify that the expected match rect also matches the currently active match.
-    // Compare the enclosing rects to prevent precision issues caused by CSS transforms.
+    // Verify that the expected match rect also matches the currently active
+    // match.  Compare the enclosing rects to prevent precision issues caused by
+    // CSS transforms.
     FloatRect activeMatch = mainFrame->activeFindMatchRect();
     EXPECT_EQ(enclosingIntRect(activeMatch), enclosingIntRect(resultRect));
 
     // The rects version should not have changed.
     EXPECT_EQ(mainFrame->findMatchMarkersVersion(), rectsVersion);
   }
 
   // Resizing should update the rects version.
   webViewHelper.resize(WebSize(800, 600));
   runPendingTasks();
@@ skipping 158 matching lines @@
   runPendingTasks();
   EXPECT_FALSE(client.findResultsAreReady());
 
   mainFrame->ensureTextFinder().resetMatchCount();
 
   for (WebLocalFrameImpl* frame = mainFrame; frame;
        frame = static_cast<WebLocalFrameImpl*>(frame->traverseNext(false)))
     frame->ensureTextFinder().scopeStringMatches(kFindIdentifier, searchText,
                                                  options, true);
 
-  // The first scopeStringMatches will have reset the state. Detach before it actually scopes.
+  // The first scopeStringMatches will have reset the state. Detach before it
+  // actually scopes.
   removeElementById(mainFrame, "frame");
 
   runPendingTasks();
   EXPECT_TRUE(client.findResultsAreReady());
 }
 
 TEST_P(ParameterizedWebFrameTest, ResetMatchCount) {
   registerMockedHttpURLLoad("find_in_generated_frame.html");
 
   FindUpdateWebFrameClient client;
@@ skipping 156 matching lines @@
 
   FrameTestHelpers::WebViewHelper webViewHelper;
   initializeTextSelectionWebView(m_baseURL + "select_range_basic.html",
                                  &webViewHelper);
   frame = webViewHelper.webView()->mainFrameImpl();
   EXPECT_EQ("Some test text for testing.", selectionAsString(frame));
   webViewHelper.webView()->selectionBounds(startWebRect, endWebRect);
   frame->executeCommand(WebString::fromUTF8("Unselect"));
   EXPECT_EQ("", selectionAsString(frame));
   frame->selectRange(topLeft(startWebRect), bottomRightMinusOne(endWebRect));
-  // On some devices, the above bottomRightMinusOne() causes the ending '.' not selected.
+  // On some devices, the above bottomRightMinusOne() causes the ending '.' not
+  // selected.
   std::string selectionString = selectionAsString(frame);
   EXPECT_TRUE(selectionString == "Some test text for testing." ||
               selectionString == "Some test text for testing");
 
   initializeTextSelectionWebView(m_baseURL + "select_range_scroll.html",
                                  &webViewHelper);
   frame = webViewHelper.webView()->mainFrameImpl();
   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));
-  // On some devices, the above bottomRightMinusOne() causes the ending '.' not selected.
+  // On some devices, the above bottomRightMinusOne() causes the ending '.' not
+  // selected.
   selectionString = selectionAsString(frame);
   EXPECT_TRUE(selectionString == "Some offscreen test text for testing." ||
               selectionString == "Some offscreen test text for testing");
 }
 
 TEST_P(ParameterizedWebFrameTest, SelectRangeInIframe) {
   WebFrame* frame;
   WebRect startWebRect;
   WebRect endWebRect;
 
   registerMockedHttpURLLoad("select_range_iframe.html");
   registerMockedHttpURLLoad("select_range_basic.html");
 
   FrameTestHelpers::WebViewHelper webViewHelper;
   initializeTextSelectionWebView(m_baseURL + "select_range_iframe.html",
                                  &webViewHelper);
   frame = webViewHelper.webView()->mainFrame();
   WebLocalFrame* subframe = frame->firstChild()->toWebLocalFrame();
   EXPECT_EQ("Some test text for testing.", selectionAsString(subframe));
   webViewHelper.webView()->selectionBounds(startWebRect, endWebRect);
   subframe->executeCommand(WebString::fromUTF8("Unselect"));
   EXPECT_EQ("", selectionAsString(subframe));
   subframe->selectRange(topLeft(startWebRect), bottomRightMinusOne(endWebRect));
-  // On some devices, the above bottomRightMinusOne() causes the ending '.' not selected.
+  // On some devices, the above bottomRightMinusOne() causes the ending '.' not
+  // selected.
   std::string selectionString = selectionAsString(subframe);
   EXPECT_TRUE(selectionString == "Some test text for testing." ||
               selectionString == "Some test text for testing");
 }
 
 TEST_P(ParameterizedWebFrameTest, SelectRangeDivContentEditable) {
   WebLocalFrame* frame;
   WebRect startWebRect;
   WebRect endWebRect;
 
   registerMockedHttpURLLoad("select_range_div_editable.html");
 
-  // Select the middle of an editable element, then try to extend the selection to the top of the document.
-  // The selection range should be clipped to the bounds of the editable element.
+  // 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;
   initializeTextSelectionWebView(m_baseURL + "select_range_div_editable.html",
                                  &webViewHelper);
   frame = webViewHelper.webView()->mainFrameImpl();
   EXPECT_EQ("This text is initially selected.", selectionAsString(frame));
   webViewHelper.webView()->selectionBounds(startWebRect, endWebRect);
 
   frame->selectRange(bottomRightMinusOne(endWebRect), WebPoint(0, 0));
   EXPECT_EQ("16-char header. This text is initially selected.",
             selectionAsString(frame));
@@ skipping 16 matching lines @@
 
 // positionForPoint returns the wrong values for contenteditable spans. See
 // http://crbug.com/238334.
 TEST_P(ParameterizedWebFrameTest, DISABLED_SelectRangeSpanContentEditable) {
   WebLocalFrame* frame;
   WebRect startWebRect;
   WebRect endWebRect;
 
   registerMockedHttpURLLoad("select_range_span_editable.html");
 
-  // Select the middle of an editable element, then try to extend the selection to the top of the document.
-  // The selection range should be clipped to the bounds of the editable element.
+  // 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;
   initializeTextSelectionWebView(m_baseURL + "select_range_span_editable.html",
                                  &webViewHelper);
   frame = webViewHelper.webView()->mainFrameImpl();
   EXPECT_EQ("This text is initially selected.", selectionAsString(frame));
   webViewHelper.webView()->selectionBounds(startWebRect, endWebRect);
 
   frame->selectRange(bottomRightMinusOne(endWebRect), WebPoint(0, 0));
   EXPECT_EQ("16-char header. This text is initially selected.",
             selectionAsString(frame));
@@ skipping 53 matching lines @@
   EXPECT_EQ(" [ Footer 1. Footer 2.", selectionAsString(frame));
 
   // Can extend the selection completely across editable elements.
   frame->executeScript(WebScriptSource("selectElement('footer_2');"));
   EXPECT_EQ("Footer 2.", selectionAsString(frame));
   frame->selectRange(bottomRightMinusOne(elementBounds(frame, "footer_2")),
                      topLeft(elementBounds(frame, "header_2")));
   EXPECT_EQ("Header 2. ] [ Editable 1. Editable 2. ] [ Footer 1. Footer 2.",
             selectionAsString(frame));
 
-  // If the selection is editable text, we can't extend it into non-editable text.
+  // 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(ParameterizedWebFrameTest, SelectRangeCanMoveSelectionEnd) {
@@ skipping 34 matching lines @@
   EXPECT_EQ("Header 1. Header 2. ] ", selectionAsString(frame));
 
   // Can extend the selection completely across editable elements.
   frame->executeScript(WebScriptSource("selectElement('header_1');"));
   EXPECT_EQ("Header 1.", selectionAsString(frame));
   frame->selectRange(topLeft(elementBounds(frame, "header_1")),
                      bottomRightMinusOne(elementBounds(frame, "footer_1")));
   EXPECT_EQ("Header 1. Header 2. ] [ Editable 1. Editable 2. ] [ Footer 1.",
             selectionAsString(frame));
 
-  // If the selection is editable text, we can't extend it into non-editable text.
+  // 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(ParameterizedWebFrameTest, MoveRangeSelectionExtent) {
@@ skipping 560 matching lines @@
     client.resetTriggered();
     webViewHelper.webView()->handleInputEvent(fatTap(10 + i * 5, 590));
 
     int j = i % 10;
     if (j >= 7 && j <= 9)
       EXPECT_TRUE(client.triggered());
     else
       EXPECT_FALSE(client.triggered());
   }
 
-  // The same taps shouldn't trigger didTapMultipleTargets() after disabling the notification for
-  // multi-target-tap.
+  // The same taps shouldn't trigger didTapMultipleTargets() after disabling the
+  // notification for 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());
   }
 }
 
@@ skipping 117 matching lines @@
 
   // Scroll visual viewport to the bottom of the main frame.
   visualViewport.setLocation(FloatPoint(0, 200));
   EXPECT_FLOAT_POINT_EQ(FloatPoint(0, 200), visualViewport.location());
 
   // Now the tap with the same coordinates should hit two elements.
   client.resetTriggered();
   webViewHelper.webView()->handleInputEvent(fatTap(10, 60));
   EXPECT_TRUE(client.triggered());
 
-  // The same tap shouldn't trigger didTapMultipleTargets() after disabling the notification for
-  // multi-target-tap.
+  // 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(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
   // only becomes available after the load begins.
   FrameTestHelpers::WebViewHelper webViewHelper;
   webViewHelper.initializeAndLoad(m_baseURL + htmlFile, true, 0, &client);
   webViewHelper.resize(WebSize(viewportWidth, viewportHeight));
 
   // Click somewhere where the popup shouldn't appear.
   client.resetTriggered();
   webViewHelper.webView()->handleInputEvent(fatTap(viewportWidth / 2, 0));
   EXPECT_FALSE(client.triggered());
 
-  // Click directly in between two container divs with click handlers, with children that don't handle clicks.
+  // Click directly in between two container divs with click handlers, with
+  // children that don't handle clicks.
   client.resetTriggered();
   webViewHelper.webView()->handleInputEvent(
       fatTap(viewportWidth / 2, divHeight));
   EXPECT_TRUE(client.triggered());
 
-  // The third div container should be blacklisted if you click on the link it contains.
+  // The third div container should be blacklisted if you click on the link it
+  // contains.
   client.resetTriggered();
   webViewHelper.webView()->handleInputEvent(
       fatTap(viewportWidth / 2, divHeight * 3.25));
   EXPECT_FALSE(client.triggered());
 }
 
 TEST_P(ParameterizedWebFrameTest, DisambiguationPopupPageScale) {
   registerMockedHttpURLLoad("disambiguation_popup_page_scale.html");
 
   DisambiguationPopupTestWebViewClient client;
@@ skipping 52 matching lines @@
   bool m_commitCalled;
 };
 
 TEST_P(ParameterizedWebFrameTest, ReplaceNavigationAfterHistoryNavigation) {
   TestSubstituteDataWebFrameClient webFrameClient;
 
   FrameTestHelpers::WebViewHelper webViewHelper;
   webViewHelper.initializeAndLoad("about:blank", true, &webFrameClient);
   WebFrame* frame = webViewHelper.webView()->mainFrame();
 
-  // Load a url as a history navigation that will return an error. TestSubstituteDataWebFrameClient
-  // will start a SubstituteData load in response to the load failure, which should get fully committed.
-  // Due to https://bugs.webkit.org/show_bug.cgi?id=91685, FrameLoader::didReceiveData() wasn't getting
-  // called in this case, which resulted in the SubstituteData document not getting displayed.
+  // Load a url as a history navigation that will return an error.
+  // TestSubstituteDataWebFrameClient will start a SubstituteData load in
+  // response to the load failure, which should get fully committed.  Due to
+  // https://bugs.webkit.org/show_bug.cgi?id=91685,
+  // FrameLoader::didReceiveData() wasn't getting called in this case, which
+  // resulted in the SubstituteData document not getting displayed.
   WebURLError error;
   error.reason = 1337;
   error.domain = "WebFrameTest";
   std::string errorURL = "http://0.0.0.0";
   WebURLResponse response;
   response.setURL(URLTestHelpers::toKURL(errorURL));
   response.setMIMEType("text/html");
   response.setHTTPStatusCode(500);
   WebHistoryItem errorHistoryItem;
   errorHistoryItem.initialize();
@@ skipping 45 matching lines @@
 }
 
 TEST_P(ParameterizedWebFrameTest, EmptyDocument) {
   registerMockedHttpURLLoad("frameserializer/svg/green_rectangle.svg");
 
   TestWillInsertBodyWebFrameClient webFrameClient;
   FrameTestHelpers::WebViewHelper webViewHelper;
   webViewHelper.initialize(false, &webFrameClient);
 
   EXPECT_FALSE(webFrameClient.m_didLoad);
-  EXPECT_EQ(
-      1,
-      webFrameClient
-          .m_numBodies);  // The empty document that a new frame starts with triggers this.
+  // The empty document that a new frame starts with triggers this.
+  EXPECT_EQ(1, webFrameClient.m_numBodies);
 }
 
 TEST_P(ParameterizedWebFrameTest,
        MoveCaretSelectionTowardsWindowPointWithNoSelection) {
   FrameTestHelpers::WebViewHelper webViewHelper;
   webViewHelper.initializeAndLoad("about:blank", true);
   WebFrame* frame = webViewHelper.webView()->mainFrame();
 
   // This test passes if this doesn't crash.
   frame->toWebLocalFrame()->moveCaretSelection(WebPoint(0, 0));
@@ skipping 496 matching lines @@
   TestScrolledFrameClient() { reset(); }
   void reset() { m_didScrollFrame = false; }
   bool wasFrameScrolled() const { return m_didScrollFrame; }
 
   // WebFrameClient:
   void didChangeScrollOffset(WebLocalFrame* frame) override {
     if (frame->parent())
       return;
     EXPECT_FALSE(m_didScrollFrame);
     FrameView* view = toWebLocalFrameImpl(frame)->frameView();
-    // FrameView can be scrolled in FrameView::setFixedVisibleContentRect
-    // which is called from LocalFrame::createView (before the frame is associated
+    // FrameView can be scrolled in FrameView::setFixedVisibleContentRect which
+    // is called from LocalFrame::createView (before the frame is associated
     // with the the view).
     if (view)
       m_didScrollFrame = true;
   }
 
  private:
   bool m_didScrollFrame;
 };
 
 TEST_F(WebFrameTest, CompositorScrollIsUserScrollLongPage) {
@@ skipping 181 matching lines @@
       PlatformMouseEvent::RealOrIndistinguishable, String(), nullptr);
   FrameLoadRequest frameRequest(document, ResourceRequest(destination));
   frameRequest.setTriggeringEvent(event);
   UserGestureIndicator gesture(DefinitelyProcessingUserGesture);
   toLocalFrame(webViewHelper.webView()->page()->mainFrame())
       ->loader()
       .load(frameRequest);
   FrameTestHelpers::pumpPendingRequestsForFrameToLoad(
       webViewHelper.webView()->mainFrame());
 
-  // decidePolicyForNavigation should be called both for the original request and the ctrl+click.
+  // decidePolicyForNavigation should be called both for the original request
+  // and the ctrl+click.
   EXPECT_EQ(2, webFrameClient.decidePolicyCallCount());
 }
 
 TEST_P(ParameterizedWebFrameTest, BackToReload) {
   registerMockedHttpURLLoad("fragment_middle_click.html");
   FrameTestHelpers::WebViewHelper webViewHelper;
   webViewHelper.initializeAndLoad(m_baseURL + "fragment_middle_click.html",
                                   true);
   WebFrame* frame = webViewHelper.webView()->mainFrame();
   const FrameLoader& mainFrameLoader =
@@ skipping 19 matching lines @@
   registerMockedHttpURLLoad("page_with_blank_iframe.html");
   FrameTestHelpers::WebViewHelper webViewHelper;
   webViewHelper.initializeAndLoad(m_baseURL + "page_with_blank_iframe.html",
                                   true);
   WebLocalFrame* mainFrame = webViewHelper.webView()->mainFrameImpl();
   const FrameLoader& mainFrameLoader =
       webViewHelper.webView()->mainFrameImpl()->frame()->loader();
   WebFrame* childFrame = mainFrame->firstChild();
   ASSERT_TRUE(childFrame);
 
-  // Start a history navigation, then have a different frame commit a navigation.
-  // In this case, reload an about:blank frame, which will commit synchronously.
-  // After the history navigation completes, both the appropriate document url and
-  // the current history item should reflect the history navigation.
+  // Start a history navigation, then have a different frame commit a
+  // navigation.  In this case, reload an about:blank frame, which will commit
+  // synchronously.  After the history navigation completes, both the
+  // appropriate document url and the current history item should reflect the
+  // history navigation.
   registerMockedHttpURLLoad("white-1x1.png");
   WebHistoryItem item;
   item.initialize();
   WebURL historyURL(toKURL(m_baseURL + "white-1x1.png"));
   item.setURLString(historyURL.string());
   WebURLRequest request = mainFrame->requestFromHistoryItem(
       item, WebCachePolicy::UseProtocolCachePolicy);
   mainFrame->load(request, WebFrameLoadType::BackForward, item);
 
   FrameTestHelpers::reloadFrame(childFrame);
@@ skipping 124 matching lines @@
   WebLocalFrameImpl* mainFrame = webViewHelper.webView()->mainFrameImpl();
   WebLocalFrameImpl* childFrame = toWebLocalFrameImpl(mainFrame->firstChild());
   ASSERT_EQ(childFrame->client(), &childClient);
   EXPECT_EQ(mainClient.childFrameCreationCount(), 1);
   EXPECT_EQ(childClient.willSendRequestCallCount(), 1);
   EXPECT_EQ(childClient.getCachePolicy(),
             WebCachePolicy::UseProtocolCachePolicy);
 
   FrameTestHelpers::reloadFrame(mainFrame);
 
-  // A new WebFrame should have been created, but the child WebFrameClient should be reused.
+  // A new WebFrame should have been created, but the child WebFrameClient
+  // should be reused.
   ASSERT_NE(childFrame, toWebLocalFrameImpl(mainFrame->firstChild()));
   ASSERT_EQ(toWebLocalFrameImpl(mainFrame->firstChild())->client(),
             &childClient);
 
   EXPECT_EQ(mainClient.childFrameCreationCount(), 2);
   EXPECT_EQ(childClient.willSendRequestCallCount(), 2);
   EXPECT_EQ(childClient.getCachePolicy(), WebCachePolicy::ValidatingCacheData);
 }
 
 class TestSameDocumentWebFrameClient
@@ skipping 91 matching lines @@
   KURL testURL = toKURL("about:blank");
   FrameTestHelpers::loadHTMLString(frame, bluePNG, testURL);
 
   WebNode node = frame->document().body().firstChild();
   EXPECT_TRUE(node.isElementNode());
   WebElement element = node.to<WebElement>();
   WebImage image = element.imageContents();
   ASSERT_FALSE(image.isNull());
   EXPECT_EQ(image.size().width, 10);
   EXPECT_EQ(image.size().height, 10);
-  //    FIXME: The rest of this test is disabled since the ImageDecodeCache state may be inconsistent when this test runs.
-  //    crbug.com/266088
-  //    SkBitmap bitmap = image.getSkBitmap();
-  //    SkAutoLockPixels locker(bitmap);
-  //    EXPECT_EQ(bitmap.getColor(0, 0), SK_ColorBLUE);
+  // FIXME: The rest of this test is disabled since the ImageDecodeCache state
+  // may be inconsistent when this test runs, crbug.com/266088
+  //SkBitmap bitmap = image.getSkBitmap();
+  //SkAutoLockPixels locker(bitmap);
+  //EXPECT_EQ(bitmap.getColor(0, 0), SK_ColorBLUE);
 }
 
 class TestStartStopCallbackWebFrameClient
     : public FrameTestHelpers::TestWebFrameClient {
  public:
   TestStartStopCallbackWebFrameClient()
       : m_startLoadingCount(0),
         m_stopLoadingCount(0),
         m_differentDocumentStartCount(0) {}
 
@@ skipping 180 matching lines @@
 
   // Call javascript to make the layer scrollable, and verify it.
   WebLocalFrameImpl* frame =
       (WebLocalFrameImpl*)webViewHelper.webView()->mainFrame();
   frame->executeScript(WebScriptSource("allowScroll();"));
   webViewHelper.webView()->updateAllLifecyclePhases();
   ASSERT_TRUE(webScrollLayer->userScrollableHorizontal());
   ASSERT_TRUE(webScrollLayer->userScrollableVertical());
 }
 
-// Test that currentHistoryItem reflects the current page, not the provisional load.
+// Test that currentHistoryItem reflects the current page, not the provisional
+// load.
 TEST_P(ParameterizedWebFrameTest, CurrentHistoryItem) {
   registerMockedHttpURLLoad("fixed_layout.html");
   std::string url = m_baseURL + "fixed_layout.html";
 
   FrameTestHelpers::WebViewHelper webViewHelper;
   webViewHelper.initialize();
   WebFrame* frame = webViewHelper.webView()->mainFrame();
   const FrameLoader& mainFrameLoader =
       webViewHelper.webView()->mainFrameImpl()->frame()->loader();
   WebURLRequest request;
@@ skipping 53 matching lines @@
 
   WebViewImpl* webView = webViewHelper.webView();
   webViewHelper.resize(WebSize(100, 100));
 
   Document* document = webView->mainFrameImpl()->frame()->document();
   Element* bottomFixed = document->getElementById("bottom-fixed");
   Element* topBottomFixed = document->getElementById("top-bottom-fixed");
   Element* rightFixed = document->getElementById("right-fixed");
   Element* leftRightFixed = document->getElementById("left-right-fixed");
 
-  // The layout viewport will hit the min-scale limit of 0.25, so it'll be 400x800.
+  // The layout viewport will hit the min-scale limit of 0.25, so it'll be
+  // 400x800.
   webViewHelper.resize(WebSize(100, 200));
   EXPECT_EQ(800, bottomFixed->offsetTop() + bottomFixed->offsetHeight());
   EXPECT_EQ(800, topBottomFixed->offsetHeight());
 
-  // Now the layout viewport hits the content width limit of 500px so it'll be 500x500.
+  // Now the layout viewport hits the content width limit of 500px so it'll be
+  // 500x500.
   webViewHelper.resize(WebSize(200, 200));
   EXPECT_EQ(500, rightFixed->offsetLeft() + rightFixed->offsetWidth());
   EXPECT_EQ(500, leftRightFixed->offsetWidth());
 }
 
 TEST_P(ParameterizedWebFrameTest, FrameViewMoveWithSetFrameRect) {
   FrameTestHelpers::WebViewHelper webViewHelper;
   webViewHelper.initializeAndLoad("about:blank");
   webViewHelper.resize(WebSize(200, 200));
   webViewHelper.webView()->updateAllLifecyclePhases();
@@ skipping 1083 matching lines @@
   remoteFrame->setReplicatedOrigin(SecurityOrigin::createUnique());
   v8::Local<v8::Value> remoteWindow = mainFrame()->executeScriptAndReturnValue(
       WebScriptSource("document.querySelector('#frame2').contentWindow;"));
   EXPECT_TRUE(originalWindow->StrictEquals(remoteWindow));
   // Check that its view is consistent with the world.
   v8::Local<v8::Value> remoteWindowTop =
       mainFrame()->executeScriptAndReturnValue(WebScriptSource(
           "document.querySelector('#frame2').contentWindow.top;"));
   EXPECT_TRUE(windowTop->StrictEquals(remoteWindowTop));
 
-  // Now check that remote -> local works too, since it goes through a different code path.
+  // Now check that remote -> local works too, since it goes through a different
+  // code path.
   FrameTestHelpers::TestWebFrameClient client;
   WebLocalFrame* localFrame = WebLocalFrame::createProvisional(
       &client, remoteFrame, WebSandboxFlags::None);
   remoteFrame->swap(localFrame);
   v8::Local<v8::Value> localWindow = mainFrame()->executeScriptAndReturnValue(
       WebScriptSource("document.querySelector('#frame2').contentWindow;"));
   EXPECT_TRUE(originalWindow->StrictEquals(localWindow));
   v8::Local<v8::Value> localWindowTop =
       mainFrame()->executeScriptAndReturnValue(WebScriptSource(
           "document.querySelector('#frame2').contentWindow.top;"));
@@ skipping 109 matching lines @@
       childFrame->executeScriptAndReturnValue(
           WebScriptSource("parent.frames[0]"));
   EXPECT_TRUE(childOfRemoteParent->IsObject());
   EXPECT_TRUE(window->StrictEquals(childOfRemoteParent));
 
   v8::Local<v8::Value> windowLength = childFrame->executeScriptAndReturnValue(
       WebScriptSource("parent.frames.length"));
   ASSERT_TRUE(windowLength->IsInt32());
   EXPECT_EQ(1, windowLength.As<v8::Int32>()->Value());
 
-  // Manually reset to break WebViewHelper's dependency on the stack allocated clients.
+  // Manually reset to break WebViewHelper's dependency on the stack allocated
+  // clients.
   reset();
 }
 
-// Check that frames with a remote parent don't crash while accessing window.frameElement.
+// Check that frames with a remote parent don't crash while accessing
+// window.frameElement.
 TEST_F(WebFrameSwapTest, FrameElementInFramesWithRemoteParent) {
   v8::HandleScope scope(v8::Isolate::GetCurrent());
 
   FrameTestHelpers::TestWebRemoteFrameClient remoteClient;
   WebRemoteFrame* remoteParentFrame = remoteClient.frame();
   mainFrame()->swap(remoteParentFrame);
   remoteParentFrame->setReplicatedOrigin(SecurityOrigin::createUnique());
 
   WebLocalFrame* childFrame =
       FrameTestHelpers::createLocalChild(remoteParentFrame);
   FrameTestHelpers::loadFrame(childFrame, m_baseURL + "subframe-hello.html");
 
   v8::Local<v8::Value> frameElement = childFrame->executeScriptAndReturnValue(
       WebScriptSource("window.frameElement"));
   // frameElement should be null if cross-origin.
   ASSERT_FALSE(frameElement.IsEmpty());
   EXPECT_TRUE(frameElement->IsNull());
 
-  // Manually reset to break WebViewHelper's dependency on the stack allocated clients.
+  // Manually reset to break WebViewHelper's dependency on the stack allocated
+  // clients.
   reset();
 }
 
 class RemoteToLocalSwapWebFrameClient
     : public FrameTestHelpers::TestWebFrameClient {
  public:
   explicit RemoteToLocalSwapWebFrameClient(WebRemoteFrame* remoteFrame)
       : m_historyCommitType(WebHistoryInertCommit),
         m_remoteFrame(remoteFrame) {}
 
@@ skipping 309 matching lines @@
 };
 
 TEST_P(ParameterizedWebFrameTest, RemoteFrameInitialCommitType) {
   FrameTestHelpers::TestWebViewClient viewClient;
   FrameTestHelpers::TestWebRemoteFrameClient remoteClient;
   WebView* view = WebView::create(&viewClient, WebPageVisibilityStateVisible);
   view->setMainFrame(remoteClient.frame());
   remoteClient.frame()->setReplicatedOrigin(
       WebSecurityOrigin::createFromString(WebString::fromUTF8(m_baseURL)));
 
-  // If an iframe has a remote main frame, ensure the inital commit is correctly identified as WebInitialCommitInChildFrame.
+  // If an iframe has a remote main frame, ensure the inital commit is correctly
+  // identified as WebInitialCommitInChildFrame.
   CommitTypeWebFrameClient childFrameClient;
   WebLocalFrame* childFrame = FrameTestHelpers::createLocalChild(
       view->mainFrame()->toWebRemoteFrame(), "frameName", &childFrameClient);
   registerMockedHttpURLLoad("foo.html");
   FrameTestHelpers::loadFrame(childFrame, m_baseURL + "foo.html");
   EXPECT_EQ(WebInitialCommitInChildFrame, childFrameClient.historyCommitType());
   view->close();
 }
 
 class GestureEventTestWebWidgetClient
@@ skipping 465 matching lines @@
 TEST_P(WebFrameOverscrollTest,
        AccumulatedRootOverscrollAndUnsedDeltaValuesOnOverscroll) {
   OverscrollWebViewClient client;
   registerMockedHttpURLLoad("overscroll/overscroll.html");
   FrameTestHelpers::WebViewHelper webViewHelper;
   webViewHelper.initializeAndLoad(m_baseURL + "overscroll/overscroll.html",
                                   true, nullptr, &client, nullptr,
                                   configureAndroid);
   webViewHelper.resize(WebSize(200, 200));
 
-  // Calculation of accumulatedRootOverscroll and unusedDelta on multiple scrollUpdate.
+  // Calculation of accumulatedRootOverscroll and unusedDelta on multiple
+  // scrollUpdate.
   ScrollBegin(&webViewHelper);
   EXPECT_CALL(client, didOverscroll(WebFloatSize(8, 16), WebFloatSize(8, 16),
                                     WebFloatPoint(100, 100), WebFloatSize()));
   ScrollUpdate(&webViewHelper, -308, -316);
   Mock::VerifyAndClearExpectations(&client);
 
   EXPECT_CALL(client, didOverscroll(WebFloatSize(0, 13), WebFloatSize(8, 29),
                                     WebFloatPoint(100, 100), WebFloatSize()));
   ScrollUpdate(&webViewHelper, 0, -13);
   Mock::VerifyAndClearExpectations(&client);
@@ skipping 45 matching lines @@
   ScrollEnd(&webViewHelper);
   ScrollBegin(&webViewHelper);
 
   // Now On Scrolling DIV, scroll is bubbled and root layer is over-scrolled.
   EXPECT_CALL(client, didOverscroll(WebFloatSize(0, 100), WebFloatSize(0, 100),
                                     WebFloatPoint(100, 100), WebFloatSize()));
   ScrollUpdate(&webViewHelper, 0, -100);
   ScrollUpdate(&webViewHelper, 0, -100);
   Mock::VerifyAndClearExpectations(&client);
 
-  // TODO(bokan): This has never worked but by the accident that this test was being
-  // run in a WebView without a size. This test should be fixed along with the bug.
-  // crbug.com/589320.
+  // TODO(bokan): This has never worked but by the accident that this test was
+  // being run in a WebView without a size. This test should be fixed along with
+  // the bug, crbug.com/589320.
   // Page scrolls vertically, but over-scrolls horizontally.
-  // EXPECT_CALL(client, didOverscroll(WebFloatSize(-100, 0), WebFloatSize(-100, 0), WebFloatPoint(100, 100), WebFloatSize()));
+  // EXPECT_CALL(client, didOverscroll(WebFloatSize(-100, 0), WebFloatSize(-100,
+  // 0), WebFloatPoint(100, 100), WebFloatSize()));
   // ScrollUpdate(&webViewHelper, 100, 50);
   // Mock::VerifyAndClearExpectations(&client);
 
   // Scrolling up, Overscroll is not reported.
   // EXPECT_CALL(client, didOverscroll(_, _, _, _)).Times(0);
   // ScrollUpdate(&webViewHelper, 0, -50);
   // Mock::VerifyAndClearExpectations(&client);
 
   // Page scrolls horizontally, but over-scrolls vertically.
-  // EXPECT_CALL(client, didOverscroll(WebFloatSize(0, 100), WebFloatSize(0, 100), WebFloatPoint(100, 100), WebFloatSize()));
+  // EXPECT_CALL(client, didOverscroll(WebFloatSize(0, 100), WebFloatSize(0,
+  // 100), WebFloatPoint(100, 100), WebFloatSize()));
   // ScrollUpdate(&webViewHelper, -100, -100);
   // Mock::VerifyAndClearExpectations(&client);
 }
 
 TEST_P(WebFrameOverscrollTest, RootLayerOverscrolledOnInnerDivOverScroll) {
   OverscrollWebViewClient client;
   registerMockedHttpURLLoad("overscroll/div-overscroll.html");
   FrameTestHelpers::WebViewHelper webViewHelper;
   webViewHelper.initializeAndLoad(m_baseURL + "overscroll/div-overscroll.html",
                                   true, nullptr, &client, nullptr,
@@ skipping 28 matching lines @@
   webViewHelper.resize(WebSize(200, 200));
 
   ScrollBegin(&webViewHelper);
   // Scroll the IFrame to the end.
   EXPECT_CALL(client, didOverscroll(_, _, _, _)).Times(0);
 
   // This scroll will fully scroll the iframe but will be consumed before being
   // counted as overscroll.
   ScrollUpdate(&webViewHelper, 0, -320);
 
-  // This scroll will again target the iframe but wont bubble further up. Make sure
-  // that the unused scroll isn't handled as overscroll.
+  // This scroll will again target the iframe but wont bubble further up. Make
+  // sure that the unused scroll isn't handled as overscroll.
   ScrollUpdate(&webViewHelper, 0, -50);
   Mock::VerifyAndClearExpectations(&client);
 
   ScrollEnd(&webViewHelper);
   ScrollBegin(&webViewHelper);
 
   // Now On Scrolling IFrame, scroll is bubbled and root layer is over-scrolled.
   EXPECT_CALL(client, didOverscroll(WebFloatSize(0, 50), WebFloatSize(0, 50),
                                     WebFloatPoint(100, 100), WebFloatSize()));
   ScrollUpdate(&webViewHelper, 0, -150);
   Mock::VerifyAndClearExpectations(&client);
 
   ScrollEnd(&webViewHelper);
 }
 
 TEST_P(WebFrameOverscrollTest, ScaledPageRootLayerOverscrolled) {
   OverscrollWebViewClient client;
   registerMockedHttpURLLoad("overscroll/overscroll.html");
   FrameTestHelpers::WebViewHelper webViewHelper;
   WebViewImpl* webViewImpl = webViewHelper.initializeAndLoad(
       m_baseURL + "overscroll/overscroll.html", true, nullptr, &client, nullptr,
       configureAndroid);
   webViewHelper.resize(WebSize(200, 200));
   webViewImpl->setPageScaleFactor(3.0);
 
-  // Calculation of accumulatedRootOverscroll and unusedDelta on scaled page. The point is (99, 99) because we clamp
-  // in the division by 3 to 33 so when we go back to viewport coordinates it becomes (99, 99).
+  // Calculation of accumulatedRootOverscroll and unusedDelta on scaled page.
+  // The point is (99, 99) because we clamp in the division by 3 to 33 so when
+  // we go back to viewport coordinates it becomes (99, 99).
   ScrollBegin(&webViewHelper);
   EXPECT_CALL(client, didOverscroll(WebFloatSize(0, -30), WebFloatSize(0, -30),
                                     WebFloatPoint(99, 99), WebFloatSize()));
   ScrollUpdate(&webViewHelper, 0, 30);
   Mock::VerifyAndClearExpectations(&client);
 
   EXPECT_CALL(client, didOverscroll(WebFloatSize(0, -30), WebFloatSize(0, -60),
                                     WebFloatPoint(99, 99), WebFloatSize()));
   ScrollUpdate(&webViewHelper, 0, 30);
   Mock::VerifyAndClearExpectations(&client);
@@ skipping 37 matching lines @@
                             WebFloatPoint(100, 100), WebFloatSize()));
   ScrollUpdate(&webViewHelper, 0, 0.10);
   Mock::VerifyAndClearExpectations(&client);
 
   EXPECT_CALL(client, didOverscroll(WebFloatSize(-0.10, 0),
                                     WebFloatSize(-10.10, -10.10),
                                     WebFloatPoint(100, 100), WebFloatSize()));
   ScrollUpdate(&webViewHelper, 0.10, 0);
   Mock::VerifyAndClearExpectations(&client);
 
-  // For residual values overscrollDelta should be reset and didOverscroll shouldn't be called.
+  // For residual values overscrollDelta should be reset and didOverscroll
+  // shouldn't be called.
   EXPECT_CALL(client, didOverscroll(_, _, _, _)).Times(0);
   ScrollUpdate(&webViewHelper, 0, 0.09);
   Mock::VerifyAndClearExpectations(&client);
 
   EXPECT_CALL(client, didOverscroll(_, _, _, _)).Times(0);
   ScrollUpdate(&webViewHelper, 0.09, 0.09);
   Mock::VerifyAndClearExpectations(&client);
 
   EXPECT_CALL(client, didOverscroll(_, _, _, _)).Times(0);
   ScrollUpdate(&webViewHelper, 0.09, 0);
@@ skipping 296 matching lines @@
   webView->setPageScaleFactor(4);
   webView->setVisualViewportOffset(WebFloatPoint(1, 1));
 
   client.reset();
   localFrame->saveImageAt(WebPoint(3, 3));
   EXPECT_EQ(
       WebString::fromUTF8("data:image/gif;base64"
                           ",R0lGODlhAQABAIAAAAUEBAAAACwAAAAAAQABAAACAkQBADs="),
       client.result());
 
-  helper
-      .reset();  // Explicitly reset to break dependency on locally scoped client.
+  // Explicitly reset to break dependency on locally scoped client.
+  helper.reset();
 }
 
 TEST_F(WebFrameTest, SaveImageWithImageMap) {
   std::string url = m_baseURL + "image-map.html";
   URLTestHelpers::registerMockedURLLoad(toKURL(url), "image-map.html");
 
   FrameTestHelpers::WebViewHelper helper;
   SaveImageFromDataURLWebFrameClient client;
   WebViewImpl* webView = helper.initializeAndLoad(url, true, &client);
   webView->resize(WebSize(400, 400));
@@ skipping 11 matching lines @@
   localFrame->saveImageAt(WebPoint(75, 25));
   EXPECT_EQ(
       WebString::fromUTF8("data:image/gif;base64"
                           ",R0lGODlhAQABAIAAAAUEBAAAACwAAAAAAQABAAACAkQBADs="),
       client.result());
 
   client.reset();
   localFrame->saveImageAt(WebPoint(125, 25));
   EXPECT_EQ(WebString(), client.result());
 
-  helper
-      .reset();  // Explicitly reset to break dependency on locally scoped client.
+  // Explicitly reset to break dependency on locally scoped client.
+  helper.reset();
 }
 
 TEST_F(WebFrameTest, CopyImageAt) {
   std::string url = m_baseURL + "canvas-copy-image.html";
   URLTestHelpers::registerMockedURLLoad(toKURL(url), "canvas-copy-image.html");
 
   FrameTestHelpers::WebViewHelper helper;
   WebViewImpl* webView = helper.initializeAndLoad(url, true, 0);
   webView->resize(WebSize(400, 400));
 
@@ skipping 63 matching lines @@
   client.reset();
   localFrame->saveImageAt(WebPoint(75, 25));
   EXPECT_EQ(
       WebString::fromUTF8("data:image/gif;base64"
                           ",R0lGODlhAQABAIAAAAUEBAAAACwAAAAAAQABAAACAkQBADs="),
       client.result());
 
   client.reset();
   localFrame->saveImageAt(WebPoint(125, 25));
   EXPECT_EQ(WebString(), client.result());
-
-  helper
-      .reset();  // Explicitly reset to break dependency on locally scoped client.
+  // Explicitly reset to break dependency on locally scoped client.
+  helper.reset();
 }
 
 TEST_F(WebFrameTest, LoadJavascriptURLInNewFrame) {
   FrameTestHelpers::WebViewHelper helper;
   helper.initialize(true);
 
   WebURLRequest request;
   std::string redirectURL = m_baseURL + "foo.html";
   URLTestHelpers::registerMockedURLLoad(toKURL(redirectURL), "foo.html");
   request.setURL(toKURL("javascript:location='" + redirectURL + "'"));
@@ skipping 139 matching lines @@
   Platform::current()->getURLLoaderMockFactory()->setLoaderDelegate(nullptr);
 
   Document* document =
       toLocalFrame(helper.webView()->page()->mainFrame())->document();
   EXPECT_TRUE(document->isImageDocument());
   EXPECT_EQ(Resource::DecodeError,
             toImageDocument(document)->cachedImage()->getStatus());
 }
 
 }  // namespace blink