reflow comments in web/

third_party/WebKit/Source/web/WebViewImpl.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 212 matching lines @@
 
 // Change the text zoom level by kTextSizeMultiplierRatio each time the user
 // zooms text in or out (ie., change by 20%).  The min and max values limit
 // text zoom to half and 3x the original text size.  These three values match
 // those in Apple's port in WebKit/WebKit/WebView/WebView.mm
 const double WebView::textSizeMultiplierRatio = 1.2;
 const double WebView::minTextSizeMultiplier = 0.5;
 const double WebView::maxTextSizeMultiplier = 3.0;
 
 // Used to defer all page activity in cases where the embedder wishes to run
-// a nested event loop. Using a stack enables nesting of message loop invocations.
+// a nested event loop. Using a stack enables nesting of message loop
+// invocations.
 static Vector<std::unique_ptr<ScopedPageLoadDeferrer>>&
 pageLoadDeferrerStack() {
   DEFINE_STATIC_LOCAL(Vector<std::unique_ptr<ScopedPageLoadDeferrer>>,
                       deferrerStack, ());
   return deferrerStack;
 }
 
 // Ensure that the WebDragOperation enum values stay in sync with the original
 // DragOperation constants.
 #define STATIC_ASSERT_ENUM(a, b)                            \
@@ skipping 305 matching lines @@
   }
 
   PageWidgetEventHandler::handleMouseDown(mainFrame, event);
 
   if (event.button == WebMouseEvent::Button::Left && m_mouseCaptureNode)
     m_mouseCaptureGestureToken =
         mainFrame.eventHandler().takeLastMouseDownGestureToken();
 
   if (m_pagePopup && pagePopup &&
       m_pagePopup->hasSamePopupClient(pagePopup.get())) {
-    // That click triggered a page popup that is the same as the one we just closed.
-    // It needs to be closed.
+    // That click triggered a page popup that is the same as the one we just
+    // closed.  It needs to be closed.
     cancelPagePopup();
   }
 
   // Dispatch the contextmenu event regardless of if the click was swallowed.
   if (!page()->settings().showContextMenuOnMouseUp()) {
 #if OS(MACOSX)
     if (event.button == WebMouseEvent::Button::Right ||
         (event.button == WebMouseEvent::Button::Left &&
          event.modifiers & WebMouseEvent::ControlKey))
       mouseContextMenu(event);
@@ skipping 104 matching lines @@
     syntheticWheel.x = m_positionOnFlingStart.x;
     syntheticWheel.y = m_positionOnFlingStart.y;
     syntheticWheel.globalX = m_globalPositionOnFlingStart.x;
     syntheticWheel.globalY = m_globalPositionOnFlingStart.y;
     syntheticWheel.modifiers = m_flingModifier;
 
     if (handleMouseWheel(*m_page->deprecatedLocalMainFrame(), syntheticWheel) !=
         WebInputEventResult::NotHandled)
       return true;
 
-    // TODO(dtapuska): Remove these GSB/GSE sequences when trackpad latching is implemented; see crbug.com/526463.
+    // TODO(dtapuska): Remove these GSB/GSE sequences when trackpad latching is
+    // implemented; see crbug.com/526463.
     WebGestureEvent syntheticScrollBegin = createGestureScrollEventFromFling(
         WebInputEvent::GestureScrollBegin, WebGestureDeviceTouchpad);
     syntheticScrollBegin.data.scrollBegin.deltaXHint = delta.width;
     syntheticScrollBegin.data.scrollBegin.deltaYHint = delta.height;
     syntheticScrollBegin.data.scrollBegin.inertialPhase =
         WebGestureEvent::MomentumPhase;
     handleGestureEvent(syntheticScrollBegin);
 
     WebGestureEvent syntheticScrollUpdate = createGestureScrollEventFromFling(
         WebInputEvent::GestureScrollUpdate, WebGestureDeviceTouchpad);
@@ skipping 90 matching lines @@
 
   // Special handling for double tap and scroll events as we don't want to
   // hit test for them.
   switch (event.type) {
     case WebInputEvent::GestureDoubleTap:
       if (m_webSettings->doubleTapToZoomEnabled() &&
           minimumPageScaleFactor() != maximumPageScaleFactor()) {
         m_client->cancelScheduledContentIntents();
         animateDoubleTapZoom(platformEvent.position());
       }
-      // GestureDoubleTap is currently only used by Android for zooming. For WebCore,
-      // GestureTap with tap count = 2 is used instead. So we drop GestureDoubleTap here.
+      // GestureDoubleTap is currently only used by Android for zooming. For
+      // WebCore, GestureTap with tap count = 2 is used instead. So we drop
+      // GestureDoubleTap here.
       eventResult = WebInputEventResult::HandledSystem;
       m_client->didHandleGestureEvent(event, eventCancelled);
       return eventResult;
     case WebInputEvent::GestureScrollBegin:
       m_client->cancelScheduledContentIntents();
     case WebInputEvent::GestureScrollEnd:
     case WebInputEvent::GestureScrollUpdate:
     case WebInputEvent::GestureFlingStart:
-      // Scrolling-related gesture events invoke EventHandler recursively for each frame down
-      // the chain, doing a single-frame hit-test per frame. This matches handleWheelEvent.
-      // Perhaps we could simplify things by rewriting scroll handling to work inner frame
-      // out, and then unify with other gesture events.
+      // Scrolling-related gesture events invoke EventHandler recursively for
+      // each frame down the chain, doing a single-frame hit-test per frame.
+      // This matches handleWheelEvent.  Perhaps we could simplify things by
+      // rewriting scroll handling to work inner frame out, and then unify with
+      // other gesture events.
       eventResult =
           mainFrameImpl()->frame()->eventHandler().handleGestureScrollEvent(
               platformEvent);
       m_client->didHandleGestureEvent(event, eventCancelled);
       return eventResult;
     case WebInputEvent::GesturePinchBegin:
     case WebInputEvent::GesturePinchEnd:
     case WebInputEvent::GesturePinchUpdate:
       return WebInputEventResult::NotHandled;
     default:
       break;
   }
 
-  // Hit test across all frames and do touch adjustment as necessary for the event type.
+  // Hit test across all frames and do touch adjustment as necessary for the
+  // event type.
   GestureEventWithHitTestResults targetedEvent =
       m_page->deprecatedLocalMainFrame()->eventHandler().targetGestureEvent(
           platformEvent);
 
-  // Handle link highlighting outside the main switch to avoid getting lost in the
-  // complicated set of cases handled below.
+  // Handle link highlighting outside the main switch to avoid getting lost in
+  // the complicated set of cases handled below.
   switch (event.type) {
     case WebInputEvent::GestureShowPress:
       // Queue a highlight animation, then hand off to regular handler.
       enableTapHighlightAtPoint(targetedEvent);
       break;
     case WebInputEvent::GestureTapCancel:
     case WebInputEvent::GestureTap:
     case WebInputEvent::GestureLongPress:
       for (size_t i = 0; i < m_linkHighlights.size(); ++i)
         m_linkHighlights[i]->startHighlightAnimationIfNeeded();
@@ skipping 10 matching lines @@
       RefPtr<WebPagePopupImpl> pagePopup = m_pagePopup;
       hidePopups();
       DCHECK(!m_pagePopup);
 
       m_client->cancelScheduledContentIntents();
       if (detectContentOnTouch(targetedEvent)) {
         eventResult = WebInputEventResult::HandledSystem;
         break;
       }
 
-      // Don't trigger a disambiguation popup on sites designed for mobile devices.
-      // Instead, assume that the page has been designed with big enough buttons and links.
-      // Don't trigger a disambiguation popup when screencasting, since it's implemented outside of
-      // compositor pipeline and is not being screencasted itself. This leads to bad user experience.
+      // Don't trigger a disambiguation popup on sites designed for mobile
+      // devices.  Instead, assume that the page has been designed with big
+      // enough buttons and links.  Don't trigger a disambiguation popup when
+      // screencasting, since it's implemented outside of compositor pipeline
+      // and is not being screencasted itself. This leads to bad user
+      // experience.
       WebDevToolsAgentImpl* devTools = mainFrameDevToolsAgentImpl();
       VisualViewport& visualViewport = page()->frameHost().visualViewport();
       bool screencastEnabled = devTools && devTools->screencastEnabled();
       if (event.data.tap.width > 0 &&
           !visualViewport.shouldDisableDesktopWorkarounds() &&
           !screencastEnabled) {
         IntRect boundingBox(visualViewport.viewportToRootFrame(
             IntRect(event.x - event.data.tap.width / 2,
                     event.y - event.data.tap.height / 2, event.data.tap.width,
                     event.data.tap.height)));
 
-        // TODO(bokan): We shouldn't pass details of the VisualViewport offset to render_view_impl.
-        //              crbug.com/459591
+        // TODO(bokan): We shouldn't pass details of the VisualViewport offset
+        // to render_view_impl.  crbug.com/459591
         WebSize visualViewportOffset =
             flooredIntSize(visualViewport.location());
 
         if (m_webSettings->multiTargetTapNotificationEnabled()) {
           Vector<IntRect> goodTargets;
           HeapVector<Member<Node>> highlightNodes;
           findGoodTouchTargets(boundingBox, mainFrameImpl()->frame(),
                                goodTargets, highlightNodes);
           // FIXME: replace touch adjustment code when numberOfGoodTargets == 1?
-          // Single candidate case is currently handled by: https://bugs.webkit.org/show_bug.cgi?id=85101
+          // Single candidate case is currently handled by:
+          // https://bugs.webkit.org/show_bug.cgi?id=85101
           if (goodTargets.size() >= 2 && m_client &&
               m_client->didTapMultipleTargets(visualViewportOffset, boundingBox,
                                               goodTargets)) {
             enableTapHighlights(highlightNodes);
             for (size_t i = 0; i < m_linkHighlights.size(); ++i)
               m_linkHighlights[i]->startHighlightAnimationIfNeeded();
             eventResult = WebInputEventResult::HandledSystem;
             eventCancelled = true;
             break;
           }
         }
       }
 
       eventResult = mainFrameImpl()->frame()->eventHandler().handleGestureEvent(
           targetedEvent);
 
       if (m_pagePopup && pagePopup &&
           m_pagePopup->hasSamePopupClient(pagePopup.get())) {
-        // The tap triggered a page popup that is the same as the one we just closed.
-        // It needs to be closed.
+        // The tap triggered a page popup that is the same as the one we just
+        // closed.  It needs to be closed.
         cancelPagePopup();
       }
       break;
     }
     case WebInputEvent::GestureTwoFingerTap:
     case WebInputEvent::GestureLongPress:
     case WebInputEvent::GestureLongTap: {
       if (!mainFrameImpl() || !mainFrameImpl()->frameView())
         break;
 
@@ skipping 21 matching lines @@
       NOTREACHED();
   }
   m_client->didHandleGestureEvent(event, eventCancelled);
   return eventResult;
 }
 
 WebInputEventResult WebViewImpl::handleSyntheticWheelFromTouchpadPinchEvent(
     const WebGestureEvent& pinchEvent) {
   DCHECK_EQ(pinchEvent.type, WebInputEvent::GesturePinchUpdate);
 
-  // For pinch gesture events, match typical trackpad behavior on Windows by sending fake
-  // wheel events with the ctrl modifier set when we see trackpad pinch gestures.  Ideally
-  // we'd someday get a platform 'pinch' event and send that instead.
+  // For pinch gesture events, match typical trackpad behavior on Windows by
+  // sending fake wheel events with the ctrl modifier set when we see trackpad
+  // pinch gestures.  Ideally we'd someday get a platform 'pinch' event and
+  // send that instead.
   WebMouseWheelEvent wheelEvent;
   wheelEvent.type = WebInputEvent::MouseWheel;
   wheelEvent.timeStampSeconds = pinchEvent.timeStampSeconds;
   wheelEvent.windowX = wheelEvent.x = pinchEvent.x;
   wheelEvent.windowY = wheelEvent.y = pinchEvent.y;
   wheelEvent.globalX = pinchEvent.globalX;
   wheelEvent.globalY = pinchEvent.globalY;
   wheelEvent.modifiers = pinchEvent.modifiers | WebInputEvent::ControlKey;
   wheelEvent.deltaX = 0;
 
@@ skipping 167 matching lines @@
   }
 
   if (!focusedFrame || !focusedFrame->isLocalFrame())
     return WebInputEventResult::NotHandled;
 
   LocalFrame* frame = toLocalFrame(focusedFrame);
 
   WebInputEventResult result = frame->eventHandler().keyEvent(event);
   if (result != WebInputEventResult::NotHandled) {
     if (WebInputEvent::RawKeyDown == event.type) {
-      // Suppress the next keypress event unless the focused node is a plugin node.
-      // (Flash needs these keypress events to handle non-US keyboards.)
+      // Suppress the next keypress event unless the focused node is a plugin
+      // node.  (Flash needs these keypress events to handle non-US keyboards.)
       Element* element = focusedElement();
       if (element && element->layoutObject() &&
           element->layoutObject()->isEmbeddedObject()) {
         if (event.windowsKeyCode == VKEY_TAB) {
-          // If the plugin supports keyboard focus then we should not send a tab keypress event.
+          // If the plugin supports keyboard focus then we should not send a tab
+          // keypress event.
           Widget* widget = toLayoutPart(element->layoutObject())->widget();
           if (widget && widget->isPluginContainer()) {
             WebPluginContainerImpl* plugin = toWebPluginContainerImpl(widget);
             if (plugin && plugin->supportsKeyboardFocus())
               m_suppressNextKeypressEvent = true;
           }
         }
       } else {
         m_suppressNextKeypressEvent = true;
       }
@@ skipping 96 matching lines @@
   HitTestResult result =
       mainFrameImpl()->frame()->eventHandler().hitTestResultAtPoint(point,
                                                                     hitType);
   result.setToShadowHostIfInUserAgentShadowRoot();
 
   Node* node = result.innerNodeOrImageMapImage();
   if (!node)
     return WebRect();
 
   // Find the block type node based on the hit node.
-  // FIXME: This wants to walk flat tree with LayoutTreeBuilderTraversal::parent().
+  // FIXME: This wants to walk flat tree with
+  // LayoutTreeBuilderTraversal::parent().
   while (node && (!node->layoutObject() || node->layoutObject()->isInline()))
     node = LayoutTreeBuilderTraversal::parent(*node);
 
   // Return the bounding box in the root frame's coordinate space.
   if (node) {
     IntRect pointInRootFrame = node->Node::pixelSnappedBoundingBox();
     LocalFrame* frame = node->document().frame();
     return frame->view()->contentsToRootFrame(pointInRootFrame);
   }
   return WebRect();
@@ skipping 162 matching lines @@
 
   Node* cursorDefiningAncestor = findCursorDefiningAncestor(
       bestTouchNode, m_page->deprecatedLocalMainFrame());
   // We show a highlight on tap only when the current node shows a hand cursor
   if (!cursorDefiningAncestor ||
       !showsHandCursor(cursorDefiningAncestor,
                        m_page->deprecatedLocalMainFrame())) {
     return nullptr;
   }
 
-  // We should pick the largest enclosing node with hand cursor set. We do this by first jumping
-  // up to cursorDefiningAncestor (which is already known to have hand cursor set). Then we locate
-  // the next cursor-defining ancestor up in the the tree and repeat the jumps as long as the node
-  // has hand cursor set.
+  // We should pick the largest enclosing node with hand cursor set. We do this
+  // by first jumping up to cursorDefiningAncestor (which is already known to
+  // have hand cursor set). Then we locate the next cursor-defining ancestor up
+  // in the the tree and repeat the jumps as long as the node has hand cursor
+  // set.
   do {
     bestTouchNode = cursorDefiningAncestor;
     cursorDefiningAncestor = findCursorDefiningAncestor(
         LayoutTreeBuilderTraversal::parent(*bestTouchNode),
         m_page->deprecatedLocalMainFrame());
   } while (cursorDefiningAncestor &&
            showsHandCursor(cursorDefiningAncestor,
                            m_page->deprecatedLocalMainFrame()));
 
   return bestTouchNode;
@@ skipping 18 matching lines @@
   // don't get a new target to highlight.
   m_linkHighlights.clear();
 
   for (size_t i = 0; i < highlightNodes.size(); ++i) {
     Node* node = highlightNodes[i];
 
     if (!node || !node->layoutObject())
       continue;
 
     Color highlightColor = node->layoutObject()->style()->tapHighlightColor();
-    // Safari documentation for -webkit-tap-highlight-color says if the specified color has 0 alpha,
-    // then tap highlighting is disabled.
+    // Safari documentation for -webkit-tap-highlight-color says if the
+    // specified color has 0 alpha, then tap highlighting is disabled.
     // http://developer.apple.com/library/safari/#documentation/appleapplications/reference/safaricssref/articles/standardcssproperties.html
     if (!highlightColor.alpha())
       continue;
 
     m_linkHighlights.append(LinkHighlightImpl::create(node, this));
   }
 
   updateAllLifecyclePhases();
 }
 
@@ skipping 25 matching lines @@
     scale = minimumPageScaleFactor();
     IntPoint targetPosition =
         mainFrameImpl()->frameView()->rootFrameToContents(pointInRootFrame);
     isAnimating = startPageScaleAnimation(
         targetPosition, true, scale, doubleTapZoomAnimationDurationInSeconds);
   } else {
     isAnimating = startPageScaleAnimation(
         scroll, false, scale, doubleTapZoomAnimationDurationInSeconds);
   }
 
