Move ScrollbarManager from core to platform and use as Scrollbar parent

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 188 matching lines @@
       scrollbars_suppressed_(false),
       in_update_scrollbars_(false),
       frame_timing_requests_dirty_(true),
       hidden_for_throttling_(false),
       subtree_throttled_(false),
       lifecycle_updates_throttled_(false),
       needs_paint_property_update_(true),
       current_update_lifecycle_phases_target_state_(
           DocumentLifecycle::kUninitialized),
       scroll_anchor_(this),
-      scrollbar_manager_(*this),
       needs_scrollbars_update_(false),
       suppress_adjust_view_size_(false),
       allows_layout_invalidation_after_layout_clean_(true),
       main_thread_scrolling_reasons_(0) {
   Init();
 }
 
 FrameView* FrameView::Create(LocalFrame& frame) {
   FrameView* view = new FrameView(frame);
   view->Show();
@@ skipping 19 matching lines @@
   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);
 }
 
 void FrameView::Reset() {
   // The compositor throttles the main frame using deferred commits, we can't
   // throttle it here or it seems the root compositor doesn't get setup
   // properly.
   if (RuntimeEnabledFeatures::
@@ skipping 134 matching lines @@
 
 void FrameView::DetachScrollbars() {
   // Previously, we detached custom scrollbars as early as possible to prevent
   // Document::detachLayoutTree() from messing with the view such that its
   // scroll bars won't be torn down. However, scripting in
   // Document::detachLayoutTree() is forbidden
   // now, so it's not clear if these edge cases can still happen.
   // However, for Oilpan, we still need to remove the native scrollbars before
   // we lose the connection to the ChromeClient, so we just unconditionally
   // detach any scrollbars now.
-  scrollbar_manager_.Dispose();
+  ScrollbarManager::Dispose();
 
   if (scroll_corner_) {
     scroll_corner_->Destroy();
     scroll_corner_ = nullptr;
   }
 }
 
-void FrameView::ScrollbarManager::SetHasHorizontalScrollbar(
-    bool has_scrollbar) {
+void FrameView::SetHasHorizontalScrollbar(bool has_scrollbar) {
   if (has_scrollbar == HasHorizontalScrollbar())
     return;
 
   if (has_scrollbar) {
     h_bar_ = CreateScrollbar(kHorizontalScrollbar);
     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) {
+void FrameView::SetHasVerticalScrollbar(bool has_scrollbar) {
   if (has_scrollbar == HasVerticalScrollbar())
     return;
 
   if (has_scrollbar) {
     v_bar_ = CreateScrollbar(kVerticalScrollbar);
     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();
 }
 
-Scrollbar* FrameView::ScrollbarManager::CreateScrollbar(
-    ScrollbarOrientation orientation) {
+Scrollbar* FrameView::CreateScrollbar(ScrollbarOrientation orientation) {
   Element* custom_scrollbar_element = nullptr;
   LayoutBox* box = scrollable_area_->GetLayoutBox();
   if (box->GetDocument().View()->ShouldUseCustomScrollbars(
           custom_scrollbar_element)) {
     return LayoutScrollbar::CreateCustomScrollbar(
         scrollable_area_.Get(), orientation, custom_scrollbar_element);
   }
 
   // Nobody set a custom style, so we just use a native scrollbar.
   return Scrollbar::Create(scrollable_area_.Get(), orientation,
                            kRegularScrollbar,
                            &box->GetFrame()->GetPage()->GetChromeClient());
 }
 
-void FrameView::ScrollbarManager::DestroyScrollbar(
-    ScrollbarOrientation orientation) {
+void FrameView::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()->RemoveScrollbar(
       scrollbar);
@@ skipping 12 matching lines @@
     did_style_change = true;
   }
   if (did_style_change) {
     UpdateScrollbarGeometry();
     UpdateScrollCorner();
     PositionScrollbarLayers();
   }
 }
 
 void FrameView::InvalidateAllCustomScrollbarsOnActiveChanged() {
-  bool uses_window_inactive_selector =
-      frame_->GetDocument()->GetStyleEngine().UsesWindowInactiveSelector();
+  if (!frame_->GetDocument()->GetStyleEngine().UsesWindowInactiveSelector())
+    return;
 
   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();
     }
   }
 
   for (const Member<Scrollbar>& scrollbar : *Scrollbars()) {
-    if (uses_window_inactive_selector && scrollbar->IsCustomScrollbar())
-      scrollbar->StyleChanged();
+    scrollbar->StyleChanged();
   }
 
-  if (uses_window_inactive_selector)
-    RecalculateCustomScrollbarStyle();
+  RecalculateCustomScrollbarStyle();
 }
 
 void FrameView::Clear() {
   Reset();
   SetScrollbarsSuppressed(true);
 }
 
 bool FrameView::DidFirstLayout() const {
   return !first_layout_;
 }
@@ skipping 163 matching lines @@
   if (doc_element && doc_element->GetLayoutObject() &&
       doc_element->GetLayoutObject()->Style()->HasPseudoStyle(
           kPseudoIdScrollbar)) {
     custom_scrollbar_element = doc_element;
     return true;
   }
 
   return false;
 }
 
-Scrollbar* FrameView::CreateScrollbar(ScrollbarOrientation orientation) {
-  return scrollbar_manager_.CreateScrollbar(orientation);
-}
-
 void FrameView::SetContentsSize(const IntSize& size) {
   if (size == ContentsSize())
     return;
 
   contents_size_ = size;
   UpdateScrollbars();
   ScrollableArea::ContentsResized();
 
   Page* page = GetFrame().GetPage();
   if (!page)
@@ skipping 2176 matching lines @@
 
 // TODO(pdr): This logic is similar to adjustScrollbarExistence and the common
 // logic should be factored into a helper.
 void FrameView::VisualViewportScrollbarsChanged() {
   bool has_horizontal_scrollbar = HorizontalScrollbar();
   bool has_vertical_scrollbar = VerticalScrollbar();
   bool should_have_horizontal_scrollbar = false;
   bool should_have_vertical_scrollbar = false;
   ComputeScrollbarExistence(should_have_horizontal_scrollbar,
                             should_have_vertical_scrollbar, ContentsSize());
-  scrollbar_manager_.SetHasHorizontalScrollbar(
-      should_have_horizontal_scrollbar);
-  scrollbar_manager_.SetHasVerticalScrollbar(should_have_vertical_scrollbar);
+  SetHasHorizontalScrollbar(should_have_horizontal_scrollbar);
+  SetHasVerticalScrollbar(should_have_vertical_scrollbar);
 
   if (has_horizontal_scrollbar != should_have_horizontal_scrollbar ||
       has_vertical_scrollbar != should_have_vertical_scrollbar) {
     ScrollbarExistenceDidChange();
 
     if (!VisualViewportSuppliesScrollbars())
       UpdateScrollbarGeometry();
   }
 }
 
@@ skipping 1355 matching lines @@
   bool new_has_vertical_scrollbar = false;
   ComputeScrollbarExistence(new_has_horizontal_scrollbar,
                             new_has_vertical_scrollbar, ContentsSize(), option);
 
   bool scrollbar_existence_changed =
       has_horizontal_scrollbar != new_has_horizontal_scrollbar ||
       has_vertical_scrollbar != new_has_vertical_scrollbar;
   if (!scrollbar_existence_changed)
     return false;
 
-  scrollbar_manager_.SetHasHorizontalScrollbar(new_has_horizontal_scrollbar);
-  scrollbar_manager_.SetHasVerticalScrollbar(new_has_vertical_scrollbar);
+  SetHasHorizontalScrollbar(new_has_horizontal_scrollbar);
+  SetHasVerticalScrollbar(new_has_vertical_scrollbar);
 
   if (scrollbars_suppressed_)
     return true;
 
   if (!HasOverlayScrollbars())
     ContentsResized();
   ScrollbarExistenceDidChange();
   return true;
 }
 
@@ skipping 41 matching lines @@
   needs_scrollbars_update_ = false;
 
   if (RuntimeEnabledFeatures::rootLayerScrollingEnabled())
     return;
 
   if (RuntimeEnabledFeatures::slimmingPaintInvalidationEnabled())
     SetNeedsPaintPropertyUpdate();
 
   // Avoid drawing two sets of scrollbars when visual viewport is enabled.
   if (VisualViewportSuppliesScrollbars()) {
-    scrollbar_manager_.SetHasHorizontalScrollbar(false);
-    scrollbar_manager_.SetHasVerticalScrollbar(false);
+    SetHasHorizontalScrollbar(false);
+    SetHasVerticalScrollbar(false);
     AdjustScrollOffsetFromUpdateScrollbars();
     return;
   }
 
   if (in_update_scrollbars_)
     return;
   InUpdateScrollbarsScope in_update_scrollbars_scope(this);
 
   bool scrollbar_existence_changed = false;
 
   if (NeedsScrollbarReconstruction()) {
-    scrollbar_manager_.SetHasHorizontalScrollbar(false);
-    scrollbar_manager_.SetHasVerticalScrollbar(false);
+    SetHasHorizontalScrollbar(false);
+    SetHasVerticalScrollbar(false);
     scrollbar_existence_changed = true;
   }
 
   int max_update_scrollbars_pass =
       HasOverlayScrollbars() || scrollbars_suppressed_ ? 1 : 3;
   for (int update_scrollbars_pass = 0;
        update_scrollbars_pass < max_update_scrollbars_pass;
        update_scrollbars_pass++) {
     if (!AdjustScrollbarExistence(update_scrollbars_pass ? kIncremental
                                                          : kFirstPass))
@@ skipping 985 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