Update from https://crrev.com/314320

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/debug/trace_event.h"
-#include "base/debug/trace_event_argument.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"
 #include "ui/gfx/geometry/point_conversions.h"
 #include "ui/gfx/geometry/quad_f.h"
 #include "ui/gfx/geometry/rect_conversions.h"
 #include "ui/gfx/geometry/size_conversions.h"
 #include "ui/gfx/geometry/vector2d_conversions.h"
 
 namespace cc {
-LayerImpl::LayerImpl(LayerTreeImpl* tree_impl, int id)
+LayerImpl::LayerImpl(LayerTreeImpl* layer_impl, int id)
+    : LayerImpl(layer_impl, id, new LayerImpl::SyncedScrollOffset) {
+}
+
+LayerImpl::LayerImpl(LayerTreeImpl* tree_impl,
+                     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_clip_layer_(nullptr),
       should_scroll_on_main_thread_(false),
       have_wheel_event_handlers_(false),
       have_scroll_event_handlers_(false),
       user_scrollable_horizontal_(true),
       user_scrollable_vertical_(true),
       stacking_order_changed_(false),
       double_sided_(true),
       should_flatten_transform_(true),
@@ skipping 175 matching lines @@
       continue;
 
     gfx::Rect request_in_layer_space = request->area();
     gfx::Rect request_in_content_space =
         LayerRectToContentRect(request_in_layer_space);
     request->set_area(MathUtil::MapEnclosingClippedRect(
         draw_properties_.target_space_transform, request_in_content_space));
   }
 
   layer_tree_impl()->RemoveLayerWithCopyOutputRequest(this);
+  layer_tree_impl()->set_needs_update_draw_properties();
 }
 
 void LayerImpl::ClearRenderSurfaceLayerList() {
   if (render_surface_)
     render_surface_->ClearLayerLists();
 }
 
 void LayerImpl::PopulateSharedQuadState(SharedQuadState* state) const {
   state->SetAll(
       draw_properties_.target_space_transform, draw_properties_.content_bounds,
@@ skipping 90 matching lines @@
                             bool resourceless_software_draw) {
   return false;
 }
 
 void LayerImpl::GetContentsResourceId(ResourceProvider::ResourceId* resource_id,
                                       gfx::Size* resource_size) const {
   NOTREACHED();
   *resource_id = 0;
 }
 
-void LayerImpl::SetSentScrollDelta(const gfx::Vector2dF& sent_scroll_delta) {
-  // Pending tree never has sent scroll deltas
-  DCHECK(layer_tree_impl()->IsActiveTree());
+gfx::Vector2dF LayerImpl::ScrollBy(const gfx::Vector2dF& scroll) {
+  RefreshFromScrollDelegate();
 
-  if (sent_scroll_delta_ == sent_scroll_delta)
-    return;
-
-  sent_scroll_delta_ = sent_scroll_delta;
-}
-
-gfx::Vector2dF LayerImpl::ScrollBy(const gfx::Vector2dF& scroll) {
-  gfx::Vector2dF adjusted_scroll = scroll;
+  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::Vector2dF min_delta = -ScrollOffsetToVector2dF(scroll_offset_);
-  gfx::Vector2dF max_delta = MaxScrollOffset().DeltaFrom(scroll_offset_);
-  // Clamp new_delta so that position + delta stays within scroll bounds.
-  gfx::Vector2dF new_delta = (ScrollDelta() + adjusted_scroll);
-  new_delta.SetToMax(min_delta);
-  new_delta.SetToMin(max_delta);
-  gfx::Vector2dF unscrolled =
-      ScrollDelta() + scroll - new_delta;
-  SetScrollDelta(new_delta);
+  gfx::ScrollOffset old_offset = CurrentScrollOffset();
+  gfx::ScrollOffset new_offset =
+      ClampScrollOffsetToLimits(old_offset + adjusted_scroll);
+  SetCurrentScrollOffset(new_offset);
 
-  return unscrolled;
+  gfx::ScrollOffset unscrolled =
+      old_offset + gfx::ScrollOffset(scroll) - new_offset;
+  return gfx::Vector2dF(unscrolled.x(), unscrolled.y());
 }
 
 void LayerImpl::SetScrollClipLayer(int scroll_clip_layer_id) {
   scroll_clip_layer_ = layer_tree_impl()->LayerById(scroll_clip_layer_id);
 }
 
 bool LayerImpl::user_scrollable(ScrollbarOrientation orientation) const {
   return (orientation == HORIZONTAL) ? user_scrollable_horizontal_
                                      : user_scrollable_vertical_;
 }
 
 void LayerImpl::ApplySentScrollDeltasFromAbortedCommit() {
-  if (sent_scroll_delta_.IsZero())
-    return;
-
-  // Pending tree never has sent scroll deltas
   DCHECK(layer_tree_impl()->IsActiveTree());
-
-  // The combination of pending tree and aborted commits with impl scrolls
-  // shouldn't happen; we don't know how to update its deltas correctly.
-  DCHECK(!layer_tree_impl()->FindPendingTreeLayerById(id()));
-
-  // Apply sent scroll deltas to scroll position / scroll delta as if the
-  // main thread had applied them and then committed those values.
-  SetScrollOffsetAndDelta(
-      scroll_offset_ + gfx::ScrollOffset(sent_scroll_delta_),
-      ScrollDelta() - sent_scroll_delta_);
-  SetSentScrollDelta(gfx::Vector2dF());
-}
-
-void LayerImpl::ApplyScrollDeltasSinceBeginMainFrame() {
-  // Only the pending tree can have missing scrolls.
-  DCHECK(layer_tree_impl()->IsPendingTree());
-  if (!scrollable())
-    return;
-
-  // Pending tree should never have sent scroll deltas.
-  DCHECK(sent_scroll_delta().IsZero());
-
-  LayerImpl* active_twin = layer_tree_impl()->FindActiveTreeLayerById(id());
-  if (active_twin) {
-    // Scrolls that happens after begin frame (where the sent scroll delta
-    // comes from) and commit need to be applied to the pending tree
-    // so that it is up to date with the total scroll.
-    SetScrollDelta(active_twin->ScrollDelta() -
-                   active_twin->sent_scroll_delta());
-  }
+  scroll_offset_->AbortCommit();
 }
 
 InputHandler::ScrollStatus LayerImpl::TryScroll(
     const gfx::PointF& screen_space_point,
     InputHandler::ScrollInputType type) const {
   if (should_scroll_on_main_thread()) {
     TRACE_EVENT0("cc", "LayerImpl::TryScroll: Failed ShouldScrollOnMainThread");
     return InputHandler::ScrollOnMainThread;
   }
 
@@ skipping 58 matching lines @@
   // values x and y, ceil((x / y) * y) may be x + 1.
   content_rect.Intersect(gfx::Rect(content_bounds()));
   return gfx::ToEnclosingRect(content_rect);
 }
 
 skia::RefPtr<SkPicture> LayerImpl::GetPicture() {
   return skia::RefPtr<SkPicture>();
 }
 
 scoped_ptr<LayerImpl> LayerImpl::CreateLayerImpl(LayerTreeImpl* tree_impl) {
-  return LayerImpl::Create(tree_impl, layer_id_);
+  return LayerImpl::Create(tree_impl, layer_id_, scroll_offset_);
 }
 
 void LayerImpl::PushPropertiesTo(LayerImpl* layer) {
   layer->SetTransformOrigin(transform_origin_);
   layer->SetBackgroundColor(background_color_);
   layer->SetBounds(bounds_);
   layer->SetContentBounds(content_bounds());
   layer->SetContentsScale(contents_scale_x(), contents_scale_y());
   layer->SetDoubleSided(double_sided_);
   layer->SetDrawCheckerboardForMissingTiles(
@@ skipping 19 matching lines @@
   layer->SetPositionConstraint(position_constraint_);
   layer->SetShouldFlattenTransform(should_flatten_transform_);
   layer->SetUseParentBackfaceVisibility(use_parent_backface_visibility_);
   layer->SetTransformAndInvertibility(transform_, transform_is_invertible_);
 
   layer->SetScrollClipLayer(scroll_clip_layer_ ? scroll_clip_layer_->id()
                                                : Layer::INVALID_ID);
   layer->set_user_scrollable_horizontal(user_scrollable_horizontal_);
   layer->set_user_scrollable_vertical(user_scrollable_vertical_);
 
-  // Save the difference but clear the sent delta so that we don't subtract
-  // it again in SetScrollOffsetAndDelta's pending twin mirroring logic.
-  gfx::Vector2dF remaining_delta =
-      layer_animation_controller_->scroll_offset_animation_was_interrupted()
-          ? gfx::Vector2dF()
-          : layer->ScrollDelta() - layer->sent_scroll_delta();
+  layer->SetScrollCompensationAdjustment(scroll_compensation_adjustment_);
 
-  layer->SetSentScrollDelta(gfx::Vector2dF());
-  layer->SetScrollOffsetAndDelta(scroll_offset_, remaining_delta);
+  layer->PushScrollOffset(nullptr);
 
   layer->Set3dSortingContextId(sorting_context_id_);
   layer->SetNumDescendantsThatDrawContent(num_descendants_that_draw_content_);
 
   LayerImpl* scroll_parent = nullptr;
   if (scroll_parent_) {
     scroll_parent = layer->layer_tree_impl()->LayerById(scroll_parent_->id());
     DCHECK(scroll_parent);
   }
 
@@ skipping 191 matching lines @@
   }
 
   for (size_t i = 0; i < children_.size(); ++i)
     children_[i]->ResetAllChangeTrackingForSubtree();
 
   needs_push_properties_ = false;
   num_dependents_need_push_properties_ = 0;
 }
 
 gfx::ScrollOffset LayerImpl::ScrollOffsetForAnimation() const {
-  return TotalScrollOffset();
+  return CurrentScrollOffset();
 }
 
 void LayerImpl::OnFilterAnimated(const FilterOperations& filters) {
   SetFilters(filters);
 }
 
 void LayerImpl::OnOpacityAnimated(float opacity) {
   SetOpacity(opacity);
 }
 
 void LayerImpl::OnTransformAnimated(const gfx::Transform& transform) {
   SetTransform(transform);
 }
 
 void LayerImpl::OnScrollOffsetAnimated(const gfx::ScrollOffset& scroll_offset) {
   // Only layers in the active tree should need to do anything here, since
   // layers in the pending tree will find out about these changes as a
-  // result of the call to SetScrollDelta.
+  // result of the shared SyncedProperty.
   if (!IsActive())
     return;
 
-  SetScrollDelta(scroll_offset.DeltaFrom(scroll_offset_));
+  SetCurrentScrollOffset(scroll_offset);
 
   layer_tree_impl_->DidAnimateScrollOffset();
 }
 
 void LayerImpl::OnAnimationWaitingForDeletion() {}
 
 bool LayerImpl::IsActive() const {
   return layer_tree_impl_->IsActiveTree();
 }
 
@@ skipping 295 matching lines @@
 
   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.
   DCHECK(!scroll_parent_);
-  if (!scroll_offset_delegate && scroll_offset_delegate_) {
-    scroll_delta_ = scroll_offset_delegate_->GetTotalScrollOffset().DeltaFrom(
-        scroll_offset_);
-  }
-  gfx::ScrollOffset total_offset = TotalScrollOffset();
+  RefreshFromScrollDelegate();
   scroll_offset_delegate_ = scroll_offset_delegate;
   if (scroll_offset_delegate_)
-    scroll_offset_delegate_->SetTotalScrollOffset(total_offset);
+    scroll_offset_delegate_->SetCurrentScrollOffset(CurrentScrollOffset());
 }
 
 bool LayerImpl::IsExternalFlingActive() const {
   return scroll_offset_delegate_ &&
          scroll_offset_delegate_->IsExternalFlingActive();
 }
 
-void LayerImpl::DidScroll() {
+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);
+}
+
+gfx::ScrollOffset LayerImpl::PullDeltaForMainThread() {
+  RefreshFromScrollDelegate();
+
+  // TODO(aelias, 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(),
+                          scroll_offset_->PendingDelta().get().y());
+}
+
+void LayerImpl::SetScrollDelta(const gfx::Vector2dF& delta) {
+  DCHECK(IsActive());
+  SetCurrentScrollOffset(scroll_offset_->ActiveBase() +
+                         gfx::ScrollOffset(delta));
+}
+
+gfx::ScrollOffset LayerImpl::BaseScrollOffset() const {
+  if (IsActive())
+    return scroll_offset_->ActiveBase();
+  else
+    return scroll_offset_->PendingBase();
+}
+
+void LayerImpl::PushScrollOffset(const gfx::ScrollOffset* scroll_offset) {
+  DCHECK(scroll_offset || IsActive());
+  bool changed = false;
+  if (scroll_offset) {
+    DCHECK(!IsActive() || !layer_tree_impl_->FindPendingTreeLayerById(id()));
+    changed |= scroll_offset_->PushFromMainThread(*scroll_offset);
+  }
+  if (IsActive()) {
+    changed |= scroll_offset_->PushPendingToActive();
+    if (layer_animation_controller_->scroll_offset_animation_was_interrupted())
+      SetScrollDelta(gfx::Vector2dF());
+  }
+
+  if (changed)
+    DidUpdateScrollOffset();
+}
+
+void LayerImpl::DidUpdateScrollOffset() {
+  if (scroll_offset_delegate_) {
+    scroll_offset_delegate_->SetCurrentScrollOffset(CurrentScrollOffset());
+    scroll_offset_delegate_->Update();
+    RefreshFromScrollDelegate();
+  }
+
   NoteLayerPropertyChangedForSubtree();
   ScrollbarParametersDidChange(false);
 }
 
