reflow comments in core/paint

third_party/WebKit/Source/core/paint/PaintLayerScrollableArea.h

 /*
  * Copyright (C) 2003, 2009, 2012 Apple Inc. All rights reserved.
  *
  * Portions are Copyright (C) 1998 Netscape Communications Corporation.
  *
  * Other contributors:
  *   Robert O'Callahan <roc+@cs.cmu.edu>
  *   David Baron <dbaron@fas.harvard.edu>
  *   Christian Biesinger <cbiesinger@web.de>
  *   Randall Jesup <rjesup@wgate.com>
  *   Roland Mainz <roland.mainz@informatik.med.uni-giessen.de>
  *   Josh Soref <timeless@mac.com>
  *   Boris Zbarsky <bzbarsky@mit.edu>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 2.1 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
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
  *
  * Alternatively, the contents of this file may be used under the terms
  * of either the Mozilla Public License Version 1.1, found at
  * http://www.mozilla.org/MPL/ (the "MPL") or the GNU General Public
  * License Version 2.0, found at http://www.fsf.org/copyleft/gpl.html
  * (the "GPL"), in which case the provisions of the MPL or the GPL are
  * applicable instead of those above.  If you wish to allow use of your
  * version of this file only under the terms of one of those two
  * licenses (the MPL or the GPL) and not to allow others to use your
  * version of this file under the LGPL, indicate your decision by
@@ skipping 80 matching lines @@
 class CORE_EXPORT PaintLayerScrollableArea final
     : public GarbageCollectedFinalized<PaintLayerScrollableArea>,
       public PaintInvalidationCapableScrollableArea {
   USING_GARBAGE_COLLECTED_MIXIN(PaintLayerScrollableArea);
   friend class Internals;
 
  private:
   class ScrollbarManager {
     DISALLOW_NEW();
 
-    // Helper class to manage the life cycle of Scrollbar objects.  Some layout containers
-    // (e.g., flexbox, table) run multi-pass layout on their children, applying different
-    // constraints.  If a child has overflow:auto, it may gain and lose scrollbars multiple
-    // times during multi-pass layout, causing pointless allocation/deallocation thrashing,
-    // and potentially leading to other problems (crbug.com/528940).
+    // Helper class to manage the life cycle of Scrollbar objects.  Some layout
+    // containers (e.g., flexbox, table) run multi-pass layout on their
+    // children, applying different constraints.  If a child has overflow:auto,
+    // it may gain and lose scrollbars multiple times during multi-pass layout,
+    // causing pointless allocation/deallocation thrashing, and potentially
+    // leading to other problems (crbug.com/528940).
 
-    // ScrollbarManager allows a ScrollableArea to delay the destruction of a scrollbar that
-    // is no longer needed, until the end of multi-pass layout.  If the scrollbar is then
-    // re-added before multi-pass layout finishes, the previously "deleted" scrollbar will
-    // be restored, rather than constructing a new one.
+    // ScrollbarManager allows a ScrollableArea to delay the destruction of a
+    // scrollbar that is no longer needed, until the end of multi-pass layout.
+    // If the scrollbar is then re-added before multi-pass layout finishes, the
+    // previously "deleted" scrollbar will be restored, rather than constructing
+    // a new one.
    public:
     ScrollbarManager(PaintLayerScrollableArea&);
 
     void dispose();
 
     Scrollbar* horizontalScrollbar() const {
       return m_hBarIsAttached ? m_hBar.get() : nullptr;
     }
     Scrollbar* verticalScrollbar() const {
       return m_vBarIsAttached ? m_vBar.get() : nullptr;
@@ skipping 59 matching lines @@
    public:
     FreezeScrollbarsScope() { s_count++; }
     ~FreezeScrollbarsScope() { s_count--; }
 
     static bool scrollbarsAreFrozen() { return s_count; }
 
    private:
     static int s_count;
   };
 
-  // If a DelayScrollPositionClampScope object is alive, updateAfterLayout() will not
-  // clamp scroll positions to ensure they are in the valid range.  When
-  // the last DelayScrollPositionClampScope object is destructed, all PaintLayerScrollableArea's
-  // that delayed clamping their positions will immediately clamp them.
+  // If a DelayScrollPositionClampScope object is alive, updateAfterLayout()
+  // will not clamp scroll positions to ensure they are in the valid range.
+  // When the last DelayScrollPositionClampScope object is destructed, all
+  // PaintLayerScrollableArea's that delayed clamping their positions will
+  // immediately clamp them.
   class DelayScrollPositionClampScope {
     STACK_ALLOCATED();
 
    public:
     DelayScrollPositionClampScope();
     ~DelayScrollPositionClampScope();
 
     static bool clampingIsDelayed() { return s_count; }
     static void setNeedsClamp(PaintLayerScrollableArea*);
 
@@ skipping 96 matching lines @@
       ScrollType scrollType,
       ScrollBehavior scrollBehavior = ScrollBehaviorInstant) override {
     scrollToOffset(toDoubleSize(position), scrollBehavior, scrollType);
   }
 
   // This will set the scroll position without clamping, and it will do all
   // post-update work even if the scroll position didn't change.
   void setScrollPositionUnconditionally(const DoublePoint&,
                                         ScrollType = ProgrammaticScroll);
 
-  // TODO(szager): Actually run these after all of layout is finished.  Currently, they
-  // run at the end of box()'es layout (or after all flexbox layout has finished) but while
-  // document layout is still happening.
+  // TODO(szager): Actually run these after all of layout is finished.
+  // Currently, they run at the end of box()'es layout (or after all flexbox
+  // layout has finished) but while document layout is still happening.
   void updateAfterLayout();
   void clampScrollPositionsAfterLayout();
 
   void updateAfterStyleChange(const ComputedStyle*);
   void updateAfterOverflowRecalc();
 
   bool updateAfterCompositingChange() override;
 
   bool hasScrollbar() const {
     return hasHorizontalScrollbar() || hasVerticalScrollbar();
@@ skipping 23 matching lines @@
       OverlayScrollbarClipBehavior = IgnoreOverlayScrollbarSize) const;
   int horizontalScrollbarHeight(
       OverlayScrollbarClipBehavior = IgnoreOverlayScrollbarSize) const;
 
   DoubleSize adjustedScrollOffset() const {
     return toDoubleSize(DoublePoint(scrollOrigin()) + m_scrollOffset);
   }
 
   void positionOverflowControls();
 
-  // isPointInResizeControl() is used for testing if a pointer/touch position is in the resize control
-  // area.
+  // isPointInResizeControl() is used for testing if a pointer/touch position is
+  // in the resize control area.
   bool isPointInResizeControl(const IntPoint& absolutePoint,
                               ResizerHitTestType) const;
   bool hitTestOverflowControls(HitTestResult&, const IntPoint& localPoint);
 
   bool hitTestResizerInFragments(const PaintLayerFragments&,
                                  const HitTestLocation&) const;
 
   // Returns the new position, after scrolling, of the given rect in absolute
   // coordinates, clipped by the parent's client rect.
   LayoutRect scrollIntoView(const LayoutRect&,
                             const ScrollAlignment& alignX,
                             const ScrollAlignment& alignY,
                             ScrollType = ProgrammaticScroll) override;
 
-  // Returns true if scrollable area is in the FrameView's collection of scrollable areas. This can
-  // only happen if we're scrollable, visible to hit test, and do in fact overflow. This means that
-  // 'overflow: hidden' or 'pointer-events: none' layers never get added to the FrameView's collection.
+  // Returns true if scrollable area is in the FrameView's collection of
+  // scrollable areas. This can only happen if we're scrollable, visible to hit
+  // test, and do in fact overflow. This means that 'overflow: hidden' or
+  // 'pointer-events: none' layers never get added to the FrameView's
+  // collection.
   bool scrollsOverflow() const { return m_scrollsOverflow; }
 
   // Rectangle encompassing the scroll corner and resizer rect.
   IntRect scrollCornerAndResizerRect() const final;
 
   enum LCDTextMode { ConsiderLCDText, IgnoreLCDText };
 
   void updateNeedsCompositedScrolling(LCDTextMode = ConsiderLCDText);
   bool needsCompositedScrolling() const { return m_needsCompositedScrolling; }
 
@@ skipping 31 matching lines @@
   LayoutBox* layoutBox() const override { return &box(); }
 
   bool shouldRebuildHorizontalScrollbarLayer() const {
     return m_rebuildHorizontalScrollbarLayer;
   }
   bool shouldRebuildVerticalScrollbarLayer() const {
     return m_rebuildVerticalScrollbarLayer;
   }
   void resetRebuildScrollbarLayerFlags();
 
-  // Did DelayScrollPositionClampScope prevent us from running clampScrollPositionsAfterLayout()
+  // Did DelayScrollPositionClampScope prevent us from running
+  // clampScrollPositionsAfterLayout()
   // in updateAfterLayout()?
   bool needsScrollPositionClamp() const { return m_needsScrollPositionClamp; }
   void setNeedsScrollPositionClamp(bool val) {
     m_needsScrollPositionClamp = val;
   }
 
-  // Did PreventRelayoutScope prevent us from running re-layout due to adding/subtracting
-  // scrollbars in updateAfterLayout()?
+  // Did PreventRelayoutScope prevent us from running re-layout due to
+  // adding/subtracting scrollbars in updateAfterLayout()?
   bool needsRelayout() const { return m_needsRelayout; }
   void setNeedsRelayout(bool val) { m_needsRelayout = val; }
 
   // Were we laid out with a horizontal scrollbar at the time we were marked as
   // needing relayout by PreventRelayoutScope?
   bool hadHorizontalScrollbarBeforeRelayout() const {
     return m_hadHorizontalScrollbarBeforeRelayout;
   }
   void setHadHorizontalScrollbarBeforeRelayout(bool val) {
     m_hadHorizontalScrollbarBeforeRelayout = val;
@@ skipping 58 matching lines @@
     if (!m_rareData)
       m_rareData = wrapUnique(new PaintLayerScrollableAreaRareData());
     return *m_rareData.get();
   }
 
   PaintLayer& m_layer;
 
   PaintLayer* m_nextTopmostScrollChild;
   PaintLayer* m_topmostScrollChild;
 
-  // Keeps track of whether the layer is currently resizing, so events can cause resizing to start and stop.
+  // Keeps track of whether the layer is currently resizing, so events can cause
+  // resizing to start and stop.
   unsigned m_inResizeMode : 1;
   unsigned m_scrollsOverflow : 1;
 
   unsigned m_inOverflowRelayout : 1;
 
   // FIXME: once cc can handle composited scrolling with clip paths, we will
   // no longer need this bit.
   unsigned m_needsCompositedScrolling : 1;
 
   // Set to indicate that a scrollbar layer, if present, needs to be rebuilt
@@ skipping 38 matching lines @@
 
 DEFINE_TYPE_CASTS(PaintLayerScrollableArea,
                   ScrollableArea,
                   scrollableArea,
                   scrollableArea->isPaintLayerScrollableArea(),
                   scrollableArea.isPaintLayerScrollableArea());
 
 }  // namespace blink
 
 #endif  // LayerScrollableArea_h