Convert scroll offsets to use SyncedProperty.

cc/trees/layer_tree_host_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_host_impl.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "base/basictypes.h"
@@ skipping 70 matching lines @@
 namespace cc {
 namespace {
 
 // Small helper class that saves the current viewport location as the user sees
 // it and resets to the same location.
 class ViewportAnchor {
  public:
   ViewportAnchor(LayerImpl* inner_scroll, LayerImpl* outer_scroll)
   : inner_(inner_scroll),
     outer_(outer_scroll) {
-    viewport_in_content_coordinates_ = inner_->TotalScrollOffset();
+    viewport_in_content_coordinates_ = inner_->CurrentScrollOffset();
 
     if (outer_)
-      viewport_in_content_coordinates_ += outer_->TotalScrollOffset();
+      viewport_in_content_coordinates_ += outer_->CurrentScrollOffset();
   }
 
   void ResetViewportToAnchoredPosition() {
     DCHECK(outer_);
 
     inner_->ClampScrollToMaxScrollOffset();
     outer_->ClampScrollToMaxScrollOffset();
 
-    gfx::ScrollOffset viewport_location = inner_->TotalScrollOffset() +
-                                          outer_->TotalScrollOffset();
+    gfx::ScrollOffset viewport_location =
+        inner_->CurrentScrollOffset() + outer_->CurrentScrollOffset();
 
     gfx::Vector2dF delta =
         viewport_in_content_coordinates_.DeltaFrom(viewport_location);
 
     delta = outer_->ScrollBy(delta);
     inner_->ScrollBy(delta);
   }
 
  private:
   LayerImpl* inner_;
@@ skipping 178 matching lines @@
 void LayerTreeHostImpl::BeginCommit() {
   TRACE_EVENT0("cc", "LayerTreeHostImpl::BeginCommit");
 
   if (UsePendingTreeForSync())
     CreatePendingTree();
 }
 
 void LayerTreeHostImpl::CommitComplete() {
   TRACE_EVENT0("cc", "LayerTreeHostImpl::CommitComplete");
 
-  if (pending_tree_)
-    pending_tree_->ApplyScrollDeltasSinceBeginMainFrame();
   sync_tree()->set_needs_update_draw_properties();
 
   if (settings_.impl_side_painting) {
     // Impl-side painting needs an update immediately post-commit to have the
     // opportunity to create tilings.  Other paths can call UpdateDrawProperties
     // more lazily when needed prior to drawing.
     sync_tree()->UpdateDrawProperties();
     // Start working on newly created tiles immediately if needed.
     if (tile_manager_ && tile_priorities_dirty_)
       PrepareTiles();
@@ skipping 2127 matching lines @@
   // behavior as ScrollBy to determine which layer to animate, but we do not
   // do the Android-specific things in ScrollBy like showing top controls.
   InputHandler::ScrollStatus scroll_status = ScrollBegin(viewport_point, Wheel);
   if (scroll_status == ScrollStarted) {
     gfx::Vector2dF pending_delta = scroll_delta;
     for (LayerImpl* layer_impl = CurrentlyScrollingLayer(); layer_impl;
          layer_impl = layer_impl->parent()) {
       if (!layer_impl->scrollable())
         continue;
 
-      gfx::ScrollOffset current_offset = layer_impl->TotalScrollOffset();
+      gfx::ScrollOffset current_offset = layer_impl->CurrentScrollOffset();
       gfx::ScrollOffset target_offset =
           ScrollOffsetWithDelta(current_offset, pending_delta);
       target_offset.SetToMax(gfx::ScrollOffset());
       target_offset.SetToMin(layer_impl->MaxScrollOffset());
       gfx::Vector2dF actual_delta = target_offset.DeltaFrom(current_offset);
 
       const float kEpsilon = 0.1f;
       bool can_layer_scroll = (std::abs(actual_delta.x()) > kEpsilon ||
                                std::abs(actual_delta.y()) > kEpsilon);
 
@@ skipping 69 matching lines @@
     return gfx::Vector2dF();
 
   // local_start_point and local_end_point are in content space but we want to
   // move them to layer space for scrolling.
   float width_scale = 1.f / layer_impl->contents_scale_x();
   float height_scale = 1.f / layer_impl->contents_scale_y();
   local_start_point.Scale(width_scale, height_scale);
   local_end_point.Scale(width_scale, height_scale);
 
   // Apply the scroll delta.
-  gfx::Vector2dF previous_delta = layer_impl->ScrollDelta();
+  gfx::ScrollOffset previous_offset = layer_impl->CurrentScrollOffset();
   layer_impl->ScrollBy(local_end_point - local_start_point);
+  gfx::ScrollOffset scrolled =
+      layer_impl->CurrentScrollOffset() - previous_offset;
 
   // Get the end point in the layer's content space so we can apply its
   // ScreenSpaceTransform.
-  gfx::PointF actual_local_end_point = local_start_point +
-                                       layer_impl->ScrollDelta() -
-                                       previous_delta;
+  gfx::PointF actual_local_end_point =
+      local_start_point + gfx::Vector2dF(scrolled.x(), scrolled.y());
   gfx::PointF actual_local_content_end_point =
       gfx::ScalePoint(actual_local_end_point,
                       1.f / width_scale,
                       1.f / height_scale);
 
   // Calculate the applied scroll delta in viewport space coordinates.
   gfx::PointF actual_screen_space_end_point =
       MathUtil::MapPoint(layer_impl->screen_space_transform(),
                          actual_local_content_end_point,
                          &end_clipped);
   DCHECK(!end_clipped);
   if (end_clipped)
     return gfx::Vector2dF();
   gfx::PointF actual_viewport_end_point =
       gfx::ScalePoint(actual_screen_space_end_point,
                       1.f / scale_from_viewport_to_screen_space);
   return actual_viewport_end_point - viewport_point;
 }
 
 static gfx::Vector2dF ScrollLayerWithLocalDelta(
     LayerImpl* layer_impl,
     const gfx::Vector2dF& local_delta,
     float page_scale_factor) {
-  gfx::Vector2dF previous_delta(layer_impl->ScrollDelta());
+  gfx::ScrollOffset previous_offset = layer_impl->CurrentScrollOffset();
   gfx::Vector2dF delta = local_delta;
   delta.Scale(1.f / page_scale_factor);
   layer_impl->ScrollBy(delta);
-  return layer_impl->ScrollDelta() - previous_delta;
+  gfx::ScrollOffset scrolled =
+      layer_impl->CurrentScrollOffset() - previous_offset;
+  return gfx::Vector2dF(scrolled.x(), scrolled.y());
 }
 
 bool LayerTreeHostImpl::ShouldTopControlsConsumeScroll(
     const gfx::Vector2dF& scroll_delta) const {
   DCHECK(CurrentlyScrollingLayer());
 
   if (!top_controls_manager_)
     return false;
 
   // Always consume if it's in the direction to show the top controls.
@@ skipping 429 matching lines @@
   // scales that we want when we're not inside a pinch.
   active_tree_->set_needs_update_draw_properties();
   SetNeedsRedraw();
 }
 
 static void CollectScrollDeltas(ScrollAndScaleSet* scroll_info,
                                 LayerImpl* layer_impl) {
   if (!layer_impl)
     return;
 
-  gfx::Vector2d scroll_delta =
-      gfx::ToFlooredVector2d(layer_impl->ScrollDelta());
+  layer_impl->RefreshScrollDelegate();
+  gfx::ScrollOffset scroll_delta =
+      layer_impl->scroll_offset()->PullDeltaForMainThread();
+
   if (!scroll_delta.IsZero()) {
     LayerTreeHostCommon::ScrollUpdateInfo scroll;
     scroll.layer_id = layer_impl->id();
-    scroll.scroll_delta = scroll_delta;
+    scroll.scroll_delta = gfx::Vector2d(scroll_delta.x(), scroll_delta.y());
     scroll_info->scrolls.push_back(scroll);
-    layer_impl->SetSentScrollDelta(scroll_delta);
   }
 
   for (size_t i = 0; i < layer_impl->children().size(); ++i)
     CollectScrollDeltas(scroll_info, layer_impl->children()[i]);
 }
 
 scoped_ptr<ScrollAndScaleSet> LayerTreeHostImpl::ProcessScrollDeltas() {
   scoped_ptr<ScrollAndScaleSet> scroll_info(new ScrollAndScaleSet());
 
   CollectScrollDeltas(scroll_info.get(), active_tree_->root_layer());
@@ skipping 456 matching lines @@
 }
 
 void LayerTreeHostImpl::UnregisterPictureLayerImpl(PictureLayerImpl* layer) {
   std::vector<PictureLayerImpl*>::iterator it =
       std::find(picture_layers_.begin(), picture_layers_.end(), layer);
   DCHECK(it != picture_layers_.end());
   picture_layers_.erase(it);
 }
 
 }  // namespace cc