Rename platform/Widget to platform/FrameViewBase in core.

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.
 
    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.
 
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
 */
 
 #ifndef FrameView_h
 #define FrameView_h
 
+#include <memory>
 #include "core/CoreExport.h"
 #include "core/dom/DocumentLifecycle.h"
 #include "core/frame/FrameViewAutoSizeInfo.h"
 #include "core/frame/LayoutSubtreeRootList.h"
 #include "core/frame/RootFrameViewport.h"
 #include "core/layout/MapCoordinatesFlags.h"
 #include "core/layout/ScrollAnchor.h"
 #include "core/paint/FirstMeaningfulPaintDetector.h"
 #include "core/paint/ObjectPaintProperties.h"
 #include "core/paint/PaintInvalidationCapableScrollableArea.h"
 #include "core/paint/PaintPhase.h"
 #include "core/paint/ScrollbarManager.h"
+#include "platform/FrameViewBase.h"
 #include "platform/RuntimeEnabledFeatures.h"
-#include "platform/Widget.h"
 #include "platform/animation/CompositorAnimationHost.h"
 #include "platform/animation/CompositorAnimationTimeline.h"
 #include "platform/geometry/IntRect.h"
 #include "platform/geometry/LayoutRect.h"
 #include "platform/graphics/Color.h"
 #include "platform/graphics/GraphicsLayerClient.h"
 #include "platform/scroll/ScrollTypes.h"
 #include "platform/scroll/Scrollbar.h"
 #include "public/platform/ShapeProperties.h"
 #include "public/platform/WebDisplayMode.h"
 #include "public/platform/WebRect.h"
 #include "wtf/Allocator.h"
 #include "wtf/AutoReset.h"
 #include "wtf/Forward.h"
 #include "wtf/HashSet.h"
 #include "wtf/ListHashSet.h"
 #include "wtf/text/WTFString.h"
-#include <memory>
 
 namespace blink {
 
 class AXObjectCache;
 class ComputedStyle;
 class DocumentLifecycle;
 class Cursor;
 class Element;
 class ElementVisibilityObserver;
 class Frame;
@@ skipping 21 matching lines @@
 class PrintContext;
 class ScrollingCoordinator;
 class TracedValue;
 class TransformState;
 struct AnnotatedRegionValue;
 struct CompositedSelection;
 
 typedef unsigned long long DOMTimeStamp;
 
 class CORE_EXPORT FrameView final
-    : public Widget,
+    : public FrameViewBase,
       public PaintInvalidationCapableScrollableArea {
   USING_GARBAGE_COLLECTED_MIXIN(FrameView);
 
   friend class PaintControllerPaintTestBase;
   friend class Internals;
   friend class LayoutPart;  // for invalidateTreeIfNeeded
 
  public:
   static FrameView* create(LocalFrame&);
   static FrameView* create(LocalFrame&, const IntSize& initialSize);
@@ skipping 321 matching lines @@
   bool shouldScrollOnMainThread() const override;
   PaintLayer* layer() 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;
-  Widget* getWidget() override;
+  FrameViewBase* getWidget() override;
   CompositorAnimationHost* compositorAnimationHost() const override;
   CompositorAnimationTimeline* compositorAnimationTimeline() const override;
   LayoutBox* layoutBox() const override;
   FloatQuad localToVisibleContentQuad(const FloatQuad&,
                                       const LayoutObject*,
                                       unsigned = 0) const final;
   RefPtr<WebTaskRunner> getTimerTaskRunner() const final;
 
   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.
   HostWindow* getHostWindow() const;
 
-  typedef HeapHashSet<Member<Widget>> ChildrenWidgetSet;
+  typedef HeapHashSet<Member<FrameViewBase>> ChildrenWidgetSet;
 
   // Functions for child manipulation and inspection.
-  void setParent(Widget*) override;
-  void removeChild(Widget*);
-  void addChild(Widget*);
+  void setParent(FrameViewBase*) override;
+  void removeChild(FrameViewBase*);
+  void addChild(FrameViewBase*);
   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.
   Scrollbar* horizontalScrollbar() const override {
     return m_scrollbarManager.horizontalScrollbar();
   }
   Scrollbar* verticalScrollbar() const override {
     return m_scrollbarManager.verticalScrollbar();
@@ skipping 124 matching lines @@
   FloatPoint frameToContents(const FloatPoint&) const;
   IntRect frameToContents(const IntRect&) const;
 
   // Functions for converting to screen coordinates.
   IntRect contentsToScreen(const IntRect&) const;
 
   // 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,
+  IntPoint convertChildToSelf(const FrameViewBase* 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,
+  IntPoint convertSelfToChild(const FrameViewBase* 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.
+  // FrameViewBase 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.
+  // FrameViewBase 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 294 matching lines @@
   void scheduleOrPerformPostLayoutTasks();
   void performPostLayoutTasks();
 
   void recordDeferredLoadingStats();
 
   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 FrameViewBase 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 didChangeGlobalRootScroller() override;
 
   void updateWidgetGeometriesIfNeeded();
 
   bool wasViewportResized();
@@ skipping 34 matching lines @@
 
   AXObjectCache* axObjectCache() const;
 
   void setLayoutSizeInternal(const IntSize&);
 
   bool adjustScrollbarExistence(ComputeScrollbarExistenceOption = FirstPass);
   void adjustScrollbarOpacity();
   void adjustScrollOffsetFromUpdateScrollbars();
   bool visualViewportSuppliesScrollbars();
 
-  bool isFrameViewScrollbar(const Widget* child) const {
+  bool isFrameViewScrollbar(const FrameViewBase* 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).
@@ skipping 26 matching lines @@
   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.
+  // Member<FrameViewBase> instead.
   HashSet<RefPtr<LayoutPart>> m_parts;
 
   Member<LocalFrame> m_frame;
 
   WebDisplayMode m_displayMode;
 
   DisplayShape m_displayShape;
 
   bool m_canHaveScrollbars;
 
@@ skipping 84 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_subtreeThrottled;
   bool m_lifecycleUpdatesThrottled;
 
   // Paint properties for SPv2 Only.
   // The hierarchy of transform subtree created by a FrameView.
-  // [ preTranslation ]               The offset from Widget::frameRect.
+  // [ preTranslation ]               The offset from FrameViewBase::frameRect.
   //     |                            Establishes viewport.
   //     +---[ scrollTranslation ]    Frame scrolling.
   // TODO(trchen): These will not be needed once settings->rootLayerScrolls() is
   // enabled.
   RefPtr<TransformPaintPropertyNode> m_preTranslation;
   RefPtr<TransformPaintPropertyNode> m_scrollTranslation;
   // The content clip clips the document (= LayoutView) but not the scrollbars.
   // TODO(trchen): This will not be needed once settings->rootLayerScrolls() is
   // enabled.
   RefPtr<ClipPaintPropertyNode> m_contentClip;
@@ skipping 73 matching lines @@
     return;
   m_visuallyNonEmptyPixelCount += size.area();
   // 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());
+                  FrameViewBase,
+                  frameViewBase,
+                  frameViewBase->isFrameView(),
+                  frameViewBase.isFrameView());
 DEFINE_TYPE_CASTS(FrameView,
                   ScrollableArea,
                   scrollableArea,
                   scrollableArea->isFrameView(),
                   scrollableArea.isFrameView());
 
 }  // namespace blink
 
 #endif  // FrameView_h