Refactor delegated scrolling in LayerImpl

cc/layers/layer_impl.cc

 // Copyright 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/layers/layer_impl.h"
 
 #include "base/json/json_reader.h"
 #include "base/strings/stringprintf.h"
 #include "base/trace_event/trace_event.h"
 #include "base/trace_event/trace_event_argument.h"
 #include "cc/animation/animation_registrar.h"
 #include "cc/animation/scrollbar_animation_controller.h"
 #include "cc/base/math_util.h"
 #include "cc/base/simple_enclosed_region.h"
 #include "cc/debug/debug_colors.h"
 #include "cc/debug/layer_tree_debug_state.h"
 #include "cc/debug/micro_benchmark_impl.h"
 #include "cc/debug/traced_value.h"
-#include "cc/input/layer_scroll_offset_delegate.h"
 #include "cc/layers/layer_utils.h"
 #include "cc/layers/painted_scrollbar_layer_impl.h"
 #include "cc/output/copy_output_request.h"
 #include "cc/quads/debug_border_draw_quad.h"
 #include "cc/quads/render_pass.h"
 #include "cc/trees/layer_tree_host_common.h"
 #include "cc/trees/layer_tree_impl.h"
 #include "cc/trees/layer_tree_settings.h"
 #include "cc/trees/proxy.h"
 #include "ui/gfx/geometry/box_f.h"
@@ skipping 12 matching lines @@
                      int id,
                      scoped_refptr<SyncedScrollOffset> scroll_offset)
     : parent_(nullptr),
       scroll_parent_(nullptr),
       clip_parent_(nullptr),
       mask_layer_id_(-1),
       replica_layer_id_(-1),
       layer_id_(id),
       layer_tree_impl_(tree_impl),
       scroll_offset_(scroll_offset),
-      scroll_offset_delegate_(nullptr),
+      scroll_offset_listener_(nullptr),
       scroll_clip_layer_(nullptr),
       should_scroll_on_main_thread_(false),
       have_wheel_event_handlers_(false),
       have_scroll_event_handlers_(false),
       scroll_blocks_on_(SCROLL_BLOCKS_ON_NONE),
       user_scrollable_horizontal_(true),
       user_scrollable_vertical_(true),
       stacking_order_changed_(false),
       double_sided_(true),
       should_flatten_transform_(true),
@@ skipping 95 matching lines @@
   }
 
   return false;
 }
 
 void LayerImpl::SetScrollParent(LayerImpl* parent) {
   if (scroll_parent_ == parent)
     return;
 
   // Having both a scroll parent and a scroll offset delegate is unsupported.
-  DCHECK(!scroll_offset_delegate_);
+  DCHECK(!scroll_offset_listener_);
 
   if (parent)
     DCHECK_EQ(layer_tree_impl()->LayerById(parent->id()), parent);
 
   scroll_parent_ = parent;
   SetNeedsPushProperties();
 }
 
 void LayerImpl::SetDebugInfo(
     scoped_refptr<base::trace_event::ConvertableToTraceFormat> other) {
@@ skipping 199 matching lines @@
   return RenderPassId(0, 0);
 }
 
 void LayerImpl::GetContentsResourceId(ResourceProvider::ResourceId* resource_id,
                                       gfx::Size* resource_size) const {
   NOTREACHED();
   *resource_id = 0;
 }
 
 gfx::Vector2dF LayerImpl::ScrollBy(const gfx::Vector2dF& scroll) {
-  RefreshFromScrollDelegate();
-
   gfx::ScrollOffset adjusted_scroll(scroll);
   if (layer_tree_impl()->settings().use_pinch_virtual_viewport) {
     if (!user_scrollable_horizontal_)
       adjusted_scroll.set_x(0);
     if (!user_scrollable_vertical_)
       adjusted_scroll.set_y(0);
   }
   DCHECK(scrollable());
   gfx::ScrollOffset old_offset = CurrentScrollOffset();
   gfx::ScrollOffset new_offset =
@@ skipping 701 matching lines @@
                                  float contents_scale_y) {
   if (this->contents_scale_x() == contents_scale_x &&
       this->contents_scale_y() == contents_scale_y)
     return;
 
   draw_properties_.contents_scale_x = contents_scale_x;
   draw_properties_.contents_scale_y = contents_scale_y;
   NoteLayerPropertyChanged();
 }
 
