Deleted Widget/FrameViewBase

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
@@ skipping 22 matching lines @@
 #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/PlatformFrameView.h"
 #include "platform/RuntimeEnabledFeatures.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/CompositorElementId.h"
 #include "platform/graphics/GraphicsLayerClient.h"
 #include "platform/scroll/ScrollTypes.h"
@@ skipping 43 matching lines @@
 class TracedValue;
 class TransformState;
 struct AnnotatedRegionValue;
 struct CompositedSelection;
 
 typedef unsigned long long DOMTimeStamp;
 
 class CORE_EXPORT FrameView final
     : public GarbageCollectedFinalized<FrameView>,
       public PlatformFrameView,
-      public FrameViewBase,
       public FrameOrPlugin,
       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& initial_size);
 
   ~FrameView() override;
 
   void Invalidate() { InvalidateRect(IntRect(0, 0, Width(), Height())); }
   void InvalidateRect(const IntRect&);
   void SetFrameRect(const IntRect&) override;
   const IntRect& FrameRect() const override { return frame_rect_; }
   int X() const { return frame_rect_.X(); }
   int Y() const { return frame_rect_.Y(); }
   int Width() const { return frame_rect_.Width(); }
   int Height() const { return frame_rect_.Height(); }
   IntSize Size() const { return frame_rect_.Size(); }
-  IntPoint Location() const override { return frame_rect_.Location(); }
+  IntPoint Location() const { return frame_rect_.Location(); }
   void Resize(int width, int height) {
     SetFrameRect(IntRect(frame_rect_.X(), frame_rect_.Y(), width, height));
   }
   void Resize(const IntSize& size) { SetFrameRect(IntRect(Location(), size)); }
 
   LocalFrame& GetFrame() const {
     DCHECK(frame_);
     return *frame_;
   }
 
@@ skipping 332 matching lines @@
 
   LayoutRect ScrollIntoView(const LayoutRect& rect_in_content,
                             const ScrollAlignment& align_x,
                             const ScrollAlignment& align_y,
                             ScrollType = kProgrammaticScroll) override;
 
   // The window that hosts the FrameView. The FrameView will communicate scrolls
   // and repaints to the host window in the window's coordinate space.
   PlatformChromeClient* GetChromeClient() const;
 
-  typedef HeapHashSet<Member<FrameOrPlugin>> ChildrenSet;
-  typedef HeapHashSet<Member<Scrollbar>> ScrollbarsSet;
-
   // Functions for child manipulation and inspection.
   bool IsSelfVisible() const {
     return self_visible_;
   }  // Whether or not we have been explicitly marked as visible or not.
   bool IsParentVisible() const {
     return parent_visible_;
   }  // Whether or not our parent is visible.
   bool IsVisible() const {
     return self_visible_ && parent_visible_;
   }  // Whether or not we are actually visible.
   void SetParentVisible(bool) override;
   void SetSelfVisible(bool v) { self_visible_ = v; }
   void SetParent(FrameView*) override;
   FrameView* Parent() const override { return parent_; }
   void RemoveChild(FrameOrPlugin*);
   void AddChild(FrameOrPlugin*);
+  using ChildrenSet = HeapHashSet<Member<FrameOrPlugin>>;
   const ChildrenSet& Children() const { return children_; }
+  // Custom scrollbars in PaintLayerScrollableArea need to be called with
+  // StyleChanged whenever window focus is changed.
   void RemoveScrollbar(Scrollbar*);
   void AddScrollbar(Scrollbar*);
-  const ScrollbarsSet* Scrollbars() const { return &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 scrollbar_manager_.HorizontalScrollbar();
   }
   Scrollbar* VerticalScrollbar() const override {
     return scrollbar_manager_.VerticalScrollbar();
   }
@@ skipping 126 matching lines @@
 
   // 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&);
 
   IntRect ConvertToRootFrame(const IntRect&) const;
   IntPoint ConvertToRootFrame(const IntPoint&) const;
+  IntRect ConvertFromRootFrame(const IntRect&) const;
+  IntPoint ConvertFromRootFrame(const IntPoint&) const override;
+  FloatPoint ConvertFromRootFrame(const FloatPoint&) const;
   IntPoint ConvertSelfToChild(const FrameOrPlugin&, const IntPoint&) const;
 
   // 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& damage_rect) const;
 
   void Show() override;
@@ skipping 475 matching lines @@
   bool has_been_disposed_ = false;
 #endif
 
   ScrollbarMode horizontal_scrollbar_mode_;
   ScrollbarMode vertical_scrollbar_mode_;
 
   bool horizontal_scrollbar_lock_;
   bool vertical_scrollbar_lock_;
 
   ChildrenSet children_;
-  ScrollbarsSet scrollbars_;
+  HeapHashSet<Member<Scrollbar>> scrollbars_;
 
   ScrollOffset pending_scroll_delta_;
   ScrollOffset scroll_offset_;
   IntSize contents_size_;
 
   bool scrollbars_suppressed_;
 
   bool in_update_scrollbars_;
 
   std::unique_ptr<LayoutAnalyzer> analyzer_;
@@ skipping 102 matching lines @@
   if (visually_non_empty_pixel_count_ > kVisualPixelThreshold)
     SetIsVisuallyNonEmpty();
 }
 
 DEFINE_TYPE_CASTS(FrameView,
                   PlatformFrameView,
                   platform_frame_view,
                   platform_frame_view->IsFrameView(),
                   platform_frame_view.IsFrameView());
 DEFINE_TYPE_CASTS(FrameView,
-                  FrameViewBase,
-                  frameViewBase,
-                  frameViewBase->IsFrameView(),
-                  frameViewBase.IsFrameView());
-DEFINE_TYPE_CASTS(FrameView,
                   FrameOrPlugin,
                   frame_or_plugin,
                   frame_or_plugin->IsFrameView(),
                   frame_or_plugin.IsFrameView());
 DEFINE_TYPE_CASTS(FrameView,
                   ScrollableArea,
                   scrollableArea,
                   scrollableArea->IsFrameView(),
                   scrollableArea.IsFrameView());
 
 }  // namespace blink
 
 #endif  // FrameView_h