reflow comments in web/tests

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

 /*
  * Copyright (C) 2011, 2012 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 401 matching lines @@
   EXPECT_EQ(transparentRed, frame->view()->baseBackgroundColor());
   frame->view()->dispose();
 }
 
 TEST_F(WebViewTest, SetBaseBackgroundColorBeforeMainFrame) {
   const WebColor kBlue = 0xFF0000FF;
   FrameTestHelpers::TestWebViewClient webViewClient;
   WebViewImpl* webView =
       WebViewImpl::create(&webViewClient, WebPageVisibilityStateVisible);
   EXPECT_NE(kBlue, webView->backgroundColor());
-  // webView does not have a frame yet, but we should still be able to set the background color.
+  // webView does not have a frame yet, but we should still be able to set the
+  // background color.
   webView->setBaseBackgroundColor(kBlue);
   EXPECT_EQ(kBlue, webView->backgroundColor());
   FrameTestHelpers::TestWebFrameClient webFrameClient;
   WebLocalFrame* frame =
       WebLocalFrame::create(WebTreeScopeType::Document, &webFrameClient);
   webView->setMainFrame(frame);
   webView->close();
 }
 
 TEST_F(WebViewTest, SetBaseBackgroundColorAndBlendWithExistingContent) {
@@ skipping 11 matching lines @@
   webView->updateAllLifecyclePhases();
 
   // Set canvas background to red with alpha.
   SkBitmap bitmap;
   bitmap.allocN32Pixels(kWidth, kHeight);
   SkCanvas canvas(bitmap);
   canvas.clear(kAlphaRed);
 
   SkPictureBuilder pictureBuilder(FloatRect(0, 0, kWidth, kHeight));
 
-  // Paint the root of the main frame in the way that CompositedLayerMapping would.
+  // Paint the root of the main frame in the way that CompositedLayerMapping
+  // would.
   FrameView* view = m_webViewHelper.webView()->mainFrameImpl()->frameView();
   PaintLayer* rootLayer = view->layoutViewItem().layer();
   LayoutRect paintRect(0, 0, kWidth, kHeight);
   PaintLayerPaintingInfo paintingInfo(rootLayer, paintRect,
                                       GlobalPaintNormalPhase, LayoutSize());
   PaintLayerPainter(*rootLayer)
       .paintLayerContents(pictureBuilder.context(), paintingInfo,
                           PaintLayerPaintingCompositingAllPhases);
 
   pictureBuilder.endRecording()->playback(&canvas);
@@ skipping 184 matching lines @@
   EXPECT_EQ(expectedHeight, client.testData().height());
 
 // Android disables main frame scrollbars.
 #if !OS(ANDROID)
   EXPECT_EQ(expectedHorizontalState,
             client.testData().getHorizontalScrollbarState());
   EXPECT_EQ(expectedVerticalState,
             client.testData().getVerticalScrollbarState());
 #endif
 
-  m_webViewHelper
-      .reset();  // Explicitly reset to break dependency on locally scoped client.
+  // Explicitly reset to break dependency on locally scoped client.
+  m_webViewHelper.reset();
 }
 
 TEST_F(WebViewTest, AutoResizeMinimumSize) {
   WebSize minAutoResize(91, 56);
   WebSize maxAutoResize(403, 302);
   std::string pageWidth = "91px";
   std::string pageHeight = "56px";
   int expectedWidth = 91;
   int expectedHeight = 56;
   testAutoResize(minAutoResize, maxAutoResize, pageWidth, pageHeight,
@@ skipping 89 matching lines @@
   testTextInputType(WebTextInputTypeURL, "input_field_url.html");
 }
 
 TEST_F(WebViewTest, TextInputInfoUpdateStyleAndLayout) {
   FrameTestHelpers::TestWebViewClient client;
   FrameTestHelpers::WebViewHelper m_webViewHelper;
   WebViewImpl* webViewImpl = m_webViewHelper.initialize(true, 0, &client);
 
   WebURL baseURL = URLTestHelpers::toKURL("http://example.com/");
   // Here, we need to construct a document that has a special property:
-  // Adding id="foo" to the <path> element will trigger creation of an SVG instance tree
-  // for the use <use> element.
+  // Adding id="foo" to the <path> element will trigger creation of an SVG
+  // instance tree for the use <use> element.
   // This is significant, because SVG instance trees are actually created lazily
-  // during Document::updateStyleAndLayout code, thus incrementing the DOM tree version
-  // and freaking out the EphemeralRange (invalidating it).
+  // during Document::updateStyleAndLayout code, thus incrementing the DOM tree
+  // version and freaking out the EphemeralRange (invalidating it).
   FrameTestHelpers::loadHTMLString(
       webViewImpl->mainFrame(),
       "<svg height='100%' version='1.1' viewBox='0 0 14 14' width='100%'>"
       "<use xmlns:xlink='http://www.w3.org/1999/xlink' xlink:href='#foo'></use>"
       "<path d='M 100 100 L 300 100 L 200 300 z' fill='#000'></path>"
       "</svg>"
       "<input>",
       baseURL);
   webViewImpl->setInitialFocus(false);
 
@@ skipping 734 matching lines @@
           nullptr, FrameLoader::resourceRequestFromHistoryItem(
                        item1.get(), WebCachePolicy::UseProtocolCachePolicy)),
       FrameLoadTypeBackForward, item1.get(), HistorySameDocumentLoad);
 
   // Click a different anchor
   mainFrameLocal->loader().load(FrameLoadRequest(
       mainFrameLocal->document(),
       ResourceRequest(mainFrameLocal->document()->completeURL("#b"))));
   Persistent<HistoryItem> item3 = mainFrameLocal->loader().currentItem();
 
-  // Go back, then forward. The scroll position should be properly set on the forward navigation.
+  // Go back, then forward. The scroll position should be properly set on the
+  // forward navigation.
   mainFrameLocal->loader().load(
       FrameLoadRequest(
           nullptr, FrameLoader::resourceRequestFromHistoryItem(
                        item1.get(), WebCachePolicy::UseProtocolCachePolicy)),
       FrameLoadTypeBackForward, item1.get(), HistorySameDocumentLoad);
   mainFrameLocal->loader().load(
       FrameLoadRequest(
           nullptr, FrameLoader::resourceRequestFromHistoryItem(
                        item3.get(), WebCachePolicy::UseProtocolCachePolicy)),
       FrameLoadTypeBackForward, item3.get(), HistorySameDocumentLoad);
@@ skipping 201 matching lines @@
   DragAndDropURL(webView, barUrl);
   EXPECT_EQ(barUrl, webView->mainFrame()->document().url().string().utf8());
 
   // Drag and drop fooUrl and verify that we've navigated back to it.
   DragAndDropURL(webView, fooUrl);
   EXPECT_EQ(fooUrl, webView->mainFrame()->document().url().string().utf8());
 
   // Disable navigation on drag-and-drop.
   webView->settingsImpl()->setNavigateOnDragDrop(false);
 
-  // Attempt to drag and drop to barUrl and verify that no navigation has occurred.
+  // Attempt to drag and drop to barUrl and verify that no navigation has
+  // occurred.
   DragAndDropURL(webView, barUrl);
   EXPECT_EQ(fooUrl, webView->mainFrame()->document().url().string().utf8());
 }
 
 class ContentDetectorClient : public FrameTestHelpers::TestWebViewClient {
  public:
   ContentDetectorClient() { reset(); }
 
   WebURL detectContentIntentAt(const WebHitTestResult& hitTest) override {
     m_contentDetectionRequested = true;
@@ skipping 33 matching lines @@
   WebURL m_contentDetectionResult;
 };
 
 bool WebViewTest::tapElement(WebInputEvent::Type type, Element* element) {
   if (!element || !element->layoutObject())
     return false;
 
   DCHECK(m_webViewHelper.webView());
   element->scrollIntoViewIfNeeded();
 
-  // TODO(bokan): Technically incorrect, event positions should be in viewport space. crbug.com/371902.
+  // TODO(bokan): Technically incorrect, event positions should be in viewport
+  // space. crbug.com/371902.
   IntPoint center =
       m_webViewHelper.webView()
           ->mainFrameImpl()
           ->frameView()
           ->contentsToScreen(element->layoutObject()->absoluteBoundingBoxRect())
           .center();
 
   WebGestureEvent event;
   event.type = type;
   event.sourceDevice = WebGestureDeviceTouchscreen;
@@ skipping 58 matching lines @@
   EXPECT_TRUE(client.wasInMainFrame());
 
   // Tapping elsewhere should cancel the scheduled intent.
   WebGestureEvent event;
   event.type = WebInputEvent::GestureTap;
   event.sourceDevice = WebGestureDeviceTouchscreen;
   webView->handleInputEvent(event);
   runPendingTasks();
   EXPECT_TRUE(client.pendingIntentsCancelled());
 
-  m_webViewHelper
-      .reset();  // Explicitly reset to break dependency on locally scoped client.
+  // Explicitly reset to break dependency on locally scoped client.
+  m_webViewHelper.reset();
 }
 
 TEST_F(WebViewTest, ContentDetectionInIframe) {
   URLTestHelpers::registerMockedURLFromBaseURL(
       WebString::fromUTF8(m_baseURL.c_str()),
       WebString::fromUTF8("content_listeners_iframe.html"));
 
   ContentDetectorClient client;
   WebView* webView = m_webViewHelper.initializeAndLoad(
       m_baseURL + "content_listeners_iframe.html", true, 0, &client);
   webView->resize(WebSize(500, 300));
   webView->updateAllLifecyclePhases();
   runPendingTasks();
 
   WebString noListener = WebString::fromUTF8("noListener");
   WebString frameName = WebString::fromUTF8("innerFrame");
 
   WebURL intentURL = toKURL(m_baseURL);
   client.setContentDetectionResult(intentURL);
   Element* element = static_cast<Element*>(
       webView->findFrameByName(frameName)->document().getElementById(
           noListener));
   EXPECT_TRUE(tapElement(WebInputEvent::GestureTap, element));
   EXPECT_TRUE(client.scheduledIntentURL() == intentURL);
   EXPECT_FALSE(client.wasInMainFrame());
 
-  m_webViewHelper
-      .reset();  // Explicitly reset to break dependency on locally scoped client.
+  // Explicitly reset to break dependency on locally scoped client.
+  m_webViewHelper.reset();
 }
 
 TEST_F(WebViewTest, ClientTapHandling) {
   TapHandlingWebViewClient client;
   client.reset();
   WebView* webView =
       m_webViewHelper.initializeAndLoad("about:blank", true, 0, &client);
   WebGestureEvent event;
   event.type = WebInputEvent::GestureTap;
   event.sourceDevice = WebGestureDeviceTouchscreen;
   event.x = 3;
   event.y = 8;
   webView->handleInputEvent(event);
   runPendingTasks();
   EXPECT_EQ(3, client.tapX());
   EXPECT_EQ(8, client.tapY());
   client.reset();
   event.type = WebInputEvent::GestureLongPress;
   event.x = 25;
   event.y = 7;
   webView->handleInputEvent(event);
   runPendingTasks();
   EXPECT_EQ(25, client.longpressX());
   EXPECT_EQ(7, client.longpressY());
 
-  m_webViewHelper
-      .reset();  // Explicitly reset to break dependency on locally scoped client.
+  // Explicitly reset to break dependency on locally scoped client.
+  m_webViewHelper.reset();
 }
 
 TEST_F(WebViewTest, ClientTapHandlingNullWebViewClient) {
   WebViewImpl* webView =
       WebViewImpl::create(nullptr, WebPageVisibilityStateVisible);
   FrameTestHelpers::TestWebFrameClient webFrameClient;
   WebLocalFrame* localFrame =
       WebLocalFrame::create(WebTreeScopeType::Document, &webFrameClient);
   webView->setMainFrame(localFrame);
   WebGestureEvent event;
@@ skipping 496 matching lines @@
   // Set up a composition that needs to be committed.
   WebVector<WebCompositionUnderline> emptyUnderlines;
   frame->setEditableSelectionOffsets(4, 10);
   frame->setCompositionFromExistingText(8, 12, emptyUnderlines);
   WebTextInputInfo info = webView->textInputInfo();
   EXPECT_EQ(4, info.selectionStart);
   EXPECT_EQ(10, info.selectionEnd);
   EXPECT_EQ(8, info.compositionStart);
   EXPECT_EQ(12, info.compositionEnd);
 
-  // Clear the focus and track that the subsequent composition commit does not trigger a
-  // text changed notification for autofill.
+  // Clear the focus and track that the subsequent composition commit does not
+  // trigger a text changed notification for autofill.
   client.clearChangeCounts();
   webView->setFocus(false);
   EXPECT_EQ(0, client.textChangesWhileNotIgnored());
 
   frame->setAutofillClient(0);
 }
 
 static void verifySelectionAndComposition(WebView* webView,
                                           int selectionStart,
                                           int selectionEnd,
@@ skipping 20 matching lines @@
 
   // Test both input elements.
   for (int i = 0; i < 2; ++i) {
     // Select composition and do sanity check.
     WebVector<WebCompositionUnderline> emptyUnderlines;
     frame->setEditableSelectionOffsets(6, 6);
     EXPECT_TRUE(webView->setComposition("fghij", emptyUnderlines, 0, 5));
     frame->setEditableSelectionOffsets(11, 11);
     verifySelectionAndComposition(webView, 11, 11, 6, 11, "initial case");
 
-    // Press Backspace and verify composition didn't get cancelled. This is to verify the fix
-    // for crbug.com/429916.
+    // Press Backspace and verify composition didn't get cancelled. This is to
+    // verify the fix for crbug.com/429916.
     WebKeyboardEvent keyEvent;
     keyEvent.domKey = Platform::current()->domKeyEnumFromString("\b");
     keyEvent.windowsKeyCode = VKEY_BACK;
     keyEvent.type = WebInputEvent::RawKeyDown;
     webView->handleInputEvent(keyEvent);
 
     frame->setEditableSelectionOffsets(6, 6);
     EXPECT_TRUE(webView->setComposition("fghi", emptyUnderlines, 0, 4));
     frame->setEditableSelectionOffsets(10, 10);
     verifySelectionAndComposition(webView, 10, 10, 6, 10,
@@ skipping 132 matching lines @@
   WebLocalFrameImpl* frame = webViewImpl->mainFrameImpl();
   frame->setName("_start");
 
   // Make a request that will open a new window
   WebURLRequest webURLRequest;
   FrameLoadRequest request(0, webURLRequest.toResourceRequest(), "_blank");
   toLocalFrame(webViewImpl->page()->mainFrame())->loader().load(request);
   ASSERT_TRUE(client.createdWebView());
   EXPECT_FALSE(client.didFocusCalled());
 
-  // Make a request from the new window that will navigate the original window. The original window should be focused.
+  // Make a request from the new window that will navigate the original window.
+  // The original window should be focused.
   WebURLRequest webURLRequestWithTargetStart;
   FrameLoadRequest requestWithTargetStart(
       0, webURLRequestWithTargetStart.toResourceRequest(), "_start");
   toLocalFrame(toWebViewImpl(client.createdWebView())->page()->mainFrame())
       ->loader()
       .load(requestWithTargetStart);
   EXPECT_TRUE(client.didFocusCalled());
 
   m_webViewHelper.reset();  // Remove dependency on locally scoped client.
 }
@@ skipping 117 matching lines @@
   client.chooserCompletion()->didChooseValue(0);
   client.clearChooserCompletion();
   EXPECT_STREQ("1970-W01", inputElement->value().utf8().data());
 
   openDateTimeChooser(webViewImpl, inputElement);
   client.chooserCompletion()->didChooseValue(
       std::numeric_limits<double>::quiet_NaN());
   client.clearChooserCompletion();
   EXPECT_STREQ("", inputElement->value().utf8().data());
 
-  // Clear the WebViewClient from the webViewHelper to avoid use-after-free in the
-  // WebViewHelper destructor.
+  // Clear the WebViewClient from the webViewHelper to avoid use-after-free in
+  // the WebViewHelper destructor.
   m_webViewHelper.reset();
   RuntimeEnabledFeatures::setInputMultipleFieldsUIEnabled(
       originalMultipleFieldsFlag);
 }
 
 TEST_F(WebViewTest, DispatchesFocusBlurOnViewToggle) {
   URLTestHelpers::registerMockedURLFromBaseURL(
       WebString::fromUTF8(m_baseURL.c_str()), "focus_blur_events.html");
   WebView* webView = m_webViewHelper.initializeAndLoad(
       m_baseURL + "focus_blur_events.html", true, 0);
@@ skipping 255 matching lines @@
   TouchEventHandlerWebViewClient client;
   std::string url = m_baseURL + "has_touch_event_handlers.html";
   URLTestHelpers::registerMockedURLLoad(toKURL(url),
                                         "has_touch_event_handlers.html");
   WebViewImpl* webViewImpl =
       m_webViewHelper.initializeAndLoad(url, true, 0, &client);
   const EventHandlerRegistry::EventHandlerClass touchEvent =
       EventHandlerRegistry::TouchStartOrMoveEventBlocking;
 
   // The page is initialized with at least one no-handlers call.
-  // In practice we get two such calls because WebViewHelper::initializeAndLoad first
-  // initializes and empty frame, and then loads a document into it, so there are two
-  // FrameLoader::commitProvisionalLoad calls.
+  // In practice we get two such calls because WebViewHelper::initializeAndLoad
+  // first initializes and empty frame, and then loads a document into it, so
+  // there are two FrameLoader::commitProvisionalLoad calls.
   EXPECT_GE(client.getAndResetHasTouchEventHandlerCallCount(false), 1);
   EXPECT_EQ(0, client.getAndResetHasTouchEventHandlerCallCount(true));
 
   // Adding the first document handler results in a has-handlers call.
   Document* document = webViewImpl->mainFrameImpl()->frame()->document();
   EventHandlerRegistry* registry =
       &document->frameHost()->eventHandlerRegistry();
   registry->didAddEventHandler(*document, touchEvent);
   EXPECT_EQ(0, client.getAndResetHasTouchEventHandlerCallCount(false));
   EXPECT_EQ(1, client.getAndResetHasTouchEventHandlerCallCount(true));
@@ skipping 49 matching lines @@
   // Adding a handler inside of a child iframe results in a has-handlers call.
   Element* childFrame = document->getElementById("childframe");
   DCHECK(childFrame);
   Document* childDocument = toHTMLIFrameElement(childFrame)->contentDocument();
   Element* childDiv = childDocument->getElementById("childdiv");
   DCHECK(childDiv);
   registry->didAddEventHandler(*childDiv, touchEvent);
   EXPECT_EQ(0, client.getAndResetHasTouchEventHandlerCallCount(false));
   EXPECT_EQ(1, client.getAndResetHasTouchEventHandlerCallCount(true));
 
-  // Adding and clearing handlers in the parent doc or elsewhere in the child doc
-  // has no impact.
+  // Adding and clearing handlers in the parent doc or elsewhere in the child
+  // doc has no impact.
   registry->didAddEventHandler(*document, touchEvent);
   registry->didAddEventHandler(*childFrame, touchEvent);
   registry->didAddEventHandler(*childDocument, touchEvent);
   registry->didRemoveAllEventHandlers(*document);
   registry->didRemoveAllEventHandlers(*childFrame);
   registry->didRemoveAllEventHandlers(*childDocument);
   EXPECT_EQ(0, client.getAndResetHasTouchEventHandlerCallCount(false));
   EXPECT_EQ(0, client.getAndResetHasTouchEventHandlerCallCount(true));
 
-  // Removing the final handler inside the child frame results in a no-handlers call.
+  // Removing the final handler inside the child frame results in a no-handlers
+  // call.
   registry->didRemoveAllEventHandlers(*childDiv);
   EXPECT_EQ(1, client.getAndResetHasTouchEventHandlerCallCount(false));
   EXPECT_EQ(0, client.getAndResetHasTouchEventHandlerCallCount(true));
 
   // Adding a handler inside the child frame results in a has-handlers call.
   registry->didAddEventHandler(*childDocument, touchEvent);
   EXPECT_EQ(0, client.getAndResetHasTouchEventHandlerCallCount(false));
   EXPECT_EQ(1, client.getAndResetHasTouchEventHandlerCallCount(true));
 
   // Adding a handler in the parent document and removing the one in the frame
   // has no effect.
   registry->didAddEventHandler(*childFrame, touchEvent);
   registry->didRemoveEventHandler(*childDocument, touchEvent);
   registry->didRemoveAllEventHandlers(*childDocument);
   registry->didRemoveAllEventHandlers(*document);
   EXPECT_EQ(0, client.getAndResetHasTouchEventHandlerCallCount(false));
   EXPECT_EQ(0, client.getAndResetHasTouchEventHandlerCallCount(true));
 
-  // Now removing the handler in the parent document results in a no-handlers call.
+  // Now removing the handler in the parent document results in a no-handlers
+  // call.
   registry->didRemoveEventHandler(*childFrame, touchEvent);
   EXPECT_EQ(1, client.getAndResetHasTouchEventHandlerCallCount(false));
   EXPECT_EQ(0, client.getAndResetHasTouchEventHandlerCallCount(true));
 
   // Free the webView before the TouchEventHandlerWebViewClient gets freed.
   m_webViewHelper.reset();
 }
 
 // This test checks that deleting nodes which have only non-JS-registered touch
 // handlers also removes them from the event handler registry. Note that this
 // is different from detaching and re-attaching the same node, which is covered
 // by layout tests under fast/events/.
 TEST_F(WebViewTest, DeleteElementWithRegisteredHandler) {
   std::string url = m_baseURL + "simple_div.html";
   URLTestHelpers::registerMockedURLLoad(toKURL(url), "simple_div.html");
   WebViewImpl* webViewImpl = m_webViewHelper.initializeAndLoad(url, true);
 
   Persistent<Document> document =
       webViewImpl->mainFrameImpl()->frame()->document();
   Element* div = document->getElementById("div");
   EventHandlerRegistry& registry =
       document->frameHost()->eventHandlerRegistry();
 
   registry.didAddEventHandler(*div, EventHandlerRegistry::ScrollEvent);
   EXPECT_TRUE(registry.hasEventHandlers(EventHandlerRegistry::ScrollEvent));
 
   TrackExceptionState exceptionState;
   div->remove(exceptionState);
 
-  // For oilpan we have to force a GC to ensure the event handlers have been removed when
-  // checking below. We do a precise GC (collectAllGarbage does not scan the stack)
-  // to ensure the div element dies. This is also why the Document is in a Persistent
-  // since we want that to stay around.
+  // For oilpan we have to force a GC to ensure the event handlers have been
+  // removed when checking below. We do a precise GC (collectAllGarbage does not
+  // scan the stack) to ensure the div element dies. This is also why the
+  // Document is in a Persistent since we want that to stay around.
   ThreadState::current()->collectAllGarbage();
 
   EXPECT_FALSE(registry.hasEventHandlers(EventHandlerRegistry::ScrollEvent));
 }
 
 class NonUserInputTextUpdateWebWidgetClient
     : public FrameTestHelpers::TestWebWidgetClient {
  public:
   NonUserInputTextUpdateWebWidgetClient() : m_textIsUpdated(false) {}
 
@@ skipping 60 matching lines @@
   EXPECT_EQ(WebTextInputFlagAutocapitalizeSentences, info3.flags);
 
   // (C) Verifies the WebTextInputInfo's don't equal.
   EXPECT_FALSE(info1.equals(info2));
   EXPECT_FALSE(info2.equals(info3));
 
   // Free the webView before freeing the NonUserInputTextUpdateWebViewClient.
   m_webViewHelper.reset();
 }
 
-// This test verifies that WebWidgetClient::didUpdateTextOfFocusedElementByNonUserInput is
-// called iff value of a focused element is modified via script.
+// This test verifies that
+// WebWidgetClient::didUpdateTextOfFocusedElementByNonUserInput is called iff
+// value of a focused element is modified via script.
 TEST_F(WebViewTest, NonUserInputTextUpdate) {
   NonUserInputTextUpdateWebWidgetClient client;
   std::string url = m_baseURL + "non_user_input_text_update.html";
   URLTestHelpers::registerMockedURLLoad(toKURL(url),
                                         "non_user_input_text_update.html");
   WebViewImpl* webViewImpl =
       m_webViewHelper.initializeAndLoad(url, true, nullptr, nullptr, &client);
   webViewImpl->setInitialFocus(false);
 
   WebLocalFrameImpl* frame = webViewImpl->mainFrameImpl();
@@ skipping 191 matching lines @@
   std::string url = m_baseURL + "subtree-layout.html";
   URLTestHelpers::registerMockedURLLoad(toKURL(url), "subtree-layout.html");
   WebView* webView = m_webViewHelper.initialize(true);
 
   webView->enableAutoResizeMode(WebSize(200, 200), WebSize(200, 200));
   loadFrame(webView->mainFrame(), url);
 
   FrameView* frameView =
       m_webViewHelper.webView()->mainFrameImpl()->frameView();
 
-  // Auto-resizing used to DCHECK(needsLayout()) in LayoutBlockFlow::layout. This EXPECT is
-  // merely a dummy. The real test is that we don't trigger asserts in debug builds.
+  // Auto-resizing used to DCHECK(needsLayout()) in LayoutBlockFlow::layout.
+  // This EXPECT is merely a dummy. The real test is that we don't trigger
+  // asserts in debug builds.
   EXPECT_FALSE(frameView->needsLayout());
 };
 
 TEST_F(WebViewTest, PreferredSize) {
   std::string url = m_baseURL + "specify_size.html?100px:100px";
   URLTestHelpers::registerMockedURLLoad(toKURL(url), "specify_size.html");
   WebView* webView = m_webViewHelper.initializeAndLoad(url, true);
 
   WebSize size = webView->contentsPreferredMinimumSize();
   EXPECT_EQ(100, size.width);
@@ skipping 80 matching lines @@
       WebString::fromUTF8(m_baseURL.c_str()), WebString::fromUTF8("Ahem.ttf"));
   URLTestHelpers::registerMockedURLFromBaseURL(
       WebString::fromUTF8(m_baseURL.c_str()), WebString::fromUTF8(testFile));
   UnhandledTapWebViewClient client;
   WebView* webView =
       m_webViewHelper.initializeAndLoad(m_baseURL + testFile, true, 0, &client);
   webView->resize(WebSize(500, 300));
   webView->updateAllLifecyclePhases();
   runPendingTasks();
 
-  // Scroll the bottom into view so we can distinguish window coordinates from document coordinates.
+  // Scroll the bottom into view so we can distinguish window coordinates from
+  // document coordinates.
   EXPECT_TRUE(
       tapElementById(WebInputEvent::GestureTap, WebString::fromUTF8("bottom")));
   EXPECT_TRUE(client.getWasCalled());
   EXPECT_EQ(64, client.getTappedXPos());
   EXPECT_EQ(278, client.getTappedYPos());
   EXPECT_FALSE(client.isTappedNodeNull());
   EXPECT_TRUE(client.getWebNode().isTextNode());
 
   // Test basic tap handling and notification.
   client.reset();
   EXPECT_TRUE(
       tapElementById(WebInputEvent::GestureTap, WebString::fromUTF8("target")));
   EXPECT_TRUE(client.getWasCalled());
   EXPECT_EQ(144, client.getTappedXPos());
   EXPECT_EQ(82, client.getTappedYPos());
   EXPECT_FALSE(client.isTappedNodeNull());
   EXPECT_TRUE(client.getWebNode().isTextNode());
-  // Make sure the returned text node has the parent element that was our target.
+  // Make sure the returned text node has the parent element that was our
+  // target.
   EXPECT_EQ(webView->mainFrame()->document().getElementById("target"),
             client.getWebNode().parentNode());
 
   // Test correct conversion of coordinates to viewport space under pinch-zoom.
   webView->setPageScaleFactor(2);
   webView->setVisualViewportOffset(WebFloatPoint(50, 20));
   client.reset();
   EXPECT_TRUE(
       tapElementById(WebInputEvent::GestureTap, WebString::fromUTF8("target")));
   EXPECT_TRUE(client.getWasCalled());
@@ skipping 432 matching lines @@
       .translate(-50, -55)
       .translate(50, 55)
       .scale(1. / 2.f);
   EXPECT_EQ(expectedMatrix, webViewImpl->getRootLayerTransformForTesting());
   // visibleContentRect doesn't change.
   EXPECT_EQ(IntRect(50, 55, 50, 75),
             *devToolsEmulator->visibleContentRectForPainting());
 }
 
 }  // namespace blink