-void LayerImpl::SetScrollOffsetDelegate(
-    ScrollOffsetDelegate* scroll_offset_delegate) {
-  // Having both a scroll parent and a scroll offset delegate is unsupported.
+void LayerImpl::SetExternalScrollOffsetListener(
+    ExternalScrollOffsetListener* scroll_offset_listener) {
+  // Having both a scroll parent and an external scroll offset listener is
+  // unsupported.
   DCHECK(!scroll_parent_);
-  RefreshFromScrollDelegate();
-  scroll_offset_delegate_ = scroll_offset_delegate;
-  if (scroll_offset_delegate_)
-    scroll_offset_delegate_->SetCurrentScrollOffset(CurrentScrollOffset());
+  scroll_offset_listener_ = scroll_offset_listener;
+  if (scroll_offset_listener_)
+    scroll_offset_listener_->DidUpdateScrollOffset();
 }
 
 bool LayerImpl::IsExternalFlingActive() const {
-  return scroll_offset_delegate_ &&
-         scroll_offset_delegate_->IsExternalFlingActive();
+  return scroll_offset_listener_ &&
+         scroll_offset_listener_->IsExternalFlingActive();
 }
 
 void LayerImpl::SetCurrentScrollOffset(const gfx::ScrollOffset& scroll_offset) {
   DCHECK(IsActive());
   if (scroll_offset_->SetCurrent(scroll_offset))
     DidUpdateScrollOffset();
 }
 
 void LayerImpl::PushScrollOffsetFromMainThread(
     const gfx::ScrollOffset& scroll_offset) {
   PushScrollOffset(&scroll_offset);
 }
 
 void LayerImpl::PushScrollOffsetFromMainThreadAndClobberActiveValue(
     const gfx::ScrollOffset& scroll_offset) {
   scroll_offset_->set_clobber_active_value();
   PushScrollOffset(&scroll_offset);
 }
 
 gfx::ScrollOffset LayerImpl::PullDeltaForMainThread() {
-  RefreshFromScrollDelegate();
-
   // TODO(miletus): Remove all this temporary flooring machinery when
   // Blink fully supports fractional scrolls.
   gfx::ScrollOffset current_offset = CurrentScrollOffset();
   gfx::Vector2dF current_delta = ScrollDelta();
   gfx::Vector2dF floored_delta(floor(current_delta.x()),
                                floor(current_delta.y()));
   gfx::Vector2dF diff_delta = floored_delta - current_delta;
   gfx::ScrollOffset tmp_offset = ScrollOffsetWithDelta(current_offset,
                                                        diff_delta);
   scroll_offset_->SetCurrent(tmp_offset);
   gfx::ScrollOffset delta = scroll_offset_->PullDeltaForMainThread();
   scroll_offset_->SetCurrent(current_offset);
   return delta;
 }
 
-void LayerImpl::RefreshFromScrollDelegate() {
-  if (scroll_offset_delegate_) {
-    SetCurrentScrollOffset(
-        gfx::ScrollOffset(scroll_offset_delegate_->GetCurrentScrollOffset()));
-  }
-}
-
 gfx::ScrollOffset LayerImpl::CurrentScrollOffset() const {
   return scroll_offset_->Current(IsActive());
 }
 
 gfx::Vector2dF LayerImpl::ScrollDelta() const {
   if (IsActive())
     return gfx::Vector2dF(scroll_offset_->Delta().x(),
                           scroll_offset_->Delta().y());
   else
     return gfx::Vector2dF(scroll_offset_->PendingDelta().get().x(),
@@ skipping 22 matching lines @@
   }
   if (IsActive()) {
     changed |= scroll_offset_->PushPendingToActive();
   }
 
   if (changed)
     DidUpdateScrollOffset();
 }
 
 void LayerImpl::DidUpdateScrollOffset() {
-  if (scroll_offset_delegate_) {
-    scroll_offset_delegate_->SetCurrentScrollOffset(CurrentScrollOffset());
-    scroll_offset_delegate_->Update();
-    RefreshFromScrollDelegate();
+  if (scroll_offset_listener_) {
+    scroll_offset_listener_->DidUpdateScrollOffset();
   }
-
   NoteLayerPropertyChangedForSubtree();
   ScrollbarParametersDidChange(false);
 }
 
 void LayerImpl::SetDoubleSided(bool double_sided) {
   if (double_sided_ == double_sided)
     return;
 
   double_sided_ = double_sided;
   NoteLayerPropertyChangedForSubtree();
@@ skipping 403 matching lines @@
   gfx::Transform scaled_draw_transform =
       draw_properties_.target_space_transform;
   scaled_draw_transform.Scale(SK_MScalar1 / scale, SK_MScalar1 / scale);
   gfx::Size scaled_content_bounds =
       gfx::ToCeiledSize(gfx::ScaleSize(content_bounds(), scale));
   return MathUtil::MapEnclosingClippedRect(scaled_draw_transform,
                                            gfx::Rect(scaled_content_bounds));
 }
 
 }  // namespace cc