reflow comments in core/frame

third_party/WebKit/Source/core/frame/FrameView.cpp

 /*
  * Copyright (C) 1998, 1999 Torben Weis <weis@kde.org>
  *                     1999 Lars Knoll <knoll@kde.org>
  *                     1999 Antti Koivisto <koivisto@kde.org>
  *                     2000 Dirk Mueller <mueller@kde.org>
  * Copyright (C) 2004, 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
  *           (C) 2006 Graham Dennis (graham.dennis@gmail.com)
  *           (C) 2006 Alexey Proskuryakov (ap@nypop.com)
  * Copyright (C) 2009 Google Inc. All rights reserved.
  *
@@ skipping 120 matching lines @@
     if (!(arg)) {                   \
       NOTREACHED();                 \
       return false;                 \
     }                               \
   } while (false)
 
 namespace blink {
 
 using namespace HTMLNames;
 
-// The maximum number of updateWidgets iterations that should be done before returning.
+// The maximum number of updateWidgets iterations that should be done before
+// returning.
 static const unsigned maxUpdateWidgetsIterations = 2;
 static const double resourcePriorityUpdateDelayAfterScroll = 0.250;
 
 static bool s_initialTrackAllPaintInvalidations = false;
 
 FrameView::FrameView(LocalFrame* frame)
     : m_frame(frame),
       m_displayMode(WebDisplayModeBrowser),
       m_canHaveScrollbars(true),
       m_hasPendingLayout(false),
@@ skipping 95 matching lines @@
   m_visuallyNonEmptyPixelCount = 0;
   m_isVisuallyNonEmpty = false;
   m_layoutObjectCounter.reset();
   clearFragmentAnchor();
   m_viewportConstrainedObjects.reset();
   m_layoutSubtreeRootList.clear();
   m_orthogonalWritingModeRootList.clear();
 }
 
 // Call function for each non-throttled frame view in pre tree order.
-// Note it needs a null check of the frame's layoutView to access it in case of detached frames.
+// Note it needs a null check of the frame's layoutView to access it in case of
+// detached frames.
 template <typename Function>
 void FrameView::forAllNonThrottledFrameViews(const Function& function) {
   if (shouldThrottleRendering())
     return;
 
   function(*this);
 
   for (Frame* child = m_frame->tree().firstChild(); child;
        child = child->tree().nextSibling()) {
     if (!child->isLocalFrame())
@@ skipping 52 matching lines @@
   if (ownerElement && ownerElement->ownedWidget() == this)
     ownerElement->setWidget(nullptr);
 
 #if ENABLE(ASSERT)
   m_hasBeenDisposed = true;
 #endif
 }
 
 void FrameView::detachScrollbars() {
   // Previously, we detached custom scrollbars as early as possible to prevent
-  // Document::detachLayoutTree() from messing with the view such that its scroll bars
-  // won't be torn down. However, scripting in Document::detachLayoutTree() is forbidden
+  // Document::detachLayoutTree() from messing with the view such that its
+  // scroll bars won't be torn down. However, scripting in
+  // Document::detachLayoutTree() is forbidden
   // now, so it's not clear if these edge cases can still happen.
   // However, for Oilpan, we still need to remove the native scrollbars before
   // we lose the connection to the HostWindow, so we just unconditionally
   // detach any scrollbars now.
   setHasHorizontalScrollbar(false);
   setHasVerticalScrollbar(false);
 
   if (m_scrollCorner) {
     m_scrollCorner->destroy();
     m_scrollCorner = nullptr;
@@ skipping 45 matching lines @@
 
 void FrameView::invalidateRect(const IntRect& rect) {
   LayoutPartItem layoutItem = m_frame->ownerLayoutItem();
   if (layoutItem.isNull())
     return;
 
   IntRect paintInvalidationRect = rect;
   paintInvalidationRect.move(
       (layoutItem.borderLeft() + layoutItem.paddingLeft()).toInt(),
       (layoutItem.borderTop() + layoutItem.paddingTop()).toInt());
-  // FIXME: We should not allow paint invalidation out of paint invalidation state. crbug.com/457415
+  // FIXME: We should not allow paint invalidation out of paint invalidation
+  // state. crbug.com/457415
   DisablePaintInvalidationStateAsserts paintInvalidationAssertDisabler;
   layoutItem.invalidatePaintRectangle(LayoutRect(paintInvalidationRect));
 }
 
 void FrameView::setFrameRect(const IntRect& newRect) {
   IntRect oldRect = frameRect();
   if (newRect == oldRect)
     return;
 
   Widget::setFrameRect(newRect);
@@ skipping 76 matching lines @@
     Element*& customScrollbarElement,
     LocalFrame*& customScrollbarFrame) const {
   customScrollbarElement = nullptr;
   customScrollbarFrame = nullptr;
 
   if (Settings* settings = m_frame->settings()) {
     if (!settings->allowCustomScrollbarInMainFrame() && m_frame->isMainFrame())
       return false;
   }
 
-  // FIXME: We need to update the scrollbar dynamically as documents change (or as doc elements and bodies get discovered that have custom styles).
+  // FIXME: We need to update the scrollbar dynamically as documents change (or
+  // as doc elements and bodies get discovered that have custom styles).
   Document* doc = m_frame->document();
 
   // Try the <body> element first as a scrollbar source.
   Element* body = doc ? doc->body() : 0;
   if (body && body->layoutObject() &&
       body->layoutObject()->style()->hasPseudoStyle(PseudoIdScrollbar)) {
     customScrollbarElement = body;
     return true;
   }
 
@@ skipping 111 matching lines @@
 
   // Framesets can't scroll.
   Node* body = m_frame->document()->body();
   if (isHTMLFrameSetElement(body) && body->layoutObject())
     RETURN_SCROLLBAR_MODE(ScrollbarAlwaysOff);
 
   // Scrollbars can be disabled by FrameView::setCanHaveScrollbars.
   if (!m_canHaveScrollbars && strategy != RulesFromWebContentOnly)
     RETURN_SCROLLBAR_MODE(ScrollbarAlwaysOff);
 
-  // This will be the LayoutObject for either the body element or the html element
-  // (see Document::viewportDefiningElement).
+  // This will be the LayoutObject for either the body element or the html
+  // element (see Document::viewportDefiningElement).
   LayoutObject* viewport = viewportLayoutObject();
   if (!viewport || !viewport->style())
     RETURN_SCROLLBAR_MODE(ScrollbarAuto);
 
   if (viewport->isSVGRoot()) {
     // Don't allow overflow to affect <img> and css backgrounds
     if (toLayoutSVGRoot(viewport)->isEmbeddedThroughSVGImage())
       RETURN_SCROLLBAR_MODE(ScrollbarAuto);
 
     // FIXME: evaluate if we can allow overflow for these cases too.
@@ skipping 100 matching lines @@
 }
 
 GraphicsLayer* FrameView::layerForScrollCorner() const {
   LayoutViewItem layoutView = this->layoutViewItem();
   if (layoutView.isNull())
     return nullptr;
   return layoutView.compositor()->layerForScrollCorner();
 }
 
 bool FrameView::isEnclosedInCompositingLayer() const {
-  // FIXME: It's a bug that compositing state isn't always up to date when this is called. crbug.com/366314
+  // FIXME: It's a bug that compositing state isn't always up to date when this
+  // is called. crbug.com/366314
   DisableCompositingQueryAsserts disabler;
 
   LayoutItem frameOwnerLayoutItem = m_frame->ownerLayoutItem();
   return !frameOwnerLayoutItem.isNull() &&
          frameOwnerLayoutItem.enclosingLayer()
              ->enclosingLayerForPaintInvalidationCrossingFrameBoundaries();
 }
 
 void FrameView::countObjectsNeedingLayout(unsigned& needsLayoutObjects,
                                           unsigned& totalObjects,
@@ skipping 15 matching lines @@
     return;
 
   LayoutReplaced* contentBox = embeddedReplacedContent();
   if (!contentBox)
     return;
 
   LayoutSVGRoot* svgRoot = toLayoutSVGRoot(contentBox);
   if (svgRoot->everHadLayout() && !svgRoot->needsLayout())
     return;
 
-  // If the embedded SVG document appears the first time, the ownerLayoutObject has already finished
-  // layout without knowing about the existence of the embedded SVG document, because LayoutReplaced
-  // embeddedReplacedContent() returns 0, as long as the embedded document isn't loaded yet. Before
-  // bothering to lay out the SVG document, mark the ownerLayoutObject needing layout and ask its
-  // FrameView for a layout. After that the LayoutEmbeddedObject (ownerLayoutObject) carries the
-  // correct size, which LayoutSVGRoot::computeReplacedLogicalWidth/Height rely on, when laying
-  // out for the first time, or when the LayoutSVGRoot size has changed dynamically (eg. via <script>).
+  // If the embedded SVG document appears the first time, the ownerLayoutObject
+  // has already finished layout without knowing about the existence of the
+  // embedded SVG document, because LayoutReplaced embeddedReplacedContent()
+  // returns 0, as long as the embedded document isn't loaded yet. Before
+  // bothering to lay out the SVG document, mark the ownerLayoutObject needing
+  // layout and ask its FrameView for a layout. After that the
+  // LayoutEmbeddedObject (ownerLayoutObject) carries the correct size, which
+  // LayoutSVGRoot::computeReplacedLogicalWidth/Height rely on, when laying out
+  // for the first time, or when the LayoutSVGRoot size has changed dynamically
+  // (eg. via <script>).
   FrameView* frameView = ownerLayoutItem.frame()->view();
 
   // Mark the owner layoutObject as needing layout.
   ownerLayoutItem.setNeedsLayoutAndPrefWidthsRecalcAndFullPaintInvalidation(
       LayoutInvalidationReason::Unknown);
 
-  // Synchronously enter layout, to layout the view containing the host object/embed/iframe.
+  // Synchronously enter layout, to layout the view containing the host
+  // object/embed/iframe.
   ASSERT(frameView);
   frameView->layout();
 }
 
 void FrameView::performPreLayoutTasks() {
   TRACE_EVENT0("blink,benchmark", "FrameView::performPreLayoutTasks");
   lifecycle().advanceTo(DocumentLifecycle::InPreLayout);
 
   // Don't schedule more layouts, we're in one.
   AutoReset<bool> changeSchedulingEnabled(&m_layoutSchedulingEnabled, false);
 
   if (!m_nestedLayoutCount && !m_inSynchronousPostLayout &&
       m_postLayoutTasksTimer.isActive()) {
-    // This is a new top-level layout. If there are any remaining tasks from the previous layout, finish them now.
+    // This is a new top-level layout. If there are any remaining tasks from the
+    // previous layout, finish them now.
     m_inSynchronousPostLayout = true;
     performPostLayoutTasks();
     m_inSynchronousPostLayout = false;
   }
 
   bool wasResized = wasViewportResized();
   Document* document = m_frame->document();
   if (wasResized)
     document->notifyResizeForViewportUnits();
 
-  // Viewport-dependent or device-dependent media queries may cause us to need completely different style information.
+  // Viewport-dependent or device-dependent media queries may cause us to need
+  // completely different style information.
   bool mainFrameRotation =
       m_frame->isMainFrame() && m_frame->settings() &&
       m_frame->settings()->mainFrameResizesAreOrientationChanges();
   if (!document->styleResolver() ||
       (wasResized &&
        document->styleResolver()->mediaQueryAffectedByViewportChange()) ||
       (wasResized && mainFrameRotation &&
        document->styleResolver()->mediaQueryAffectedByDeviceChange())) {
     document->mediaQueryAffectingValueChanged();
   } else if (wasResized) {
@@ skipping 60 matching lines @@
                      "FrameView::performLayout", "contentsHeightBeforeLayout",
                      contentsHeightBeforeLayout);
   prepareLayoutAnalyzer();
 
   ScriptForbiddenScope forbidScript;
 
   ASSERT(!isInPerformLayout());
   lifecycle().advanceTo(DocumentLifecycle::InPerformLayout);
 
   // performLayout is the actual guts of layout().
-  // FIXME: The 300 other lines in layout() probably belong in other helper functions
-  // so that a single human could understand what layout() is actually doing.
+  // FIXME: The 300 other lines in layout() probably belong in other helper
+  // functions so that a single human could understand what layout() is actually
+  // doing.
 
   forceLayoutParentViewIfNeeded();
 
   if (hasOrthogonalWritingModeRoots())
     layoutOrthogonalWritingModeRoots();
 
   if (inSubtreeLayout) {
     if (m_analyzer)
       m_analyzer->increment(LayoutAnalyzer::PerformLayoutRootLayoutObjects,
                             m_layoutSubtreeRootList.size());
     for (auto& root : m_layoutSubtreeRootList.ordered()) {
       if (!root->needsLayout())
         continue;
       layoutFromRootObject(*root);
 
-      // We need to ensure that we mark up all layoutObjects up to the LayoutView
-      // for paint invalidation. This simplifies our code as we just always
-      // do a full tree walk.
+      // We need to ensure that we mark up all layoutObjects up to the
+      // LayoutView for paint invalidation. This simplifies our code as we just
+      // always do a full tree walk.
       if (LayoutItem container = LayoutItem(root->container()))
         container.setMayNeedPaintInvalidation();
     }
     m_layoutSubtreeRootList.clear();
   } else {
     layoutFromRootObject(*layoutView());
   }
 
   m_frame->document()->fetcher()->updateAllImageResourcePriorities();
 
@@ skipping 13 matching lines @@
 
   if (!m_inSynchronousPostLayout) {
     m_inSynchronousPostLayout = true;
     // Calls resumeScheduledEvents()
     performPostLayoutTasks();
     m_inSynchronousPostLayout = false;
   }
 
   if (!m_postLayoutTasksTimer.isActive() &&
       (needsLayout() || m_inSynchronousPostLayout)) {
-    // If we need layout or are already in a synchronous call to postLayoutTasks(),
-    // defer widget updates and event dispatch until after we return. postLayoutTasks()
-    // can make us need to update again, and we can get stuck in a nasty cycle unless
-    // we call it through the timer here.
+    // If we need layout or are already in a synchronous call to
+    // postLayoutTasks(), defer widget updates and event dispatch until after we
+    // return.  postLayoutTasks() can make us need to update again, and we can
+    // get stuck in a nasty cycle unless we call it through the timer here.
     m_postLayoutTasksTimer.startOneShot(0, BLINK_FROM_HERE);
     if (needsLayout())
       layout();
   }
 }
 
 void FrameView::layout() {
   // We should never layout a Document which is not in a LocalFrame.
   ASSERT(m_frame);
   ASSERT(m_frame->view() == this);
@@ skipping 15 matching lines @@
   DocumentLifecycle::Scope lifecycleScope(lifecycle(),
                                           DocumentLifecycle::LayoutClean);
 
   TRACE_EVENT_BEGIN1("devtools.timeline", "Layout", "beginData",
                      InspectorLayoutEvent::beginData(this));
 
   performPreLayoutTasks();
 
   Document* document = m_frame->document();
 
-  // TODO(crbug.com/460956): The notion of a single root for layout is no longer applicable. Remove or update this code.
+  // TODO(crbug.com/460956): The notion of a single root for layout is no longer
+  // applicable. Remove or update this code.
   LayoutObject* rootForThisLayout = layoutView();
 
   FontCachePurgePreventer fontCachePurgePreventer;
   {
     AutoReset<bool> changeSchedulingEnabled(&m_layoutSchedulingEnabled, false);
     m_nestedLayoutCount++;
 
     updateCounters();
 
-    // If the layout view was marked as needing layout after we added items in the subtree roots we need
-    // to clear the roots and do the layout from the layoutView.
+    // If the layout view was marked as needing layout after we added items in
+    // the subtree roots we need to clear the roots and do the layout from the
+    // layoutView.
     if (layoutViewItem().needsLayout())
       clearLayoutSubtreeRootsAndMarkContainingBlocks();
     layoutViewItem().clearHitTestCache();
 
     bool inSubtreeLayout = isSubtreeLayout();
 
-    // TODO(crbug.com/460956): The notion of a single root for layout is no longer applicable. Remove or update this code.
+    // TODO(crbug.com/460956): The notion of a single root for layout is no
+    // longer applicable. Remove or update this code.
     if (inSubtreeLayout)
       rootForThisLayout = m_layoutSubtreeRootList.randomRoot();
 
     if (!rootForThisLayout) {
       // FIXME: Do we need to set m_size here?
       NOTREACHED();
       return;
     }
 
     if (!inSubtreeLayout) {
@@ skipping 18 matching lines @@
       ScrollbarMode currentVMode = verticalScrollbarMode();
 
       if (m_firstLayout) {
         setScrollbarsSuppressed(true);
 
         m_firstLayout = false;
         m_lastViewportSize = layoutSize(IncludeScrollbars);
         m_lastZoomFactor = layoutViewItem().style()->zoom();
 
         // Set the initial vMode to AlwaysOn if we're auto.
-        if (vMode == ScrollbarAuto)
-          setVerticalScrollbarMode(
-              ScrollbarAlwaysOn);  // This causes a vertical scrollbar to appear.
+        if (vMode == ScrollbarAuto) {
+          // This causes a vertical scrollbar to appear.
+          setVerticalScrollbarMode(ScrollbarAlwaysOn);
+        }
         // Set the initial hMode to AlwaysOff if we're auto.
-        if (hMode == ScrollbarAuto)
-          setHorizontalScrollbarMode(
-              ScrollbarAlwaysOff);  // This causes a horizontal scrollbar to disappear.
+        if (hMode == ScrollbarAuto) {
+          // This causes a horizontal scrollbar to disappear.
+          setHorizontalScrollbarMode(ScrollbarAlwaysOff);
+        }
 
         setScrollbarModes(hMode, vMode);
         setScrollbarsSuppressed(false);
       } else if (hMode != currentHMode || vMode != currentVMode) {
         setScrollbarModes(hMode, vMode);
       }
 
       updateScrollbarsIfNeeded();
 
       LayoutSize oldSize = m_size;
@@ skipping 23 matching lines @@
 
     if (!inSubtreeLayout && !document->printing())
       adjustViewSizeAndLayout();
 
     ASSERT(m_layoutSubtreeRootList.isEmpty());
   }  // Reset m_layoutSchedulingEnabled to its previous value.
   checkDoesNotNeedLayout();
 
   m_frameTimingRequestsDirty = true;
 
-  // FIXME: Could find the common ancestor layer of all dirty subtrees and mark from there. crbug.com/462719
+  // FIXME: Could find the common ancestor layer of all dirty subtrees and mark
+  // from there. crbug.com/462719
   layoutViewItem().enclosingLayer()->updateLayerPositionsAfterLayout();
 
   TRACE_EVENT_OBJECT_SNAPSHOT_WITH_ID(
       TRACE_DISABLED_BY_DEFAULT("blink.debug.layout.trees"), "LayoutTree", this,
       TracedLayoutObject::create(*layoutView(), true));
 
   layoutViewItem().compositor()->didLayout();
 
   m_layoutCount++;
 
   if (AXObjectCache* cache = document->axObjectCache()) {
     const KURL& url = document->url();
     if (url.isValid() && !url.isAboutBlankURL())
       cache->handleLayoutComplete(document);
   }
   updateDocumentAnnotatedRegions();
   checkDoesNotNeedLayout();
 
   scheduleOrPerformPostLayoutTasks();
   checkDoesNotNeedLayout();
 
-  // FIXME: The notion of a single root for layout is no longer applicable. Remove or update this code. crbug.com/460596
+  // FIXME: The notion of a single root for layout is no longer applicable.
+  // Remove or update this code. crbug.com/460596
   TRACE_EVENT_END1("devtools.timeline", "Layout", "endData",
                    InspectorLayoutEvent::endData(rootForThisLayout));
   InspectorInstrumentation::didUpdateLayout(m_frame.get());
 
   m_nestedLayoutCount--;
   if (m_nestedLayoutCount)
     return;
 
 #if ENABLE(ASSERT)
-  // Post-layout assert that nobody was re-marked as needing layout during layout.
+  // Post-layout assert that nobody was re-marked as needing layout during
+  // layout.
   layoutView()->assertSubtreeIsLaidOut();
 #endif
 
   frame().document()->layoutUpdated();
   checkDoesNotNeedLayout();
 }
 
 void FrameView::invalidateTreeIfNeeded(
     const PaintInvalidationState& paintInvalidationState) {
   DCHECK(!RuntimeEnabledFeatures::slimmingPaintInvalidationEnabled());
@@ skipping 93 matching lines @@
 
 LayoutReplaced* FrameView::embeddedReplacedContent() const {
   LayoutViewItem layoutViewItem = this->layoutViewItem();
   if (layoutViewItem.isNull())
     return nullptr;
 
   LayoutObject* firstChild = layoutView()->firstChild();
   if (!firstChild || !firstChild->isBox())
     return nullptr;
 
-  // Currently only embedded SVG documents participate in the size-negotiation logic.
+  // Currently only embedded SVG documents participate in the size-negotiation
+  // logic.
   if (firstChild->isSVGRoot())
     return toLayoutSVGRoot(firstChild);
 
   return nullptr;
 }
 
 void FrameView::addPart(LayoutPart* object) {
   m_parts.add(object);
 }
 
 void FrameView::removePart(LayoutPart* object) {
   m_parts.remove(object);
 }
 
 void FrameView::updateWidgetGeometries() {
   Vector<RefPtr<LayoutPart>> parts;
   copyToVector(m_parts, parts);
 
   for (auto part : parts) {
-    // Script or plugins could detach the frame so abort processing if that happens.
+    // Script or plugins could detach the frame so abort processing if that
+    // happens.
     if (layoutViewItem().isNull())
       break;
 
     if (Widget* widget = part->widget()) {
       if (widget->isFrameView()) {
         FrameView* frameView = toFrameView(widget);
         bool didNeedLayout = frameView->needsLayout();
         part->updateWidgetGeometry();
         if (!didNeedLayout && !frameView->shouldThrottleRendering())
           frameView->checkDoesNotNeedLayout();
@@ skipping 102 matching lines @@
     if (ScrollingCoordinator* scrollingCoordinator =
             this->scrollingCoordinator())
       scrollingCoordinator->frameViewFixedObjectsDidChange(this);
   }
 }
 
 void FrameView::viewportSizeChanged(bool widthChanged, bool heightChanged) {
   DCHECK(widthChanged || heightChanged);
 
   if (RuntimeEnabledFeatures::rootLayerScrollingEnabled()) {
-    // The background must be repainted when the FrameView is resized, even if the initial
-    // containing block does not change (so we can't rely on layout to issue the invalidation).
-    // This is because the background fills the main GraphicsLayer, which takes the size of the
-    // layout viewport.
-    // TODO(skobes): Paint non-fixed backgrounds into the scrolling contents layer and avoid
-    // this invalidation (http://crbug.com/568847).
+    // The background must be repainted when the FrameView is resized, even if
+    // the initial containing block does not change (so we can't rely on layout
+    // to issue the invalidation).  This is because the background fills the
+    // main GraphicsLayer, which takes the size of the layout viewport.
+    // TODO(skobes): Paint non-fixed backgrounds into the scrolling contents
+    // layer and avoid this invalidation (http://crbug.com/568847).
     LayoutViewItem lvi = layoutViewItem();
     if (!lvi.isNull())
       lvi.setShouldDoFullPaintInvalidation();
   }
 
   if (!hasViewportConstrainedObjects())
     return;
 
   for (const auto& viewportConstrainedObject : *m_viewportConstrainedObjects) {
     LayoutObject* layoutObject = viewportConstrainedObject;
@@ skipping 55 matching lines @@
 
     // invalidate even if there is an ancestor with a filter that moves pixels.
     layoutItem
         .setShouldDoFullPaintInvalidationIncludingNonCompositingDescendants();
 
     TRACE_EVENT_INSTANT1(
         TRACE_DISABLED_BY_DEFAULT("devtools.timeline.invalidationTracking"),
         "ScrollInvalidationTracking", TRACE_EVENT_SCOPE_THREAD, "data",
         InspectorScrollInvalidationTrackingEvent::data(*layoutObject));
 
-    // If the fixed layer has a blur/drop-shadow filter applied on at least one of its parents, we cannot
-    // scroll using the fast path, otherwise the outsets of the filter will be moved around the page.
+    // If the fixed layer has a blur/drop-shadow filter applied on at least one
+    // of its parents, we cannot scroll using the fast path, otherwise the
+    // outsets of the filter will be moved around the page.
     if (layer->hasAncestorWithFilterThatMovesPixels())
       fastPathAllowed = false;
   }
   return fastPathAllowed;
 }
 
 bool FrameView::scrollContentsFastPath(const IntSize& scrollDelta) {
   if (!contentsInCompositedLayer())
     return false;
 
   invalidateBackgroundAttachmentFixedObjects();
 
   if (!m_viewportConstrainedObjects ||
       m_viewportConstrainedObjects->isEmpty()) {
     InspectorInstrumentation::didUpdateLayout(m_frame.get());
     return true;
   }
 
   if (!invalidateViewportConstrainedObjects())
     return false;
 
   InspectorInstrumentation::didUpdateLayout(m_frame.get());
   return true;
 }
 
 void FrameView::scrollContentsSlowPath() {
   TRACE_EVENT0("blink", "FrameView::scrollContentsSlowPath");
-  // We need full invalidation during slow scrolling. For slimming paint, full invalidation
-  // of the LayoutView is not enough. We also need to invalidate all of the objects.
-  // FIXME: Find out what are enough to invalidate in slow path scrolling. crbug.com/451090#9.
+  // We need full invalidation during slow scrolling. For slimming paint, full
+  // invalidation of the LayoutView is not enough. We also need to invalidate
+  // all of the objects.
+  // FIXME: Find out what are enough to invalidate in slow path scrolling.
+  // crbug.com/451090#9.
   ASSERT(!layoutViewItem().isNull());
   if (contentsInCompositedLayer())
     layoutViewItem()
         .layer()
         ->compositedLayerMapping()
         ->setContentsNeedDisplay();
   else
     layoutViewItem()
         .setShouldDoFullPaintInvalidationIncludingNonCompositingDescendants();
 
   if (contentsInCompositedLayer()) {
     IntRect updateRect = visibleContentRect();
     ASSERT(!layoutViewItem().isNull());
-    // FIXME: We should not allow paint invalidation out of paint invalidation state. crbug.com/457415
+    // FIXME: We should not allow paint invalidation out of paint invalidation
+    // state. crbug.com/457415
     DisablePaintInvalidationStateAsserts disabler;
     layoutViewItem().invalidatePaintRectangle(LayoutRect(updateRect));
   }
   LayoutPartItem frameLayoutItem = m_frame->ownerLayoutItem();
   if (!frameLayoutItem.isNull()) {
     if (isEnclosedInCompositingLayer()) {
       LayoutRect rect(
           frameLayoutItem.borderLeft() + frameLayoutItem.paddingLeft(),
           frameLayoutItem.borderTop() + frameLayoutItem.paddingTop(),
           LayoutUnit(visibleWidth()), LayoutUnit(visibleHeight()));
-      // FIXME: We should not allow paint invalidation out of paint invalidation state. crbug.com/457415
+      // FIXME: We should not allow paint invalidation out of paint invalidation
+      // state. crbug.com/457415
       DisablePaintInvalidationStateAsserts disabler;
       frameLayoutItem.invalidatePaintRectangle(rect);
       return;
     }
   }
 }
 
 void FrameView::restoreScrollbar() {
   setScrollbarsSuppressed(false);
 }
@@ skipping 41 matching lines @@
 
   if (m_frame->document()->isSVGDocument()) {
     if (SVGSVGElement* svg =
             SVGDocumentExtensions::rootElement(*m_frame->document())) {
       svg->setupInitialView(name, anchorNode);
       if (!anchorNode)
         return true;
     }
   }
 
-  // Implement the rule that "" and "top" both mean top of page as in other browsers.
+  // Implement the rule that "" and "top" both mean top of page as in other
+  // browsers.
   if (!anchorNode && !(name.isEmpty() || equalIgnoringCase(name, "top")))
     return false;
 
   if (behavior == UrlFragmentScroll)
     setFragmentAnchor(anchorNode ? static_cast<Node*>(anchorNode)
                                  : m_frame->document());
 
   // If the anchor accepts keyboard focus and fragment scrolling is allowed,
   // move focus there to aid users relying on keyboard navigation.
   // If anchorNode is not focusable or fragment scrolling is not allowed,
@@ skipping 12 matching lines @@
   return true;
 }
 
 void FrameView::setFragmentAnchor(Node* anchorNode) {
   ASSERT(anchorNode);
   m_fragmentAnchor = anchorNode;
 
   // We need to update the layout tree before scrolling.
   m_frame->document()->updateStyleAndLayoutTree();
 
-  // If layout is needed, we will scroll in performPostLayoutTasks. Otherwise, scroll immediately.
+  // If layout is needed, we will scroll in performPostLayoutTasks. Otherwise,
+  // scroll immediately.
   LayoutViewItem layoutViewItem = this->layoutViewItem();
   if (!layoutViewItem.isNull() && layoutViewItem.needsLayout())
     layout();
   else
     scrollToFragmentAnchor();
 }
 
 void FrameView::clearFragmentAnchor() {
   m_fragmentAnchor = nullptr;
 }
@@ skipping 66 matching lines @@
     LayoutObject* layoutObject = viewportConstrainedObject;
     PaintLayer* layer = toLayoutBoxModelObject(layoutObject)->layer();
     if (layoutObject->style()->position() == StickyPosition) {
       // TODO(skobes): Resolve circular dependency between scroll offset and
       // compositing state, and remove this disabler. https://crbug.com/420741
       DisableCompositingQueryAsserts disabler;
       layer->updateLayerPositionsAfterOverflowScroll(scrollDelta);
     }
   }
 
-  // If there fixed position elements, scrolling may cause compositing layers to change.
-  // Update widget and layer positions after scrolling, but only if we're not inside of
-  // layout.
+  // If there fixed position elements, scrolling may cause compositing layers to
+  // change.  Update widget and layer positions after scrolling, but only if
+  // we're not inside of layout.
   if (!m_nestedLayoutCount) {
     updateWidgetGeometries();
     LayoutViewItem layoutViewItem = this->layoutViewItem();
     if (!layoutViewItem.isNull())
       layoutViewItem.layer()->setNeedsCompositingInputsUpdate();
   }
 }
 
 bool FrameView::computeCompositedSelection(LocalFrame& frame,
                                            CompositedSelection& selection) {
@@ skipping 83 matching lines @@
     if (TextAutosizer* textAutosizer = m_frame->document()->textAutosizer())
       textAutosizer->updatePageInfoInAllFrames();
   }
 
   ScrollableArea::contentsResized();
   setNeedsLayout();
 }
 
 void FrameView::scrollbarExistenceDidChange() {
   // We check to make sure the view is attached to a frame() as this method can
-  // be triggered before the view is attached by LocalFrame::createView(...) setting
-  // various values such as setScrollBarModes(...) for example.  An ASSERT is
-  // triggered when a view is layout before being attached to a frame().
+  // be triggered before the view is attached by LocalFrame::createView(...)
+  // setting various values such as setScrollBarModes(...) for example.  An
+  // ASSERT is triggered when a view is layout before being attached to a
+  // frame().
   if (!frame().view())
     return;
 
   bool hasOverlayScrollbars = this->hasOverlayScrollbars();
 
-  // FIXME: this call to layout() could be called within FrameView::layout(), but before performLayout(),
-  // causing double-layout. See also crbug.com/429242.
+  // FIXME: this call to layout() could be called within FrameView::layout(),
+  // but before performLayout(), causing double-layout. See also
+  // crbug.com/429242.
   if (!hasOverlayScrollbars && needsLayout())
     layout();
 
   if (!layoutViewItem().isNull() && layoutViewItem().usesCompositing()) {
     layoutViewItem().compositor()->frameViewScrollbarsExistenceDidChange();
 
     if (!hasOverlayScrollbars)
       layoutViewItem().compositor()->frameViewDidChangeSize();
   }
 }
 
 void FrameView::handleLoadCompleted() {
   // Once loading has completed, allow autoSize one last opportunity to
   // reduce the size of the frame.
   if (m_autoSizeInfo)
     m_autoSizeInfo->autoSizeIfNeeded();
 
-  // If there is a pending layout, the fragment anchor will be cleared when it finishes.
+  // If there is a pending layout, the fragment anchor will be cleared when it
+  // finishes.
   if (!needsLayout())
     clearFragmentAnchor();
 }
 
 void FrameView::clearLayoutSubtreeRoot(const LayoutObject& root) {
   m_layoutSubtreeRootList.remove(const_cast<LayoutObject&>(root));
 }
 
 void FrameView::clearLayoutSubtreeRootsAndMarkContainingBlocks() {
   m_layoutSubtreeRootList.clearAndMarkContainingBlocksForLayout();
@@ skipping 40 matching lines @@
 
     removeFloatingObjectsForSubtreeRoot(*root);
     layoutFromRootObject(*root);
   }
 }
 
 bool FrameView::checkLayoutInvalidationIsAllowed() const {
   if (m_allowsLayoutInvalidationAfterLayoutClean)
     return true;
 
-  // If we are updating all lifecycle phases beyond LayoutClean, we don't expect dirty layout after LayoutClean.
+  // If we are updating all lifecycle phases beyond LayoutClean, we don't expect
+  // dirty layout after LayoutClean.
   CHECK_FOR_DIRTY_LAYOUT(lifecycle().state() < DocumentLifecycle::LayoutClean);
 
   return true;
 }
 
 void FrameView::scheduleRelayout() {
   DCHECK(m_frame->view() == this);
 
   if (!m_layoutSchedulingEnabled)
     return;
-  // TODO(crbug.com/590856): It's still broken when we choose not to crash when the check fails.
+  // TODO(crbug.com/590856): It's still broken when we choose not to crash when
+  // the check fails.
   if (!checkLayoutInvalidationIsAllowed())
     return;
   if (!needsLayout())
     return;
   if (!m_frame->document()->shouldScheduleLayout())
     return;
   TRACE_EVENT_INSTANT1(TRACE_DISABLED_BY_DEFAULT("devtools.timeline"),
                        "InvalidateLayout", TRACE_EVENT_SCOPE_THREAD, "data",
                        InspectorInvalidateLayoutEvent::data(m_frame.get()));
 
   clearLayoutSubtreeRootsAndMarkContainingBlocks();
 
   if (m_hasPendingLayout)
     return;
   m_hasPendingLayout = true;
 
   if (!shouldThrottleRendering())
     page()->animator().scheduleVisualUpdate(m_frame.get());
 }
 
 void FrameView::scheduleRelayoutOfSubtree(LayoutObject* relayoutRoot) {
   DCHECK(m_frame->view() == this);
 
-  // TODO(crbug.com/590856): It's still broken when we choose not to crash when the check fails.
+  // TODO(crbug.com/590856): It's still broken when we choose not to crash when
+  // the check fails.
   if (!checkLayoutInvalidationIsAllowed())
     return;
 
   // FIXME: Should this call shouldScheduleLayout instead?
   if (!m_frame->document()->isActive())
     return;
 
   LayoutView* layoutView = this->layoutView();
   if (layoutView && layoutView->needsLayout()) {
     if (relayoutRoot)
@@ skipping 44 matching lines @@
   CHECK_FOR_DIRTY_LAYOUT(layoutViewItem().isNull() ||
                          !layoutViewItem().needsLayout());
   CHECK_FOR_DIRTY_LAYOUT(!isSubtreeLayout());
   return true;
 }
 
 void FrameView::setNeedsLayout() {
   LayoutViewItem layoutViewItem = this->layoutViewItem();
   if (layoutViewItem.isNull())
     return;
-  // TODO(crbug.com/590856): It's still broken if we choose not to crash when the check fails.
+  // TODO(crbug.com/590856): It's still broken if we choose not to crash when
+  // the check fails.
   if (!checkLayoutInvalidationIsAllowed())
     return;
   layoutViewItem.setNeedsLayout(LayoutInvalidationReason::Unknown);
 }
 
 bool FrameView::isTransparent() const {
   return m_isTransparent;
 }
 
 void FrameView::setTransparent(bool isTransparent) {
@@ skipping 36 matching lines @@
         frameView.setTransparent(transparent);
         frameView.setBaseBackgroundColor(backgroundColor);
       });
 }
 
 void FrameView::scrollToFragmentAnchor() {
   Node* anchorNode = m_fragmentAnchor;
   if (!anchorNode)
     return;
 
-  // Scrolling is disabled during updateScrollbars (see isProgrammaticallyScrollable).
-  // Bail now to avoid clearing m_fragmentAnchor before we actually have a chance to scroll.
+  // Scrolling is disabled during updateScrollbars (see
+  // isProgrammaticallyScrollable).  Bail now to avoid clearing m_fragmentAnchor
+  // before we actually have a chance to scroll.
   if (m_inUpdateScrollbars)
     return;
 
   if (anchorNode->layoutObject()) {
     LayoutRect rect;
     if (anchorNode != m_frame->document()) {
       rect = anchorNode->boundingBox();
     } else if (RuntimeEnabledFeatures::rootLayerScrollingEnabled()) {
       if (Element* documentElement = m_frame->document()->documentElement())
         rect = documentElement->boundingBox();
@@ skipping 15 matching lines @@
 
     if (boundaryFrame && boundaryFrame->isLocalFrame())
       toLocalFrame(boundaryFrame)
           ->view()
           ->setSafeToPropagateScrollToParent(true);
 
     if (AXObjectCache* cache = m_frame->document()->existingAXObjectCache())
       cache->handleScrolledToAnchor(anchorNode);
   }
 
-  // The fragment anchor should only be maintained while the frame is still loading.
-  // If the frame is done loading, clear the anchor now. Otherwise, restore it
-  // since it may have been cleared during scrollRectToVisible.
+  // The fragment anchor should only be maintained while the frame is still
+  // loading.  If the frame is done loading, clear the anchor now. Otherwise,
+  // restore it since it may have been cleared during scrollRectToVisible.
   m_fragmentAnchor =
       m_frame->document()->isLoadCompleted() ? nullptr : anchorNode;
 }
 
 bool FrameView::updateWidgets() {
   // This is always called from updateWidgetsTimerFired.
   // m_updateWidgetsTimer should only be scheduled if we have widgets to update.
   // Thus I believe we can stop checking isEmpty here, and just ASSERT isEmpty:
-  // FIXME: This assert has been temporarily removed due to https://crbug.com/430344
+  // FIXME: This assert has been temporarily removed due to
+  // https://crbug.com/430344
   if (m_nestedLayoutCount > 1 || m_partUpdateSet.isEmpty())
     return true;
 
-  // Need to swap because script will run inside the below loop and invalidate the iterator.
+  // Need to swap because script will run inside the below loop and invalidate
+  // the iterator.
   EmbeddedObjectSet objects;
   objects.swap(m_partUpdateSet);
 
   for (const auto& embeddedObject : objects) {
     LayoutEmbeddedObject& object = *embeddedObject;
     HTMLPlugInElement* element = toHTMLPlugInElement(object.node());
 
     // The object may have already been destroyed (thus node cleared),
     // but FrameView holds a manual ref, so it won't have been deleted.
     if (!element)
@@ skipping 37 matching lines @@
   if (m_updateWidgetsTimer.isActive() || m_partUpdateSet.isEmpty())
     return;
   m_updateWidgetsTimer.startOneShot(0, BLINK_FROM_HERE);
 }
 
 void FrameView::performPostLayoutTasks() {
   // FIXME: We can reach here, even when the page is not active!
   // http/tests/inspector/elements/html-link-import.html and many other
   // tests hit that case.
   // We should ASSERT(isActive()); or at least return early if we can!
-  ASSERT(
-      !isInPerformLayout());  // Always before or after performLayout(), part of the highest-level layout() call.
+
+  // Always called before or after performLayout(), part of the highest-level
+  // layout() call.
+  ASSERT(!isInPerformLayout());
   TRACE_EVENT0("blink,benchmark", "FrameView::performPostLayoutTasks");
 
   m_postLayoutTasksTimer.stop();
 
   m_frame->selection().setCaretRectNeedsUpdate();
   m_frame->selection().updateAppearance();
 
   ASSERT(m_frame->document());
 
   FontFaceSet::didLayout(*m_frame->document());
-  // Cursor update scheduling is done by the local root, which is the main frame if there
-  // are no RemoteFrame ancestors in the frame tree. Use of localFrameRoot() is
-  // discouraged but will change when cursor update scheduling is moved from EventHandler
-  // to PageEventHandler.
+  // Cursor update scheduling is done by the local root, which is the main frame
+  // if there are no RemoteFrame ancestors in the frame tree. Use of
+  // localFrameRoot() is discouraged but will change when cursor update
+  // scheduling is moved from EventHandler to PageEventHandler.
   frame().localFrameRoot()->eventHandler().scheduleCursorUpdate();
 
   updateWidgetGeometries();
 
   // Plugins could have torn down the page inside updateWidgetGeometries().
   if (layoutViewItem().isNull())
     return;
 
   scheduleUpdateWidgetsIfNecessary();
 
   if (ScrollingCoordinator* scrollingCoordinator = this->scrollingCoordinator())
     scrollingCoordinator->notifyGeometryChanged();
 
   scrollToFragmentAnchor();
-  // TODO(skobes): Figure out interactions between scroll anchor, fragment anchor, and history restoration.
+  // TODO(skobes): Figure out interactions between scroll anchor, fragment
+  // anchor, and history restoration.
   if (shouldPerformScrollAnchoring())
     m_scrollAnchor.restore();
 
   sendResizeEventIfNeeded();
 }
 
 bool FrameView::wasViewportResized() {
   ASSERT(m_frame);
   LayoutViewItem layoutViewItem = this->layoutViewItem();
   if (layoutViewItem.isNull())
@@ skipping 253 matching lines @@
       // If the <body> didn't have a custom style, then the root element might.
       if (Element* docElement = doc->documentElement()) {
         if (LayoutObject* layoutObject = docElement->layoutObject())
           cornerStyle = layoutObject->getUncachedPseudoStyle(
               PseudoStyleRequest(PseudoIdScrollbarCorner),
               layoutObject->style());
       }
     }
 
     if (!cornerStyle) {
-      // If we have an owning ipage/LocalFrame element, then it can set the custom scrollbar also.
+      // If we have an owning ipage/LocalFrame element, then it can set the
+      // custom scrollbar also.
       LayoutPartItem layoutItem = m_frame->ownerLayoutItem();
       if (!layoutItem.isNull())
         cornerStyle = layoutItem.getUncachedPseudoStyle(
             PseudoStyleRequest(PseudoIdScrollbarCorner), layoutItem.style());
     }
   }
 
   if (cornerStyle) {
     if (!m_scrollCorner)
       m_scrollCorner = LayoutScrollbarPart::createAnonymous(doc, this);
     m_scrollCorner->setStyleWithWritingModeOfParent(cornerStyle.release());
     setScrollCornerNeedsPaintInvalidation();
   } else if (m_scrollCorner) {
     m_scrollCorner->destroy();
     m_scrollCorner = nullptr;
   }
 }
 
 Color FrameView::documentBackgroundColor() const {
-  // The LayoutView's background color is set in Document::inheritHtmlAndBodyElementStyles.
-  // Blend this with the base background color of the FrameView. This should match the color
-  // drawn by ViewPainter::paintBoxDecorationBackground.
+  // The LayoutView's background color is set in
+  // Document::inheritHtmlAndBodyElementStyles.  Blend this with the base
+  // background color of the FrameView. This should match the color drawn by
+  // ViewPainter::paintBoxDecorationBackground.
   Color result = baseBackgroundColor();
   LayoutItem documentLayoutObject = layoutViewItem();
   if (!documentLayoutObject.isNull())
     result = result.blend(
         documentLayoutObject.resolveColor(CSSPropertyBackgroundColor));
   return result;
 }
 
 FrameView* FrameView::parentFrameView() const {
   if (!parent())
@@ skipping 37 matching lines @@
 void FrameView::updateLifecycleToLayoutClean() {
   frame().localFrameRoot()->view()->updateLifecyclePhasesInternal(
       DocumentLifecycle::LayoutClean);
 }
 
 void FrameView::scheduleVisualUpdateForPaintInvalidationIfNeeded() {
   LocalFrame* localFrameRoot = frame().localFrameRoot();
   if (localFrameRoot->view()->m_currentUpdateLifecyclePhasesTargetState <
           DocumentLifecycle::PaintInvalidationClean ||
       lifecycle().state() >= DocumentLifecycle::PrePaintClean) {
-    // Schedule visual update to process the paint invalidation in the next cycle.
+    // Schedule visual update to process the paint invalidation in the next
+    // cycle.
     localFrameRoot->scheduleVisualUpdateUnlessThrottled();
   }
-  // Otherwise the paint invalidation will be handled in paint invalidation phase of this cycle.
+  // Otherwise the paint invalidation will be handled in paint invalidation
+  // phase of this cycle.
 }
 
 void FrameView::notifyResizeObservers() {
   // Controller exists only if ResizeObserver was created.
   if (!frame().document()->resizeObserverController())
     return;
 
   ResizeObserverController& resizeController =
       m_frame->document()->ensureResizeObserverController();
 
@@ skipping 14 matching lines @@
         SourceLocation::capture(m_frame->document()), nullptr);
     m_frame->document()->dispatchErrorEvent(error, NotSharableCrossOrigin);
     // Ensure notifications will get delivered in next cycle.
     if (FrameView* frameView = m_frame->view())
       frameView->scheduleAnimation();
   }
 
   DCHECK(!layoutView()->needsLayout());
 }
 
-// TODO(leviw): We don't assert lifecycle information from documents in child PluginViews.
+// TODO(leviw): We don't assert lifecycle information from documents in child
+// PluginViews.
 void FrameView::updateLifecyclePhasesInternal(
     DocumentLifecycle::LifecycleState targetState) {
   if (m_currentUpdateLifecyclePhasesTargetState !=
       DocumentLifecycle::Uninitialized) {
     NOTREACHED() << "FrameView::updateLifecyclePhasesInternal() reentrance";
     return;
   }
 
   // This must be called from the root frame, since it recurses down, not up.
   // Otherwise the lifecycles of the frames might be out of sync.
@@ skipping 129 matching lines @@
     frameView.lifecycle().advanceTo(DocumentLifecycle::InPaint);
   });
 
   if (RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
     if (layoutView()->layer()->needsRepaint()) {
       GraphicsContext graphicsContext(*m_paintController);
       paint(graphicsContext, CullRect(LayoutRect::infiniteIntRect()));
       m_paintController->commitNewDisplayItems(LayoutSize());
     }
   } else {
-    // A null graphics layer can occur for painting of SVG images that are not parented into the main frame tree,
-    // or when the FrameView is the main frame view of a page overlay. The page overlay is in the layer tree of
-    // the host page and will be painted during synchronized painting of the host page.
+    // A null graphics layer can occur for painting of SVG images that are not
+    // parented into the main frame tree, or when the FrameView is the main
+    // frame view of a page overlay. The page overlay is in the layer tree of
+    // the host page and will be painted during synchronized painting of the
+    // host page.
     if (GraphicsLayer* rootGraphicsLayer =
             view.compositor()->rootGraphicsLayer()) {
       synchronizedPaintRecursively(rootGraphicsLayer);
     }
 
     // TODO(sataya.m):Main frame doesn't create RootFrameViewport in some
     // webkit_unit_tests (http://crbug.com/644788).
     if (m_viewportScrollableArea) {
       if (GraphicsLayer* layerForHorizontalScrollbar =
               m_viewportScrollableArea->layerForHorizontalScrollbar()) {
@@ skipping 72 matching lines @@
 void FrameView::updateStyleAndLayoutIfNeededRecursiveInternal() {
   if (shouldThrottleRendering() || !m_frame->document()->isActive())
     return;
 
   ScopedFrameBlamer frameBlamer(m_frame);
   TRACE_EVENT0("blink", "FrameView::updateStyleAndLayoutIfNeededRecursive");
 
   // We have to crawl our entire subtree looking for any FrameViews that need
   // layout and make sure they are up to date.
   // Mac actually tests for intersection with the dirty region and tries not to
-  // update layout for frames that are outside the dirty region.  Not only does this seem
-  // pointless (since those frames will have set a zero timer to layout anyway), but
-  // it is also incorrect, since if two frames overlap, the first could be excluded from the dirty
-  // region but then become included later by the second frame adding rects to the dirty region
-  // when it lays out.
+  // update layout for frames that are outside the dirty region.  Not only does
+  // this seem pointless (since those frames will have set a zero timer to
+  // layout anyway), but it is also incorrect, since if two frames overlap, the
+  // first could be excluded from the dirty region but then become included
+  // later by the second frame adding rects to the dirty region when it lays
+  // out.
 
   m_frame->document()->updateStyleAndLayoutTree();
 
   CHECK(!shouldThrottleRendering());
   CHECK(m_frame->document()->isActive());
   CHECK(!m_nestedLayoutCount);
 
   if (needsLayout())
     layout();
 
   checkDoesNotNeedLayout();
 
-  // WebView plugins need to update regardless of whether the LayoutEmbeddedObject
-  // that owns them needed layout.
-  // TODO(leviw): This currently runs the entire lifecycle on plugin WebViews. We
-  // should have a way to only run these other Documents to the same lifecycle stage
-  // as this frame.
+  // WebView plugins need to update regardless of whether the
+  // LayoutEmbeddedObject that owns them needed layout.
+  // TODO(leviw): This currently runs the entire lifecycle on plugin WebViews.
+  // We should have a way to only run these other Documents to the same
+  // lifecycle stage as this frame.
   const ChildrenWidgetSet* viewChildren = children();
   for (const Member<Widget>& child : *viewChildren) {
     if ((*child).isPluginContainer())
       toPluginView(child.get())->updateAllLifecyclePhases();
   }
   checkDoesNotNeedLayout();
 
   // FIXME: Calling layout() shouldn't trigger script execution or have any
   // observable effects on the frame tree but we're not quite there yet.
   HeapVector<Member<FrameView>> frameViews;
   for (Frame* child = m_frame->tree().firstChild(); child;
        child = child->tree().nextSibling()) {
     if (!child->isLocalFrame())
       continue;
     if (FrameView* view = toLocalFrame(child)->view())
       frameViews.append(view);
   }
 
   for (const auto& frameView : frameViews)
     frameView->updateStyleAndLayoutIfNeededRecursiveInternal();
 
   checkDoesNotNeedLayout();
 
-  // When SVG filters are invalidated using Document::scheduleSVGFilterLayerUpdateHack() they may trigger an
-  // extra style recalc. See PaintLayer::filterNeedsPaintInvalidation().
+  // When SVG filters are invalidated using
+  // Document::scheduleSVGFilterLayerUpdateHack() they may trigger an extra
+  // style recalc. See PaintLayer::filterNeedsPaintInvalidation().
   if (m_frame->document()->hasSVGFilterElementsRequiringLayerUpdate()) {
     m_frame->document()->updateStyleAndLayoutTree();
 
     if (needsLayout())
       layout();
   }
 
-  // These asserts ensure that parent frames are clean, when child frames finished updating layout and style.
+  // These asserts ensure that parent frames are clean, when child frames
+  // finished updating layout and style.
   checkDoesNotNeedLayout();
   ASSERT(!m_frame->document()->hasSVGFilterElementsRequiringLayerUpdate());
 #if ENABLE(ASSERT)
   m_frame->document()->layoutView()->assertLaidOut();
 #endif
 
   updateWidgetGeometriesIfNeeded();
 
   if (lifecycle().state() < DocumentLifecycle::LayoutClean)
     lifecycle().advanceTo(DocumentLifecycle::LayoutClean);
 
   // Ensure that we become visually non-empty eventually.
   // TODO(esprehn): This should check isRenderingReady() instead.
   if (frame().document()->hasFinishedParsing() &&
       frame().loader().stateMachine()->committedFirstRealDocumentLoad())
     m_isVisuallyNonEmpty = true;
 }
 
 void FrameView::invalidateTreeIfNeededRecursive() {
   SCOPED_BLINK_UMA_HISTOGRAM_TIMER("Blink.PaintInvalidation.UpdateTime");
   invalidateTreeIfNeededRecursiveInternal();
 }
 
 void FrameView::invalidateTreeIfNeededRecursiveInternal() {
   DCHECK(!RuntimeEnabledFeatures::slimmingPaintV2Enabled());
   CHECK(layoutView());
 
-  // We need to stop recursing here since a child frame view might not be throttled
-  // even though we are (e.g., it didn't compute its visibility yet).
+  // We need to stop recursing here since a child frame view might not be
+  // throttled even though we are (e.g., it didn't compute its visibility yet).
   if (shouldThrottleRendering())
     return;
   TRACE_EVENT1("blink", "FrameView::invalidateTreeIfNeededRecursive", "root",
                layoutView()->debugName().ascii());
 
   Vector<const LayoutObject*> pendingDelayedPaintInvalidations;
   PaintInvalidationState rootPaintInvalidationState(
       *layoutView(), pendingDelayedPaintInvalidations);
 
   if (lifecycle().state() < DocumentLifecycle::PaintInvalidationClean)
     invalidateTreeIfNeeded(rootPaintInvalidationState);
 
-  // Some frames may be not reached during the above invalidateTreeIfNeeded because
+  // Some frames may be not reached during the above invalidateTreeIfNeeded
+  // because
   // - the frame is a detached frame; or
   // - it didn't need paint invalidation.
-  // We need to call invalidateTreeIfNeededRecursive() for such frames to finish required
-  // paint invalidation and advance their life cycle state.
+  // We need to call invalidateTreeIfNeededRecursive() for such frames to finish
+  // required paint invalidation and advance their life cycle state.
   for (Frame* child = m_frame->tree().firstChild(); child;
        child = child->tree().nextSibling()) {
     if (child->isLocalFrame()) {
       FrameView& childFrameView = *toLocalFrame(child)->view();
       // The children frames can be in any state, including stopping.
       // Thus we have to check that it makes sense to do paint
       // invalidation onto them here.
       if (!childFrameView.layoutView())
         continue;
       childFrameView.invalidateTreeIfNeededRecursiveInternal();
     }
   }
 
-  // Process objects needing paint invalidation on the next frame. See the definition of PaintInvalidationDelayedFull for more details.
+  // Process objects needing paint invalidation on the next frame. See the
+  // definition of PaintInvalidationDelayedFull for more details.
   for (auto& target : pendingDelayedPaintInvalidations)
     target->getMutableForPainting().setShouldDoFullPaintInvalidation(
         PaintInvalidationDelayedFull);
 }
 
 void FrameView::enableAutoSizeMode(const IntSize& minSize,
                                    const IntSize& maxSize) {
   if (!m_autoSizeInfo)
     m_autoSizeInfo = FrameViewAutoSizeInfo::create(this);
 
@@ skipping 14 matching lines @@
   // Since autosize mode forces the scrollbar mode, change them to being auto.
   setVerticalScrollbarLock(false);
   setHorizontalScrollbarLock(false);
   setScrollbarModes(ScrollbarAuto, ScrollbarAuto);
   m_autoSizeInfo.clear();
 }
 
 void FrameView::forceLayoutForPagination(const FloatSize& pageSize,
                                          const FloatSize& originalPageSize,
                                          float maximumShrinkFactor) {
-  // Dumping externalRepresentation(m_frame->layoutObject()).ascii() is a good trick to see
-  // the state of things before and after the layout
+  // Dumping externalRepresentation(m_frame->layoutObject()).ascii() is a good
+  // trick to see the state of things before and after the layout
   if (LayoutView* layoutView = this->layoutView()) {
     float pageLogicalWidth = layoutView->style()->isHorizontalWritingMode()
                                  ? pageSize.width()
                                  : pageSize.height();
     float pageLogicalHeight = layoutView->style()->isHorizontalWritingMode()
                                   ? pageSize.height()
                                   : pageSize.width();
 
     LayoutUnit flooredPageLogicalWidth =
         static_cast<LayoutUnit>(pageLogicalWidth);
     LayoutUnit flooredPageLogicalHeight =
         static_cast<LayoutUnit>(pageLogicalHeight);
     layoutView->setLogicalWidth(flooredPageLogicalWidth);
     layoutView->setPageLogicalHeight(flooredPageLogicalHeight);
     layoutView->setNeedsLayoutAndPrefWidthsRecalcAndFullPaintInvalidation(
         LayoutInvalidationReason::PrintingChanged);
     layout();
 
-    // If we don't fit in the given page width, we'll lay out again. If we don't fit in the
-    // page width when shrunk, we will lay out at maximum shrink and clip extra content.
-    // FIXME: We are assuming a shrink-to-fit printing implementation.  A cropping
-    // implementation should not do this!
+    // If we don't fit in the given page width, we'll lay out again. If we don't
+    // fit in the page width when shrunk, we will lay out at maximum shrink and
+    // clip extra content.
+    // FIXME: We are assuming a shrink-to-fit printing implementation.  A
+    // cropping implementation should not do this!
     bool horizontalWritingMode = layoutView->style()->isHorizontalWritingMode();
     const LayoutRect& documentRect = LayoutRect(layoutView->documentRect());
     LayoutUnit docLogicalWidth =
         horizontalWritingMode ? documentRect.width() : documentRect.height();
     if (docLogicalWidth > pageLogicalWidth) {
       FloatSize expectedPageSize(
           std::min<float>(documentRect.width().toFloat(),
                           pageSize.width() * maximumShrinkFactor),
           std::min<float>(documentRect.height().toFloat(),
                           pageSize.height() * maximumShrinkFactor));
@@ skipping 54 matching lines @@
   return rect;
 }
 
 IntRect FrameView::convertToLayoutObject(const LayoutObject& layoutObject,
                                          const IntRect& frameRect) const {
   IntRect rectInContent = frameToContents(frameRect);
 
   // Convert from FrameView coords into page ("absolute") coordinates.
   rectInContent.moveBy(scrollPosition());
 
-  // FIXME: we don't have a way to map an absolute rect down to a local quad, so just
-  // move the rect for now.
+  // FIXME: we don't have a way to map an absolute rect down to a local quad, so
+  // just move the rect for now.
   rectInContent.setLocation(roundedIntPoint(
       layoutObject.absoluteToLocal(rectInContent.location(), UseTransforms)));
   return rectInContent;
 }
 
 IntPoint FrameView::convertFromLayoutObject(
     const LayoutObject& layoutObject,
     const IntPoint& layoutObjectPoint) const {
   IntPoint point = roundedIntPoint(
       layoutObject.localToAbsolute(layoutObjectPoint, UseTransforms));
@@ skipping 275 matching lines @@
                                 ScrollbarOrientation orientation) {
   ScrollableArea::didAddScrollbar(scrollbar, orientation);
 }
 
 void FrameView::setTopControlsViewportAdjustment(float adjustment) {
   m_topControlsViewportAdjustment = adjustment;
 }
 
 IntPoint FrameView::maximumScrollPosition() const {
   // Make the same calculation as in CC's LayerImpl::MaxScrollOffset()
-  // FIXME: We probably shouldn't be storing the bounds in a float. crbug.com/422331.
+  // FIXME: We probably shouldn't be storing the bounds in a float.
+  // crbug.com/422331.
   IntSize visibleSize =
       visibleContentSize(ExcludeScrollbars) + topControlsSize();
   IntSize contentBounds = contentsSize();
   IntPoint maximumPosition = -scrollOrigin() + (contentBounds - visibleSize);
   return maximumPosition.expandedTo(minimumScrollPosition());
 }
 
 void FrameView::addChild(Widget* child) {
   ASSERT(child != this && !child->parent());
   child->setParent(this);
@@ skipping 51 matching lines @@
 
   setScrollCornerNeedsPaintInvalidation();
 }
 
 void FrameView::setScrollbarModes(ScrollbarMode horizontalMode,
                                   ScrollbarMode verticalMode,
                                   bool horizontalLock,
                                   bool verticalLock) {
   bool needsUpdate = false;
 
-  // If the page's overflow setting has disabled scrolling, do not allow anything to override that setting.
-  // http://crbug.com/426447
+  // If the page's overflow setting has disabled scrolling, do not allow
+  // anything to override that setting, http://crbug.com/426447
   LayoutObject* viewport = viewportLayoutObject();
   if (viewport && !shouldIgnoreOverflowHidden()) {
     if (viewport->style()->overflowX() == OverflowHidden)
       horizontalMode = ScrollbarAlwaysOff;
     if (viewport->style()->overflowY() == OverflowHidden)
       verticalMode = ScrollbarAlwaysOff;
   }
 
   if (horizontalMode != horizontalScrollbarMode() &&
       !m_horizontalScrollbarLock) {
@@ skipping 247 matching lines @@
       setScrollbarNeedsPaintInvalidation(VerticalScrollbar);
 
     m_verticalScrollbar->setEnabled(contentsHeight() > clientHeight);
     m_verticalScrollbar->setProportion(clientHeight, contentsHeight());
     m_verticalScrollbar->offsetDidChange();
   }
 }
 
 IntRect FrameView::adjustScrollbarRectForResizer(const IntRect& rect,
                                                  Scrollbar& scrollbar) {
-  // Get our window resizer rect and see if we overlap. Adjust to avoid the overlap
-  // if necessary.
+  // Get our window resizer rect and see if we overlap. Adjust to avoid the
+  // overlap if necessary.
   IntRect adjustedRect(rect);
   bool overlapsResizer = false;
   if (!rect.isEmpty() && !windowResizerRect().isEmpty()) {
     IntRect resizerRect = convertFromRootFrame(windowResizerRect());
     if (rect.intersects(resizerRect)) {
       if (scrollbar.orientation() == HorizontalScrollbar) {
         int overlap = rect.maxX() - resizerRect.x();
         if (overlap > 0 && resizerRect.maxX() >= rect.maxX()) {
           adjustedRect.setWidth(rect.width() - overlap);
           overlapsResizer = true;
@@ skipping 11 matching lines @@
     scrollbar.setOverlapsResizer(overlapsResizer);
     adjustScrollbarsAvoidingResizerCount(overlapsResizer ? 1 : -1);
   }
   return adjustedRect;
 }
 
 bool FrameView::adjustScrollbarExistence(
     ComputeScrollbarExistenceOption option) {
   ASSERT(m_inUpdateScrollbars);
 
-  // If we came in here with the view already needing a layout, then go ahead and do that
-  // first.  (This will be the common case, e.g., when the page changes due to window resizing for example).
-  // This layout will not re-enter updateScrollbars and does not count towards our max layout pass total.
+  // If we came in here with the view already needing a layout, then go ahead
+  // and do that first.  (This will be the common case, e.g., when the page
+  // changes due to window resizing for example).  This layout will not re-enter
+  // updateScrollbars and does not count towards our max layout pass total.
   if (!m_scrollbarsSuppressed)
     scrollbarExistenceDidChange();
 
   bool hasHorizontalScrollbar = m_horizontalScrollbar;
   bool hasVerticalScrollbar = m_verticalScrollbar;
 
   bool newHasHorizontalScrollbar = false;
   bool newHasVerticalScrollbar = false;
   computeScrollbarExistence(newHasHorizontalScrollbar, newHasVerticalScrollbar,
                             contentsSize(), option);
@@ skipping 73 matching lines @@
        updateScrollbarsPass < maxUpdateScrollbarsPass; updateScrollbarsPass++) {
     if (!adjustScrollbarExistence(updateScrollbarsPass ? Incremental
                                                        : FirstPass))
       break;
     scrollbarExistenceChanged = true;
   }
 
   updateScrollbarGeometry();
 
   if (scrollbarExistenceChanged) {
-    // FIXME: Is frameRectsChanged really necessary here? Have any frame rects changed?
+    // FIXME: Is frameRectsChanged really necessary here? Have any frame rects
+    // changed?
     frameRectsChanged();
     positionScrollbarLayers();
     updateScrollCorner();
   }
 
   adjustScrollPositionFromUpdateScrollbars();
 }
 
 void FrameView::adjustScrollPositionFromUpdateScrollbars() {
   DoublePoint clamped = clampScrollPosition(scrollPositionDouble());
@@ skipping 22 matching lines @@
 void FrameView::scrollContents(const IntSize& scrollDelta) {
   HostWindow* window = getHostWindow();
   if (!window)
     return;
 
   TRACE_EVENT0("blink", "FrameView::scrollContents");
 
   if (!scrollContentsFastPath(-scrollDelta))
     scrollContentsSlowPath();
 
-  // This call will move children with native widgets (plugins) and invalidate them as well.
+  // This call will move children with native widgets (plugins) and invalidate
+  // them as well.
   frameRectsChanged();
 }
 
 IntPoint FrameView::contentsToFrame(const IntPoint& pointInContentSpace) const {
   return pointInContentSpace - scrollOffset();
 }
 
 IntRect FrameView::contentsToFrame(const IntRect& rectInContentSpace) const {
   return IntRect(contentsToFrame(rectInContentSpace.location()),
                  rectInContentSpace.size());
@@ skipping 93 matching lines @@
   return !m_scrollbarsAvoidingResizer;
 }
 
 void FrameView::adjustScrollbarsAvoidingResizerCount(int overlapDelta) {
   int oldCount = m_scrollbarsAvoidingResizer;
   m_scrollbarsAvoidingResizer += overlapDelta;
   if (parent()) {
     toFrameView(parent())->adjustScrollbarsAvoidingResizerCount(overlapDelta);
   } else if (!scrollbarsSuppressed()) {
     // If we went from n to 0 or from 0 to n and we're the outermost view,
-    // we need to invalidate the windowResizerRect(), since it will now need to paint
-    // differently.
+    // we need to invalidate the windowResizerRect(), since it will now need to
+    // paint differently.
     if ((oldCount > 0 && m_scrollbarsAvoidingResizer == 0) ||
         (oldCount == 0 && m_scrollbarsAvoidingResizer > 0))
       invalidateRect(windowResizerRect());
   }
 }
 
 Scrollbar* FrameView::scrollbarAtFramePoint(const IntPoint& pointInFrame) {
   if (m_horizontalScrollbar &&
       m_horizontalScrollbar->shouldParticipateInHitTesting() &&
       m_horizontalScrollbar->frameRect().contains(pointInFrame))
@@ skipping 72 matching lines @@
 LayoutRect FrameView::scrollIntoView(const LayoutRect& rectInContent,
                                      const ScrollAlignment& alignX,
                                      const ScrollAlignment& alignY,
                                      ScrollType scrollType) {
   LayoutRect viewRect(visibleContentRect());
   LayoutRect exposeRect =
       ScrollAlignment::getRectToExpose(viewRect, rectInContent, alignX, alignY);
   if (exposeRect != viewRect)
     setScrollPosition(DoublePoint(exposeRect.x(), exposeRect.y()), scrollType);
 
-  // Scrolling the FrameView cannot change the input rect's location relative to the document.
+  // Scrolling the FrameView cannot change the input rect's location relative to
+  // the document.
   return rectInContent;
 }
 
 IntRect FrameView::scrollCornerRect() const {
   IntRect cornerRect;
 
   if (hasOverlayScrollbars())
     return cornerRect;
 
   if (m_horizontalScrollbar && width() - m_horizontalScrollbar->width() > 0) {
@@ skipping 125 matching lines @@
                                       CompositingUpdateType updateType) {
   if (PaintLayerCompositor* compositor =
           !layoutViewItem.isNull() ? layoutViewItem.compositor() : nullptr)
     compositor->setNeedsCompositingUpdate(updateType);
 }
 
 void FrameView::setParentVisible(bool visible) {
   if (isParentVisible() == visible)
     return;
 
-  // As parent visibility changes, we may need to recomposite this frame view and potentially child frame views.
+  // As parent visibility changes, we may need to recomposite this frame view
+  // and potentially child frame views.
   setNeedsCompositingUpdate(layoutViewItem(), CompositingUpdateRebuildTree);
 
   Widget::setParentVisible(visible);
 
   if (!isSelfVisible())
     return;
 
   for (const auto& child : m_children)
     child->setParentVisible(visible);
 }
@@ skipping 99 matching lines @@
 
   // Transform our bounds into the root frame's content coordinate space,
   // making sure we have valid layout data in our parent document. If our
   // parent is throttled, we'll use possible stale layout information and
   // rely on the fact that another lifecycle update will be scheduled once
   // our parent becomes unthrottled.
   ASSERT(parent->lifecycle().state() >= DocumentLifecycle::LayoutClean ||
          parent->shouldThrottleRendering());
   m_viewportIntersection = parent->contentsToRootFrame(frameRect());
 
-  // TODO(skyostil): Expand the viewport to make it less likely to see stale content while scrolling.
+  // TODO(skyostil): Expand the viewport to make it less likely to see stale
+  // content while scrolling.
   IntRect viewport = parent->m_viewportIntersection;
   m_viewportIntersection.intersect(viewport);
 }
 
 void FrameView::updateViewportIntersectionsForSubtree(
     DocumentLifecycle::LifecycleState targetState) {
   bool hadValidIntersection = m_viewportIntersectionValid;
   bool hadEmptyIntersection = m_viewportIntersection.isEmpty();
   updateViewportIntersectionIfNeeded();
 
@@ skipping 83 matching lines @@
     // If this FrameView became throttled, we must make sure all of its
     // children become throttled at the same time. Otherwise we might
     // attempt to paint one of the children with an out-of-date layout
     // before |notifyRenderThrottlingObservers| has made it throttled.
     forAllNonThrottledFrameViews([](FrameView& frameView) {
       frameView.m_subtreeThrottled = true;
       DCHECK(frameView.canThrottleRendering());
     });
   }
   if (becameUnthrottled) {
-    // ScrollingCoordinator needs to update according to the new throttling status.
+    // ScrollingCoordinator needs to update according to the new throttling
+    // status.
     if (scrollingCoordinator)
       scrollingCoordinator->notifyGeometryChanged();
     // Start ticking animation frames again if necessary.
     if (page())
       page()->animator().scheduleVisualUpdate(m_frame.get());
     // Force a full repaint of this frame to ensure we are not left with a
     // partially painted version of this frame's contents if we skipped
     // painting them while the frame was throttled.
     LayoutViewItem layoutViewItem = this->layoutViewItem();
     if (!layoutViewItem.isNull())
@@ skipping 22 matching lines @@
 }
 
 bool FrameView::canThrottleRendering() const {
   if (!RuntimeEnabledFeatures::renderingPipelineThrottlingEnabled())
     return false;
   return m_subtreeThrottled ||
          (m_hiddenForThrottling && m_crossOriginForThrottling);
 }
 
 }  // namespace blink