-  // TODO(dglazkov): The only reason why we're using isAnimating and not just checking for
-  // m_layerTreeView->hasPendingPageScaleAnimation() is because of fake page scale animation plumbing
-  // for testing, which doesn't actually initiate a page scale animation.
+  // TODO(dglazkov): The only reason why we're using isAnimating and not just
+  // checking for m_layerTreeView->hasPendingPageScaleAnimation() is because of
+  // fake page scale animation plumbing for testing, which doesn't actually
+  // initiate a page scale animation.
   if (isAnimating) {
     m_doubleTapZoomPageScaleFactor = scale;
     m_doubleTapZoomPending = true;
   }
 }
 
 void WebViewImpl::zoomToFindInPageRect(const WebRect& rectInRootFrame) {
   if (!mainFrameImpl())
     return;
 
@@ skipping 37 matching lines @@
                           multipleTargetsZoomAnimationDurationInSeconds);
   return true;
 }
 
 void WebViewImpl::hasTouchEventHandlers(bool hasTouchHandlers) {
   if (m_client)
     m_client->hasTouchEventHandlers(hasTouchHandlers);
 }
 
 bool WebViewImpl::hasTouchEventHandlersAt(const WebPoint& point) {
-  // FIXME: Implement this. Note that the point must be divided by pageScaleFactor.
+  // FIXME: Implement this. Note that the point must be divided by
+  // pageScaleFactor.
   return true;
 }
 
 #if !OS(MACOSX)
 // Mac has no way to open a context menu based on a keyboard event.
 WebInputEventResult WebViewImpl::sendContextMenuEvent(
     const WebKeyboardEvent& event) {
   // The contextMenuController() holds onto the last context menu that was
   // popped up on the page until a new one is created. We need to clear
   // this menu before propagating the event through the DOM so that we can
   // detect if we create a new menu for this event, since we won't create
   // a new menu if the DOM swallows the event and the defaultEventHandler does
   // not run.
   page()->contextMenuController().clearContextMenu();
 
   {
     ContextMenuAllowedScope scope;
     Frame* focusedFrame = page()->focusController().focusedOrMainFrame();
     if (!focusedFrame->isLocalFrame())
       return WebInputEventResult::NotHandled;
-    // Firefox reveal focus based on "keydown" event but not "contextmenu" event, we match FF.
+    // Firefox reveal focus based on "keydown" event but not "contextmenu"
+    // event, we match FF.
     if (Element* focusedElement =
             toLocalFrame(focusedFrame)->document()->focusedElement())
       focusedElement->scrollIntoViewIfNeeded();
     return toLocalFrame(focusedFrame)
         ->eventHandler()
         .sendContextMenuEventForKey(nullptr);
   }
 }
 #endif
 
