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/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"
 #include "platform/scroll/Scrollbar.h"
@@ skipping 41 matching lines @@
 class ScrollingCoordinator;
 class TracedValue;
 class TransformState;
 struct AnnotatedRegionValue;
 struct CompositedSelection;
 
 typedef unsigned long long DOMTimeStamp;
 
 class CORE_EXPORT FrameView final
     : public GarbageCollectedFinalized<FrameView>,
-      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 {
     ASSERT(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_; }
   FrameView* Root() const;
   void RemoveChild(FrameOrPlugin*);
   void AddChild(FrameOrPlugin*);
+  typedef HeapHashSet<Member<FrameOrPlugin>> ChildrenSet;
   const ChildrenSet& Children() const { return children_; }
-  void RemoveScrollbar(Scrollbar*);
-  void AddScrollbar(Scrollbar*);
-  const ScrollbarsSet& Scrollbars() const { return scrollbars_; }
+  // Custom PaintLayer scrollbars need to be called with StyleChanged
+  // whenever window focus is changed.
+  void RemovePaintScrollbar(Scrollbar*);

[dcheng, 2017/05/09 08:05:55]

Is the term "PaintScrollbar" used elsewhere in Chrome code as a noun?
It's not clear to me what a custom PaintLayer scrollbar is.

[joelhockey, 2017/05/10 04:17:13]

No, I don't believe PaintScrollbar is used elsewhere.  PaintLayer Scrollbar is
to Scrollbar as PaintLayerScrollableArea is to ScrollableArea.

PaintLayerScrollableArea (PLSA) and ScrollableArea are parallel classes which
are containers of scrollbars.  See http://bit.ly/root-layer-scrolling for more
info.

It turns out that FrameView has been holding the scrollbars (horizontal and / or
vertical) of both ScrollableArea (itself) and PLSA.  When there are scrollbars
with custom CSS, then all (up to 4) scrollbars need to be notified when focus
changes.  The 2 scrollbars that are part of ScrollableArea already get looked
after in FrameView::RecalculateCustomScrollbarStyle, so the old
FrameView::scrollbars_ container only really needs to hold references to the 2
scrollbars in PLSA.

So these names could be:

AddPaintLayerScrollableAreaScrollbar
RemovePaintLayerScrollableAreaScrollbar

But I went with the shorter:

AddPaintScrollbar
RemovePaintScrollbar

I don't mind changing the name to anything else.

Ideally, this parallel scrollbar container setup wouldn't exist, and there are
plans to remove it.

[dcheng, 2017/05/10 07:27:00]

Unless I'm missing something, I think the original names might be the clearest.
The caller can pass in a scrollbar created by LayoutScrollbar::Create() or
Scrollbar::Create(): neither of these mentions "Paint", so it's not clear how
"Paint" relates (I guess it's an implementation detail in this case, but not a
particularly obvious one?)

+  void AddPaintScrollbar(Scrollbar*);
 
   // 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 IntPoint&, 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>> paint_scrollbars_;
 
   ScrollOffset pending_scroll_delta_;
   ScrollOffset scroll_offset_;
   IntSize contents_size_;
 
   bool scrollbars_suppressed_;
 
   bool in_update_scrollbars_;
 
   std::unique_ptr<LayoutAnalyzer> analyzer_;
@@ skipping 97 matching lines @@
     return;
   visually_non_empty_pixel_count_ += size.Area();
   // Use a threshold value to prevent very small amounts of visible content from
   // triggering didMeaningfulLayout.
   static const unsigned kVisualPixelThreshold = 32 * 32;
   if (visually_non_empty_pixel_count_ > kVisualPixelThreshold)
     SetIsVisuallyNonEmpty();
 }
 
 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,
                   scrollable_area,
                   scrollable_area->IsFrameView(),
                   scrollable_area.IsFrameView());
 
 }  // namespace blink
 
 #endif  // FrameView_h