Fix virtual/override/final usage in the rest of Source/core/.

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.
 
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
@@ skipping 63 matching lines @@
 
 class CORE_EXPORT FrameView final : public Widget, public ScrollableArea {
     WILL_BE_USING_GARBAGE_COLLECTED_MIXIN(FrameView);
 public:
     friend class LayoutView;
     friend class Internals;
 
     static PassRefPtrWillBeRawPtr<FrameView> create(LocalFrame*);
     static PassRefPtrWillBeRawPtr<FrameView> create(LocalFrame*, const IntSize& initialSize);
 
-    virtual ~FrameView();
+    ~FrameView() override;
 
-    virtual void invalidateRect(const IntRect&) override;
-    virtual void setFrameRect(const IntRect&) override;
+    void invalidateRect(const IntRect&) override;
+    void setFrameRect(const IntRect&) override;
 
     LocalFrame& frame() const
     {
         ASSERT(m_frame);
         return *m_frame;
     }
 
     Page* page() const;
 
     LayoutView* layoutView() const;
@@ skipping 66 matching lines @@
     // |unobscuredRect| receives the clip rect that is not clipped to the root window. It may be nullptr.
     IntRect clipRectsForFrameOwner(const HTMLFrameOwnerElement*, IntRect* unobscuredRect) const;
 
     // Scale used to convert incoming input events.
     float inputEventsScaleFactor() const;
 
     // Offset used to convert incoming input events while emulating device metics.
     IntSize inputEventsOffsetForEmulation() const;
     void setInputEventsTransformForEmulation(const IntSize&, float);
 
-    virtual void setScrollPosition(const DoublePoint&, ScrollType, ScrollBehavior = ScrollBehaviorInstant) override;
+    void setScrollPosition(const DoublePoint&, ScrollType, ScrollBehavior = ScrollBehaviorInstant) override;
 
     FloatSize elasticOverscroll() const { return m_elasticOverscroll; }
     void setElasticOverscroll(const FloatSize&);
 
     void viewportSizeChanged(bool widthChanged, bool heightChanged);
 
     AtomicString mediaType() const;
     void setMediaType(const AtomicString&);
     void adjustMediaTypeForPrinting(bool printing);
 
@@ skipping 75 matching lines @@
     bool isFrameViewScrollCorner(LayoutScrollbarPart* scrollCorner) const { return m_scrollCorner == scrollCorner; }
 
     enum ScrollingReasons {
         Scrollable,
         NotScrollableNoOverflow,
         NotScrollableNotVisible,
         NotScrollableExplicitlyDisabled
     };
 
     ScrollingReasons scrollingReasons();
-    virtual bool isScrollable() override;
-    virtual bool isProgrammaticallyScrollable() override;
+    bool isScrollable() override;
+    bool isProgrammaticallyScrollable() override;
 
     enum ScrollbarModesCalculationStrategy { RulesFromWebContentOnly, AnyRule };
     void calculateScrollbarModesForLayout(ScrollbarMode& hMode, ScrollbarMode& vMode, ScrollbarModesCalculationStrategy = AnyRule);
 
-    virtual IntPoint lastKnownMousePosition() const override;
+    IntPoint lastKnownMousePosition() const override;
     bool shouldSetCursor() const;
 
     void setCursor(const Cursor&);
 
-    virtual bool scrollbarsCanBeActive() const override;
+    bool scrollbarsCanBeActive() const override;
 
     // FIXME: Remove this method once plugin loading is decoupled from layout.
     void flushAnyPendingPostLayoutTasks();
 
-    virtual bool shouldSuspendScrollAnimations() const override;
-    virtual void scrollbarStyleChanged() override;
+    bool shouldSuspendScrollAnimations() const override;
+    void scrollbarStyleChanged() override;
 
     LayoutBox* embeddedContentBox() const;
 
     void setTracksPaintInvalidations(bool);
     bool isTrackingPaintInvalidations() const { return m_isTrackingPaintInvalidations; }
     void resetTrackedPaintInvalidations();
 
     String trackedPaintInvalidationRectsAsText() const;
 
     using ScrollableAreaSet = WillBeHeapHashSet<RawPtrWillBeMember<ScrollableArea>>;
@@ skipping 11 matching lines @@
     typedef HashSet<LayoutBox*> ResizerAreaSet;
     void addResizerArea(LayoutBox&);
     void removeResizerArea(LayoutBox&);
     const ResizerAreaSet* resizerAreas() const { return m_resizerAreas.get(); }
 
     // This function exists for ports that need to handle wheel events manually.
     // On Mac WebKit1 the underlying NSScrollView just does the scrolling, but on most other platforms
     // we need this function in order to do the scroll ourselves.
     ScrollResult wheelEvent(const PlatformWheelEvent&);
 
-    virtual bool shouldUseIntegerScrollOffset() const override;
+    bool shouldUseIntegerScrollOffset() const override;
 
-    virtual bool isActive() const override;
+    bool isActive() const override;
 
     // Override scrollbar notifications to update the AXObject cache.
-    virtual void didAddScrollbar(Scrollbar*, ScrollbarOrientation) override;
+    void didAddScrollbar(Scrollbar*, ScrollbarOrientation) override;
 
     // FIXME: This should probably be renamed as the 'inSubtreeLayout' parameter
     // passed around the FrameView layout methods can be true while this returns
     // false.
     bool isSubtreeLayout() const { return !m_layoutSubtreeRoots.isEmpty(); }
 
     // Sets the tickmarks for the FrameView, overriding the default behavior
     // which is to display the tickmarks corresponding to find results.
     // If |m_tickmarks| is empty, the default behavior is restored.
     void setTickmarks(const Vector<IntRect>& tickmarks)
     {
         m_tickmarks = tickmarks;
         invalidatePaintForTickmarks();
     }
 
     void invalidatePaintForTickmarks() const;
 
     // Since the compositor can resize the viewport due to top controls and
     // commit scroll offsets before a WebView::resize occurs, we need to adjust
     // our scroll extents to prevent clamping the scroll offsets.
     void setTopControlsViewportAdjustment(float);
 
-    virtual IntPoint maximumScrollPosition() const override;
+    IntPoint maximumScrollPosition() const override;
 
     // ScrollableArea interface
-    virtual void invalidateScrollbarRect(Scrollbar*, const IntRect&) override;
-    virtual void getTickmarks(Vector<IntRect>&) const override;
+    void invalidateScrollbarRect(Scrollbar*, const IntRect&) override;
+    void getTickmarks(Vector<IntRect>&) const override;
     void scrollTo(const DoublePoint&);
-    virtual IntRect scrollableAreaBoundingBox() const override;
-    virtual bool scrollAnimatorEnabled() const override;
-    virtual bool usesCompositedScrolling() const override;
-    virtual GraphicsLayer* layerForScrolling() const override;
-    virtual GraphicsLayer* layerForHorizontalScrollbar() const override;
-    virtual GraphicsLayer* layerForVerticalScrollbar() const override;
-    virtual GraphicsLayer* layerForScrollCorner() const override;
-    virtual int scrollSize(ScrollbarOrientation) const override;
-    virtual bool isScrollCornerVisible() const override;
-    virtual bool userInputScrollable(ScrollbarOrientation) const override;
-    virtual bool shouldPlaceVerticalScrollbarOnLeft() const override;
+    IntRect scrollableAreaBoundingBox() const override;
+    bool scrollAnimatorEnabled() const override;
+    bool usesCompositedScrolling() const override;
+    GraphicsLayer* layerForScrolling() const override;
+    GraphicsLayer* layerForHorizontalScrollbar() const override;
+    GraphicsLayer* layerForVerticalScrollbar() const override;
+    GraphicsLayer* layerForScrollCorner() const override;
+    int scrollSize(ScrollbarOrientation) const override;
+    bool isScrollCornerVisible() const override;
+    bool userInputScrollable(ScrollbarOrientation) const override;
+    bool shouldPlaceVerticalScrollbarOnLeft() const override;
     virtual LayoutRect scrollIntoView(
         const LayoutRect& rectInContent,
         const ScrollAlignment& alignX,
         const ScrollAlignment& alignY) override;
 
     // The window that hosts the FrameView. The FrameView will communicate scrolls and repaints to the
     // host window in the window's coordinate space.
     HostWindow* hostWindow() const override;
 
     // Returns a clip rect in host window coordinates. Used to clip the blit on a scroll.
     IntRect windowClipRect(IncludeScrollbarsInRect = ExcludeScrollbars) const;
 
     typedef WillBeHeapHashSet<RefPtrWillBeMember<Widget>> ChildrenWidgetSet;
 
     // Functions for child manipulation and inspection.
-    virtual void setParent(Widget*) override;
+    void setParent(Widget*) override;
     void removeChild(Widget*);
     void addChild(PassRefPtrWillBeRawPtr<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.
-    virtual Scrollbar* horizontalScrollbar() const override { return m_horizontalScrollbar.get(); }
-    virtual Scrollbar* verticalScrollbar() const override { return m_verticalScrollbar.get(); }
+    Scrollbar* horizontalScrollbar() const override { return m_horizontalScrollbar.get(); }
+    Scrollbar* verticalScrollbar() const override { return m_verticalScrollbar.get(); }
     LayoutScrollbarPart* scrollCorner() { 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.
     void setScrollbarModes(ScrollbarMode horizontalMode, ScrollbarMode verticalMode, bool horizontalLock = false, bool verticalLock = false);
@@ skipping 13 matching lines @@
 
     // By default, paint events are clipped to the visible area.  If set to
     // false, paint events are no longer clipped.
     bool clipsPaintInvalidations() const { return m_clipsRepaints; }
     void setClipsRepaints(bool);
 
     // The visible content rect has a location that is the scrolled offset of
     // the document. The width and height are the layout viewport width and
     // height. By default the scrollbars themselves are excluded from this
     // rectangle, but an optional boolean argument allows them to be included.
-    virtual IntRect visibleContentRect(IncludeScrollbarsInRect = ExcludeScrollbars) const override;
+    IntRect visibleContentRect(IncludeScrollbarsInRect = ExcludeScrollbars) const override;
     IntSize visibleContentSize(IncludeScrollbarsInRect = ExcludeScrollbars) const;
 
     // Functions for getting/setting the size of the document contained inside the FrameView (as an IntSize or as individual width and height
     // values).
-    virtual IntSize contentsSize() const override; // Always at least as big as the visibleWidth()/visibleHeight().
+    IntSize contentsSize() const override; // Always at least as big as the visibleWidth()/visibleHeight().
     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.
-    virtual IntPoint scrollPosition() const override { return visibleContentRect().location(); }
-    virtual DoublePoint scrollPositionDouble() const override { return m_scrollPosition; }
+    IntPoint scrollPosition() const override { return visibleContentRect().location(); }
+    DoublePoint scrollPositionDouble() const override { return m_scrollPosition; }
     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; }
-    virtual IntPoint minimumScrollPosition() const override; // The minimum position we can be scrolled to.
+    IntPoint minimumScrollPosition() const override; // The minimum position we can be scrolled to.
     int scrollX() const { return scrollPosition().x(); }
     int scrollY() const { return scrollPosition().y(); }
 
     void cacheCurrentScrollPosition() { m_cachedScrollPosition = scrollPositionDouble(); }
     DoublePoint cachedScrollPosition() const { return m_cachedScrollPosition; }
 
     // 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 painting on our scrollbars until the first layout has occurred.
@@ skipping 38 matching lines @@
     // 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).
     Scrollbar* scrollbarAtRootFramePoint(const IntPoint&);
     Scrollbar* scrollbarAtFramePoint(const IntPoint&);
 
-    virtual IntPoint convertChildToSelf(const Widget* child, const IntPoint& point) const override
+    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;
     }
 
-    virtual IntPoint convertSelfToChild(const Widget* child, const IntPoint& point) const override
+    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.
-    virtual void paint(GraphicsContext*, const IntRect&) override;
+    void paint(GraphicsContext*, const IntRect&) override;
     void paintContents(GraphicsContext*, const IntRect& damageRect);
 
     // Widget overrides to ensure that our children's visibility status is kept up to date when we get shown and hidden.
-    virtual void show() override;
-    virtual void hide() override;
-    virtual void setParentVisible(bool) override;
+    void show() override;
+    void hide() override;
+    void setParentVisible(bool) override;
 
     bool isPointInScrollbarCorner(const IntPoint&);
     bool scrollbarCornerPresent() const;
-    virtual IntRect scrollCornerRect() const override;
+    IntRect scrollCornerRect() const override;
 
-    virtual IntRect convertFromScrollbarToContainingView(const Scrollbar*, const IntRect&) const override;
-    virtual IntRect convertFromContainingViewToScrollbar(const Scrollbar*, const IntRect&) const override;
-    virtual IntPoint convertFromScrollbarToContainingView(const Scrollbar*, const IntPoint&) const override;
-    virtual IntPoint convertFromContainingViewToScrollbar(const Scrollbar*, const IntPoint&) const override;
+    IntRect convertFromScrollbarToContainingView(const Scrollbar*, const IntRect&) const override;
+    IntRect convertFromContainingViewToScrollbar(const Scrollbar*, const IntRect&) const override;
+    IntPoint convertFromScrollbarToContainingView(const Scrollbar*, const IntPoint&) const override;
+    IntPoint convertFromContainingViewToScrollbar(const Scrollbar*, const IntPoint&) const override;
 
-    virtual bool isFrameView() const override { return true; }
+    bool isFrameView() const override { return true; }
 
     DECLARE_VIRTUAL_TRACE();
     void notifyPageThatContentAreaWillPaint() const;
     FrameView* parentFrameView() const;
 
     // Returns the scrollable area for the frame. For the root frame, this will
     // be the RootFrameViewport, which adds pinch-zoom semantics to scrolling.
     // For non-root frames, this will be the the ScrollableArea used by the
     // FrameView, depending on whether root-layer-scrolls is enabled.
     ScrollableArea* scrollableArea();
@@ skipping 22 matching lines @@
     void scrollContentsSlowPath(const IntRect& updateRect);
 
     // Prevents creation of scrollbars. Used to prevent drawing two sets of
     // overlay scrollbars in the case of the pinch viewport.
     bool scrollbarsDisabled() const;
 
     // These functions are used to create/destroy scrollbars.
     void setHasHorizontalScrollbar(bool);
     void setHasVerticalScrollbar(bool);
 
-    virtual void invalidateScrollCornerRect(const IntRect&) override;
-    virtual ScrollBehavior scrollBehaviorStyle() const override;
+    void invalidateScrollCornerRect(const IntRect&) override;
+    ScrollBehavior scrollBehaviorStyle() const override;
 
     void scrollContentsIfNeeded();
 
     void setScrollOrigin(const IntPoint&, bool updatePositionAtAll, bool updatePositionSynchronously);
 
     enum ComputeScrollbarExistenceOption {
         FirstPass,
         Incremental
     };
     void computeScrollbarExistence(bool& newHasHorizontalScrollbar, bool& newHasVerticalScrollbar, const IntSize& docSize, ComputeScrollbarExistenceOption = FirstPass) const;
@@ skipping 11 matching lines @@
     private:
         TemporaryChange<bool> m_scope;
     };
 
     // Only for LayoutPart to traverse into sub frames during paint invalidation.
     void invalidateTreeIfNeeded(PaintInvalidationState&);
 
 private:
     explicit FrameView(LocalFrame*);
 
