DO NOT COMMIT: Results of running new (proposed) clang-format on Blink

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 1171 matching lines @@
   FixedLayoutTestWebViewClient client;
   client.m_screenInfo.deviceScaleFactor = 1;
   int viewportWidth = 1280;
   int viewportHeight = 0;
 
   FrameTestHelpers::WebViewHelper webViewHelper;
   webViewHelper.initialize(true, nullptr, &client, nullptr,
                            enableViewportSettings);
   webViewHelper.resize(WebSize(viewportWidth, viewportHeight));
 
-  EXPECT_EQ(viewportWidth, webViewHelper.webView()
-                               ->mainFrameImpl()
-                               ->frameView()
-                               ->layoutSize()
-                               .width());
-  EXPECT_EQ(viewportHeight, webViewHelper.webView()
-                                ->mainFrameImpl()
-                                ->frameView()
-                                ->layoutSize()
-                                .height());
+  EXPECT_EQ(viewportWidth,
+            webViewHelper.webView()
+                ->mainFrameImpl()
+                ->frameView()
+                ->layoutSize()
+                .width());
+  EXPECT_EQ(viewportHeight,
+            webViewHelper.webView()
+                ->mainFrameImpl()
+                ->frameView()
+                ->layoutSize()
+                .height());
 }
 
 TEST_P(ParameterizedWebFrameTest,
        DeviceScaleFactorUsesDefaultWithoutViewportTag) {
   registerMockedHttpURLLoad("no_viewport_tag.html");
 
   int viewportWidth = 640;
   int viewportHeight = 480;
 
   FixedLayoutTestWebViewClient client;
@@ skipping 178 matching lines @@
   FrameTestHelpers::WebViewHelper webViewHelper;
   webViewHelper.initializeAndLoad(
       m_baseURL + "viewport-auto-initial-scale.html", true, nullptr, &client,
       nullptr, enableViewportSettings);
   webViewHelper.webView()->settings()->setWideViewportQuirkEnabled(true);
   webViewHelper.webView()->settings()->setUseWideViewport(false);
   webViewHelper.resize(WebSize(viewportWidth, viewportHeight));
 
   // The page sets viewport width to 3000, but with UseWideViewport == false is
   // must be ignored.
-  EXPECT_EQ(viewportWidth, webViewHelper.webView()
-                               ->mainFrameImpl()
-                               ->frameView()
-                               ->contentsSize()
-                               .width());
-  EXPECT_EQ(viewportHeight, webViewHelper.webView()
-                                ->mainFrameImpl()
-                                ->frameView()
-                                ->contentsSize()
-                                .height());
+  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.
-  EXPECT_EQ(viewportWidth / 2, webViewHelper.webView()
-                                   ->mainFrameImpl()
-                                   ->frameView()
-                                   ->contentsSize()
-                                   .width());
-  EXPECT_EQ(viewportHeight / 2, webViewHelper.webView()
-                                    ->mainFrameImpl()
-                                    ->frameView()
-                                    ->contentsSize()
-                                    .height());
+  EXPECT_EQ(viewportWidth / 2,
+            webViewHelper.webView()
+                ->mainFrameImpl()
+                ->frameView()
+                ->contentsSize()
+                .width());
+  EXPECT_EQ(viewportHeight / 2,
+            webViewHelper.webView()
+                ->mainFrameImpl()
+                ->frameView()
+                ->contentsSize()
+                .height());
 }
 
 TEST_P(ParameterizedWebFrameTest, WideViewportSetsTo980WithoutViewportTag) {
   registerMockedHttpURLLoad("no_viewport_tag.html");
 
   FixedLayoutTestWebViewClient client;
   client.m_screenInfo.deviceScaleFactor = 1;
   int viewportWidth = 640;
   int viewportHeight = 480;
 
   FrameTestHelpers::WebViewHelper webViewHelper;
   webViewHelper.initializeAndLoad(m_baseURL + "no_viewport_tag.html", true,
                                   nullptr, &client, nullptr,
                                   enableViewportSettings);
   applyViewportStyleOverride(&webViewHelper);
   webViewHelper.webView()->settings()->setWideViewportQuirkEnabled(true);
   webViewHelper.webView()->settings()->setUseWideViewport(true);
   webViewHelper.resize(WebSize(viewportWidth, viewportHeight));
 
-  EXPECT_EQ(980, webViewHelper.webView()
-                     ->mainFrameImpl()
-                     ->frameView()
-                     ->contentsSize()
-                     .width());
-  EXPECT_EQ(980.0 / viewportWidth * viewportHeight, webViewHelper.webView()
-                                                        ->mainFrameImpl()
-                                                        ->frameView()
-                                                        ->contentsSize()
-                                                        .height());
+  EXPECT_EQ(980,
+            webViewHelper.webView()
+                ->mainFrameImpl()
+                ->frameView()
+                ->contentsSize()
+                .width());
+  EXPECT_EQ(980.0 / viewportWidth * viewportHeight,
+            webViewHelper.webView()
+                ->mainFrameImpl()
+                ->frameView()
+                ->contentsSize()
+                .height());
 }
 
 TEST_P(ParameterizedWebFrameTest, WideViewportSetsTo980WithXhtmlMp) {
   registerMockedHttpURLLoad("viewport/viewport-legacy-xhtmlmp.html");
 
   FixedLayoutTestWebViewClient client;
   client.m_screenInfo.deviceScaleFactor = 1;
   int viewportWidth = 640;
   int viewportHeight = 480;
 
   FrameTestHelpers::WebViewHelper webViewHelper;
   webViewHelper.initialize(true, nullptr, &client, nullptr,
                            enableViewportSettings);
   applyViewportStyleOverride(&webViewHelper);
   webViewHelper.webView()->settings()->setWideViewportQuirkEnabled(true);
   webViewHelper.webView()->settings()->setUseWideViewport(true);
   FrameTestHelpers::loadFrame(
       webViewHelper.webView()->mainFrame(),
       m_baseURL + "viewport/viewport-legacy-xhtmlmp.html");
 
   webViewHelper.resize(WebSize(viewportWidth, viewportHeight));
-  EXPECT_EQ(viewportWidth, webViewHelper.webView()
-                               ->mainFrameImpl()
-                               ->frameView()
-                               ->contentsSize()
-                               .width());
-  EXPECT_EQ(viewportHeight, webViewHelper.webView()
-                                ->mainFrameImpl()
-                                ->frameView()
-                                ->contentsSize()
-                                .height());
+  EXPECT_EQ(viewportWidth,
+            webViewHelper.webView()
+                ->mainFrameImpl()
+                ->frameView()
+                ->contentsSize()
+                .width());
+  EXPECT_EQ(viewportHeight,
+            webViewHelper.webView()
+                ->mainFrameImpl()
+                ->frameView()
+                ->contentsSize()
+                .height());
 }
 
 TEST_P(ParameterizedWebFrameTest, NoWideViewportAndHeightInMeta) {
   registerMockedHttpURLLoad("viewport-height-1000.html");
 
   FixedLayoutTestWebViewClient client;
   client.m_screenInfo.deviceScaleFactor = 1;
   int viewportWidth = 640;
   int viewportHeight = 480;
 
   FrameTestHelpers::WebViewHelper webViewHelper;
   webViewHelper.initializeAndLoad(m_baseURL + "viewport-height-1000.html", true,
                                   nullptr, &client, nullptr,
                                   enableViewportSettings);
   webViewHelper.webView()->settings()->setWideViewportQuirkEnabled(true);
   webViewHelper.webView()->settings()->setUseWideViewport(false);
   webViewHelper.resize(WebSize(viewportWidth, viewportHeight));
 
-  EXPECT_EQ(viewportWidth, webViewHelper.webView()
-                               ->mainFrameImpl()
-                               ->frameView()
-                               ->contentsSize()
-                               .width());
+  EXPECT_EQ(viewportWidth,
+            webViewHelper.webView()
+                ->mainFrameImpl()
+                ->frameView()
+                ->contentsSize()
+                .width());
 }
 
 TEST_P(ParameterizedWebFrameTest, WideViewportSetsTo980WithAutoWidth) {
   registerMockedHttpURLLoad("viewport-2x-initial-scale.html");
 
   FixedLayoutTestWebViewClient client;
   client.m_screenInfo.deviceScaleFactor = 1;
   int viewportWidth = 640;
   int viewportHeight = 480;
 
   FrameTestHelpers::WebViewHelper webViewHelper;
   webViewHelper.initializeAndLoad(m_baseURL + "viewport-2x-initial-scale.html",
                                   true, nullptr, &client, nullptr,
                                   enableViewportSettings);
   applyViewportStyleOverride(&webViewHelper);
   webViewHelper.webView()->settings()->setWideViewportQuirkEnabled(true);
   webViewHelper.webView()->settings()->setUseWideViewport(true);
   webViewHelper.resize(WebSize(viewportWidth, viewportHeight));
 
-  EXPECT_EQ(980, webViewHelper.webView()
-                     ->mainFrameImpl()
-                     ->frameView()
-                     ->contentsSize()
-                     .width());
-  EXPECT_EQ(980.0 / viewportWidth * viewportHeight, webViewHelper.webView()
-                                                        ->mainFrameImpl()
-                                                        ->frameView()
-                                                        ->contentsSize()
-                                                        .height());
+  EXPECT_EQ(980,
+            webViewHelper.webView()
+                ->mainFrameImpl()
+                ->frameView()
+                ->contentsSize()
+                .width());
+  EXPECT_EQ(980.0 / viewportWidth * viewportHeight,
+            webViewHelper.webView()
+                ->mainFrameImpl()
+                ->frameView()
+                ->contentsSize()
+                .height());
 }
 
 TEST_P(ParameterizedWebFrameTest,
        PageViewportInitialScaleOverridesLoadWithOverviewMode) {
   registerMockedHttpURLLoad("viewport-wide-2x-initial-scale.html");
 
   FixedLayoutTestWebViewClient client;
   client.m_screenInfo.deviceScaleFactor = 1;
   int viewportWidth = 640;
   int viewportHeight = 480;
@@ skipping 137 matching lines @@
 
   FrameTestHelpers::WebViewHelper webViewHelper;
   webViewHelper.initializeAndLoad("about:blank", true, nullptr, &client,
                                   nullptr, enableViewportSettings);
   webViewHelper.webView()->settings()->setWideViewportQuirkEnabled(true);
   webViewHelper.webView()->settings()->setUseWideViewport(false);
   webViewHelper.webView()->settings()->setLoadWithOverviewMode(false);
   webViewHelper.webView()->setInitialPageScaleOverride(enforcedPageScaleFactor);
   webViewHelper.resize(WebSize(viewportWidth, viewportHeight));
 
-  EXPECT_EQ(viewportWidth / enforcedPageScaleFactor, webViewHelper.webView()
-                                                         ->mainFrameImpl()
-                                                         ->frameView()
-                                                         ->contentsSize()
-                                                         .width());
+  EXPECT_EQ(viewportWidth / enforcedPageScaleFactor,
+            webViewHelper.webView()
+                ->mainFrameImpl()
+                ->frameView()
+                ->contentsSize()
+                .width());
   EXPECT_EQ(enforcedPageScaleFactor,
             webViewHelper.webView()->pageScaleFactor());
 }
 
 TEST_P(ParameterizedWebFrameTest,
        DocumentElementClientHeightWorksWithWrapContentMode) {
   registerMockedHttpURLLoad("0-by-0.html");
 
   FixedLayoutTestWebViewClient client;
   client.m_screenInfo.deviceScaleFactor = 1;
@@ skipping 21 matching lines @@
   client.m_screenInfo.deviceScaleFactor = 1;
   int viewportWidth = 640;
   int viewportHeight = 480;
 
   FrameTestHelpers::WebViewHelper webViewHelper;
 
   webViewHelper.initializeAndLoad(m_baseURL + "0-by-0.html", true, nullptr,
                                   &client, nullptr, configureAndroid);
   webViewHelper.webView()->settings()->setForceZeroLayoutHeight(true);
   PaintLayerCompositor* compositor = webViewHelper.webView()->compositor();
-  EXPECT_EQ(0, webViewHelper.webView()
-                   ->mainFrameImpl()
-                   ->frameView()
-                   ->layoutSize()
-                   .width());
-  EXPECT_EQ(0, webViewHelper.webView()
-                   ->mainFrameImpl()
-                   ->frameView()
-                   ->layoutSize()
-                   .height());
+  EXPECT_EQ(0,
+            webViewHelper.webView()
+                ->mainFrameImpl()
+                ->frameView()
+                ->layoutSize()
+                .width());
+  EXPECT_EQ(0,
+            webViewHelper.webView()
+                ->mainFrameImpl()
+                ->frameView()
+                ->layoutSize()
+                .height());
   EXPECT_EQ(0.0, compositor->containerLayer()->size().width());
   EXPECT_EQ(0.0, compositor->containerLayer()->size().height());
 
   webViewHelper.resize(WebSize(viewportWidth, 0));
-  EXPECT_EQ(viewportWidth, webViewHelper.webView()
-                               ->mainFrameImpl()
-                               ->frameView()
-                               ->layoutSize()
-                               .width());
-  EXPECT_EQ(0, webViewHelper.webView()
-                   ->mainFrameImpl()
-                   ->frameView()
-                   ->layoutSize()
-                   .height());
+  EXPECT_EQ(viewportWidth,
+            webViewHelper.webView()
+                ->mainFrameImpl()
+                ->frameView()
+                ->layoutSize()
+                .width());
+  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.
   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()
-                   ->frameView()
-                   ->layoutSize()
-                   .height());
+  EXPECT_EQ(viewportWidth,
+            webViewHelper.webView()
+                ->mainFrameImpl()
+                ->frameView()
+                ->layoutSize()
+                .width());
+  EXPECT_EQ(0,
+            webViewHelper.webView()
+                ->mainFrameImpl()
+                ->frameView()
+                ->layoutSize()
+                .height());
   EXPECT_EQ(viewportWidth, compositor->containerLayer()->size().width());
   EXPECT_EQ(viewportHeight, compositor->containerLayer()->size().height());
 
   LocalFrame* frame = webViewHelper.webView()->mainFrameImpl()->frame();
   VisualViewport& visualViewport = frame->page()->frameHost().visualViewport();
   EXPECT_EQ(viewportHeight, visualViewport.containerLayer()->size().height());
   EXPECT_TRUE(
       visualViewport.containerLayer()->platformLayer()->masksToBounds());
   EXPECT_FALSE(compositor->containerLayer()->platformLayer()->masksToBounds());
 }
 
 TEST_P(ParameterizedWebFrameTest, SetForceZeroLayoutHeight) {
   registerMockedHttpURLLoad("200-by-300.html");
 
   FixedLayoutTestWebViewClient client;
   client.m_screenInfo.deviceScaleFactor = 1;
   int viewportWidth = 640;
   int viewportHeight = 480;
 
   FrameTestHelpers::WebViewHelper webViewHelper;
 
   webViewHelper.initializeAndLoad(m_baseURL + "200-by-300.html", true, nullptr,
                                   &client, nullptr, enableViewportSettings);
   webViewHelper.resize(WebSize(viewportWidth, viewportHeight));
 
-  EXPECT_LE(viewportHeight, webViewHelper.webView()
-                                ->mainFrameImpl()
-                                ->frameView()
-                                ->layoutSize()
-                                .height());
+  EXPECT_LE(viewportHeight,
+            webViewHelper.webView()
+                ->mainFrameImpl()
+                ->frameView()
+                ->layoutSize()
+                .height());
   webViewHelper.webView()->settings()->setForceZeroLayoutHeight(true);
   EXPECT_TRUE(
       webViewHelper.webView()->mainFrameImpl()->frameView()->needsLayout());
 
-  EXPECT_EQ(0, webViewHelper.webView()
-                   ->mainFrameImpl()
-                   ->frameView()
-                   ->layoutSize()
-                   .height());
+  EXPECT_EQ(0,
+            webViewHelper.webView()
+                ->mainFrameImpl()
+                ->frameView()
+                ->layoutSize()
+                .height());
 
   webViewHelper.resize(WebSize(viewportWidth, viewportHeight * 2));
   EXPECT_FALSE(
       webViewHelper.webView()->mainFrameImpl()->frameView()->needsLayout());
-  EXPECT_EQ(0, webViewHelper.webView()
-                   ->mainFrameImpl()
-                   ->frameView()
-                   ->layoutSize()
-                   .height());
+  EXPECT_EQ(0,
+            webViewHelper.webView()
+                ->mainFrameImpl()
+                ->frameView()
+                ->layoutSize()
+                .height());
 
   webViewHelper.resize(WebSize(viewportWidth * 2, viewportHeight));
-  EXPECT_EQ(0, webViewHelper.webView()
-                   ->mainFrameImpl()
-                   ->frameView()
-                   ->layoutSize()
-                   .height());
+  EXPECT_EQ(0,
+            webViewHelper.webView()
+                ->mainFrameImpl()
+                ->frameView()
+                ->layoutSize()
+                .height());
 
   webViewHelper.webView()->settings()->setForceZeroLayoutHeight(false);
-  EXPECT_LE(viewportHeight, webViewHelper.webView()
-                                ->mainFrameImpl()
-                                ->frameView()
-                                ->layoutSize()
-                                .height());
+  EXPECT_LE(viewportHeight,
+            webViewHelper.webView()
+                ->mainFrameImpl()
+                ->frameView()
+                ->layoutSize()
+                .height());
 }
 
 TEST_F(WebFrameTest, ToggleViewportMetaOnOff) {
   registerMockedHttpURLLoad("viewport-device-width.html");
 
   FixedLayoutTestWebViewClient client;
   client.m_screenInfo.deviceScaleFactor = 1;
   int viewportWidth = 640;
   int viewportHeight = 480;
 
@@ skipping 85 matching lines @@
   WebLocalFrameImpl* localFrame = FrameTestHelpers::createLocalChild(
       root, "frameName", nullptr, nullptr, nullptr, properties);
 
   registerMockedHttpURLLoad("frame_owner_properties.html");
   FrameTestHelpers::loadFrame(localFrame,
                               m_baseURL + "frame_owner_properties.html");
 
   // Check if the LocalFrame has seen the marginwidth and marginheight
   // properties.
   Document* childDocument = localFrame->frame()->document();
-  EXPECT_EQ(11, childDocument->firstBodyElement()->getIntegralAttribute(
-                    HTMLNames::marginwidthAttr));
-  EXPECT_EQ(22, childDocument->firstBodyElement()->getIntegralAttribute(
-                    HTMLNames::marginheightAttr));
+  EXPECT_EQ(11,
+            childDocument->firstBodyElement()->getIntegralAttribute(
+                HTMLNames::marginwidthAttr));
+  EXPECT_EQ(22,
+            childDocument->firstBodyElement()->getIntegralAttribute(
+                HTMLNames::marginheightAttr));
 
   FrameView* frameView = localFrame->frameView();
   // Expect scrollbars to be enabled by default.
   EXPECT_NE(nullptr, frameView->horizontalScrollbar());
   EXPECT_NE(nullptr, frameView->verticalScrollbar());
 
   view->close();
 }
 
 TEST_F(WebFrameTest, FrameOwnerPropertiesScrolling) {
   FrameTestHelpers::TestWebViewClient viewClient;
   FrameTestHelpers::TestWebRemoteFrameClient remoteClient;
   WebView* view = WebView::create(&viewClient, WebPageVisibilityStateVisible);
   view->settings()->setJavaScriptEnabled(true);
   view->setMainFrame(remoteClient.frame());
   WebRemoteFrame* root = view->mainFrame()->toWebRemoteFrame();
   root->setReplicatedOrigin(SecurityOrigin::createUnique());
 
   WebFrameOwnerProperties properties;
   // Turn off scrolling in the subframe.
   properties.scrollingMode = WebFrameOwnerProperties::ScrollingMode::AlwaysOff;
   WebLocalFrameImpl* localFrame = FrameTestHelpers::createLocalChild(
       root, "frameName", nullptr, nullptr, nullptr, properties);
 
   registerMockedHttpURLLoad("frame_owner_properties.html");
   FrameTestHelpers::loadFrame(localFrame,
                               m_baseURL + "frame_owner_properties.html");
 
   Document* childDocument = localFrame->frame()->document();
-  EXPECT_EQ(0, childDocument->firstBodyElement()->getIntegralAttribute(
-                   HTMLNames::marginwidthAttr));
-  EXPECT_EQ(0, childDocument->firstBodyElement()->getIntegralAttribute(
-                   HTMLNames::marginheightAttr));
+  EXPECT_EQ(0,
+            childDocument->firstBodyElement()->getIntegralAttribute(
+                HTMLNames::marginwidthAttr));
+  EXPECT_EQ(0,
+            childDocument->firstBodyElement()->getIntegralAttribute(
+                HTMLNames::marginheightAttr));
 
   FrameView* frameView =
       static_cast<WebLocalFrameImpl*>(localFrame)->frameView();
   EXPECT_EQ(nullptr, frameView->horizontalScrollbar());
   EXPECT_EQ(nullptr, frameView->verticalScrollbar());
 
   view->close();
 }
 
 TEST_P(ParameterizedWebFrameTest,
@@ skipping 10 matching lines @@
 
   webViewHelper.initializeAndLoad(m_baseURL + "200-by-300.html", true, nullptr,
                                   &client, nullptr, enableViewportSettings);
   webViewHelper.webView()->settings()->setForceZeroLayoutHeight(true);
   webViewHelper.resize(WebSize(viewportWidth, viewportHeight));
 
   FrameTestHelpers::loadFrame(webViewHelper.webView()->mainFrame(),
                               m_baseURL + "large-div.html");
   webViewHelper.webView()->updateAllLifecyclePhases();
 
-  EXPECT_EQ(0, webViewHelper.webView()
-                   ->mainFrameImpl()
-                   ->frameView()
-                   ->layoutSize()
-                   .height());
+  EXPECT_EQ(0,
+            webViewHelper.webView()
+                ->mainFrameImpl()
+                ->frameView()
+                ->layoutSize()
+                .height());
 }
 
 TEST_P(ParameterizedWebFrameTest,
        SetForceZeroLayoutHeightWithWideViewportQuirk) {
   registerMockedHttpURLLoad("200-by-300.html");
 
   FixedLayoutTestWebViewClient client;
   client.m_screenInfo.deviceScaleFactor = 1;
   int viewportWidth = 640;
   int viewportHeight = 480;
 
   FrameTestHelpers::WebViewHelper webViewHelper;
 
   webViewHelper.initializeAndLoad(m_baseURL + "200-by-300.html", true, nullptr,
                                   &client, nullptr, enableViewportSettings);
   webViewHelper.webView()->settings()->setWideViewportQuirkEnabled(true);
   webViewHelper.webView()->settings()->setUseWideViewport(true);
   webViewHelper.webView()->settings()->setForceZeroLayoutHeight(true);
   webViewHelper.resize(WebSize(viewportWidth, viewportHeight));
 
-  EXPECT_EQ(0, webViewHelper.webView()
-                   ->mainFrameImpl()
-                   ->frameView()
-                   ->layoutSize()
-                   .height());
+  EXPECT_EQ(0,
+            webViewHelper.webView()
+                ->mainFrameImpl()
+                ->frameView()
+                ->layoutSize()
+                .height());
 }
 
 TEST_P(ParameterizedWebFrameTest, WideViewportAndWideContentWithInitialScale) {
   registerMockedHttpURLLoad("wide_document_width_viewport.html");
   registerMockedHttpURLLoad("white-1x1.png");
 
   FixedLayoutTestWebViewClient client;
   client.m_screenInfo.deviceScaleFactor = 1;
   int viewportWidth = 600;
   int viewportHeight = 800;
@@ skipping 30 matching lines @@
                                   nullptr, enableViewportSettings);
   webViewHelper.webView()->settings()->setWideViewportQuirkEnabled(true);
   webViewHelper.webView()->settings()->setUseWideViewport(false);
   webViewHelper.webView()->settings()->setViewportMetaLayoutSizeQuirk(true);
   webViewHelper.resize(WebSize(viewportWidth, viewportHeight));
 
   FrameTestHelpers::loadFrame(webViewHelper.webView()->mainFrame(),
                               m_baseURL + "viewport-height-1000.html");
   webViewHelper.resize(WebSize(viewportWidth, viewportHeight));
 
