Update from https://crrev.com/318214

cc/input/top_controls_manager.cc

 // Copyright 2013 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/input/top_controls_manager.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "cc/animation/keyframed_animation_curve.h"
@@ skipping 21 matching lines @@
                                                 top_controls_show_threshold,
                                                 top_controls_hide_threshold));
 }
 
 TopControlsManager::TopControlsManager(TopControlsManagerClient* client,
                                        float top_controls_show_threshold,
                                        float top_controls_hide_threshold)
     : client_(client),
       animation_direction_(NO_ANIMATION),
       permitted_state_(BOTH),
-      current_scroll_delta_(0.f),
-      controls_scroll_begin_offset_(0.f),
+      accumulated_scroll_delta_(0.f),
+      baseline_content_offset_(0.f),
       top_controls_show_threshold_(top_controls_hide_threshold),
       top_controls_hide_threshold_(top_controls_show_threshold),
       pinch_gesture_active_(false) {
   CHECK(client_);
 }
 
 TopControlsManager::~TopControlsManager() {
 }
 
 float TopControlsManager::ControlsTopOffset() const {
@@ skipping 35 matching lines @@
     SetupAnimation(final_shown_ratio ? SHOWING_CONTROLS : HIDING_CONTROLS);
   } else {
     ResetAnimations();
     client_->SetCurrentTopControlsShownRatio(final_shown_ratio);
   }
 }
 
 void TopControlsManager::ScrollBegin() {
   DCHECK(!pinch_gesture_active_);
   ResetAnimations();
-  current_scroll_delta_ = 0.f;
-  controls_scroll_begin_offset_ = ContentTopOffset();
+  ResetBaseline();
 }
 
 gfx::Vector2dF TopControlsManager::ScrollBy(
     const gfx::Vector2dF& pending_delta) {
   if (pinch_gesture_active_)
     return pending_delta;
 
   if (permitted_state_ == SHOWN && pending_delta.y() > 0)
     return pending_delta;
   else if (permitted_state_ == HIDDEN && pending_delta.y() < 0)
     return pending_delta;
 
-  current_scroll_delta_ += pending_delta.y();
+  accumulated_scroll_delta_ += pending_delta.y();
 
   float old_offset = ContentTopOffset();
   client_->SetCurrentTopControlsShownRatio(
-      (controls_scroll_begin_offset_ - current_scroll_delta_) /
+      (baseline_content_offset_ - accumulated_scroll_delta_) /
       TopControlsHeight());
 
   // If the controls are fully visible, treat the current position as the
   // new baseline even if the gesture didn't end.
-  if (TopControlsShownRatio() == 1.f) {
-    current_scroll_delta_ = 0.f;
-    controls_scroll_begin_offset_ = ContentTopOffset();
-  }
+  if (TopControlsShownRatio() == 1.f)
+    ResetBaseline();
 
   ResetAnimations();
 
   gfx::Vector2dF applied_delta(0.f, old_offset - ContentTopOffset());
   return pending_delta - applied_delta;
 }
 
 void TopControlsManager::ScrollEnd() {
   DCHECK(!pinch_gesture_active_);
   StartAnimationIfNecessary();
 }
 
 void TopControlsManager::PinchBegin() {
   DCHECK(!pinch_gesture_active_);
   pinch_gesture_active_ = true;
   StartAnimationIfNecessary();
 }
 
 void TopControlsManager::PinchEnd() {
   DCHECK(pinch_gesture_active_);
   // Pinch{Begin,End} will always occur within the scope of Scroll{Begin,End},
   // so return to a state expected by the remaining scroll sequence.
   pinch_gesture_active_ = false;
   ScrollBegin();
 }
 
+void TopControlsManager::MainThreadHasStoppedFlinging() {
+  StartAnimationIfNecessary();
+}
+
 gfx::Vector2dF TopControlsManager::Animate(base::TimeTicks monotonic_time) {
   if (!top_controls_animation_ || !client_->HaveRootScrollLayer())
     return gfx::Vector2dF();
 
   base::TimeDelta time = monotonic_time - base::TimeTicks();
 
   float old_offset = ContentTopOffset();
   client_->SetCurrentTopControlsShownRatio(
       top_controls_animation_->GetValue(time));
 
@@ skipping 37 matching lines @@
   if (TopControlsShownRatio() >= 1.f - top_controls_hide_threshold_) {
     // If we're showing so much that the hide threshold won't trigger, show.
     SetupAnimation(SHOWING_CONTROLS);
   } else if (TopControlsShownRatio() <= top_controls_show_threshold_) {
     // If we're showing so little that the show threshold won't trigger, hide.
     SetupAnimation(HIDING_CONTROLS);
   } else {
     // If we could be either showing or hiding, we determine which one to
     // do based on whether or not the total scroll delta was moving up or
     // down.
-    SetupAnimation(current_scroll_delta_ <= 0.f ? SHOWING_CONTROLS
-                                                : HIDING_CONTROLS);
+    SetupAnimation(accumulated_scroll_delta_ <= 0.f ? SHOWING_CONTROLS
+                                                    : HIDING_CONTROLS);
   }
 }
 
 bool TopControlsManager::IsAnimationCompleteAtTime(base::TimeTicks time) {
   if (!top_controls_animation_)
     return true;
 
   base::TimeDelta animation_time = time - base::TimeTicks();
   float new_ratio = top_controls_animation_->GetValue(animation_time);
 
   if ((animation_direction_ == SHOWING_CONTROLS && new_ratio >= 1.f) ||
       (animation_direction_ == HIDING_CONTROLS && new_ratio <= 0.f)) {
     return true;
   }
   return false;
 }
 
+void TopControlsManager::ResetBaseline() {
+  accumulated_scroll_delta_ = 0.f;
+  baseline_content_offset_ = ContentTopOffset();
+}
+
 }  // namespace cc