-    virtual void setScrollOffset(const IntPoint&, ScrollType) override;
-    virtual void setScrollOffset(const DoublePoint&, ScrollType) override;
+    void setScrollOffset(const IntPoint&, ScrollType) override;
+    void setScrollOffset(const DoublePoint&, ScrollType) override;
 
     void updateAllLifecyclePhasesInternal();
     void invalidateTreeIfNeededRecursive();
     void scrollContentsIfNeededRecursive();
     void updateStyleAndLayoutIfNeededRecursive();
     void updatePostLifecycleData();
 
     void reset();
     void init();
 
     void clearLayoutSubtreeRootsAndMarkContainingBlocks();
 
     // Called when our frame rect changes (or the rect/scroll position of an ancestor changes).
-    virtual void frameRectsChanged() override;
+    void frameRectsChanged() override;
 
     friend class LayoutPart;
 
     bool contentsInCompositedLayer() const;
 
     void applyOverflowToViewport(LayoutObject*, ScrollbarMode& hMode, ScrollbarMode& vMode);
 
     void updateCounters();
     void forceLayoutParentViewIfNeeded();
     void performPreLayoutTasks();
     void performLayout(bool inSubtreeLayout);
     void scheduleOrPerformPostLayoutTasks();
     void performPostLayoutTasks();
 
     DocumentLifecycle& lifecycle() const;
 
     void contentRectangleForPaintInvalidation(const IntRect&);