-void LayerImpl::SetScrollOffset(const gfx::ScrollOffset& scroll_offset) {
-  SetScrollOffsetAndDelta(scroll_offset, ScrollDelta());
-}
-
-void LayerImpl::SetScrollOffsetAndDelta(const gfx::ScrollOffset& scroll_offset,
-                                        const gfx::Vector2dF& scroll_delta) {
-  bool changed = false;
-
-  last_scroll_offset_ = scroll_offset;
-
-  if (scroll_offset_ != scroll_offset) {
-    changed = true;
-    scroll_offset_ = scroll_offset;
-
-    if (scroll_offset_delegate_)
-      scroll_offset_delegate_->SetTotalScrollOffset(TotalScrollOffset());
-  }
-
-  if (ScrollDelta() != scroll_delta) {
-    changed = true;
-    if (layer_tree_impl()->IsActiveTree()) {
-      LayerImpl* pending_twin =
-          layer_tree_impl()->FindPendingTreeLayerById(id());
-      if (pending_twin) {
-        // The pending twin can't mirror the scroll delta of the active
-        // layer.  Although the delta - sent scroll delta difference is
-        // identical for both twins, the sent scroll delta for the pending
-        // layer is zero, as anything that has been sent has been baked
-        // into the layer's position/scroll offset as a part of commit.
-        DCHECK(pending_twin->sent_scroll_delta().IsZero());
-        pending_twin->SetScrollDelta(scroll_delta - sent_scroll_delta());
-      }
-    }
-
-    if (scroll_offset_delegate_) {
-      scroll_offset_delegate_->SetTotalScrollOffset(
-          ScrollOffsetWithDelta(scroll_offset_, scroll_delta));
-    } else {
-      scroll_delta_ = scroll_delta;
-    }
-  }
-
-  if (changed) {
-    if (scroll_offset_delegate_)
-      scroll_offset_delegate_->Update();
-    DidScroll();
-  }
-}
-
-gfx::Vector2dF LayerImpl::ScrollDelta() const {
-  if (scroll_offset_delegate_) {
-    return scroll_offset_delegate_->GetTotalScrollOffset().DeltaFrom(
-        scroll_offset_);
-  }
-  return scroll_delta_;
-}
-
-void LayerImpl::SetScrollDelta(const gfx::Vector2dF& scroll_delta) {
-  SetScrollOffsetAndDelta(scroll_offset_, scroll_delta);
-}
-
-gfx::ScrollOffset LayerImpl::TotalScrollOffset() const {
-  return ScrollOffsetWithDelta(scroll_offset_, ScrollDelta());
-}
-
 void LayerImpl::SetDoubleSided(bool double_sided) {
   if (double_sided_ == double_sided)
     return;
 
   double_sided_ = double_sided;
   NoteLayerPropertyChangedForSubtree();
 }
 
 SimpleEnclosedRegion LayerImpl::VisibleContentOpaqueRegion() const {
   if (contents_opaque())
     return SimpleEnclosedRegion(visible_content_rect());
   return SimpleEnclosedRegion();
 }
 
 void LayerImpl::DidBeginTracing() {}
 
 void LayerImpl::ReleaseResources() {}
 
 gfx::ScrollOffset LayerImpl::MaxScrollOffset() const {
   if (!scroll_clip_layer_ || bounds().IsEmpty())
     return gfx::ScrollOffset();
 
   LayerImpl const* page_scale_layer = layer_tree_impl()->page_scale_layer();
   DCHECK(this != page_scale_layer);
   DCHECK(this != layer_tree_impl()->InnerViewportScrollLayer() ||
          IsContainerForFixedPositionLayers());
 
-  gfx::SizeF scaled_scroll_bounds(BoundsForScrolling());
-
   float scale_factor = 1.f;
   for (LayerImpl const* current_layer = this;
-       current_layer != scroll_clip_layer_;
+       current_layer != scroll_clip_layer_->parent();
        current_layer = current_layer->parent()) {
-    DCHECK(current_layer);
-    float current_layer_scale = 1.f;
+    if (current_layer == page_scale_layer)
+      scale_factor = layer_tree_impl()->current_page_scale_factor();
+  }
 
-    const gfx::Transform& layer_transform = current_layer->transform();
-    if (current_layer == page_scale_layer) {
-      DCHECK(layer_transform.IsIdentity());
-      current_layer_scale = layer_tree_impl()->current_page_scale_factor();
-    } else {
-      // TODO(wjmaclean) Should we allow for translation too?
-      DCHECK(layer_transform.IsScale2d());
-      gfx::Vector2dF layer_scale = layer_transform.Scale2d();
-      // TODO(wjmaclean) Allow for non-isotropic scales.
-      DCHECK(layer_scale.x() == layer_scale.y());
-      current_layer_scale = layer_scale.x();
-    }
-
-    scale_factor *= current_layer_scale;
-  }
-  // TODO(wjmaclean) Once we move to a model where the two-viewport model is
-  // turned on in all builds, remove the next two lines. For now however, the
-  // page scale layer may coincide with the clip layer, and so this is
-  // necessary.
-  if (page_scale_layer == scroll_clip_layer_)
-    scale_factor *= layer_tree_impl()->current_page_scale_factor();
-
-  scaled_scroll_bounds.SetSize(scale_factor * scaled_scroll_bounds.width(),
-                               scale_factor * scaled_scroll_bounds.height());
+  gfx::SizeF scaled_scroll_bounds =
+      gfx::ToFlooredSize(gfx::ScaleSize(BoundsForScrolling(), scale_factor));
   scaled_scroll_bounds = gfx::ToFlooredSize(scaled_scroll_bounds);
 
   gfx::ScrollOffset max_offset(
       scaled_scroll_bounds.width() - scroll_clip_layer_->bounds().width(),
       scaled_scroll_bounds.height() - scroll_clip_layer_->bounds().height());
   // We need the final scroll offset to be in CSS coords.
   max_offset.Scale(1 / scale_factor);
   max_offset.SetToMax(gfx::ScrollOffset());
   return max_offset;
 }
 
