Make LayerScrollOffsetDelegate updates consistent.

cc/trees/layer_tree_impl.cc

 // Copyright 2011 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/trees/layer_tree_impl.h"
 
 #include <limits>
 #include <set>
 
 #include "base/debug/trace_event.h"
@@ skipping 14 matching lines @@
 #include "cc/trees/layer_tree_host_impl.h"
 #include "ui/gfx/point_conversions.h"
 #include "ui/gfx/size_conversions.h"
 #include "ui/gfx/vector2d_conversions.h"
 
 namespace cc {
 
 // This class exists to split the LayerScrollOffsetDelegate between the
 // InnerViewportScrollLayer and the OuterViewportScrollLayer in a manner
 // that never requires the embedder or LayerImpl to know about.
-class LayerScrollOffsetDelegateProxy : public LayerScrollOffsetDelegate {
+class LayerScrollOffsetDelegateProxy : public LayerImpl::ScrollOffsetDelegate {
  public:
   LayerScrollOffsetDelegateProxy(LayerImpl* layer,
                                  LayerScrollOffsetDelegate* delegate,
                                  LayerTreeImpl* layer_tree)
       : layer_(layer), delegate_(delegate), layer_tree_impl_(layer_tree) {}
+  virtual ~LayerScrollOffsetDelegateProxy() {}
 
   gfx::Vector2dF last_set_scroll_offset() const {
     return last_set_scroll_offset_;
   }
 
   // LayerScrollOffsetDelegate implementation.
-
   virtual void SetTotalScrollOffset(const gfx::Vector2dF& new_offset) OVERRIDE {
     last_set_scroll_offset_ = new_offset;
     layer_tree_impl_->UpdateScrollOffsetDelegate();
   }
 
   virtual gfx::Vector2dF GetTotalScrollOffset() OVERRIDE {
     return layer_tree_impl_->GetDelegatedScrollOffset(layer_);
   }
 
   virtual bool IsExternalFlingActive() const OVERRIDE {
     return delegate_->IsExternalFlingActive();
   }
 
-  // Functions below this point are never called by LayerImpl on its
-  // LayerScrollOffsetDelegate, and so are not implemented.
-  virtual void SetMaxScrollOffset(const gfx::Vector2dF&) OVERRIDE {
-    NOTIMPLEMENTED();
-  }
-
-  virtual void SetTotalPageScaleFactorAndLimits(float, float, float) OVERRIDE {
-    NOTIMPLEMENTED();
-  }
-
-  virtual void SetScrollableSize(const gfx::SizeF& scrollable_size) OVERRIDE {
-    NOTIMPLEMENTED();
-  }
-
  private:
   LayerImpl* layer_;
   LayerScrollOffsetDelegate* delegate_;
   LayerTreeImpl* layer_tree_impl_;
   gfx::Vector2dF last_set_scroll_offset_;
 };
 
 LayerTreeImpl::LayerTreeImpl(LayerTreeHostImpl* layer_tree_host_impl)
     : layer_tree_host_impl_(layer_tree_host_impl),
       source_frame_number_(-1),
@@ skipping 228 matching lines @@
   if (min_page_scale_factor == min_page_scale_factor_ &&
       max_page_scale_factor == max_page_scale_factor_ &&
       page_scale_factor == page_scale_factor_)
     return;
 
   min_page_scale_factor_ = min_page_scale_factor;
   max_page_scale_factor_ = max_page_scale_factor;
   page_scale_factor_ = page_scale_factor;
 
   if (root_layer_scroll_offset_delegate_) {
-    root_layer_scroll_offset_delegate_->SetTotalPageScaleFactorAndLimits(
+    root_layer_scroll_offset_delegate_->UpdateRootLayerState(
+        TotalScrollOffset(),
+        TotalMaxScrollOffset(),
+        ScrollableSize(),
         total_page_scale_factor(),
         this->min_page_scale_factor(),
         this->max_page_scale_factor());
   }
 
   ForceScrollbarParameterUpdateAfterScaleChange(page_scale_layer());
 }
 
 void LayerTreeImpl::SetPageScaleDelta(float delta) {
   // Clamp to the current min/max limits.
@@ skipping 13 matching lines @@
     if (pending_tree) {
       DCHECK_EQ(1, pending_tree->sent_page_scale_delta());
       pending_tree->SetPageScaleDelta(
           page_scale_delta_ / sent_page_scale_delta_);
     }
   }
 
   set_needs_update_draw_properties();
 
   if (root_layer_scroll_offset_delegate_) {
-    root_layer_scroll_offset_delegate_->SetTotalPageScaleFactorAndLimits(
+    root_layer_scroll_offset_delegate_->UpdateRootLayerState(
+        TotalScrollOffset(),
+        TotalMaxScrollOffset(),
+        ScrollableSize(),
         total_page_scale_factor(),
         min_page_scale_factor(),
         max_page_scale_factor());
   }
 }
 
 gfx::SizeF LayerTreeImpl::ScrollableViewportSize() const {
   if (outer_viewport_scroll_layer_)
     return layer_tree_host_impl_->UnscaledScrollableViewportSize();
   else
@@ skipping 443 matching lines @@
       InnerViewportScrollLayer()->SetScrollOffsetDelegate(NULL);
     if (OuterViewportScrollLayer())
       OuterViewportScrollLayer()->SetScrollOffsetDelegate(NULL);
     inner_viewport_scroll_delegate_proxy_.reset();
     outer_viewport_scroll_delegate_proxy_.reset();
   }
 
   root_layer_scroll_offset_delegate_ = root_layer_scroll_offset_delegate;
 
   if (root_layer_scroll_offset_delegate_) {
-    root_layer_scroll_offset_delegate_->SetTotalScrollOffset(
-        TotalScrollOffset());
-    root_layer_scroll_offset_delegate_->SetMaxScrollOffset(
-        TotalMaxScrollOffset());
-    root_layer_scroll_offset_delegate_->SetScrollableSize(ScrollableSize());
-    root_layer_scroll_offset_delegate_->SetTotalPageScaleFactorAndLimits(
+    root_layer_scroll_offset_delegate_->UpdateRootLayerState(
+        TotalScrollOffset(),
+        TotalMaxScrollOffset(),
+        ScrollableSize(),
         total_page_scale_factor(),
         min_page_scale_factor(),
         max_page_scale_factor());
 
     if (inner_viewport_scroll_layer_) {
       inner_viewport_scroll_delegate_proxy_ = make_scoped_ptr(
           new LayerScrollOffsetDelegateProxy(InnerViewportScrollLayer(),
                                              root_layer_scroll_offset_delegate_,
                                              this));
       inner_viewport_scroll_layer_->SetScrollOffsetDelegate(
@@ skipping 14 matching lines @@
 void LayerTreeImpl::UpdateScrollOffsetDelegate() {
   DCHECK(InnerViewportScrollLayer());
   DCHECK(root_layer_scroll_offset_delegate_);
 
   gfx::Vector2dF offset =
       inner_viewport_scroll_delegate_proxy_->last_set_scroll_offset();
 
   if (OuterViewportScrollLayer())
     offset += outer_viewport_scroll_delegate_proxy_->last_set_scroll_offset();
 
-  root_layer_scroll_offset_delegate_->SetTotalScrollOffset(offset);
-  root_layer_scroll_offset_delegate_->SetMaxScrollOffset(
-      TotalMaxScrollOffset());
+  root_layer_scroll_offset_delegate_->UpdateRootLayerState(
+      offset,
+      TotalMaxScrollOffset(),
+      ScrollableSize(),
+      total_page_scale_factor(),
+      min_page_scale_factor(),
+      max_page_scale_factor());
 }
 
 gfx::Vector2dF LayerTreeImpl::GetDelegatedScrollOffset(LayerImpl* layer) {
   DCHECK(root_layer_scroll_offset_delegate_);
   DCHECK(InnerViewportScrollLayer());
   if (layer == InnerViewportScrollLayer() && !OuterViewportScrollLayer())
     return root_layer_scroll_offset_delegate_->GetTotalScrollOffset();
 
   // If we get here, we have both inner/outer viewports, and need to distribute
   // the scroll offset between them.
@@ skipping 404 matching lines @@
 LayerImpl* LayerTreeImpl::FindLayerThatIsHitByPointInTouchHandlerRegion(
     const gfx::PointF& screen_space_point) {
   FindTouchEventLayerFunctor func = {screen_space_point};
   FindClosestMatchingLayerDataForRecursion data_for_recursion;
   FindClosestMatchingLayer(
       screen_space_point, root_layer(), func, &data_for_recursion);
   return data_for_recursion.closest_match;
 }
 
 }  // namespace cc