@@ skipping 322 matching lines @@
 }
 
 void WebViewImpl::resizeViewWhileAnchored(FrameView* view,
                                           float topControlsHeight,
                                           bool topControlsShrinkLayout) {
   DCHECK(mainFrameImpl());
 
   topControls().setHeight(topControlsHeight, topControlsShrinkLayout);
 
   {
-    // Avoids unnecessary invalidations while various bits of state in TextAutosizer are updated.
+    // Avoids unnecessary invalidations while various bits of state in
+    // TextAutosizer are updated.
     TextAutosizer::DeferUpdatePageInfo deferUpdatePageInfo(page());
     performResize();
   }
 
   m_fullscreenController->updateSize();
 
-  // Update lifecyle phases immediately to recalculate the minimum scale limit for rotation anchoring,
-  // and to make sure that no lifecycle states are stale if this WebView is embedded in another one.
+  // Update lifecyle phases immediately to recalculate the minimum scale limit
+  // for rotation anchoring, and to make sure that no lifecycle states are
+  // stale if this WebView is embedded in another one.
   updateAllLifecyclePhases();
 }
 
 void WebViewImpl::resizeWithTopControls(const WebSize& newSize,
                                         float topControlsHeight,
                                         bool topControlsShrinkLayout) {
   if (m_shouldAutoResize)
     return;
 
   if (m_size == newSize && topControls().height() == topControlsHeight &&
@@ skipping 113 matching lines @@
 
   if (InspectorOverlay* overlay = inspectorOverlay()) {
     overlay->updateAllLifecyclePhases();
     // TODO(chrishtr): integrate paint into the overlay's lifecycle.
     if (overlay->pageOverlay() && overlay->pageOverlay()->graphicsLayer())
       overlay->pageOverlay()->graphicsLayer()->paint(nullptr);
   }
   if (m_pageColorOverlay)
     m_pageColorOverlay->graphicsLayer()->paint(nullptr);
 
-  // TODO(chrishtr): link highlights don't currently paint themselves, it's still driven by cc.
-  // Fix this.
+  // TODO(chrishtr): link highlights don't currently paint themselves, it's
+  // still driven by cc.  Fix this.
   for (size_t i = 0; i < m_linkHighlights.size(); ++i)
     m_linkHighlights[i]->updateGeometry();
 
   if (FrameView* view = mainFrameImpl()->frameView()) {
     LocalFrame* frame = mainFrameImpl()->frame();
     WebWidgetClient* client =
         WebLocalFrameImpl::fromFrame(frame)->frameWidget()->client();
 
     if (m_shouldDispatchFirstVisuallyNonEmptyLayout &&
         view->isVisuallyNonEmpty()) {
@@ skipping 117 matching lines @@
     return WebInputEventResult::HandledSuppressed;
 
   if (m_devToolsEmulator->handleInputEvent(inputEvent))
     return WebInputEventResult::HandledSuppressed;
 
   if (InspectorOverlay* overlay = inspectorOverlay()) {
     if (overlay->handleInputEvent(inputEvent))
       return WebInputEventResult::HandledSuppressed;
   }
 
-  // Report the event to be NOT processed by WebKit, so that the browser can handle it appropriately.
+  // Report the event to be NOT processed by WebKit, so that the browser can
+  // handle it appropriately.
   if (m_ignoreInputEvents)
     return WebInputEventResult::NotHandled;
 
   AutoReset<const WebInputEvent*> currentEventChange(&m_currentInputEvent,
                                                      &inputEvent);
   UIEventWithKeyState::clearNewTabModifierSetFromIsolatedWorld();
 
   bool isPointerLocked = false;
   if (WebFrameWidgetBase* widget = mainFrameImpl()->frameWidget()) {
     if (WebWidgetClient* client = widget->client())
@@ skipping 132 matching lines @@
     LocalFrame* focusedFrame = focusedLocalFrameInWidget();
     if (focusedFrame) {
       // Finish an ongoing composition to delete the composition node.
       if (focusedFrame->inputMethodController().hasComposition()) {
         WebAutofillClient* autofillClient =
             WebLocalFrameImpl::fromFrame(focusedFrame)->autofillClient();
 
         if (autofillClient)
           autofillClient->setIgnoreTextChanges(true);
 
-        // TODO(xiaochengh): The use of updateStyleAndLayoutIgnorePendingStylesheets
+        // TODO(xiaochengh): The use of
+        // updateStyleAndLayoutIgnorePendingStylesheets
         // needs to be audited.  See http://crbug.com/590369 for more details.
         focusedFrame->document()
             ->updateStyleAndLayoutIgnorePendingStylesheets();
 
         focusedFrame->inputMethodController().finishComposingText(
             InputMethodController::KeepSelection);
 
         if (autofillClient)
           autofillClient->setIgnoreTextChanges(false);
       }
@@ skipping 138 matching lines @@
   info.inputMode = inputModeOfFocusedElement();
 
   info.type = textInputType();
   info.flags = textInputFlags();
   if (info.type == WebTextInputTypeNone)
     return info;
 
   if (!focused->editor().canEdit())
     return info;
 
-  // TODO(dglazkov): The use of updateStyleAndLayoutIgnorePendingStylesheets needs to be audited.
-  // see http://crbug.com/590369 for more details.
+  // TODO(dglazkov): The use of updateStyleAndLayoutIgnorePendingStylesheets
+  // needs to be audited.  see http://crbug.com/590369 for more details.
   focused->document()->updateStyleAndLayoutIgnorePendingStylesheets();
 
   DocumentLifecycle::DisallowTransitionScope disallowTransition(
       focused->document()->lifecycle());
 
   // Emits an object replacement character for each replaced element so that
   // it is exposed to IME and thus could be deleted by IME on android.
   info.value = plainText(EphemeralRange::rangeOfContents(*element),
                          TextIteratorEmitsObjectReplacementCharacter);
 
@@ skipping 27 matching lines @@
 WebTextInputType WebViewImpl::textInputType() {
   LocalFrame* focusedFrame = focusedLocalFrameInWidget();
   if (!focusedFrame)
     return WebTextInputTypeNone;
 
   if (!focusedFrame->selection().isAvailable()) {
     // "mouse-capture-inside-shadow.html" reaches here.
     return WebTextInputTypeNone;
   }
 
-  // It's important to preserve the equivalence of textInputInfo().type and textInputType(),
-  // so perform the same rootEditableElement() existence check here for consistency.
+  // It's important to preserve the equivalence of textInputInfo().type and
+  // textInputType(), so perform the same rootEditableElement() existence check
+  // here for consistency.
   if (!focusedFrame->selection().selection().rootEditableElement())
     return WebTextInputTypeNone;
 
   Document* document = focusedFrame->document();
   if (!document)
     return WebTextInputTypeNone;
 
   Element* element = document->focusedElement();
   if (!element)
     return WebTextInputTypeNone;
@@ skipping 378 matching lines @@
 
   return m_page->deprecatedLocalMainFrame()->document()->encodingName();
 }
 
 WebFrame* WebViewImpl::mainFrame() {
   return WebFrame::fromFrame(m_page ? m_page->mainFrame() : nullptr);
 }
 
 WebFrame* WebViewImpl::findFrameByName(const WebString& name,
                                        WebFrame* relativeToFrame) {
-  // FIXME: Either this should only deal with WebLocalFrames or it should move to WebFrame.
+  // FIXME: Either this should only deal with WebLocalFrames or it should move
+  // to WebFrame.
   if (!relativeToFrame)
     relativeToFrame = mainFrame();
   Frame* frame = toWebLocalFrameImpl(relativeToFrame)->frame();
   frame = frame->tree().find(name);
   if (!frame || !frame->isLocalFrame())
     return nullptr;
   return WebLocalFrameImpl::fromFrame(toLocalFrame(frame));
 }
 
 WebLocalFrame* WebViewImpl::focusedFrame() {
@@ skipping 100 matching lines @@
   if (!isElementEditable(element))
     return false;
 
   element->document().updateStyleAndLayoutIgnorePendingStylesheets();
 
   bool zoomInToLegibleScale =
       m_webSettings->autoZoomFocusedNodeToLegibleScale() &&
       !page()->frameHost().visualViewport().shouldDisableDesktopWorkarounds();
 
   if (zoomInToLegibleScale) {
-    // When deciding whether to zoom in on a focused text box, we should decide not to
-    // zoom in if the user won't be able to zoom out. e.g if the textbox is within a
-    // touch-action: none container the user can't zoom back out.
+    // When deciding whether to zoom in on a focused text box, we should decide
+    // not to zoom in if the user won't be able to zoom out. e.g if the textbox
+    // is within a touch-action: none container the user can't zoom back out.
     TouchAction action = TouchActionUtil::computeEffectiveTouchAction(*element);
     if (!(action & TouchActionPinchZoom))
       zoomInToLegibleScale = false;
   }
 
   float scale;
   IntPoint scroll;
   bool needAnimation;
   computeScaleAndScrollForFocusedNode(element, zoomInToLegibleScale, scale,
                                       scroll, needAnimation);
@@ skipping 13 matching lines @@
 void WebViewImpl::computeScaleAndScrollForFocusedNode(Node* focusedNode,
                                                       bool zoomInToLegibleScale,
                                                       float& newScale,
                                                       IntPoint& newScroll,
                                                       bool& needAnimation) {
   VisualViewport& visualViewport = page()->frameHost().visualViewport();
 
   WebRect caretInViewport, unusedEnd;
   selectionBounds(caretInViewport, unusedEnd);
 
-  // 'caretInDocument' is rect encompassing the blinking cursor relative to the root document.
+  // 'caretInDocument' is rect encompassing the blinking cursor relative to the
+  // root document.
   IntRect caretInDocument = mainFrameImpl()->frameView()->frameToContents(
       visualViewport.viewportToRootFrame(caretInViewport));
   IntRect textboxRectInDocument = mainFrameImpl()->frameView()->frameToContents(
       focusedNode->document().view()->contentsToRootFrame(
           pixelSnappedIntRect(focusedNode->Node::boundingBox())));
 
   if (!zoomInToLegibleScale) {
     newScale = pageScaleFactor();
   } else {
     // Pick a scale which is reasonably readable. This is the scale at which
@@ skipping 106 matching lines @@
     m_zoomLevel = m_maximumZoomLevel;
   else
     m_zoomLevel = zoomLevel;
 
   float zoomFactor =
       m_zoomFactorOverride
           ? m_zoomFactorOverride
           : static_cast<float>(zoomLevelToZoomFactor(m_zoomLevel));
   if (m_zoomFactorForDeviceScaleFactor) {
     if (m_compositorDeviceScaleFactorOverride) {
-      // Adjust the page's DSF so that DevicePixelRatio becomes m_zoomFactorForDeviceScaleFactor.
+      // Adjust the page's DSF so that DevicePixelRatio becomes
+      // m_zoomFactorForDeviceScaleFactor.
       page()->setDeviceScaleFactor(m_zoomFactorForDeviceScaleFactor /
                                    m_compositorDeviceScaleFactorOverride);
       zoomFactor *= m_compositorDeviceScaleFactorOverride;
     } else {
       page()->setDeviceScaleFactor(1.f);
       zoomFactor *= m_zoomFactorForDeviceScaleFactor;
     }
   }
   propagateZoomFactorToLocalFrameRoots(m_page->mainFrame(), zoomFactor);
 
@@ skipping 208 matching lines @@
       pageScaleConstraintsSet().finalConstraints().initialScale != -1) {
     newPageScaleFactor =
         pageScaleConstraintsSet().finalConstraints().initialScale;
     pageScaleConstraintsSet().setNeedsReset(false);
   }
   setPageScaleFactor(newPageScaleFactor);
 
   updateLayerTreeViewport();
 
   // Changes to page-scale during layout may require an additional frame.
-  // We can't update the lifecycle here because we may be in the middle of layout in the
-  // caller of this method.
-  // TODO(chrishtr): clean all this up. All layout should happen in one lifecycle run (crbug.com/578239).
+  // We can't update the lifecycle here because we may be in the middle of
+  // layout in the caller of this method.
+  // TODO(chrishtr): clean all this up. All layout should happen in one
+  // lifecycle run (crbug.com/578239).
   if (mainFrameImpl()->frameView()->needsLayout())
     mainFrameImpl()->frameWidget()->scheduleAnimation();
 }
 
 void WebViewImpl::updatePageDefinedViewportConstraints(
     const ViewportDescription& description) {
   if (!page() || (!m_size.width && !m_size.height) ||
       !page()->mainFrame()->isLocalFrame())
     return;
 
@@ skipping 367 matching lines @@
                     static_cast<DragOperation>(m_operationsAllowed));
 
   DragSession dragSession;
   if (dragAction == DragEnter)
     dragSession = m_page->dragController().dragEntered(&dragData);
   else
     dragSession = m_page->dragController().dragUpdated(&dragData);
 
   DragOperation dropEffect = dragSession.operation;
 
-  // Mask the drop effect operation against the drag source's allowed operations.
+  // Mask the drop effect operation against the drag source's allowed
+  // operations.
   if (!(dropEffect & dragData.draggingSourceOperationMask()))
     dropEffect = DragOperationNone;
 
   m_dragOperation = static_cast<WebDragOperation>(dropEffect);
 
   return m_dragOperation;
 }
 
 void WebViewImpl::sendResizeEventAndRepaint() {
   // FIXME: This is wrong. The FrameView is responsible sending a resizeEvent
@@ skipping 557 matching lines @@
     m_layerTreeView = m_client->widgetClient()->layerTreeView();
   }
 
   if (WebDevToolsAgentImpl* devTools = mainFrameDevToolsAgentImpl())
     devTools->layerTreeViewChanged(m_layerTreeView);
 
   m_page->settings().setAcceleratedCompositingEnabled(m_layerTreeView);
   if (m_layerTreeView)
     m_page->layerTreeViewInitialized(*m_layerTreeView);
 
-  // FIXME: only unittests, click to play, Android printing, and printing (for headers and footers)
-  // make this assert necessary. We should make them not hit this code and then delete allowsBrokenNullLayerTreeView.
+  // FIXME: only unittests, click to play, Android printing, and printing (for
+  // headers and footers) make this assert necessary. We should make them not
+  // hit this code and then delete allowsBrokenNullLayerTreeView.
   DCHECK(m_layerTreeView || !m_client ||
          m_client->widgetClient()->allowsBrokenNullLayerTreeView());
 
   if (Platform::current()->isThreadedAnimationEnabled() && m_layerTreeView) {
     m_linkHighlightsTimeline = CompositorAnimationTimeline::create();
     attachCompositorAnimationTimeline(m_linkHighlightsTimeline.get());
   }
 }
 
 void WebViewImpl::applyViewportDeltas(
@@ skipping 61 matching lines @@
 void WebViewImpl::updateRootLayerTransform() {
   if (m_visualViewportContainerLayer)
     m_visualViewportContainerLayer->setTransform(m_rootLayerTransform);
 }
 
 bool WebViewImpl::detectContentOnTouch(
     const GestureEventWithHitTestResults& targetedEvent) {
   if (!m_page->mainFrame()->isLocalFrame())
     return false;
 
-  // Need a local copy of the hit test as setToShadowHostIfInUserAgentShadowRoot() will modify it.
+  // Need a local copy of the hit test as
+  // setToShadowHostIfInUserAgentShadowRoot() will modify it.
   HitTestResult touchHit = targetedEvent.hitTestResult();
   touchHit.setToShadowHostIfInUserAgentShadowRoot();
 
   if (touchHit.isContentEditable())
     return false;
 
   Node* node = touchHit.innerNode();
   if (!node || !node->isTextNode())
     return false;
 
-  // Ignore when tapping on links or nodes listening to click events, unless the click event is on the
-  // body element, in which case it's unlikely that the original node itself was intended to be clickable.
+  // Ignore when tapping on links or nodes listening to click events, unless
+  // the click event is on the body element, in which case it's unlikely that
+  // the original node itself was intended to be clickable.
   for (; node && !isHTMLBodyElement(*node);
        node = LayoutTreeBuilderTraversal::parent(*node)) {
     if (node->isLink() || node->willRespondToTouchEvents() ||
         node->willRespondToMouseClickEvents())
       return false;
   }
 
   WebURL intent = m_client->detectContentIntentAt(touchHit);
   if (!intent.isValid())
     return false;
 
-  // This code is called directly after hit test code, with no user code running in between,
-  // thus it is assumed that the frame pointer is non-null.
+  // This code is called directly after hit test code, with no user code
+  // running in between, thus it is assumed that the frame pointer is non-null.
   bool isMainFrame = node ? node->document().frame()->isMainFrame() : true;
   m_client->scheduleContentIntent(intent, isMainFrame);
   return true;
 }
 
 WebViewScheduler* WebViewImpl::scheduler() const {
   return m_scheduler.get();
 }
 
 void WebViewImpl::setVisibilityState(WebPageVisibilityState visibilityState,
@@ skipping 74 matching lines @@
   if (m_pageColorOverlay)
     m_pageColorOverlay->update();
   if (InspectorOverlay* overlay = inspectorOverlay()) {
     PageOverlay* inspectorPageOverlay = overlay->pageOverlay();
     if (inspectorPageOverlay)
       inspectorPageOverlay->update();
   }
 }
 
 float WebViewImpl::deviceScaleFactor() const {
-  // TODO(oshima): Investigate if this should return the ScreenInfo's scale factor rather than
-  // page's scale factor, which can be 1 in use-zoom-for-dsf mode.
+  // TODO(oshima): Investigate if this should return the ScreenInfo's scale
+  // factor rather than page's scale factor, which can be 1 in use-zoom-for-dsf
+  // mode.
   if (!page())
     return 1;
 
   return page()->deviceScaleFactor();
 }
 
 LocalFrame* WebViewImpl::focusedLocalFrameInWidget() const {
   if (!mainFrameImpl())
     return nullptr;
 
   LocalFrame* focusedFrame = toLocalFrame(focusedCoreFrame());
   if (focusedFrame->localFrameRoot() != mainFrameImpl()->frame())
     return nullptr;
   return focusedFrame;
 }
 
 LocalFrame* WebViewImpl::focusedLocalFrameAvailableForIme() const {
   return m_imeAcceptEvents ? focusedLocalFrameInWidget() : nullptr;
 }
 
 }  // namespace blink