+gfx::ScrollOffset LayerImpl::ClampScrollOffsetToLimits(
+    gfx::ScrollOffset offset) const {
+  offset.SetToMin(MaxScrollOffset());
+  offset.SetToMax(gfx::ScrollOffset());
+  return offset;
+}
+
 gfx::Vector2dF LayerImpl::ClampScrollToMaxScrollOffset() {
-  gfx::ScrollOffset max_offset = MaxScrollOffset();
-  gfx::ScrollOffset old_offset = TotalScrollOffset();
-  gfx::ScrollOffset clamped_offset = old_offset;
-
-  clamped_offset.SetToMin(max_offset);
-  clamped_offset.SetToMax(gfx::ScrollOffset());
+  gfx::ScrollOffset old_offset = CurrentScrollOffset();
+  gfx::ScrollOffset clamped_offset = ClampScrollOffsetToLimits(old_offset);
   gfx::Vector2dF delta = clamped_offset.DeltaFrom(old_offset);
   if (!delta.IsZero())
     ScrollBy(delta);
-
   return delta;
 }
 
 void LayerImpl::SetScrollbarPosition(ScrollbarLayerImplBase* scrollbar_layer,
                                      LayerImpl* scrollbar_clip_layer,
                                      bool on_resize) const {
   DCHECK(scrollbar_layer);
   LayerImpl* page_scale_layer = layer_tree_impl()->page_scale_layer();
 
   DCHECK(this != page_scale_layer);
   DCHECK(scrollbar_clip_layer);
   gfx::RectF clip_rect(gfx::PointF(),
                        scrollbar_clip_layer->BoundsForScrolling());
 
   // See comment in MaxScrollOffset() regarding the use of the content layer
   // bounds here.
   gfx::RectF scroll_rect(gfx::PointF(), BoundsForScrolling());
 
   if (scroll_rect.size().IsEmpty())
     return;
 
-  // TODO(wjmaclean) This computation is nearly identical to the one in
-  // MaxScrollOffset. Find some way to combine these.
   gfx::ScrollOffset current_offset;
   for (LayerImpl const* current_layer = this;
-       current_layer != scrollbar_clip_layer;
+       current_layer != scrollbar_clip_layer->parent();
        current_layer = current_layer->parent()) {
-    DCHECK(current_layer);
-    const gfx::Transform& layer_transform = current_layer->transform();
+    current_offset += current_layer->CurrentScrollOffset();
     if (current_layer == page_scale_layer) {
-      DCHECK(layer_transform.IsIdentity());
       float scale_factor = layer_tree_impl()->current_page_scale_factor();
       current_offset.Scale(scale_factor);
       scroll_rect.Scale(scale_factor);
-    } else {
-      DCHECK(layer_transform.IsScale2d());
-      gfx::Vector2dF layer_scale = layer_transform.Scale2d();
-      DCHECK(layer_scale.x() == layer_scale.y());
-      gfx::ScrollOffset new_offset = ScrollOffsetWithDelta(
-          current_layer->scroll_offset(), current_layer->ScrollDelta());
-      new_offset.Scale(layer_scale.x(), layer_scale.y());
-      current_offset += new_offset;
     }
   }
-  // TODO(wjmaclean) Once we move to a model where the two-viewport model is
-  // turned on in all builds, remove the next two lines. For now however, the
-  // page scale layer may coincide with the clip layer, and so this is
-  // necessary.
-  if (page_scale_layer == scrollbar_clip_layer) {
-    scroll_rect.Scale(layer_tree_impl()->current_page_scale_factor());
-    current_offset.Scale(layer_tree_impl()->current_page_scale_factor());
-  }
 
   bool scrollbar_needs_animation = false;
   scrollbar_needs_animation |= scrollbar_layer->SetVerticalAdjust(
       scrollbar_clip_layer->bounds_delta().y());
   if (scrollbar_layer->orientation() == HORIZONTAL) {
     float visible_ratio = clip_rect.width() / scroll_rect.width();
     scrollbar_needs_animation |=
         scrollbar_layer->SetCurrentPos(current_offset.x());
     scrollbar_needs_animation |=
         scrollbar_layer->SetMaximum(scroll_rect.width() - clip_rect.width());
     scrollbar_needs_animation |=
         scrollbar_layer->SetVisibleToTotalLengthRatio(visible_ratio);
   } else {
     float visible_ratio = clip_rect.height() / scroll_rect.height();
     scrollbar_needs_animation |=
         scrollbar_layer->SetCurrentPos(current_offset.y());
     scrollbar_needs_animation |=
         scrollbar_layer->SetMaximum(scroll_rect.height() - clip_rect.height());
     scrollbar_needs_animation |=
         scrollbar_layer->SetVisibleToTotalLengthRatio(visible_ratio);
   }
   if (scrollbar_needs_animation) {
     layer_tree_impl()->set_needs_update_draw_properties();
     // TODO(wjmaclean) The scrollbar animator for the pinch-zoom scrollbars
     // should activate for every scroll on the main frame, not just the
     // scrolls that move the pinch virtual viewport (i.e. trigger from
     // either inner or outer viewport).
     if (scrollbar_animation_controller_) {
-      // When both non-overlay and overlay scrollbars are both present, don't
-      // animate the overlay scrollbars when page scale factor is at the min.
-      // Non-overlay scrollbars also shouldn't trigger animations.
-      bool is_animatable_scrollbar =
-          scrollbar_layer->is_overlay_scrollbar() &&
-          ((layer_tree_impl()->current_page_scale_factor() >
-            layer_tree_impl()->min_page_scale_factor()) ||
-           !layer_tree_impl()->settings().use_pinch_zoom_scrollbars);
-      if (is_animatable_scrollbar)
+      // Non-overlay scrollbars shouldn't trigger animations.
+      if (scrollbar_layer->is_overlay_scrollbar())
         scrollbar_animation_controller_->DidScrollUpdate(on_resize);
     }
   }
 }
 
 void LayerImpl::DidBecomeActive() {
   if (layer_tree_impl_->settings().scrollbar_animator ==
       LayerTreeSettings::NoAnimator) {
     return;
   }
@@ skipping 101 matching lines @@
   state->SetInteger("layer_id", id());
   MathUtil::AddToTracedValue("bounds", bounds_, state);
 
   state->SetDouble("opacity", opacity());
 
   MathUtil::AddToTracedValue("position", position_, state);
 
   state->SetInteger("draws_content", DrawsContent());
   state->SetInteger("gpu_memory_usage", GPUMemoryUsageInBytes());
 
-  MathUtil::AddToTracedValue("scroll_offset", scroll_offset_, state);
+  MathUtil::AddToTracedValue(
+      "scroll_offset", scroll_offset_ ? scroll_offset_->Current(IsActive())
+                                      : gfx::ScrollOffset(),
+      state);
+
   MathUtil::AddToTracedValue("transform_origin", transform_origin_, state);
 
   bool clipped;
   gfx::QuadF layer_quad = MathUtil::MapQuad(
       screen_space_transform(),
       gfx::QuadF(gfx::Rect(content_bounds())),
       &clipped);
   MathUtil::AddToTracedValue("layer_quad", layer_quad, state);
   if (!touch_event_handler_region_.IsEmpty()) {
     state->BeginArray("touch_event_handler_region");
@@ skipping 117 matching lines @@
   SetNeedsPushProperties();
   layer_tree_impl()->set_needs_update_draw_properties();
   if (should_have_render_surface) {
     render_surface_ = make_scoped_ptr(new RenderSurfaceImpl(this));
     return;
   }
   render_surface_.reset();
 }
 
 }  // namespace cc