Add a scroll threshold/marker to control hiding/showing top controls.

cc/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/top_controls_manager.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/time.h"
@@ skipping 16 matching lines @@
 scoped_ptr<TopControlsManager> TopControlsManager::Create(
     TopControlsManagerClient* client, float top_controls_height) {
   return make_scoped_ptr(new TopControlsManager(client, top_controls_height));
 }
 
 TopControlsManager::TopControlsManager(TopControlsManagerClient* client,
                                        float top_controls_height)
     : client_(client),
       animation_direction_(NO_ANIMATION),
       is_overlay_mode_(false),
-      scroll_readjustment_enabled_(false),
+      in_scroll_gesture_(false),
       top_controls_height_(top_controls_height),
       controls_top_offset_(0),
       content_top_offset_(top_controls_height),
-      previous_root_scroll_offset_(0.f) {
+      previous_root_scroll_offset_(0.f),
+      scroll_start_offset_(0.f) {
   CHECK(client_);
 }
 
 TopControlsManager::~TopControlsManager() {
 }
 
 void TopControlsManager::UpdateDrawPositions() {
   if (!client_->haveRootScrollLayer())
     return;
 
   // If the scroll position has changed underneath us (i.e. a javascript
   // scroll), then simulate a scroll that covers the delta.
   float scroll_total_y = RootScrollLayerTotalScrollY();
-  if (scroll_readjustment_enabled_
+  if (!in_scroll_gesture_
       && scroll_total_y != previous_root_scroll_offset_) {
     ScrollBy(gfx::Vector2dF(0, scroll_total_y - previous_root_scroll_offset_));
     StartAnimationIfNecessary();
     previous_root_scroll_offset_ = RootScrollLayerTotalScrollY();
   }
 }
 
 void TopControlsManager::ScrollBegin() {
   ResetAnimations();
-  scroll_readjustment_enabled_ = false;
+  in_scroll_gesture_ = true;
+  scroll_start_offset_ = RootScrollLayerTotalScrollY() + controls_top_offset_;
 }
 
 gfx::Vector2dF TopControlsManager::ScrollBy(
     const gfx::Vector2dF pending_delta) {
+  if (pending_delta.y() == 0)
+    return pending_delta;
+
+  float scroll_total_y = RootScrollLayerTotalScrollY();
+  if (in_scroll_gesture_ &&
+      ((pending_delta.y() > 0 && scroll_total_y < scroll_start_offset_) ||
+       (pending_delta.y() < 0 &&
+           scroll_total_y > scroll_start_offset_ + top_controls_height_))) {
+    return pending_delta;
+  }
+
   ResetAnimations();
   return ScrollInternal(pending_delta);
 }
 
 gfx::Vector2dF TopControlsManager::ScrollInternal(
     const gfx::Vector2dF pending_delta) {
   float scroll_total_y = RootScrollLayerTotalScrollY();
   float scroll_delta_y = pending_delta.y();
 
   float previous_controls_offset = controls_top_offset_;
   float previous_content_offset = content_top_offset_;
   bool previous_was_overlay = is_overlay_mode_;
 
   controls_top_offset_ -= scroll_delta_y;
   controls_top_offset_ = std::min(
       std::max(controls_top_offset_, -top_controls_height_), 0.f);
 
   if (scroll_total_y > 0 || (scroll_total_y == 0
       && content_top_offset_ < scroll_delta_y)) {
     is_overlay_mode_ = true;
-    content_top_offset_ = 0;
+
+    // The first case is where the page applies a scroll (javascript) and is
+    // being re-adjusted in a call to UpdateDrawPositions.  Instead of slamming
+    // the controls to the top, we adjust by the scroll delta until we reach
+    // zero as we expect.
+    if (scroll_total_y > 0 && content_top_offset_ != 0)
+      content_top_offset_ -= scroll_delta_y;
+    else
+      content_top_offset_ = 0;
   } else if (scroll_total_y <= 0 && (scroll_delta_y < 0
       || (scroll_delta_y > 0 && content_top_offset_ > 0))) {
     is_overlay_mode_ = false;
     content_top_offset_ -= scroll_delta_y;
   }
   content_top_offset_ = std::max(
       std::min(content_top_offset_,
                controls_top_offset_ + top_controls_height_), 0.f);
 
   gfx::Vector2dF applied_delta;
   if (!previous_was_overlay)
     applied_delta.set_y(previous_content_offset - content_top_offset_);
 
   if (is_overlay_mode_ != previous_was_overlay
       || previous_controls_offset != controls_top_offset_
       || previous_content_offset != content_top_offset_) {
     client_->setNeedsRedraw();
     client_->setNeedsUpdateDrawProperties();
   }
 
   return pending_delta - applied_delta;
 }
 
 void TopControlsManager::ScrollEnd() {
   StartAnimationIfNecessary();
   previous_root_scroll_offset_ = RootScrollLayerTotalScrollY();
-  scroll_readjustment_enabled_ = true;
+  in_scroll_gesture_ = false;
 }
 
 void TopControlsManager::Animate(base::TimeTicks monotonic_time) {
   if (!top_controls_animation_ || !client_->haveRootScrollLayer())
     return;
 
   double time = (monotonic_time - base::TimeTicks()).InMillisecondsF();
   float new_offset = top_controls_animation_->getValue(time);
   gfx::Vector2dF scroll_vector(0.f, -(new_offset - controls_top_offset_));
   ScrollInternal(scroll_vector);
@@ skipping 54 matching lines @@
 
   if ((animation_direction_ == SHOWING_CONTROLS && new_offset >= 0) ||
       (animation_direction_ == HIDING_CONTROLS
           && new_offset <= -top_controls_height_)) {
     return true;
   }
   return false;
 }
 
 }  // namespace cc