Deleted Widget/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 225 matching lines @@
 }
 
 DEFINE_TRACE(FrameView) {
   visitor->Trace(frame_);
   visitor->Trace(parent_);
   visitor->Trace(fragment_anchor_);
   visitor->Trace(scrollable_areas_);
   visitor->Trace(animating_scrollable_areas_);
   visitor->Trace(auto_size_info_);
   visitor->Trace(children_);
-  visitor->Trace(scrollbars_);
+  visitor->Trace(paint_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_);
   ScrollableArea::Trace(visitor);
 }
 
 void FrameView::Reset() {
@@ skipping 153 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()->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()->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()->RemoveScrollbar(
-      scrollbar);
   scrollbar->DisconnectFromScrollableArea();
   scrollbar = nullptr;
 }
 
 void FrameView::RecalculateCustomScrollbarStyle() {
   bool did_style_change = false;
   if (HorizontalScrollbar() && HorizontalScrollbar()->IsCustomScrollbar()) {
     HorizontalScrollbar()->StyleChanged();
     did_style_change = true;
   }
   if (VerticalScrollbar() && VerticalScrollbar()->IsCustomScrollbar()) {
     VerticalScrollbar()->StyleChanged();
     did_style_change = true;
   }
   if (did_style_change) {
     UpdateScrollbarGeometry();
     UpdateScrollCorner();
     PositionScrollbarLayers();
   }
 }
 
 void FrameView::InvalidateAllCustomScrollbarsOnActiveChanged() {
-  bool uses_window_inactive_selector =
-      frame_->GetDocument()->GetStyleEngine().UsesWindowInactiveSelector();
-
   for (const auto& child : children_) {
     if (child->IsFrameView())
       ToFrameView(child)->InvalidateAllCustomScrollbarsOnActiveChanged();
   }
 
-  for (const auto& scrollbar : scrollbars_) {
-    if (uses_window_inactive_selector && scrollbar->IsCustomScrollbar())
-      scrollbar->StyleChanged();
+  if (frame_->GetDocument()->GetStyleEngine().UsesWindowInactiveSelector()) {

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

Ditto: a separate CL for small cleanups like this helps to separate functional
from cleanup changes.

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

reverted

+    for (const auto& paint_scrollbar : paint_scrollbars_) {
+      if (paint_scrollbar->IsCustomScrollbar())
+        paint_scrollbar->StyleChanged();
+    }
+
+    RecalculateCustomScrollbarStyle();
   }
-
-  if (uses_window_inactive_selector)
-    RecalculateCustomScrollbarStyle();
 }
 
 void FrameView::Clear() {
   Reset();
   SetScrollbarsSuppressed(true);
 }
 
 bool FrameView::DidFirstLayout() const {
   return !first_layout_;
 }
@@ skipping 3351 matching lines @@
   DCHECK(child->Parent() == this);
 
   if (child->IsFrameView() &&
       !RuntimeEnabledFeatures::rootLayerScrollingEnabled())
     RemoveScrollableArea(ToFrameView(child));
 
   child->SetParent(nullptr);
   children_.erase(child);
 }
 
-void FrameView::RemoveScrollbar(Scrollbar* scrollbar) {
-  DCHECK(scrollbars_.Contains(scrollbar));
-  scrollbar->SetParent(nullptr);
-  scrollbars_.erase(scrollbar);
+void FrameView::RemovePaintScrollbar(Scrollbar* scrollbar) {
+  DCHECK(paint_scrollbars_.Contains(scrollbar));
+  paint_scrollbars_.erase(scrollbar);
 }
 
-void FrameView::AddScrollbar(Scrollbar* scrollbar) {
-  DCHECK(!scrollbars_.Contains(scrollbar));
-  scrollbar->SetParent(this);
-  scrollbars_.insert(scrollbar);
+void FrameView::AddPaintScrollbar(Scrollbar* scrollbar) {
+  DCHECK(!paint_scrollbars_.Contains(scrollbar));
+  paint_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();
@@ skipping 831 matching lines @@
 }
 
 IntPoint FrameView::ConvertToRootFrame(const IntPoint& local_point) const {
   if (parent_) {
     IntPoint parent_point = ConvertToContainingFrameView(local_point);
     return parent_->ConvertToRootFrame(parent_point);
   }
   return local_point;
 }
 
+IntRect FrameView::ConvertFromRootFrame(
+    const IntRect& rect_in_root_frame) const {
+  if (parent_) {
+    IntRect parent_rect = parent_->ConvertFromRootFrame(rect_in_root_frame);
+    return ConvertFromContainingFrameView(parent_rect);
+  }
+  return rect_in_root_frame;
+}
+
+IntPoint FrameView::ConvertFromRootFrame(
+    const IntPoint& point_in_root_frame) const {
+  if (parent_) {
+    IntPoint parent_point = parent_->ConvertFromRootFrame(point_in_root_frame);
+    return ConvertFromContainingFrameView(parent_point);
+  }
+  return point_in_root_frame;
+}
+
+FloatPoint FrameView::ConvertFromRootFrame(
+    const FloatPoint& point_in_root_frame) const {
+  // FrameViews / windows are required to be IntPoint aligned, but we may
+  // need to convert FloatPoint values within them (eg. for event
+  // co-ordinates).
+  IntPoint floored_point = FlooredIntPoint(point_in_root_frame);
+  FloatPoint parent_point = ConvertFromRootFrame(floored_point);
+  FloatSize window_fraction = point_in_root_frame - floored_point;
+  // Use linear interpolation handle any fractional value (eg. for iframes
+  // subject to a transform beyond just a simple translation).
+  // FIXME: Add FloatPoint variants of all co-ordinate space conversion APIs.
+  if (!window_fraction.IsEmpty()) {
+    const int kFactor = 1000;
+    IntPoint parent_line_end = ConvertFromRootFrame(
+        floored_point + RoundedIntSize(window_fraction.ScaledBy(kFactor)));
+    FloatSize parent_fraction =
+        (parent_line_end - parent_point).ScaledBy(1.0f / kFactor);
+    parent_point.Move(parent_fraction);
+  }
+  return parent_point;
+}
+
 IntPoint FrameView::ConvertFromContainingFrameViewToScrollbar(
     const Scrollbar& scrollbar,
     const IntPoint& parent_point) const {
   IntPoint new_point = parent_point;
   // Scrollbars won't be transformed within us
   new_point.MoveBy(-scrollbar.Location());
   return new_point;
 }
 
 static void SetNeedsCompositingUpdate(LayoutViewItem layout_view_item,
@@ skipping 601 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