Reformat comments in core/layout

third_party/WebKit/Source/core/layout/LayoutView.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
- * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
+ * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009 Apple Inc.
+ *               All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
@@ skipping 89 matching lines @@
   m_maxPreferredLogicalWidth = LayoutUnit();
 
   setPreferredLogicalWidthsDirty(MarkOnlyThis);
 
   setPositionState(AbsolutePosition);  // to 0,0 :)
 }
 
 LayoutView::~LayoutView() {}
 
 bool LayoutView::hitTest(HitTestResult& result) {
-  // We have to recursively update layout/style here because otherwise, when the hit test recurses
-  // into a child document, it could trigger a layout on the parent document, which can destroy PaintLayer
-  // that are higher up in the call stack, leading to crashes.
+  // We have to recursively update layout/style here because otherwise, when the
+  // hit test recurses into a child document, it could trigger a layout on the
+  // parent document, which can destroy PaintLayer that are higher up in the
+  // call stack, leading to crashes.
   // Note that Document::updateLayout calls its parent's updateLayout.
-  // Note that if an iframe has its render pipeline throttled, it will not update layout here,
-  // and it will also not propagate the hit test into the iframe's inner document.
+  // Note that if an iframe has its render pipeline throttled, it will not
+  // update layout here, and it will also not propagate the hit test into the
+  // iframe's inner document.
   frameView()->updateLifecycleToCompositingCleanPlusScrolling();
   HitTestLatencyRecorder hitTestLatencyRecorder(
       result.hitTestRequest().allowsChildFrameContent());
   return hitTestNoLifecycleUpdate(result);
 }
 
 bool LayoutView::hitTestNoLifecycleUpdate(HitTestResult& result) {
   TRACE_EVENT_BEGIN0("blink,devtools.timeline", "HitTest");
   m_hitTestCount++;
 
   ASSERT(!result.hitTestLocation().isRectBasedTest() ||
          result.hitTestRequest().listBased());
 
   commitPendingSelection();
 
   uint64_t domTreeVersion = document().domTreeVersion();
   HitTestResult cacheResult = result;
   bool hitLayer = false;
   if (m_hitTestCache->lookupCachedResult(cacheResult, domTreeVersion)) {
     m_hitTestCacheHits++;
     hitLayer = true;
     result = cacheResult;
   } else {
     hitLayer = layer()->hitTest(result);
 
-    // FrameView scrollbars are not the same as Layer scrollbars tested by Layer::hitTestOverflowControls,
-    // so we need to test FrameView scrollbars separately here. Note that it's important we do this after
-    // the hit test above, because that may overwrite the entire HitTestResult when it finds a hit.
+    // FrameView scrollbars are not the same as Layer scrollbars tested by
+    // Layer::hitTestOverflowControls, so we need to test FrameView scrollbars
+    // separately here. Note that it's important we do this after the hit test
+    // above, because that may overwrite the entire HitTestResult when it finds
+    // a hit.
     IntPoint framePoint =
         frameView()->contentsToFrame(result.hitTestLocation().roundedPoint());
     if (Scrollbar* frameScrollbar =
             frameView()->scrollbarAtFramePoint(framePoint))
       result.setScrollbar(frameScrollbar);
 
     if (hitLayer)
       m_hitTestCache->addCachedResult(result, domTreeVersion);
   }
 
@@ skipping 37 matching lines @@
 #endif
 }
 
 #if ENABLE(ASSERT)
 void LayoutView::checkLayoutState() {
   ASSERT(!m_layoutState->next());
 }
 #endif
 
 void LayoutView::setShouldDoFullPaintInvalidationOnResizeIfNeeded() {
-  // When background-attachment is 'fixed', we treat the viewport (instead of the 'root'
-  // i.e. html or body) as the background positioning area, and we should fully invalidate
-  // on viewport resize if the background image is not composited and needs full paint
-  // invalidation on background positioning area resize.
+  // When background-attachment is 'fixed', we treat the viewport (instead of
+  // the 'root' i.e. html or body) as the background positioning area, and we
+  // should fully invalidate on viewport resize if the background image is not
+  // composited and needs full paint invalidation on background positioning area
+  // resize.
   if (style()->hasFixedBackgroundImage() &&
       (!m_compositor ||
        !m_compositor->needsFixedRootBackgroundLayer(layer()))) {
     IncludeScrollbarsInRect includeScrollbars =
         RuntimeEnabledFeatures::rootLayerScrollingEnabled() ? IncludeScrollbars
                                                             : ExcludeScrollbars;
     if ((offsetWidth() != viewWidth(includeScrollbars) &&
          mustInvalidateFillLayersPaintOnWidthChange(
              style()->backgroundLayers())) ||
         (offsetHeight() != viewHeight(includeScrollbars) &&
@@ skipping 14 matching lines @@
     if (!m_fragmentationContext)
       m_fragmentationContext = wrapUnique(new ViewFragmentationContext(*this));
   } else if (m_fragmentationContext) {
     m_fragmentationContext.reset();
   }
 
   SubtreeLayoutScope layoutScope(*this);
 
   LayoutRect oldLayoutOverflowRect = layoutOverflowRect();
 
-  // Use calcWidth/Height to get the new width/height, since this will take the full page zoom factor into account.
+  // Use calcWidth/Height to get the new width/height, since this will take the
+  // full page zoom factor into account.
   bool relayoutChildren =
       !shouldUsePrintingLayout() &&
       (!m_frameView || logicalWidth() != viewLogicalWidthForBoxSizing() ||
        logicalHeight() != viewLogicalHeightForBoxSizing());
   if (relayoutChildren) {
     layoutScope.setChildNeedsLayout(this);
     for (LayoutObject* child = firstChild(); child;
          child = child->nextSibling()) {
       if (child->isSVGRoot())
         continue;
@@ skipping 16 matching lines @@
     return;
 
   LayoutState rootLayoutState(pageLogicalHeight(), pageLogicalHeightChanged(),
                               *this);
 
   m_pageLogicalHeightChanged = false;
 
   layoutContent();
 
   if (layoutOverflowRect() != oldLayoutOverflowRect) {
-    // The document element paints the viewport background, so we need to invalidate it when
-    // layout overflow changes.
-    // FIXME: Improve viewport background styling/invalidation/painting. crbug.com/475115
+    // The document element paints the viewport background, so we need to
+    // invalidate it when layout overflow changes.
+    // FIXME: Improve viewport background styling/invalidation/painting.
+    // crbug.com/475115
     if (Element* documentElement = document().documentElement()) {
       if (LayoutObject* rootObject = documentElement->layoutObject())
         rootObject->setShouldDoFullPaintInvalidation();
     }
   }
 
 #if ENABLE(ASSERT)
   checkLayoutState();
 #endif
   clearNeedsLayout();
 }
 
 LayoutRect LayoutView::visualOverflowRect() const {
   // In root layer scrolling mode, the LayoutView performs overflow clipping
   // like a regular scrollable div.
   if (RuntimeEnabledFeatures::rootLayerScrollingEnabled())
     return LayoutBlockFlow::visualOverflowRect();
 
   // Ditto when not in compositing mode.
   if (!usesCompositing())
     return LayoutBlockFlow::visualOverflowRect();
 
   // In normal compositing mode, LayoutView doesn't actually apply clipping
   // on its descendants. Instead their visual overflow is propagated to
   // compositor()->m_rootContentLayer for accelerated scrolling.
   return layoutOverflowRect();
 }
 
 LayoutRect LayoutView::localOverflowRectForPaintInvalidation() const {
-  // TODO(wangxianzhu): This is only required without rootLayerScrolls (though it is also correct
-  // but unnecessary with rootLayerScrolls) because of the special LayoutView overflow model.
+  // TODO(wangxianzhu): This is only required without rootLayerScrolls (though
+  // it is also correct but unnecessary with rootLayerScrolls) because of the
+  // special LayoutView overflow model.
   return visualOverflowRect();
 }
 
 void LayoutView::mapLocalToAncestor(const LayoutBoxModelObject* ancestor,
                                     TransformState& transformState,
                                     MapCoordinatesFlags mode) const {
   if (!ancestor && mode & UseTransforms && shouldUseTransformFromContainer(0)) {
     TransformationMatrix t;
     getTransformFromContainer(0, LayoutSize(), t);
     transformState.applyTransform(t);
@@ skipping 67 matching lines @@
 
 void LayoutView::mapAncestorToLocal(const LayoutBoxModelObject* ancestor,
                                     TransformState& transformState,
                                     MapCoordinatesFlags mode) const {
   if (this == ancestor)
     return;
 
   if (mode & TraverseDocumentBoundaries) {
     if (LayoutPart* parentDocLayoutObject = toLayoutPart(
             LayoutAPIShim::layoutObjectFrom(frame()->ownerLayoutItem()))) {
-      // A LayoutView is a containing block for fixed-position elements, so don't carry this state across frames.
+      // A LayoutView is a containing block for fixed-position elements, so
+      // don't carry this state across frames.
       parentDocLayoutObject->mapAncestorToLocal(ancestor, transformState,
                                                 mode & ~IsFixed);
 
       transformState.move(parentDocLayoutObject->contentBoxOffset());
       transformState.move(LayoutSize(-frame()->view()->scrollOffset()));
     }
   } else {
     ASSERT(!ancestor);
   }
 
   if (mode & IsFixed)
     transformState.move(LayoutSize(frame()->view()->scrollOffset()));
 }
 
 void LayoutView::computeSelfHitTestRects(Vector<LayoutRect>& rects,
                                          const LayoutPoint&) const {
-  // Record the entire size of the contents of the frame. Note that we don't just
-  // use the viewport size (containing block) here because we want to ensure this includes
-  // all children (so we can avoid walking them explicitly).
+  // Record the entire size of the contents of the frame. Note that we don't
+  // just use the viewport size (containing block) here because we want to
+  // ensure this includes all children (so we can avoid walking them
+  // explicitly).
   rects.append(
       LayoutRect(LayoutPoint::zero(), LayoutSize(frameView()->contentsSize())));
 }
 
 void LayoutView::paint(const PaintInfo& paintInfo,
                        const LayoutPoint& paintOffset) const {
   ViewPainter(*this).paint(paintInfo, paintOffset);
 }
 
 void LayoutView::paintBoxDecorationBackground(const PaintInfo& paintInfo,
@@ skipping 10 matching lines @@
   }
 }
 
 void LayoutView::setShouldDoFullPaintInvalidationForViewAndAllDescendants() {
   setShouldDoFullPaintInvalidationForViewAndAllDescendantsInternal(this);
 }
 
 void LayoutView::invalidatePaintForViewAndCompositedLayers() {
   setShouldDoFullPaintInvalidationIncludingNonCompositingDescendants();
 
-  // The only way we know how to hit these ASSERTS below this point is via the Chromium OS login screen.
+  // The only way we know how to hit these ASSERTS below this point is via the
+  // Chromium OS login screen.
   DisableCompositingQueryAsserts disabler;
 
   if (compositor()->inCompositingMode())
     compositor()->fullyInvalidatePaint();
 }
 
 bool LayoutView::mapToVisualRectInAncestorSpace(
     const LayoutBoxModelObject* ancestor,
     LayoutRect& rect,
     VisualRectFlags visualRectFlags) const {
@@ skipping 27 matching lines @@
       if (visualRectFlags & EdgeInclusive) {
         if (!rect.inclusiveIntersect(viewRectangle))
           return false;
       } else {
         rect.intersect(viewRectangle);
       }
 
       // Adjust for scroll offset of the view.
       rect.moveBy(-viewRectangle.location());
     }
-    // Frames are painted at rounded-int position. Since we cannot efficiently compute the subpixel offset
-    // of painting at this point in a a bottom-up walk, round to the enclosing int rect, which will enclose
-    // the actual visible rect.
+    // Frames are painted at rounded-int position. Since we cannot efficiently
+    // compute the subpixel offset of painting at this point in a a bottom-up
+    // walk, round to the enclosing int rect, which will enclose the actual
+    // visible rect.
     rect = LayoutRect(enclosingIntRect(rect));
 
     // Adjust for frame border.
     rect.move(obj->contentBoxOffset());
     return obj->mapToVisualRectInAncestorSpace(ancestor, rect, visualRectFlags);
   }
 
   // This can happen, e.g., if the iframe element has display:none.
   rect = LayoutRect();
   return false;
 }
 
 void LayoutView::adjustOffsetForFixedPosition(LayoutRect& rect) const {
   if (m_frameView) {
     rect.move(LayoutSize(m_frameView->scrollOffset()));
     if (hasOverflowClip())
       rect.move(scrolledContentOffset());
 
-    // FIXME: Paint invalidation should happen after scroll updates, so there should be no pending scroll delta.
-    // However, we still have paint invalidation during layout, so we can't ASSERT for now. crbug.com/434950.
+    // FIXME: Paint invalidation should happen after scroll updates, so there
+    // should be no pending scroll delta.
+    // However, we still have paint invalidation during layout, so we can't
+    // ASSERT for now. crbug.com/434950.
     // ASSERT(m_frameView->pendingScrollDelta().isZero());
     // If we have a pending scroll, invalidate the previous scroll position.
     if (!m_frameView->pendingScrollDelta().isZero())
       rect.move(-LayoutSize(m_frameView->pendingScrollDelta()));
   }
 }
 
 void LayoutView::absoluteRects(Vector<IntRect>& rects,
                                const LayoutPoint& accumulatedOffset) const {
   rects.append(
@@ skipping 31 matching lines @@
   VisitedContainingBlockSet visitedContainingBlocks;
 
   commitPendingSelection();
   LayoutObject* os = m_selectionStart;
   LayoutObject* stop =
       layoutObjectAfterPosition(m_selectionEnd, m_selectionEndPos);
   while (os && os != stop) {
     if ((os->canBeSelectionLeaf() || os == m_selectionStart ||
          os == m_selectionEnd) &&
         os->getSelectionState() != SelectionNone) {
-      // Blocks are responsible for painting line gaps and margin gaps. They must be examined as well.
+      // Blocks are responsible for painting line gaps and margin gaps. They
+      // must be examined as well.
       selRect.unite(selectionRectForLayoutObject(os));
       const LayoutBlock* cb = os->containingBlock();
       while (cb && !cb->isLayoutView()) {
         selRect.unite(selectionRectForLayoutObject(cb));
         VisitedContainingBlockSet::AddResult addResult =
             visitedContainingBlocks.add(cb);
         if (!addResult.isNewEntry)
           break;
         cb = cb->containingBlock();
       }
@@ skipping 15 matching lines @@
     if (!o->canBeSelectionLeaf() && o != m_selectionStart &&
         o != m_selectionEnd)
       continue;
     if (o->getSelectionState() == SelectionNone)
       continue;
 
     o->setShouldInvalidateSelection();
   }
 }
 
-// When exploring the LayoutTree looking for the nodes involved in the Selection, sometimes it's
-// required to change the traversing direction because the "start" position is below the "end" one.
+// When exploring the LayoutTree looking for the nodes involved in the
+// Selection, sometimes it's required to change the traversing direction because
+// the "start" position is below the "end" one.
 static inline LayoutObject* getNextOrPrevLayoutObjectBasedOnDirection(
     const LayoutObject* o,
     const LayoutObject* stop,
     bool& continueExploring,
     bool& exploringBackwards) {
   LayoutObject* next;
   if (exploringBackwards) {
     next = o->previousInPreOrder();
     continueExploring = next && !(next)->isLayoutView();
   } else {
     next = o->nextInPreOrder();
     continueExploring = next && next != stop;
     exploringBackwards = !next && (next != stop);
     if (exploringBackwards) {
       next = stop->previousInPreOrder();
       continueExploring = next && !next->isLayoutView();
     }
   }
 
   return next;
 }
 
 void LayoutView::setSelection(
     LayoutObject* start,
     int startPos,
     LayoutObject* end,
     int endPos,
     SelectionPaintInvalidationMode blockPaintInvalidationMode) {
-  // This code makes no assumptions as to if the layout tree is up to date or not
-  // and will not try to update it. Currently clearSelection calls this
+  // This code makes no assumptions as to if the layout tree is up to date or
+  // not and will not try to update it. Currently clearSelection calls this
   // (intentionally) without updating the layout tree as it doesn't care.
   // Other callers may want to force recalc style before calling this.
 
   // Make sure both our start and end objects are defined.
-  // Check www.msnbc.com and try clicking around to find the case where this happened.
+  // Check www.msnbc.com and try clicking around to find the case where this
+  // happened.
   if ((start && !end) || (end && !start))
     return;
 
   // Just return if the selection hasn't changed.
   if (m_selectionStart == start && m_selectionStartPos == startPos &&
       m_selectionEnd == end && m_selectionEndPos == endPos)
     return;
 
-  // Record the old selected objects.  These will be used later
-  // when we compare against the new selected objects.
+  // Record the old selected objects. These will be used later when we compare
+  // against the new selected objects.
   int oldStartPos = m_selectionStartPos;
   int oldEndPos = m_selectionEndPos;
 
   // Objects each have a single selection rect to examine.
   typedef HashMap<LayoutObject*, SelectionState> SelectedObjectMap;
   SelectedObjectMap oldSelectedObjects;
-  // FIXME: |newSelectedObjects| doesn't really need to store the SelectionState, it's just more convenient
-  // to have it use the same data structure as |oldSelectedObjects|.
+  // FIXME: |newSelectedObjects| doesn't really need to store the
+  // SelectionState, it's just more convenient to have it use the same data
+  // structure as |oldSelectedObjects|.
   SelectedObjectMap newSelectedObjects;
 
-  // Blocks contain selected objects and fill gaps between them, either on the left, right, or in between lines and blocks.
-  // In order to get the paint invalidation rect right, we have to examine left, middle, and right rects individually, since otherwise
-  // the union of those rects might remain the same even when changes have occurred.
+  // Blocks contain selected objects and fill gaps between them, either on the
+  // left, right, or in between lines and blocks.
+  // In order to get the paint invalidation rect right, we have to examine left,
+  // middle, and right rects individually, since otherwise the union of those
+  // rects might remain the same even when changes have occurred.
   typedef HashMap<LayoutBlock*, SelectionState> SelectedBlockMap;
   SelectedBlockMap oldSelectedBlocks;
-  // FIXME: |newSelectedBlocks| doesn't really need to store the SelectionState, it's just more convenient
-  // to have it use the same data structure as |oldSelectedBlocks|.
+  // FIXME: |newSelectedBlocks| doesn't really need to store the SelectionState,
+  // it's just more convenient to have it use the same data structure as
+  // |oldSelectedBlocks|.
   SelectedBlockMap newSelectedBlocks;
 
   LayoutObject* os = m_selectionStart;
   LayoutObject* stop =
       layoutObjectAfterPosition(m_selectionEnd, m_selectionEndPos);
   bool exploringBackwards = false;
   bool continueExploring = os && (os != stop);
   while (continueExploring) {
     if ((os->canBeSelectionLeaf() || os == m_selectionStart ||
          os == m_selectionEnd) &&
         os->getSelectionState() != SelectionNone) {
-      // Blocks are responsible for painting line gaps and margin gaps.  They must be examined as well.
+      // Blocks are responsible for painting line gaps and margin gaps.  They
+      // must be examined as well.
       oldSelectedObjects.set(os, os->getSelectionState());
       if (blockPaintInvalidationMode == PaintInvalidationNewXOROld) {
         LayoutBlock* cb = os->containingBlock();
         while (cb && !cb->isLayoutView()) {
           SelectedBlockMap::AddResult result =
               oldSelectedBlocks.add(cb, cb->getSelectionState());
           if (!result.isNewEntry)
             break;
           cb = cb->containingBlock();
         }
       }
     }
 
     os = getNextOrPrevLayoutObjectBasedOnDirection(os, stop, continueExploring,
                                                    exploringBackwards);
   }
 
   // Now clear the selection.
   SelectedObjectMap::iterator oldObjectsEnd = oldSelectedObjects.end();
   for (SelectedObjectMap::iterator i = oldSelectedObjects.begin();
        i != oldObjectsEnd; ++i)
     i->key->setSelectionStateIfNeeded(SelectionNone);
 
   // set selection start and end
   m_selectionStart = start;
   m_selectionStartPos = startPos;
   m_selectionEnd = end;
   m_selectionEndPos = endPos;
 
-  // Update the selection status of all objects between m_selectionStart and m_selectionEnd
+  // Update the selection status of all objects between m_selectionStart and
+  // m_selectionEnd
   if (start && start == end) {
     start->setSelectionStateIfNeeded(SelectionBoth);
   } else {
     if (start)
       start->setSelectionStateIfNeeded(SelectionStart);
     if (end)
       end->setSelectionStateIfNeeded(SelectionEnd);
   }
 
   LayoutObject* o = start;
   stop = layoutObjectAfterPosition(end, endPos);
 
   while (o && o != stop) {
     if (o != start && o != end && o->canBeSelectionLeaf())
       o->setSelectionStateIfNeeded(SelectionInside);
     o = o->nextInPreOrder();
   }
 
-  // Now that the selection state has been updated for the new objects, walk them again and
-  // put them in the new objects list.
+  // Now that the selection state has been updated for the new objects, walk
+  // them again and put them in the new objects list.
   o = start;
   exploringBackwards = false;
   continueExploring = o && (o != stop);
   while (continueExploring) {
     if ((o->canBeSelectionLeaf() || o == start || o == end) &&
         o->getSelectionState() != SelectionNone) {
       newSelectedObjects.set(o, o->getSelectionState());
       LayoutBlock* cb = o->containingBlock();
       while (cb && !cb->isLayoutView()) {
         SelectedBlockMap::AddResult result =
@@ skipping 18 matching lines @@
     SelectionState newSelectionState = obj->getSelectionState();
     SelectionState oldSelectionState = i->value;
     if (newSelectionState != oldSelectionState ||
         (m_selectionStart == obj && oldStartPos != m_selectionStartPos) ||
         (m_selectionEnd == obj && oldEndPos != m_selectionEndPos)) {
       obj->setShouldInvalidateSelection();
       newSelectedObjects.remove(obj);
     }
   }
 
-  // Any new objects that remain were not found in the old objects dict, and so they need to be updated.
+  // Any new objects that remain were not found in the old objects dict, and so
+  // they need to be updated.
   SelectedObjectMap::iterator newObjectsEnd = newSelectedObjects.end();
   for (SelectedObjectMap::iterator i = newSelectedObjects.begin();
        i != newObjectsEnd; ++i)
     i->key->setShouldInvalidateSelection();
 
   // Have any of the old blocks changed?
   SelectedBlockMap::iterator oldBlocksEnd = oldSelectedBlocks.end();
   for (SelectedBlockMap::iterator i = oldSelectedBlocks.begin();
        i != oldBlocksEnd; ++i) {
     LayoutBlock* block = i->key;
     SelectionState newSelectionState = block->getSelectionState();
     SelectionState oldSelectionState = i->value;
     if (newSelectionState != oldSelectionState) {
       block->setShouldInvalidateSelection();
       newSelectedBlocks.remove(block);
     }
   }
 
-  // Any new blocks that remain were not found in the old blocks dict, and so they need to be updated.
+  // Any new blocks that remain were not found in the old blocks dict, and so
+  // they need to be updated.
   SelectedBlockMap::iterator newBlocksEnd = newSelectedBlocks.end();
   for (SelectedBlockMap::iterator i = newSelectedBlocks.begin();
        i != newBlocksEnd; ++i)
     i->key->setShouldInvalidateSelection();
 }
 
 void LayoutView::clearSelection() {
   // For querying Layer::compositingState()
-  // This is correct, since destroying layout objects needs to cause eager paint invalidations.
+  // This is correct, since destroying layout objects needs to cause eager paint
+  // invalidations.
   DisableCompositingQueryAsserts disabler;
 
   setSelection(0, -1, 0, -1, PaintInvalidationNewMinusOld);
 }
 
 bool LayoutView::hasPendingSelection() const {
   return m_frameView->frame().selection().isAppearanceDirty();
 }
 
 void LayoutView::commitPendingSelection() {
@@ skipping 129 matching lines @@
   if (!m_compositor)
     m_compositor = wrapUnique(new PaintLayerCompositor(*this));
 
   return m_compositor.get();
 }
 
 void LayoutView::setIsInWindow(bool isInWindow) {
   if (m_compositor)
     m_compositor->setIsInWindow(isInWindow);
 #if CHECK_DISPLAY_ITEM_CLIENT_ALIVENESS
-  // We don't invalidate layers during Document::detachLayoutTree(), so must clear the should-keep-alive
-  // DisplayItemClients which may be deleted before the layers being subsequence owners.
+  // We don't invalidate layers during Document::detachLayoutTree(), so must
+  // clear the should-keep-alive DisplayItemClients which may be deleted before
+  // the layers being subsequence owners.
   if (!isInWindow && layer())
     layer()->endShouldKeepAliveAllClientsRecursive();
 #endif
 }
 
 IntervalArena* LayoutView::intervalArena() {
   if (!m_intervalArena)
     m_intervalArena = IntervalArena::create();
   return m_intervalArena.get();
 }
@@ skipping 72 matching lines @@
   if (block)
     block->adjustChildDebugRect(rect);
 
   rect.setWidth(LayoutUnit(viewWidth(IncludeScrollbars)));
   rect.setHeight(LayoutUnit(viewHeight(IncludeScrollbars)));
 
   return rect;
 }
 
 }  // namespace blink