-    virtual void contentsResized() override;
+    void contentsResized() override;
     void scrollbarExistenceDidChange();
 
     // Override Widget methods to do point conversion via layoutObjects, in order to
     // take transforms into account.
-    virtual IntRect convertToContainingView(const IntRect&) const override;
-    virtual IntRect convertFromContainingView(const IntRect&) const override;
-    virtual IntPoint convertToContainingView(const IntPoint&) const override;
-    virtual IntPoint convertFromContainingView(const IntPoint&) const override;
+    IntRect convertToContainingView(const IntRect&) const override;
+    IntRect convertFromContainingView(const IntRect&) const override;
+    IntPoint convertToContainingView(const IntPoint&) const override;
+    IntPoint convertFromContainingView(const IntPoint&) const override;
 
     void updateWidgetPositionsIfNeeded();
 
     bool wasViewportResized();
     void sendResizeEventIfNeeded();
 
     void updateScrollableAreaSet();
 
     void scheduleUpdateWidgetsIfNecessary();
     void updateWidgetsTimerFired(Timer<FrameView>*);
@@ skipping 203 matching lines @@
     static const unsigned visualPixelThreshold = 32 * 32;
     if (m_visuallyNonEmptyPixelCount > visualPixelThreshold)
         setIsVisuallyNonEmpty();
 }
 
 DEFINE_TYPE_CASTS(FrameView, Widget, widget, widget->isFrameView(), widget.isFrameView());
 
 } // namespace blink
 
 #endif // FrameView_h