reflow comments in core/frame

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

 /*
    Copyright (C) 1997 Martin Jones (mjones@kde.org)
              (C) 1998 Waldo Bastian (bastian@kde.org)
              (C) 1998, 1999 Torben Weis (weis@kde.org)
              (C) 1999 Lars Knoll (knoll@kde.org)
              (C) 1999 Antti Koivisto (koivisto@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 125 matching lines @@
                                  bool& isPartial);
 
   bool needsLayout() const;
   bool checkDoesNotNeedLayout() const;
   void setNeedsLayout();
 
   void setNeedsUpdateWidgetGeometries() {
     m_needsUpdateWidgetGeometries = true;
   }
 
-  // Methods for getting/setting the size Blink should use to layout the contents.
-  // NOTE: Scrollbar exclusion is based on the FrameView's scrollbars. To exclude
-  // scrollbars on the root PaintLayer, use LayoutView::layoutSize.
+  // Methods for getting/setting the size Blink should use to layout the
+  // contents.
+  // NOTE: Scrollbar exclusion is based on the FrameView's scrollbars. To
+  // exclude scrollbars on the root PaintLayer, use LayoutView::layoutSize.
   IntSize layoutSize(IncludeScrollbarsInRect = ExcludeScrollbars) const;
   void setLayoutSize(const IntSize&);
 
-  // If this is set to false, the layout size will need to be explicitly set by the owner.
-  // E.g. WebViewImpl sets its mainFrame's layout size manually
+  // If this is set to false, the layout size will need to be explicitly set by
+  // the owner.  E.g. WebViewImpl sets its mainFrame's layout size manually
   void setLayoutSizeFixedToFrameSize(bool isFixed) {
     m_layoutSizeFixedToFrameSize = isFixed;
   }
   bool layoutSizeFixedToFrameSize() { return m_layoutSizeFixedToFrameSize; }
 
   void updateAcceleratedCompositingSettings();
 
   void recalcOverflowAfterStyleChange();
 
   bool isEnclosedInCompositingLayer() const;
 
   void dispose() override;
   void detachScrollbars();
   void recalculateCustomScrollbarStyle();
   void invalidateAllCustomScrollbarsOnActiveChanged();
 
   void clear();
 
   bool isTransparent() const;
   void setTransparent(bool isTransparent);
 
-  // True if the FrameView is not transparent, and the base background color is opaque.
+  // True if the FrameView is not transparent, and the base background color is
+  // opaque.
   bool hasOpaqueBackground() const;
 
   Color baseBackgroundColor() const;
   void setBaseBackgroundColor(const Color&);
   void updateBackgroundRecursively(const Color&, bool);
 
   void adjustViewSize();
   void adjustViewSizeAndLayout();
 
   // Scale used to convert incoming input events.
@@ skipping 58 matching lines @@
 
   void addPart(LayoutPart*);
   void removePart(LayoutPart*);
 
   void updateWidgetGeometries();
 
   void addPartToUpdate(LayoutEmbeddedObject&);
 
   Color documentBackgroundColor() const;
 
-  // Run all needed lifecycle stages. After calling this method, all frames will be in the lifecycle state PaintInvalidationClean.
-  // If lifecycle throttling is allowed (see DocumentLifecycle::AllowThrottlingScope), some frames may skip the lifecycle update
-  // (e.g., based on visibility) and will not end up being PaintInvalidationClean.
+  // Run all needed lifecycle stages. After calling this method, all frames will
+  // be in the lifecycle state PaintInvalidationClean.  If lifecycle throttling
+  // is allowed (see DocumentLifecycle::AllowThrottlingScope), some frames may
+  // skip the lifecycle update (e.g., based on visibility) and will not end up
+  // being PaintInvalidationClean.
   void updateAllLifecyclePhases();
 
   // Everything except paint (the last phase).
   void updateAllLifecyclePhasesExceptPaint();
 
-  // Computes the style, layout and compositing lifecycle stages if needed. After calling this method, all frames will be in a lifecycle
-  // state >= CompositingClean, and scrolling has been updated (unless throttling is allowed).
+  // Computes the style, layout and compositing lifecycle stages if needed.
+  // After calling this method, all frames will be in a lifecycle
+  // state >= CompositingClean, and scrolling has been updated (unless
+  // throttling is allowed).
   void updateLifecycleToCompositingCleanPlusScrolling();
 
   // Computes only the style and layout lifecycle stages.
-  // After calling this method, all frames will be in a lifecycle state >= LayoutClean (unless throttling is allowed).
+  // After calling this method, all frames will be in a lifecycle
+  // state >= LayoutClean (unless throttling is allowed).
   void updateLifecycleToLayoutClean();
 
   void scheduleVisualUpdateForPaintInvalidationIfNeeded();
 
   bool invalidateViewportConstrainedObjects();
 
   void incrementLayoutObjectCount() { m_layoutObjectCounter.increment(); }
   void incrementVisuallyNonEmptyCharacterCount(unsigned);
   void incrementVisuallyNonEmptyPixelCount(const IntSize&);
   bool isVisuallyNonEmpty() const { return m_isVisuallyNonEmpty; }
   void setIsVisuallyNonEmpty() { m_isVisuallyNonEmpty = true; }
   void enableAutoSizeMode(const IntSize& minSize, const IntSize& maxSize);
   void disableAutoSizeMode();
 
   void forceLayoutForPagination(const FloatSize& pageSize,
                                 const FloatSize& originalPageSize,
                                 float maximumShrinkFactor);
 
   enum UrlFragmentBehavior { UrlFragmentScroll, UrlFragmentDontScroll };
   // Updates the fragment anchor element based on URL's fragment identifier.
   // Updates corresponding ':target' CSS pseudo class on the anchor element.
   // If |UrlFragmentScroll| is passed in then makes the anchor element
   // focused and also visible by scrolling to it. The scroll position is
   // maintained during the frame loading process.
   void processUrlFragment(const KURL&, UrlFragmentBehavior = UrlFragmentScroll);
   void clearFragmentAnchor();
 
-  // Methods to convert points and rects between the coordinate space of the layoutObject, and this view.
+  // Methods to convert points and rects between the coordinate space of the
+  // layoutObject, and this view.
   IntRect convertFromLayoutObject(const LayoutObject&, const IntRect&) const;
   IntRect convertToLayoutObject(const LayoutObject&, const IntRect&) const;
   IntPoint convertFromLayoutObject(const LayoutObject&, const IntPoint&) const;
   IntPoint convertToLayoutObject(const LayoutObject&, const IntPoint&) const;
 
   bool isFrameViewScrollCorner(LayoutScrollbarPart* scrollCorner) const {
     return m_scrollCorner == scrollCorner;
   }
 
   enum ScrollingReasons {
@@ skipping 45 matching lines @@
   const ScrollableAreaSet* scrollableAreas() const {
     return m_scrollableAreas.get();
   }
 
   void addAnimatingScrollableArea(ScrollableArea*);
   void removeAnimatingScrollableArea(ScrollableArea*);
   const ScrollableAreaSet* animatingScrollableAreas() const {
     return m_animatingScrollableAreas.get();
   }
 
-  // With CSS style "resize:" enabled, a little resizer handle will appear at the bottom
-  // right of the object. We keep track of these resizer areas for checking if touches
-  // (implemented using Scroll gesture) are targeting the resizer.
+  // With CSS style "resize:" enabled, a little resizer handle will appear at
+  // the bottom right of the object. We keep track of these resizer areas for
+  // checking if touches (implemented using Scroll gesture) are targeting the
+  // resizer.
   typedef HashSet<LayoutBox*> ResizerAreaSet;
   void addResizerArea(LayoutBox&);
   void removeResizerArea(LayoutBox&);
   const ResizerAreaSet* resizerAreas() const { return m_resizerAreas.get(); }
 
   bool shouldUseIntegerScrollOffset() const override;
 
   bool isActive() const override;
 
   // Override scrollbar notifications to update the AXObject cache.
@@ skipping 40 matching lines @@
   bool shouldPlaceVerticalScrollbarOnLeft() const override;
   Widget* getWidget() override;
   CompositorAnimationTimeline* compositorAnimationTimeline() const override;
   LayoutBox* layoutBox() const override;
 
   LayoutRect scrollIntoView(const LayoutRect& rectInContent,
                             const ScrollAlignment& alignX,
                             const ScrollAlignment& alignY,
                             ScrollType = ProgrammaticScroll) override;
 
-  // The window that hosts the FrameView. The FrameView will communicate scrolls and repaints to the
-  // host window in the window's coordinate space.
+  // The window that hosts the FrameView. The FrameView will communicate scrolls
+  // and repaints to the host window in the window's coordinate space.
   HostWindow* getHostWindow() const;
 
   typedef HeapHashSet<Member<Widget>> ChildrenWidgetSet;
 
   // Functions for child manipulation and inspection.
   void setParent(Widget*) override;
   void removeChild(Widget*);
   void addChild(Widget*);
   const ChildrenWidgetSet* children() const { return &m_children; }
 
-  // If the scroll view does not use a native widget, then it will have cross-platform Scrollbars. These functions
-  // can be used to obtain those scrollbars.
+  // If the scroll view does not use a native widget, then it will have
+  // cross-platform Scrollbars. These functions can be used to obtain those
+  // scrollbars.
   Scrollbar* horizontalScrollbar() const override {
     return m_horizontalScrollbar.get();
   }
   Scrollbar* verticalScrollbar() const override {
     return m_verticalScrollbar.get();
   }
   LayoutScrollbarPart* scrollCorner() const override { return m_scrollCorner; }
 
   void positionScrollbarLayers();
 
-  // Functions for setting and retrieving the scrolling mode in each axis (horizontal/vertical). The mode has values of
-  // AlwaysOff, AlwaysOn, and Auto. AlwaysOff means never show a scrollbar, AlwaysOn means always show a scrollbar.
-  // Auto means show a scrollbar only when one is needed.
-  // Note that for platforms with native widgets, these modes are considered advisory. In other words the underlying native
-  // widget may choose not to honor the requested modes.
+  // Functions for setting and retrieving the scrolling mode in each axis
+  // (horizontal/vertical). The mode has values of AlwaysOff, AlwaysOn, and
+  // Auto. AlwaysOff means never show a scrollbar, AlwaysOn means always show a
+  // scrollbar.  Auto means show a scrollbar only when one is needed.
+  // Note that for platforms with native widgets, these modes are considered
+  // advisory. In other words the underlying native widget may choose not to
+  // honor the requested modes.
   void setScrollbarModes(ScrollbarMode horizontalMode,
                          ScrollbarMode verticalMode,
                          bool horizontalLock = false,
                          bool verticalLock = false);
   void setHorizontalScrollbarMode(ScrollbarMode mode, bool lock = false) {
     setScrollbarModes(mode, verticalScrollbarMode(), lock,
                       verticalScrollbarLock());
   }
   void setVerticalScrollbarMode(ScrollbarMode mode, bool lock = false) {
     setScrollbarModes(horizontalScrollbarMode(), mode,
@@ skipping 30 matching lines @@
   // rectangle, but an optional boolean argument allows them to be included.
   IntRect visibleContentRect(
       IncludeScrollbarsInRect = ExcludeScrollbars) const override;
   IntSize visibleContentSize(IncludeScrollbarsInRect = ExcludeScrollbars) const;
 
   // Clips the provided rect to the visible content area. For this purpose, we
   // also query the chrome client for any active overrides to the visible area
   // (e.g. DevTool's viewport override).
   void clipPaintRect(FloatRect*) const;
 
-  // Functions for getting/setting the size of the document contained inside the FrameView (as an IntSize or as individual width and height
-  // values).
-  IntSize contentsSize() const
-      override;  // Always at least as big as the visibleWidth()/visibleHeight().
+  // Functions for getting/setting the size of the document contained inside the
+  // FrameView (as an IntSize or as individual width and height values).
+  IntSize contentsSize() const override;  // Always at least as big as the
+                                          // visibleWidth()/visibleHeight().

[dcheng, 2016/10/06 02:43:13]

Nit: own line?

[Nico, 2016/10/06 03:22:09]

Done.

   int contentsWidth() const { return contentsSize().width(); }
   int contentsHeight() const { return contentsSize().height(); }
 
-  // Functions for querying the current scrolled position (both as a point, a size, or as individual X and Y values).
-  // Be careful in using the Double version scrollPositionDouble() and scrollOffsetDouble(). They are meant to be
-  // used to communicate the fractional scroll position/offset with chromium compositor which can do sub-pixel positioning.
-  // Do not call these if the scroll position/offset is used in Blink for positioning. Use the Int version instead.
+  // Functions for querying the current scrolled position (both as a point, a
+  // size, or as individual X and Y values).  Be careful in using the Double
+  // version scrollPositionDouble() and scrollOffsetDouble(). They are meant to
+  // be used to communicate the fractional scroll position/offset with chromium
+  // compositor which can do sub-pixel positioning.  Do not call these if the
+  // scroll position/offset is used in Blink for positioning. Use the Int
+  // version instead.
   IntPoint scrollPosition() const override {
     return visibleContentRect().location();
   }
   DoublePoint scrollPositionDouble() const override { return m_scrollPosition; }
+  // Gets the scrolled position as an IntSize. Convenient for adding to other
+  // sizes.
   IntSize scrollOffset() const {
     return toIntSize(visibleContentRect().location());
-  }  // Gets the scrolled position as an IntSize. Convenient for adding to other sizes.
+  }
   DoubleSize scrollOffsetDouble() const {
     return DoubleSize(m_scrollPosition.x(), m_scrollPosition.y());
   }
   DoubleSize pendingScrollDelta() const { return m_pendingScrollDelta; }
-  IntPoint minimumScrollPosition()
-      const override;  // The minimum position we can be scrolled to.
+  // The minimum position we can be scrolled to.
+  IntPoint minimumScrollPosition() const override;
   int scrollX() const { return scrollPosition().x(); }
   int scrollY() const { return scrollPosition().y(); }
 
-  // Scroll the actual contents of the view (either blitting or invalidating as needed).
+  // Scroll the actual contents of the view (either blitting or invalidating as
+  // needed).
   void scrollContents(const IntSize& scrollDelta);
 
-  // This gives us a means of blocking updating our scrollbars until the first layout has occurred.
+  // This gives us a means of blocking updating our scrollbars until the first
+  // layout has occurred.
   void setScrollbarsSuppressed(bool suppressed) {
     m_scrollbarsSuppressed = suppressed;
   }
   bool scrollbarsSuppressed() const { return m_scrollbarsSuppressed; }
 
   // Methods for converting between this frame and other coordinate spaces.
   // For definitions and an explanation of the varous spaces, please see:
   // http://www.chromium.org/developers/design-documents/blink-coordinate-spaces
   IntPoint rootFrameToContents(const IntPoint&) const;
   FloatPoint rootFrameToContents(const FloatPoint&) const;
   IntRect rootFrameToContents(const IntRect&) const;
   IntPoint contentsToRootFrame(const IntPoint&) const;
   IntRect contentsToRootFrame(const IntRect&) const;
 
   IntRect viewportToContents(const IntRect&) const;
   IntRect contentsToViewport(const IntRect&) const;
   IntPoint contentsToViewport(const IntPoint&) const;
   IntPoint viewportToContents(const IntPoint&) const;
 
   // FIXME: Some external callers expect to get back a rect that's positioned
   // in viewport space, but sized in CSS pixels. This is an artifact of the
   // old pinch-zoom path. These callers should be converted to expect a rect
   // fully in viewport space. crbug.com/459591.
   IntRect soonToBeRemovedContentsToUnscaledViewport(const IntRect&) const;
   IntPoint soonToBeRemovedUnscaledViewportToContents(const IntPoint&) const;
 
-  // Methods for converting between Frame and Content (i.e. Document) coordinates.
-  // Frame coordinates are relative to the top left corner of the frame and so
-  // they are affected by scroll offset. Content coordinates are relative to the
-  // document's top left corner and thus are not affected by scroll offset.
+  // Methods for converting between Frame and Content (i.e. Document)
+  // coordinates.  Frame coordinates are relative to the top left corner of the
+  // frame and so they are affected by scroll offset. Content coordinates are
+  // relative to the document's top left corner and thus are not affected by
+  // scroll offset.
   IntPoint contentsToFrame(const IntPoint&) const;
   IntRect contentsToFrame(const IntRect&) const;
   IntPoint frameToContents(const IntPoint&) const;
   FloatPoint frameToContents(const FloatPoint&) const;
   IntRect frameToContents(const IntRect&) const;
 
   // Functions for converting to screen coordinates.
   IntRect contentsToScreen(const IntRect&) const;
 
-  // These functions are used to enable scrollbars to avoid window resizer controls that overlap the scroll view.
-  // This happens only on Mac OS X 10.6.
+  // These functions are used to enable scrollbars to avoid window resizer
+  // controls that overlap the scroll view.  This happens only on Mac OS X 10.6.
   IntRect windowResizerRect() const;
   bool containsScrollbarsAvoidingResizer() const;
   void adjustScrollbarsAvoidingResizerCount(int overlapDelta);
   void windowResizerRectChanged();
 
-  // For platforms that need to hit test scrollbars from within the engine's event handlers (like Win32).
+  // For platforms that need to hit test scrollbars from within the engine's
+  // event handlers (like Win32).
   Scrollbar* scrollbarAtFramePoint(const IntPoint&);
 
   IntPoint convertChildToSelf(const Widget* child,
                               const IntPoint& point) const override {
     IntPoint newPoint = point;
     if (!isFrameViewScrollbar(child))
       newPoint = contentsToFrame(point);
     newPoint.moveBy(child->location());
     return newPoint;
   }
 
   IntPoint convertSelfToChild(const Widget* child,
                               const IntPoint& point) const override {
     IntPoint newPoint = point;
     if (!isFrameViewScrollbar(child))
       newPoint = frameToContents(point);
     newPoint.moveBy(-child->location());
     return newPoint;
   }
 
-  // Widget override. Handles painting of the contents of the view as well as the scrollbars.
+  // Widget override. Handles painting of the contents of the view as well as
+  // the scrollbars.
   void paint(GraphicsContext&, const CullRect&) const override;
   void paint(GraphicsContext&, const GlobalPaintFlags, const CullRect&) const;
   void paintContents(GraphicsContext&,
                      const GlobalPaintFlags,
                      const IntRect& damageRect) const;
 
-  // Widget overrides to ensure that our children's visibility status is kept up to date when we get shown and hidden.
+  // Widget overrides to ensure that our children's visibility status is kept up
+  // to date when we get shown and hidden.
   void show() override;
   void hide() override;
   void setParentVisible(bool) override;
 
   bool isPointInScrollbarCorner(const IntPoint&);
   bool scrollbarCornerPresent() const;
   IntRect scrollCornerRect() const override;
 
   IntRect convertFromScrollbarToContainingWidget(const Scrollbar&,
                                                  const IntRect&) const override;
@@ skipping 34 matching lines @@
   LayoutAnalyzer* layoutAnalyzer() { return m_analyzer.get(); }
 
   // Returns true if this frame should not render or schedule visual updates.
   bool shouldThrottleRendering() const;
 
   // Returns true if this frame could potentially skip rendering and avoid
   // scheduling visual updates.
   bool canThrottleRendering() const;
   bool isHiddenForThrottling() const { return m_hiddenForThrottling; }
 
-  // For testing, run pending intersection observer notifications for this frame.
+  // For testing, run pending intersection observer notifications for this
+  // frame.
   void notifyRenderThrottlingObserversForTesting();
 
   // Paint properties for SPv2 Only.
   void setPreTranslation(
       PassRefPtr<TransformPaintPropertyNode> preTranslation) {
     m_preTranslation = preTranslation;
   }
   TransformPaintPropertyNode* preTranslation() const {
     return m_preTranslation.get();
   }
@@ skipping 30 matching lines @@
   // TODO(ojan): Merge this with IntersectionObserver once it lands.
   IntRect computeVisibleArea();
 
   // Viewport size that should be used for viewport units (i.e. 'vh'/'vw').
   FloatSize viewportSizeForViewportUnits() const;
 
   ScrollAnchor* scrollAnchor() override { return &m_scrollAnchor; }
   void clearScrollAnchor();
   bool shouldPerformScrollAnchoring() const override;
 
-  // For PaintInvalidator temporarily. TODO(wangxianzhu): Move into PaintInvalidator.
+  // For PaintInvalidator temporarily. TODO(wangxianzhu): Move into
+  // PaintInvalidator.
   void invalidatePaintIfNeeded(const PaintInvalidationState&);
 
   // Only for SPv2.
   std::unique_ptr<JSONObject> compositedLayersAsJSON(LayerTreeFlags);
 
  protected:
   // Scroll the content via the compositor.
   bool scrollContentsFastPath(const IntSize& scrollDelta);
 
   // Scroll the content by invalidating everything.
   void scrollContentsSlowPath();
 
   // These functions are used to create/destroy scrollbars.
   void setHasHorizontalScrollbar(bool);
   void setHasVerticalScrollbar(bool);
 
   ScrollBehavior scrollBehaviorStyle() const override;
 
   void scrollContentsIfNeeded();
 
   enum ComputeScrollbarExistenceOption { FirstPass, Incremental };
   void computeScrollbarExistence(
       bool& newHasHorizontalScrollbar,
       bool& newHasVerticalScrollbar,
       const IntSize& docSize,
       ComputeScrollbarExistenceOption = FirstPass) const;
   void updateScrollbarGeometry();
   IntRect adjustScrollbarRectForResizer(const IntRect&, Scrollbar&);
 
-  // Called to update the scrollbars to accurately reflect the state of the view.
+  // Called to update the scrollbars to accurately reflect the state of the
+  // view.
   void updateScrollbars();
   void updateScrollbarsIfNeeded();
 
   class InUpdateScrollbarsScope {
     STACK_ALLOCATED();
 
    public:
     explicit InUpdateScrollbarsScope(FrameView* view)
         : m_scope(&view->m_inUpdateScrollbars, true) {}
 
@@ skipping 22 matching lines @@
   void updateStyleAndLayoutIfNeededRecursiveInternal();
   void invalidateTreeIfNeededRecursiveInternal();
 
   void pushPaintArtifactToCompositor();
 
   void reset();
   void init();
 
   void clearLayoutSubtreeRootsAndMarkContainingBlocks();
 
-  // Called when our frame rect changes (or the rect/scroll position of an ancestor changes).
+  // Called when our frame rect changes (or the rect/scroll position of an
+  // ancestor changes).
   void frameRectsChanged() override;
 
   bool contentsInCompositedLayer() const;
 
   void calculateScrollbarModesFromOverflowStyle(const ComputedStyle*,
                                                 ScrollbarMode& hMode,
                                                 ScrollbarMode& vMode);
 
   void updateCounters();
   void forceLayoutParentViewIfNeeded();
   void performPreLayoutTasks();
   void performLayout(bool inSubtreeLayout);
   void scheduleOrPerformPostLayoutTasks();
   void performPostLayoutTasks();
 
   DocumentLifecycle& lifecycle() const;
 
   void contentsResized() override;
   void scrollbarExistenceDidChange();
 
-  // Override Widget methods to do point conversion via layoutObjects, in order to
-  // take transforms into account.
+  // Override Widget methods to do point conversion via layoutObjects, in order
+  // to take transforms into account.
   IntRect convertToContainingWidget(const IntRect&) const override;
   IntRect convertFromContainingWidget(const IntRect&) const override;
   IntPoint convertToContainingWidget(const IntPoint&) const override;
   IntPoint convertFromContainingWidget(const IntPoint&) const override;
 
   void updateWidgetGeometriesIfNeeded();
 
   bool wasViewportResized();
   void sendResizeEventIfNeeded();
 
   void updateScrollableAreaSet();
 
   void scheduleUpdateWidgetsIfNecessary();
   void updateWidgetsTimerFired(TimerBase*);
   bool updateWidgets();
 
   bool processUrlFragmentHelper(const String&, UrlFragmentBehavior);
   void setFragmentAnchor(Node*);
   void scrollToFragmentAnchor();
   void didScrollTimerFired(TimerBase*);
 
   void updateLayersAndCompositingAfterScrollIfNeeded(
       const DoubleSize& scrollDelta);
 
   static bool computeCompositedSelection(LocalFrame&, CompositedSelection&);
   void updateCompositedSelectionIfNeeded();
 
-  // Returns true if the FrameView's own scrollbars overlay its content when visible.
+  // Returns true if the FrameView's own scrollbars overlay its content when
+  // visible.
   bool hasOverlayScrollbars() const;
 
   // Returns true if the frame should use custom scrollbars. If true, one of
   // either |customScrollbarElement| or |customScrollbarFrame| will be set to
   // the element or frame which owns the scrollbar with the other set to null.
   bool shouldUseCustomScrollbars(Element*& customScrollbarElement,
                                  LocalFrame*& customScrollbarFrame) const;
 
-  // Returns true if a scrollbar needs to go from native -> custom or vice versa.
+  // Returns true if a scrollbar needs to go from native -> custom or vice
+  // versa.
   bool needsScrollbarReconstruction() const;
 
   bool shouldIgnoreOverflowHidden() const;
 
   void updateScrollCorner();
 
   AXObjectCache* axObjectCache() const;
 
   void setLayoutSizeInternal(const IntSize&);
 
   bool adjustScrollbarExistence(ComputeScrollbarExistenceOption = FirstPass);
   void adjustScrollbarOpacity();
   void adjustScrollPositionFromUpdateScrollbars();
   bool visualViewportSuppliesScrollbars() const;
 
   bool isFrameViewScrollbar(const Widget* child) const {
     return horizontalScrollbar() == child || verticalScrollbar() == child;
   }
 
   ScrollingCoordinator* scrollingCoordinator() const;
 
   void prepareLayoutAnalyzer();
   std::unique_ptr<TracedValue> analyzerCounters();
 
-  // LayoutObject for the viewport-defining element (see Document::viewportDefiningElement).
+  // LayoutObject for the viewport-defining element (see
+  // Document::viewportDefiningElement).
   LayoutObject* viewportLayoutObject() const;
 
   void collectAnnotatedRegions(LayoutObject&,
                                Vector<AnnotatedRegionValue>&) const;
 
   template <typename Function>
   void forAllNonThrottledFrameViews(const Function&);
 
   void setNeedsUpdateViewportIntersection();
   void updateViewportIntersectionsForSubtree(
       DocumentLifecycle::LifecycleState targetState);
   void updateViewportIntersectionIfNeeded();
   void notifyRenderThrottlingObservers();
   void updateThrottlingStatus();
   void notifyResizeObservers();
 
   // PaintInvalidationCapableScrollableArea
   LayoutScrollbarPart* resizer() const override { return nullptr; }
 
   bool checkLayoutInvalidationIsAllowed() const;
 
   PaintController* paintController() { return m_paintController.get(); }
 
   LayoutSize m_size;
 
   typedef HashSet<RefPtr<LayoutEmbeddedObject>> EmbeddedObjectSet;
   EmbeddedObjectSet m_partUpdateSet;
 
-  // FIXME: These are just "children" of the FrameView and should be Member<Widget> instead.
+  // FIXME: These are just "children" of the FrameView and should be
+  // Member<Widget> instead.
   HashSet<RefPtr<LayoutPart>> m_parts;
 
   // The RefPtr cycle between LocalFrame and FrameView is broken
   // when a LocalFrame is detached by LocalFrame::detach().
   // It clears the LocalFrame's m_view reference via setView(nullptr).
   //
   // For Oilpan, Member reference cycles pose no problem, but
   // LocalFrame's FrameView is also cleared by that setView(), so as to
   // keep the observable lifespan of LocalFrame::view() identical.
   Member<LocalFrame> m_frame;
@@ skipping 102 matching lines @@
 
   // The following members control rendering pipeline throttling for this
   // frame. They are only updated in response to intersection observer
   // notifications, i.e., not in the middle of the lifecycle.
   bool m_hiddenForThrottling;
   bool m_crossOriginForThrottling;
   bool m_subtreeThrottled;
 
   // Paint properties for SPv2 Only.
   // The hierarchy of transform subtree created by a FrameView.
-  // [ preTranslation ]               The offset from Widget::frameRect. Establishes viewport.
+  // [ preTranslation ]               The offset from Widget::frameRect.
+  //     |                            Establishes viewport.
   //     +---[ scrollTranslation ]    Frame scrolling.
-  // TODO(trchen): These will not be needed once settings->rootLayerScrolls() is enabled.
+  // TODO(trchen): These will not be needed once settings->rootLayerScrolls() is
+  // enabled.
   RefPtr<TransformPaintPropertyNode> m_preTranslation;
   RefPtr<TransformPaintPropertyNode> m_scrollTranslation;
   RefPtr<ScrollPaintPropertyNode> m_scroll;
   // The content clip clips the document (= LayoutView) but not the scrollbars.
-  // TODO(trchen): This will not be needed once settings->rootLayerScrolls() is enabled.
+  // TODO(trchen): This will not be needed once settings->rootLayerScrolls() is
+  // enabled.
   RefPtr<ClipPaintPropertyNode> m_contentClip;
   // The property tree state that should be used for painting contents. These
   // properties are either created by this FrameView or are inherited from
   // an ancestor.
   std::unique_ptr<PropertyTreeState> m_totalPropertyTreeStateForContents;
 
   // This is set on the local root frame view only.
   DocumentLifecycle::LifecycleState m_currentUpdateLifecyclePhasesTargetState;
 
   ScrollAnchor m_scrollAnchor;
@@ skipping 12 matching lines @@
 
   // For Slimming Paint v2 only.
   std::unique_ptr<PaintController> m_paintController;
   std::unique_ptr<PaintArtifactCompositor> m_paintArtifactCompositor;
 };
 
 inline void FrameView::incrementVisuallyNonEmptyCharacterCount(unsigned count) {
   if (m_isVisuallyNonEmpty)
     return;
   m_visuallyNonEmptyCharacterCount += count;
-  // Use a threshold value to prevent very small amounts of visible content from triggering didMeaningfulLayout.
-  // The first few hundred characters rarely contain the interesting content of the page.
+  // Use a threshold value to prevent very small amounts of visible content from
+  // triggering didMeaningfulLayout.  The first few hundred characters rarely
+  // contain the interesting content of the page.
   static const unsigned visualCharacterThreshold = 200;
   if (m_visuallyNonEmptyCharacterCount > visualCharacterThreshold)
     setIsVisuallyNonEmpty();
 }
 
 inline void FrameView::incrementVisuallyNonEmptyPixelCount(
     const IntSize& size) {
   if (m_isVisuallyNonEmpty)
     return;
   m_visuallyNonEmptyPixelCount += size.area();
-  // Use a threshold value to prevent very small amounts of visible content from triggering didMeaningfulLayout.
+  // Use a threshold value to prevent very small amounts of visible content from
+  // triggering didMeaningfulLayout.
   static const unsigned visualPixelThreshold = 32 * 32;
   if (m_visuallyNonEmptyPixelCount > visualPixelThreshold)
     setIsVisuallyNonEmpty();
 }
 
 DEFINE_TYPE_CASTS(FrameView,
                   Widget,
                   widget,
                   widget->isFrameView(),
                   widget.isFrameView());
 DEFINE_TYPE_CASTS(FrameView,
                   ScrollableArea,
                   scrollableArea,
                   scrollableArea->isFrameView(),
                   scrollableArea.isFrameView());
 
 }  // namespace blink
 
 #endif  // FrameView_h