Make aborted commits inform the scroll delegate.

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"
@@ skipping 382 matching lines @@
 
 bool LayerImpl::user_scrollable(ScrollbarOrientation orientation) const {
   return (orientation == HORIZONTAL) ? user_scrollable_horizontal_
                                      : user_scrollable_vertical_;
 }
 
 void LayerImpl::ApplySentScrollDeltasFromAbortedCommit() {
   // Pending tree never has sent scroll deltas
   DCHECK(layer_tree_impl()->IsActiveTree());
 
+  // The pending tree shouldn't exist during aborted commits; we don't know how

[danakj, 2014/11/04 21:11:34]

Can you maybe say the pending tree shouldn't exist during aborted commits while
doing an impl scroll?

Should there be an early out if the sent delta is empty? Won't we try apply an
empty scroll delta here for every aborted beginmainframe?

[aelias_OOO_until_Jul13, 2014/11/04 21:19:16]

Good idea.  I added an early return and made the comment more specific.

+  // to update its deltas in this case.
+  DCHECK(!layer_tree_impl()->FindPendingTreeLayerById(id()));

[enne (OOO), 2014/11/04 23:31:49]

Yeah, by definition there is no pending tree during an aborted commit, since a
commit is what creates a pending tree.  Even in the future when we send begin
main frame messages while there is a pending tree, the commit itself cannot
happen until the pending tree activates and a new pending tree is created during
the commit.

This DCHECK should really just check that the pending tree doesn't exist at all,
rather than the pending layer by id.

[aelias_OOO_until_Jul13, 2014/11/04 23:35:00]

Thanks for the clarification.  I wanted to check for the pending tree itself but
didn't find a public method for that and it didn't seem like I should add one
for a DCHECK.

+
   // Apply sent scroll deltas to scroll position / scroll delta as if the
   // main thread had applied them and then committed those values.
-  //
-  // This function should not change the total scroll offset; it just shifts
-  // some of the scroll delta to the scroll offset.  Therefore, adjust these
-  // variables directly rather than calling the scroll offset delegate to
-  // avoid sending it multiple spurious calls.
-  //
-  // Because of the way scroll delta is calculated with a delegate, this will
-  // leave the total scroll offset unchanged on this layer regardless of
-  // whether a delegate is being used.
-  scroll_offset_ += gfx::ScrollOffset(sent_scroll_delta_);
-  scroll_delta_ -= sent_scroll_delta_;
-  sent_scroll_delta_ = gfx::Vector2dF();
+  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());
@@ skipping 1162 matching lines @@
 
 void LayerImpl::NotifyAnimationFinished(
     base::TimeTicks monotonic_time,
     Animation::TargetProperty target_property,
     int group) {
   if (target_property == Animation::ScrollOffset)
     layer_tree_impl_->InputScrollAnimationFinished();
 }
 
 }  // namespace cc