Scrollbar no longer inherits from FrameViewBase.

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

 /*
  * Copyright (C) 1998, 1999 Torben Weis <weis@kde.org>
  *                     1999 Lars Knoll <knoll@kde.org>
  *                     1999 Antti Koivisto <koivisto@kde.org>
  *                     2000 Dirk Mueller <mueller@kde.org>
  * Copyright (C) 2004, 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
  *           (C) 2006 Graham Dennis (graham.dennis@gmail.com)
  *           (C) 2006 Alexey Proskuryakov (ap@nypop.com)
  * Copyright (C) 2009 Google Inc. All rights reserved.
  *
@@ skipping 223 matching lines @@
 }
 
 DEFINE_TRACE(FrameView) {
   visitor->Trace(frame_);
   visitor->Trace(fragment_anchor_);
   visitor->Trace(scrollable_areas_);
   visitor->Trace(animating_scrollable_areas_);
   visitor->Trace(auto_size_info_);
   visitor->Trace(children_);
   visitor->Trace(plugins_);
+  visitor->Trace(scrollbars_);
   visitor->Trace(viewport_scrollable_area_);
   visitor->Trace(visibility_observer_);
   visitor->Trace(scroll_anchor_);
   visitor->Trace(anchoring_adjustment_queue_);
   visitor->Trace(scrollbar_manager_);
   visitor->Trace(print_context_);
   FrameViewBase::Trace(visitor);
   ScrollableArea::Trace(visitor);
 }
 
@@ skipping 154 matching lines @@
   }
 }
 
 void FrameView::ScrollbarManager::SetHasHorizontalScrollbar(
     bool has_scrollbar) {
   if (has_scrollbar == HasHorizontalScrollbar())
     return;
 
   if (has_scrollbar) {
     h_bar_ = CreateScrollbar(kHorizontalScrollbar);
-    scrollable_area_->GetLayoutBox()->GetDocument().View()->AddChild(
-        h_bar_.Get());
+    scrollable_area_->GetLayoutBox()->GetDocument().View()->AddScrollbar(
+        h_bar_);
     h_bar_is_attached_ = 1;
     scrollable_area_->DidAddScrollbar(*h_bar_, kHorizontalScrollbar);
     h_bar_->StyleChanged();
   } else {
     h_bar_is_attached_ = 0;
     DestroyScrollbar(kHorizontalScrollbar);
   }
 
   scrollable_area_->SetScrollCornerNeedsPaintInvalidation();
 }
 
 void FrameView::ScrollbarManager::SetHasVerticalScrollbar(bool has_scrollbar) {
   if (has_scrollbar == HasVerticalScrollbar())
     return;
 
   if (has_scrollbar) {
     v_bar_ = CreateScrollbar(kVerticalScrollbar);
-    scrollable_area_->GetLayoutBox()->GetDocument().View()->AddChild(
-        v_bar_.Get());
+    scrollable_area_->GetLayoutBox()->GetDocument().View()->AddScrollbar(
+        v_bar_);
     v_bar_is_attached_ = 1;
     scrollable_area_->DidAddScrollbar(*v_bar_, kVerticalScrollbar);
     v_bar_->StyleChanged();
   } else {
     v_bar_is_attached_ = 0;
     DestroyScrollbar(kVerticalScrollbar);
   }
 
   scrollable_area_->SetScrollCornerNeedsPaintInvalidation();
 }
@@ skipping 17 matching lines @@
 void FrameView::ScrollbarManager::DestroyScrollbar(
     ScrollbarOrientation orientation) {
   Member<Scrollbar>& scrollbar =
       orientation == kHorizontalScrollbar ? h_bar_ : v_bar_;
   DCHECK(orientation == kHorizontalScrollbar ? !h_bar_is_attached_
                                              : !v_bar_is_attached_);
   if (!scrollbar)
     return;
 
   scrollable_area_->WillRemoveScrollbar(*scrollbar, orientation);
-  scrollable_area_->GetLayoutBox()->GetDocument().View()->RemoveChild(
-      scrollbar.Get());
+  scrollable_area_->GetLayoutBox()->GetDocument().View()->RemoveScrollbar(
+      scrollbar);
   scrollbar->DisconnectFromScrollableArea();
   scrollbar = nullptr;
 }
 
 void FrameView::RecalculateCustomScrollbarStyle() {
   bool did_style_change = false;
   if (HorizontalScrollbar() && HorizontalScrollbar()->IsCustomScrollbar()) {
     HorizontalScrollbar()->StyleChanged();
     did_style_change = true;
   }
@@ skipping 11 matching lines @@
 void FrameView::InvalidateAllCustomScrollbarsOnActiveChanged() {
   bool uses_window_inactive_selector =
       frame_->GetDocument()->GetStyleEngine().UsesWindowInactiveSelector();
 
   const ChildrenSet* view_children = Children();
   for (const Member<FrameViewBase>& child : *view_children) {
     FrameViewBase* frame_view_base = child.Get();
     if (frame_view_base->IsFrameView()) {
       ToFrameView(frame_view_base)
           ->InvalidateAllCustomScrollbarsOnActiveChanged();
-    } else if (uses_window_inactive_selector &&
-               frame_view_base->IsScrollbar() &&
-               ToScrollbar(frame_view_base)->IsCustomScrollbar()) {
-      ToScrollbar(frame_view_base)->StyleChanged();
     }
   }
+
+  for (const Member<Scrollbar>& scrollbar : *Scrollbars()) {
+    if (uses_window_inactive_selector && scrollbar->IsCustomScrollbar())
+      scrollbar->StyleChanged();
+  }
+
   if (uses_window_inactive_selector)
     RecalculateCustomScrollbarStyle();
 }
 
 void FrameView::Clear() {
   Reset();
   SetScrollbarsSuppressed(true);
 }
 
 bool FrameView::DidFirstLayout() const {
@@ skipping 3093 matching lines @@
   IntPoint point = frame_point;
 
   // Convert from FrameView coords into page ("absolute") coordinates.
   point += IntSize(ScrollX(), ScrollY());
 
   return RoundedIntPoint(layout_item.AbsoluteToLocal(point, kUseTransforms));
 }
 
 IntPoint FrameView::ConvertSelfToChild(const FrameViewBase* child,
                                        const IntPoint& point) const {
-  // TODO(joelhockey): Remove this check once Scrollbar no longer inherits from
-  // FrameViewBase.
-  DCHECK(!IsFrameViewScrollbar(child));
   IntPoint new_point = point;
   new_point = FrameToContents(point);
   new_point.MoveBy(-child->Location());
   return new_point;
 }
 
 IntRect FrameView::ConvertToContainingFrameViewBase(
     const IntRect& local_rect) const {
   if (const FrameView* parent = ToFrameView(Parent())) {
     // Get our layoutObject in the parent view
@@ skipping 211 matching lines @@
   plugins_.erase(plugin);
 }
 
 void FrameView::AddPlugin(PluginView* plugin) {
   DCHECK(!plugin->Parent());
   DCHECK(!plugins_.Contains(plugin));
   plugin->SetParent(this);
   plugins_.insert(plugin);
 }
 
+void FrameView::RemoveScrollbar(Scrollbar* scrollbar) {
+  DCHECK(scrollbars_.Contains(scrollbar));
+  scrollbar->SetParent(nullptr);
+  scrollbars_.erase(scrollbar);
+}
+
+void FrameView::AddScrollbar(Scrollbar* scrollbar) {
+  DCHECK(!scrollbars_.Contains(scrollbar));
+  scrollbar->SetParent(this);
+  scrollbars_.insert(scrollbar);
+}
+
 bool FrameView::VisualViewportSuppliesScrollbars() {
   // On desktop, we always use the layout viewport's scrollbars.
   if (!frame_->GetSettings() || !frame_->GetSettings()->GetViewportEnabled() ||
       !frame_->GetDocument() || !frame_->GetPage())
     return false;
 
   const TopDocumentRootScrollerController& controller =
       frame_->GetPage()->GlobalRootScrollerController();
 
   if (!LayoutViewportScrollableArea())
@@ skipping 14 matching lines @@
   if (!page || frame_->GetEventHandler().IsMousePositionUnknown())
     return;
   page->GetChromeClient().SetCursor(cursor, frame_);
 }
 
 void FrameView::FrameRectsChanged() {
   TRACE_EVENT0("blink", "FrameView::frameRectsChanged");
   if (LayoutSizeFixedToFrameSize())
     SetLayoutSizeInternal(FrameRect().Size());
 
   for (const auto& child : children_)

[haraken, 2017/04/21 08:42:03]

Don't we need to call FrameRectChanged for scrollbars_?

     child->FrameRectsChanged();
 
   for (const auto& plugin : plugins_)
     plugin->FrameRectsChanged();
 }
 
 void FrameView::SetLayoutSizeInternal(const IntSize& size) {
   if (layout_size_ == size)
     return;
 
@@ skipping 833 matching lines @@
 
   // As parent visibility changes, we may need to recomposite this frame view
   // and potentially child frame views.
   SetNeedsCompositingUpdate(GetLayoutViewItem(), kCompositingUpdateRebuildTree);
 
   FrameViewBase::SetParentVisible(visible);
 
   if (!IsSelfVisible())
     return;
 
   for (const auto& child : children_)

[haraken, 2017/04/21 08:42:03]

Ditto. Don't we need to call SetParentVisible for scrollbars_?

     child->SetParentVisible(visible);
 
   for (const auto& plugin : plugins_)
     plugin->SetParentVisible(visible);
 }
 
 void FrameView::Show() {
   if (!IsSelfVisible()) {
     SetSelfVisible(true);
     if (ScrollingCoordinator* scrolling_coordinator =
             this->GetScrollingCoordinator())
       scrolling_coordinator->FrameViewVisibilityDidChange();
     SetNeedsCompositingUpdate(GetLayoutViewItem(),
                               kCompositingUpdateRebuildTree);
     UpdateParentScrollableAreaSet();
     if (RuntimeEnabledFeatures::slimmingPaintInvalidationEnabled() &&
         !RuntimeEnabledFeatures::rootLayerScrollingEnabled()) {
       // The existance of scrolling properties depends on visibility through
       // isScrollable() so ensure properties are updated if visibility changes.
       SetNeedsPaintPropertyUpdate();
     }
     if (IsParentVisible()) {
       for (const auto& child : children_)
         child->SetParentVisible(true);

[haraken, 2017/04/21 08:42:03]

Ditto.

 
       for (const auto& plugin : plugins_)
         plugin->SetParentVisible(true);
     }
   }
 }
 
 void FrameView::Hide() {
   if (IsSelfVisible()) {
     if (IsParentVisible()) {
       for (const auto& child : children_)

[haraken, 2017/04/21 08:42:03]

Ditto.

         child->SetParentVisible(false);
 
       for (const auto& plugin : plugins_)
         plugin->SetParentVisible(false);
     }
     SetSelfVisible(false);
     if (ScrollingCoordinator* scrolling_coordinator =
             this->GetScrollingCoordinator())
       scrolling_coordinator->FrameViewVisibilityDidChange();
     SetNeedsCompositingUpdate(GetLayoutViewItem(),
@@ skipping 546 matching lines @@
 void FrameView::SetAnimationHost(
     std::unique_ptr<CompositorAnimationHost> host) {
   animation_host_ = std::move(host);
 }
 
 LayoutUnit FrameView::CaretWidth() const {
   return LayoutUnit(GetChromeClient()->WindowToViewportScalar(1));
 }
 
 }  // namespace blink