-  EXPECT_EQ(800, webViewHelper.webView()
-                     ->mainFrameImpl()
-                     ->frameView()
-                     ->layoutSize()
-                     .height());
+  EXPECT_EQ(800,
+            webViewHelper.webView()
+                ->mainFrameImpl()
+                ->frameView()
+                ->layoutSize()
+                .height());
   EXPECT_EQ(1, webViewHelper.webView()->pageScaleFactor());
 }
 
 TEST_P(ParameterizedWebFrameTest, LayoutSize320Quirk) {
   registerMockedHttpURLLoad("viewport/viewport-30.html");
 
   FixedLayoutTestWebViewClient client;
   client.m_screenInfo.deviceScaleFactor = 1;
   int viewportWidth = 600;
   int viewportHeight = 800;
 
   FrameTestHelpers::WebViewHelper webViewHelper;
   webViewHelper.initializeAndLoad("about:blank", true, nullptr, &client,
                                   nullptr, enableViewportSettings);
   webViewHelper.webView()->settings()->setWideViewportQuirkEnabled(true);
   webViewHelper.webView()->settings()->setUseWideViewport(true);
   webViewHelper.webView()->settings()->setViewportMetaLayoutSizeQuirk(true);
   webViewHelper.resize(WebSize(viewportWidth, viewportHeight));
 
   FrameTestHelpers::loadFrame(webViewHelper.webView()->mainFrame(),
                               m_baseURL + "viewport/viewport-30.html");
   webViewHelper.resize(WebSize(viewportWidth, viewportHeight));
 
-  EXPECT_EQ(600, webViewHelper.webView()
-                     ->mainFrameImpl()
-                     ->frameView()
-                     ->layoutSize()
-                     .width());
-  EXPECT_EQ(800, webViewHelper.webView()
-                     ->mainFrameImpl()
-                     ->frameView()
-                     ->layoutSize()
-                     .height());
+  EXPECT_EQ(600,
+            webViewHelper.webView()
+                ->mainFrameImpl()
+                ->frameView()
+                ->layoutSize()
+                .width());
+  EXPECT_EQ(800,
+            webViewHelper.webView()
+                ->mainFrameImpl()
+                ->frameView()
+                ->layoutSize()
+                .height());
   EXPECT_EQ(1, webViewHelper.webView()->pageScaleFactor());
 
   // The magic number to snap to device-width is 320, so test that 321 is
   // respected.
   Document* document =
       toLocalFrame(webViewHelper.webView()->page()->mainFrame())->document();
   ViewportDescription description = document->viewportDescription();
   description.minWidth = Length(321, blink::Fixed);
   description.maxWidth = Length(321, blink::Fixed);
   document->setViewportDescription(description);
   webViewHelper.webView()->updateAllLifecyclePhases();
-  EXPECT_EQ(321, webViewHelper.webView()
-                     ->mainFrameImpl()
-                     ->frameView()
-                     ->layoutSize()
-                     .width());
+  EXPECT_EQ(321,
+            webViewHelper.webView()
+                ->mainFrameImpl()
+                ->frameView()
+                ->layoutSize()
+                .width());
 
   description.minWidth = Length(320, blink::Fixed);
   description.maxWidth = Length(320, blink::Fixed);
   document->setViewportDescription(description);
   webViewHelper.webView()->updateAllLifecyclePhases();
-  EXPECT_EQ(600, webViewHelper.webView()
-                     ->mainFrameImpl()
-                     ->frameView()
-                     ->layoutSize()
-                     .width());
+  EXPECT_EQ(600,
+            webViewHelper.webView()
+                ->mainFrameImpl()
+                ->frameView()
+                ->layoutSize()
+                .width());
 
   description = document->viewportDescription();
   description.maxHeight = Length(1000, blink::Fixed);
   document->setViewportDescription(description);
   webViewHelper.webView()->updateAllLifecyclePhases();
-  EXPECT_EQ(1000, webViewHelper.webView()
-                      ->mainFrameImpl()
-                      ->frameView()
-                      ->layoutSize()
-                      .height());
+  EXPECT_EQ(1000,
+            webViewHelper.webView()
+                ->mainFrameImpl()
+                ->frameView()
+                ->layoutSize()
+                .height());
 
   description.maxHeight = Length(320, blink::Fixed);
   document->setViewportDescription(description);
   webViewHelper.webView()->updateAllLifecyclePhases();
-  EXPECT_EQ(800, webViewHelper.webView()
-                     ->mainFrameImpl()
-                     ->frameView()
-                     ->layoutSize()
-                     .height());
+  EXPECT_EQ(800,
+            webViewHelper.webView()
+                ->mainFrameImpl()
+                ->frameView()
+                ->layoutSize()
+                .height());
 }
 
 TEST_P(ParameterizedWebFrameTest, ZeroValuesQuirk) {
   registerMockedHttpURLLoad("viewport-zero-values.html");
 
   FixedLayoutTestWebViewClient client;
   client.m_screenInfo.deviceScaleFactor = 1;
   int viewportWidth = 640;
   int viewportHeight = 480;
 
   FrameTestHelpers::WebViewHelper webViewHelper;
   webViewHelper.initialize(true, nullptr, &client, nullptr,
                            enableViewportSettings);
   webViewHelper.webView()->settings()->setViewportMetaZeroValuesQuirk(true);
   webViewHelper.webView()->settings()->setWideViewportQuirkEnabled(true);
   webViewHelper.webView()->settings()->setViewportMetaLayoutSizeQuirk(true);
   FrameTestHelpers::loadFrame(webViewHelper.webView()->mainFrame(),
                               m_baseURL + "viewport-zero-values.html");
   webViewHelper.resize(WebSize(viewportWidth, viewportHeight));
 
-  EXPECT_EQ(viewportWidth, webViewHelper.webView()
-                               ->mainFrameImpl()
-                               ->frameView()
-                               ->layoutSize()
-                               .width());
+  EXPECT_EQ(viewportWidth,
+            webViewHelper.webView()
+                ->mainFrameImpl()
+                ->frameView()
+                ->layoutSize()
+                .width());
   EXPECT_EQ(1.0f, webViewHelper.webView()->pageScaleFactor());
 
   webViewHelper.webView()->settings()->setUseWideViewport(true);
   webViewHelper.webView()->updateAllLifecyclePhases();
-  EXPECT_EQ(viewportWidth, webViewHelper.webView()
-                               ->mainFrameImpl()
-                               ->frameView()
-                               ->layoutSize()
-                               .width());
+  EXPECT_EQ(viewportWidth,
+            webViewHelper.webView()
+                ->mainFrameImpl()
+                ->frameView()
+                ->layoutSize()
+                .width());
   EXPECT_EQ(1.0f, webViewHelper.webView()->pageScaleFactor());
 }
 
 TEST_P(ParameterizedWebFrameTest, OverflowHiddenDisablesScrolling) {
   registerMockedHttpURLLoad("body-overflow-hidden.html");
 
   FixedLayoutTestWebViewClient client;
   client.m_screenInfo.deviceScaleFactor = 1;
   int viewportWidth = 640;
   int viewportHeight = 480;
@@ skipping 64 matching lines @@
 
   FrameTestHelpers::WebViewHelper webViewHelper;
   webViewHelper.initialize(true, nullptr, &client, nullptr,
                            enableViewportSettings);
   webViewHelper.webView()->settings()->setViewportMetaZeroValuesQuirk(true);
   webViewHelper.webView()->settings()->setWideViewportQuirkEnabled(true);
   FrameTestHelpers::loadFrame(webViewHelper.webView()->mainFrame(),
                               m_baseURL + "viewport-nonzero-values.html");
   webViewHelper.resize(WebSize(viewportWidth, viewportHeight));
 
-  EXPECT_EQ(viewportWidth / expectedPageScaleFactor, webViewHelper.webView()
-                                                         ->mainFrameImpl()
-                                                         ->frameView()
-                                                         ->layoutSize()
-                                                         .width());
+  EXPECT_EQ(viewportWidth / expectedPageScaleFactor,
+            webViewHelper.webView()
+                ->mainFrameImpl()
+                ->frameView()
+                ->layoutSize()
+                .width());
   EXPECT_EQ(expectedPageScaleFactor,
             webViewHelper.webView()->pageScaleFactor());
 
   webViewHelper.webView()->settings()->setUseWideViewport(true);
   webViewHelper.webView()->updateAllLifecyclePhases();
-  EXPECT_EQ(viewportWidth / expectedPageScaleFactor, webViewHelper.webView()
-                                                         ->mainFrameImpl()
-                                                         ->frameView()
-                                                         ->layoutSize()
-                                                         .width());
+  EXPECT_EQ(viewportWidth / expectedPageScaleFactor,
+            webViewHelper.webView()
+                ->mainFrameImpl()
+                ->frameView()
+                ->layoutSize()
+                .width());
   EXPECT_EQ(expectedPageScaleFactor,
             webViewHelper.webView()->pageScaleFactor());
 }
 
 TEST_P(ParameterizedWebFrameTest, setPageScaleFactorDoesNotLayout) {
   registerMockedHttpURLLoad("fixed_layout.html");
 
   FixedLayoutTestWebViewClient client;
   client.m_screenInfo.deviceScaleFactor = 1;
   // Small viewport to ensure there are always scrollbars.
@@ skipping 49 matching lines @@
   int viewportWidth = 640;
   int viewportHeight = 480;
 
   FrameTestHelpers::WebViewHelper webViewHelper;
   webViewHelper.initializeAndLoad(m_baseURL + "fixed_layout.html", true,
                                   nullptr, &client, nullptr,
                                   enableViewportSettings);
   webViewHelper.resize(WebSize(viewportWidth, viewportHeight));
 
   webViewHelper.webView()->setPageScaleFactor(3);
-  EXPECT_EQ(3, toLocalFrame(webViewHelper.webView()->page()->mainFrame())
-                   ->loader()
-                   .currentItem()
-                   ->pageScaleFactor());
+  EXPECT_EQ(3,
+            toLocalFrame(webViewHelper.webView()->page()->mainFrame())
+                ->loader()
+                .currentItem()
+                ->pageScaleFactor());
 }
 
 TEST_P(ParameterizedWebFrameTest, initialScaleWrittenToHistoryItem) {
   registerMockedHttpURLLoad("fixed_layout.html");
 
   FixedLayoutTestWebViewClient client;
   client.m_screenInfo.deviceScaleFactor = 1;
   int viewportWidth = 640;
   int viewportHeight = 480;
 
@@ skipping 65 matching lines @@
   int viewportHeight = 480;
 
   FrameTestHelpers::WebViewHelper webViewHelper;
   webViewHelper.initializeAndLoad(m_baseURL + "fixed_layout.html", true,
                                   nullptr, &client, nullptr,
                                   enableViewportSettings);
   webViewHelper.resize(WebSize(viewportWidth, viewportHeight));
 
   webViewHelper.webView()->setPageScaleFactor(2);
 
-  EXPECT_EQ(980, toLocalFrame(webViewHelper.webView()->page()->mainFrame())
-                     ->contentLayoutItem()
-                     .documentRect()
-                     .width());
-  EXPECT_EQ(980, webViewHelper.webView()
-                     ->mainFrameImpl()
-                     ->frameView()
-                     ->contentsSize()
-                     .width());
+  EXPECT_EQ(980,
+            toLocalFrame(webViewHelper.webView()->page()->mainFrame())
+                ->contentLayoutItem()
+                .documentRect()
+                .width());
+  EXPECT_EQ(980,
+            webViewHelper.webView()
+                ->mainFrameImpl()
+                ->frameView()
+                ->contentsSize()
+                .width());
 }
 
 TEST_P(ParameterizedWebFrameTest, targetDensityDpiHigh) {
   registerMockedHttpURLLoad("viewport-target-densitydpi-high.html");
 
   FixedLayoutTestWebViewClient client;
   // high-dpi = 240
   float targetDpi = 240.0f;
   float deviceScaleFactors[] = {1.0f, 4.0f / 3.0f, 2.0f};
   int viewportWidth = 640;
   int viewportHeight = 480;
 
   for (size_t i = 0; i < WTF_ARRAY_LENGTH(deviceScaleFactors); ++i) {
     float deviceScaleFactor = deviceScaleFactors[i];
     float deviceDpi = deviceScaleFactor * 160.0f;
     client.m_screenInfo.deviceScaleFactor = deviceScaleFactor;
 
     FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(
         m_baseURL + "viewport-target-densitydpi-high.html", true, nullptr,
         &client, nullptr, enableViewportSettings);
     webViewHelper.webView()->settings()->setWideViewportQuirkEnabled(true);
     webViewHelper.webView()->settings()->setSupportDeprecatedTargetDensityDPI(
         true);
     webViewHelper.resize(WebSize(viewportWidth, viewportHeight));
 
     // We need to account for the fact that logical pixels are unconditionally
     // multiplied by deviceScaleFactor to produce physical pixels.
     float densityDpiScaleRatio = deviceScaleFactor * targetDpi / deviceDpi;
-    EXPECT_NEAR(viewportWidth * densityDpiScaleRatio, webViewHelper.webView()
-                                                          ->mainFrameImpl()
-                                                          ->frameView()
-                                                          ->layoutSize()
-                                                          .width(),
+    EXPECT_NEAR(viewportWidth * densityDpiScaleRatio,
+                webViewHelper.webView()
+                    ->mainFrameImpl()
+                    ->frameView()
+                    ->layoutSize()
+                    .width(),
                 1.0f);
-    EXPECT_NEAR(viewportHeight * densityDpiScaleRatio, webViewHelper.webView()
-                                                           ->mainFrameImpl()
-                                                           ->frameView()
-                                                           ->layoutSize()
-                                                           .height(),
+    EXPECT_NEAR(viewportHeight * densityDpiScaleRatio,
+                webViewHelper.webView()
+                    ->mainFrameImpl()
+                    ->frameView()
+                    ->layoutSize()
+                    .height(),
                 1.0f);
     EXPECT_NEAR(1.0f / densityDpiScaleRatio,
                 webViewHelper.webView()->pageScaleFactor(), 0.01f);
   }
 }
 
 TEST_P(ParameterizedWebFrameTest, targetDensityDpiDevice) {
   registerMockedHttpURLLoad("viewport-target-densitydpi-device.html");
 
   float deviceScaleFactors[] = {1.0f, 4.0f / 3.0f, 2.0f};
@@ skipping 49 matching lines @@
     FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(
         m_baseURL + "viewport-target-densitydpi-device-and-fixed-width.html",
         true, nullptr, &client, nullptr, enableViewportSettings);
     webViewHelper.webView()->settings()->setWideViewportQuirkEnabled(true);
     webViewHelper.webView()->settings()->setSupportDeprecatedTargetDensityDPI(
         true);
     webViewHelper.webView()->settings()->setUseWideViewport(true);
     webViewHelper.resize(WebSize(viewportWidth, viewportHeight));
 
-    EXPECT_NEAR(viewportWidth, webViewHelper.webView()
-                                   ->mainFrameImpl()
-                                   ->frameView()
-                                   ->layoutSize()
-                                   .width(),
+    EXPECT_NEAR(viewportWidth,
+                webViewHelper.webView()
+                    ->mainFrameImpl()
+                    ->frameView()
+                    ->layoutSize()
+                    .width(),
                 1.0f);
-    EXPECT_NEAR(viewportHeight, webViewHelper.webView()
-                                    ->mainFrameImpl()
-                                    ->frameView()
-                                    ->layoutSize()
-                                    .height(),
+    EXPECT_NEAR(viewportHeight,
+                webViewHelper.webView()
+                    ->mainFrameImpl()
+                    ->frameView()
+                    ->layoutSize()
+                    .height(),
                 1.0f);
     EXPECT_NEAR(1.0f, webViewHelper.webView()->pageScaleFactor(), 0.01f);
   }
 }
 
 TEST_P(ParameterizedWebFrameTest, NoWideViewportAndScaleLessThanOne) {
   registerMockedHttpURLLoad("viewport-initial-scale-less-than-1.html");
 
   FixedLayoutTestWebViewClient client;
   client.m_screenInfo.deviceScaleFactor = 1.33f;
@@ skipping 78 matching lines @@
 
   FrameTestHelpers::WebViewHelper webViewHelper;
   webViewHelper.initializeAndLoad(m_baseURL + "large-div.html", true, nullptr,
                                   &client, nullptr, enableViewportSettings);
   webViewHelper.webView()->setDefaultPageScaleLimits(0.25f, 5);
   webViewHelper.webView()->settings()->setWideViewportQuirkEnabled(true);
   webViewHelper.webView()->settings()->setUseWideViewport(false);
   webViewHelper.webView()->setInitialPageScaleOverride(enforcedPageScaleFactor);
   webViewHelper.resize(WebSize(viewportWidth, viewportHeight));
 
-  EXPECT_NEAR(viewportWidth / enforcedPageScaleFactor, webViewHelper.webView()
-                                                           ->mainFrameImpl()
-                                                           ->frameView()
-                                                           ->layoutSize()
-                                                           .width(),
+  EXPECT_NEAR(viewportWidth / enforcedPageScaleFactor,
+              webViewHelper.webView()
+                  ->mainFrameImpl()
+                  ->frameView()
+                  ->layoutSize()
+                  .width(),
               1.0f);
-  EXPECT_NEAR(viewportHeight / enforcedPageScaleFactor, webViewHelper.webView()
-                                                            ->mainFrameImpl()
-                                                            ->frameView()
-                                                            ->layoutSize()
-                                                            .height(),
+  EXPECT_NEAR(viewportHeight / enforcedPageScaleFactor,
+              webViewHelper.webView()
+                  ->mainFrameImpl()
+                  ->frameView()
+                  ->layoutSize()
+                  .height(),
               1.0f);
   EXPECT_NEAR(enforcedPageScaleFactor,
               webViewHelper.webView()->pageScaleFactor(), 0.01f);
 }
 
 TEST_P(ParameterizedWebFrameTest, NoUserScalableQuirkIgnoresViewportScale) {
   registerMockedHttpURLLoad("viewport-initial-scale-and-user-scalable-no.html");
 
   FixedLayoutTestWebViewClient client;
   int viewportWidth = 640;
   int viewportHeight = 480;
 
   FrameTestHelpers::WebViewHelper webViewHelper;
   webViewHelper.initializeAndLoad(
       m_baseURL + "viewport-initial-scale-and-user-scalable-no.html", true,
       nullptr, &client, nullptr, enableViewportSettings);
   webViewHelper.webView()->settings()->setViewportMetaNonUserScalableQuirk(
       true);
   webViewHelper.resize(WebSize(viewportWidth, viewportHeight));
 
-  EXPECT_NEAR(viewportWidth, webViewHelper.webView()
-                                 ->mainFrameImpl()
-                                 ->frameView()
-                                 ->layoutSize()
-                                 .width(),
+  EXPECT_NEAR(viewportWidth,
+              webViewHelper.webView()
+                  ->mainFrameImpl()
+                  ->frameView()
+                  ->layoutSize()
+                  .width(),
               1.0f);
-  EXPECT_NEAR(viewportHeight, webViewHelper.webView()
-                                  ->mainFrameImpl()
-                                  ->frameView()
-                                  ->layoutSize()
-                                  .height(),
+  EXPECT_NEAR(viewportHeight,
+              webViewHelper.webView()
+                  ->mainFrameImpl()
+                  ->frameView()
+                  ->layoutSize()
+                  .height(),
               1.0f);
   EXPECT_NEAR(1.0f, webViewHelper.webView()->pageScaleFactor(), 0.01f);
 }
 
 TEST_P(ParameterizedWebFrameTest,
        NoUserScalableQuirkIgnoresViewportScaleForNonWideViewport) {
   registerMockedHttpURLLoad("viewport-initial-scale-and-user-scalable-no.html");
 
   FixedLayoutTestWebViewClient client;
   client.m_screenInfo.deviceScaleFactor = 1.33f;
@@ skipping 41 matching lines @@
   FrameTestHelpers::WebViewHelper webViewHelper;
   webViewHelper.initializeAndLoad(
       m_baseURL + "viewport-2x-initial-scale-non-user-scalable.html", true,
       nullptr, &client, nullptr, enableViewportSettings);
   webViewHelper.webView()->settings()->setViewportMetaNonUserScalableQuirk(
       true);
   webViewHelper.webView()->settings()->setWideViewportQuirkEnabled(true);
   webViewHelper.webView()->settings()->setUseWideViewport(true);
   webViewHelper.resize(WebSize(viewportWidth, viewportHeight));
 
-  EXPECT_NEAR(viewportWidth, webViewHelper.webView()
-                                 ->mainFrameImpl()
-                                 ->frameView()
-                                 ->layoutSize()
-                                 .width(),
+  EXPECT_NEAR(viewportWidth,
+              webViewHelper.webView()
+                  ->mainFrameImpl()
+                  ->frameView()
+                  ->layoutSize()
+                  .width(),
               1.0f);
-  EXPECT_NEAR(viewportHeight, webViewHelper.webView()
-                                  ->mainFrameImpl()
-                                  ->frameView()
-                                  ->layoutSize()
-                                  .height(),
+  EXPECT_NEAR(viewportHeight,
+              webViewHelper.webView()
+                  ->mainFrameImpl()
+                  ->frameView()
+                  ->layoutSize()
+                  .height(),
               1.0f);
   EXPECT_NEAR(1.0f, webViewHelper.webView()->pageScaleFactor(), 0.01f);
 }
 
 TEST_P(ParameterizedWebFrameTest,
        DesktopPageCanBeZoomedInWhenWideViewportIsTurnedOff) {
   registerMockedHttpURLLoad("no_viewport_tag.html");
 
   FixedLayoutTestWebViewClient client;
   int viewportWidth = 640;
@@ skipping 16 matching lines @@
 TEST_P(ParameterizedWebFrameTest, AtViewportInsideAtMediaInitialViewport) {
   registerMockedHttpURLLoad("viewport-inside-media.html");
 
   FixedLayoutTestWebViewClient client;
   FrameTestHelpers::WebViewHelper webViewHelper;
   webViewHelper.initializeAndLoad(m_baseURL + "viewport-inside-media.html",
                                   true, nullptr, &client, nullptr,
                                   enableViewportSettings);
   webViewHelper.resize(WebSize(640, 480));
 
-  EXPECT_EQ(2000, webViewHelper.webView()
-                      ->mainFrameImpl()
-                      ->frameView()
-                      ->layoutSize()
-                      .width());
+  EXPECT_EQ(2000,
+            webViewHelper.webView()
+                ->mainFrameImpl()
+                ->frameView()
+                ->layoutSize()
+                .width());
 
   webViewHelper.resize(WebSize(1200, 480));
 
-  EXPECT_EQ(1200, webViewHelper.webView()
-                      ->mainFrameImpl()
-                      ->frameView()
-                      ->layoutSize()
-                      .width());
+  EXPECT_EQ(1200,
+            webViewHelper.webView()
+                ->mainFrameImpl()
+                ->frameView()
+                ->layoutSize()
+                .width());
 }
 
 TEST_P(ParameterizedWebFrameTest, AtViewportAffectingAtMediaRecalcCount) {
   registerMockedHttpURLLoad("viewport-and-media.html");
 
   FixedLayoutTestWebViewClient client;
   FrameTestHelpers::WebViewHelper webViewHelper;
   webViewHelper.initialize(true, nullptr, &client, nullptr,
                            enableViewportSettings);
   webViewHelper.resize(WebSize(640, 480));
   FrameTestHelpers::loadFrame(webViewHelper.webView()->mainFrame(),
                               m_baseURL + "viewport-and-media.html");
 
   Document* document =
       webViewHelper.webView()->mainFrameImpl()->frame()->document();
-  EXPECT_EQ(2000, webViewHelper.webView()
-                      ->mainFrameImpl()
-                      ->frameView()
-                      ->layoutSize()
-                      .width());
+  EXPECT_EQ(2000,
+            webViewHelper.webView()
+                ->mainFrameImpl()
+                ->frameView()
+                ->layoutSize()
+                .width());
 
   // The styleForElementCount() should match the number of elements for a single
   // pass of computed styles construction for the document.
   EXPECT_EQ(10u, document->styleEngine().styleForElementCount());
   EXPECT_EQ(Color(0, 128, 0),
             document->body()->computedStyle()->visitedDependentColor(
                 CSSPropertyColor));
 }
 
 TEST_P(ParameterizedWebFrameTest, AtViewportWithViewportLengths) {
@@ skipping 3384 matching lines @@
   document->execCommand("InsertText", false, "_wellcome_.", exceptionState);
   EXPECT_FALSE(exceptionState.hadException());
 
   const int allTextBeginOffset = 0;
   const int allTextLength = 11;
   frame->selectRange(WebRange(allTextBeginOffset, allTextLength));
   EphemeralRange selectionRange =
       frame->frame()->selection().selection().toNormalizedEphemeralRange();
 
   EXPECT_EQ(1, spellcheck.numberOfTimesChecked());
-  EXPECT_EQ(1U, document->markers()
-                    .markersInRange(selectionRange, DocumentMarker::Spelling)
-                    .size());
+  EXPECT_EQ(1U,
+            document->markers()
+                .markersInRange(selectionRange, DocumentMarker::Spelling)
+                .size());
 
   frame->replaceMisspelledRange("welcome");
   EXPECT_EQ("_welcome_.",
             WebFrameContentDumper::dumpWebViewAsText(
                 webViewHelper.webView(), std::numeric_limits<size_t>::max())
                 .utf8());
 }
 
 TEST_P(ParameterizedWebFrameTest, RemoveSpellingMarkers) {
   registerMockedHttpURLLoad("spell.html");
@@ skipping 15 matching lines @@
   EXPECT_FALSE(exceptionState.hadException());
 
   frame->removeSpellingMarkers();
 
   const int allTextBeginOffset = 0;
   const int allTextLength = 11;
   frame->selectRange(WebRange(allTextBeginOffset, allTextLength));
   EphemeralRange selectionRange =
       frame->frame()->selection().selection().toNormalizedEphemeralRange();
 
-  EXPECT_EQ(0U, document->markers()
-                    .markersInRange(selectionRange, DocumentMarker::Spelling)
-                    .size());
+  EXPECT_EQ(0U,
+            document->markers()
+                .markersInRange(selectionRange, DocumentMarker::Spelling)
+                .size());
 }
 
 TEST_P(ParameterizedWebFrameTest, RemoveSpellingMarkersUnderWords) {
   registerMockedHttpURLLoad("spell.html");
   FrameTestHelpers::WebViewHelper webViewHelper;
   webViewHelper.initializeAndLoad(m_baseURL + "spell.html");
   SpellCheckClient spellcheck;
   webViewHelper.webView()->setSpellCheckClient(&spellcheck);
 
   LocalFrame* frame = webViewHelper.webView()->mainFrameImpl()->frame();
@@ skipping 986 matching lines @@
   TestDidNavigateCommitTypeWebFrameClient client;
   FrameTestHelpers::WebViewHelper webViewHelper;
   WebViewImpl* webViewImpl = webViewHelper.initializeAndLoad(
       m_baseURL + "push_state.html", true, &client);
   Persistent<HistoryItem> item =
       toLocalFrame(webViewImpl->page()->mainFrame())->loader().currentItem();
   runPendingTasks();
 
   toLocalFrame(webViewImpl->page()->mainFrame())
       ->loader()
-      .load(
-          FrameLoadRequest(
-              nullptr, FrameLoader::resourceRequestFromHistoryItem(
-                           item.get(), WebCachePolicy::UseProtocolCachePolicy)),
-          FrameLoadTypeBackForward, item.get(), HistorySameDocumentLoad);
+      .load(FrameLoadRequest(
+                nullptr,
+                FrameLoader::resourceRequestFromHistoryItem(
+                    item.get(), WebCachePolicy::UseProtocolCachePolicy)),
+            FrameLoadTypeBackForward, item.get(), HistorySameDocumentLoad);
   EXPECT_EQ(WebBackForwardCommit, client.lastCommitType());
 }
 
 class TestHistoryWebFrameClient : public FrameTestHelpers::TestWebFrameClient {
  public:
   TestHistoryWebFrameClient() { m_replacesCurrentHistoryItem = false; }
 
   void didStartProvisionalLoad(WebDataSource* dataSource) {
     m_replacesCurrentHistoryItem = dataSource->replacesCurrentHistoryItem();
   }
@@ skipping 1733 matching lines @@
   ASSERT_EQ(mainFrame()->firstChild(), remoteFrame);
   EXPECT_EQ(uniqueName.utf8(),
             WebString(remoteFrame->frame()->tree().uniqueName()).utf8());
 
   // Swap back to a LocalFrame.
   RemoteToLocalSwapWebFrameClient client(remoteFrame);
   WebLocalFrame* localFrame = WebLocalFrame::createProvisional(
       &client, nullptr, nullptr, remoteFrame, WebSandboxFlags::None);
   FrameTestHelpers::loadFrame(localFrame, m_baseURL + "subframe-hello.html");
   EXPECT_EQ(uniqueName.utf8(), localFrame->uniqueName().utf8());
-  EXPECT_EQ(uniqueName.utf8(), WebString(toWebLocalFrameImpl(localFrame)
-                                             ->frame()
-                                             ->loader()
-                                             .currentItem()
-                                             ->target())
-                                   .utf8());
+  EXPECT_EQ(uniqueName.utf8(),
+            WebString(toWebLocalFrameImpl(localFrame)
+                          ->frame()
+                          ->loader()
+                          .currentItem()
+                          ->target())
+                .utf8());
 
   // Repeat with no name on the frame.
   // (note that uniqueName is immutable after first real commit).
   localFrame->setName("");
   WebString uniqueName2 = localFrame->uniqueName();
   EXPECT_EQ("frame1", uniqueName2.utf8());
 
   FrameTestHelpers::TestWebRemoteFrameClient remoteFrameClient2;
   WebRemoteFrameImpl* remoteFrame2 = WebRemoteFrameImpl::create(
       WebTreeScopeType::Document, &remoteFrameClient2);
   localFrame->swap(remoteFrame2);
   ASSERT_TRUE(mainFrame()->firstChild());
   ASSERT_EQ(mainFrame()->firstChild(), remoteFrame2);
   EXPECT_EQ(uniqueName2.utf8(),
             WebString(remoteFrame2->frame()->tree().uniqueName()).utf8());
 
   RemoteToLocalSwapWebFrameClient client2(remoteFrame2);
   WebLocalFrame* localFrame2 = WebLocalFrame::createProvisional(
       &client2, nullptr, nullptr, remoteFrame2, WebSandboxFlags::None);
   FrameTestHelpers::loadFrame(localFrame2, m_baseURL + "subframe-hello.html");
   EXPECT_EQ(uniqueName2.utf8(), localFrame2->uniqueName().utf8());
-  EXPECT_EQ(uniqueName2.utf8(), WebString(toWebLocalFrameImpl(localFrame2)
-                                              ->frame()
-                                              ->loader()
-                                              .currentItem()
-                                              ->target())
-                                    .utf8());
+  EXPECT_EQ(uniqueName2.utf8(),
+            WebString(toWebLocalFrameImpl(localFrame2)
+                          ->frame()
+                          ->loader()
+                          .currentItem()
+                          ->target())
+                .utf8());
 
   // Manually reset to break WebViewHelper's dependency on the stack allocated
   // TestWebFrameClient.
   reset();
   remoteFrame->close();
   remoteFrame2->close();
 }
 
 class RemoteNavigationClient
     : public FrameTestHelpers::TestWebRemoteFrameClient {
@@ skipping 666 matching lines @@
   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.
   ScrollBegin(&webViewHelper);
-  EXPECT_CALL(client, didOverscroll(WebFloatSize(8, 16), WebFloatSize(8, 16),
-                                    WebFloatPoint(100, 100), WebFloatSize()));
+  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()));
+  EXPECT_CALL(client,
+              didOverscroll(WebFloatSize(0, 13), WebFloatSize(8, 29),
+                            WebFloatPoint(100, 100), WebFloatSize()));
   ScrollUpdate(&webViewHelper, 0, -13);
   Mock::VerifyAndClearExpectations(&client);
 
-  EXPECT_CALL(client, didOverscroll(WebFloatSize(20, 13), WebFloatSize(28, 42),
-                                    WebFloatPoint(100, 100), WebFloatSize()));
+  EXPECT_CALL(client,
+              didOverscroll(WebFloatSize(20, 13), WebFloatSize(28, 42),
+                            WebFloatPoint(100, 100), WebFloatSize()));
   ScrollUpdate(&webViewHelper, -20, -13);
   Mock::VerifyAndClearExpectations(&client);
 
   // Overscroll is not reported.
   EXPECT_CALL(client, didOverscroll(_, _, _, _)).Times(0);
   ScrollUpdate(&webViewHelper, 0, 1);
   Mock::VerifyAndClearExpectations(&client);
 
   EXPECT_CALL(client, didOverscroll(_, _, _, _)).Times(0);
   ScrollUpdate(&webViewHelper, 1, 0);
@@ skipping 26 matching lines @@
 
   // Scroll the Div to the end.
   EXPECT_CALL(client, didOverscroll(_, _, _, _)).Times(0);
   ScrollUpdate(&webViewHelper, 0, -316);
   Mock::VerifyAndClearExpectations(&client);
 
   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()));
+  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.
   // Page scrolls vertically, but over-scrolls horizontally.
   // EXPECT_CALL(client, didOverscroll(WebFloatSize(-100, 0), WebFloatSize(-100,
   // 0), WebFloatPoint(100, 100), WebFloatSize()));
@@ skipping 25 matching lines @@
 
   // Scroll the Div to the end.
   EXPECT_CALL(client, didOverscroll(_, _, _, _)).Times(0);
   ScrollUpdate(&webViewHelper, 0, -316);
   Mock::VerifyAndClearExpectations(&client);
 
   ScrollEnd(&webViewHelper);
   ScrollBegin(&webViewHelper);
 
   // Now On Scrolling DIV, scroll is bubbled and root layer is over-scrolled.
-  EXPECT_CALL(client, didOverscroll(WebFloatSize(0, 50), WebFloatSize(0, 50),
-                                    WebFloatPoint(100, 100), WebFloatSize()));
+  EXPECT_CALL(client,
+              didOverscroll(WebFloatSize(0, 50), WebFloatSize(0, 50),
+                            WebFloatPoint(100, 100), WebFloatSize()));
   ScrollUpdate(&webViewHelper, 0, -150);
   Mock::VerifyAndClearExpectations(&client);
 }
 
 TEST_P(WebFrameOverscrollTest, RootLayerOverscrolledOnInnerIFrameOverScroll) {
   OverscrollWebViewClient client;
   registerMockedHttpURLLoad("overscroll/iframe-overscroll.html");
   registerMockedHttpURLLoad("overscroll/scrollable-iframe.html");
   FrameTestHelpers::WebViewHelper webViewHelper;
   webViewHelper.initializeAndLoad(
@@ skipping 11 matching lines @@
 
   // 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()));
+  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).
   ScrollBegin(&webViewHelper);
-  EXPECT_CALL(client, didOverscroll(WebFloatSize(0, -30), WebFloatSize(0, -30),
-                                    WebFloatPoint(99, 99), WebFloatSize()));
+  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()));
+  EXPECT_CALL(client,
+              didOverscroll(WebFloatSize(0, -30), WebFloatSize(0, -60),
+                            WebFloatPoint(99, 99), WebFloatSize()));
   ScrollUpdate(&webViewHelper, 0, 30);
   Mock::VerifyAndClearExpectations(&client);
 
   EXPECT_CALL(client,
               didOverscroll(WebFloatSize(-30, -30), WebFloatSize(-30, -90),
                             WebFloatPoint(99, 99), WebFloatSize()));
   ScrollUpdate(&webViewHelper, 30, 30);
   Mock::VerifyAndClearExpectations(&client);
 
   EXPECT_CALL(client,
@@ skipping 23 matching lines @@
                             WebFloatPoint(100, 100), WebFloatSize()));
   ScrollUpdate(&webViewHelper, 10, 10);
   Mock::VerifyAndClearExpectations(&client);
 
   EXPECT_CALL(client,
               didOverscroll(WebFloatSize(0, -0.10), WebFloatSize(-10, -10.10),
                             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()));
+  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.
   EXPECT_CALL(client, didOverscroll(_, _, _, _)).Times(0);
   ScrollUpdate(&webViewHelper, 0, 0.09);
   Mock::VerifyAndClearExpectations(&client);
 
   EXPECT_CALL(client, didOverscroll(_, _, _, _)).Times(0);
@@ skipping 352 matching lines @@
   FrameTestHelpers::WebViewHelper helper;
   WebViewImpl* webView = helper.initializeAndLoad(url, true, 0);
   webView->resize(WebSize(400, 400));
 
   uint64_t sequence = Platform::current()->clipboard()->sequenceNumber(
       WebClipboard::BufferStandard);
 
   WebLocalFrame* localFrame = webView->mainFrameImpl();
   localFrame->copyImageAt(WebPoint(50, 50));
 
-  EXPECT_NE(sequence, Platform::current()->clipboard()->sequenceNumber(
-                          WebClipboard::BufferStandard));
+  EXPECT_NE(sequence,
+            Platform::current()->clipboard()->sequenceNumber(
+                WebClipboard::BufferStandard));
 
   WebImage image =
       static_cast<WebMockClipboard*>(Platform::current()->clipboard())
           ->readRawImage(WebClipboard::Buffer());
 
   SkAutoLockPixels autoLock(image.getSkBitmap());
   EXPECT_EQ(SkColorSetARGB(255, 255, 0, 0), image.getSkBitmap().getColor(0, 0));
 };
 
 TEST_F(WebFrameTest, CopyImageAtWithPinchZoom) {
   std::string url = m_baseURL + "canvas-copy-image.html";
   registerMockedURLLoadFromBase(m_baseURL, "canvas-copy-image.html");
 
   FrameTestHelpers::WebViewHelper helper;
   WebViewImpl* webView = helper.initializeAndLoad(url, true, 0);
   webView->resize(WebSize(400, 400));
   webView->updateAllLifecyclePhases();
   webView->setPageScaleFactor(2);
   webView->setVisualViewportOffset(WebFloatPoint(200, 200));
 
   uint64_t sequence = Platform::current()->clipboard()->sequenceNumber(
       WebClipboard::BufferStandard);
 
   WebLocalFrame* localFrame = webView->mainFrameImpl();
   localFrame->copyImageAt(WebPoint(0, 0));
 
-  EXPECT_NE(sequence, Platform::current()->clipboard()->sequenceNumber(
-                          WebClipboard::BufferStandard));
+  EXPECT_NE(sequence,
+            Platform::current()->clipboard()->sequenceNumber(
+                WebClipboard::BufferStandard));
 
   WebImage image =
       static_cast<WebMockClipboard*>(Platform::current()->clipboard())
           ->readRawImage(WebClipboard::Buffer());
 
   SkAutoLockPixels autoLock(image.getSkBitmap());
   EXPECT_EQ(SkColorSetARGB(255, 255, 0, 0), image.getSkBitmap().getColor(0, 0));
 };
 
 TEST_F(WebFrameTest, CopyImageWithImageMap) {
@@ skipping 34 matching lines @@
 
   std::string redirectURL = m_baseURL + "foo.html";
   URLTestHelpers::registerMockedURLLoad(toKURL(redirectURL),
                                         testing::webTestDataPath("foo.html"));
   WebURLRequest request(toKURL("javascript:location='" + redirectURL + "'"));
   helper.webView()->mainFrameImpl()->loadRequest(request);
 
   // Normally, the result of the JS url replaces the existing contents on the
   // Document. However, if the JS triggers a navigation, the contents should
   // not be replaced.
-  EXPECT_EQ("", toLocalFrame(helper.webView()->page()->mainFrame())
-                    ->document()
-                    ->documentElement()
-                    ->innerText());
+  EXPECT_EQ("",
+            toLocalFrame(helper.webView()->page()->mainFrame())
+                ->document()
+                ->documentElement()
+                ->innerText());
 }
 
 class TestResourcePriorityWebFrameClient
     : public FrameTestHelpers::TestWebFrameClient {
  public:
   class ExpectedRequest {
    public:
     ExpectedRequest(const KURL& url, WebURLRequest::Priority priority)
         : url(url), priority(priority), seen(false) {}
 
@@ skipping 876 matching lines @@
 
   EXPECT_TRUE(mainFrameClient.childClient().didCallFrameDetached());
   EXPECT_TRUE(mainFrameClient.childClient().didCallDidStopLoading());
   EXPECT_TRUE(mainFrameClient.childClient().didCallDidFinishDocumentLoad());
   EXPECT_TRUE(mainFrameClient.childClient().didCallDidHandleOnloadEvents());
 
   webViewHelper.reset();
 }
 
 }  // namespace blink