Hide location bar on Javascript-initiated scroll.

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 "base/time.h"
@@ skipping 22 matching lines @@
                                                 top_controls_show_threshold,
                                                 top_controls_hide_threshold));
 }
 
 TopControlsManager::TopControlsManager(TopControlsManagerClient* client,
                                        float top_controls_height,
                                        float top_controls_show_threshold,
                                        float top_controls_hide_threshold)
     : client_(client),
       animation_direction_(NO_ANIMATION),
-      visibility_restriction_(NONE),
+      permitted_state_(BOTH),
       controls_top_offset_(0.f),
       top_controls_height_(top_controls_height),
       current_scroll_delta_(0.f),
       controls_scroll_begin_offset_(0.f),
       top_controls_show_height_(
           top_controls_height * top_controls_hide_threshold),
       top_controls_hide_height_(
           top_controls_height * (1.f - top_controls_show_threshold)) {
   CHECK(client_);
 }
 
 TopControlsManager::~TopControlsManager() {
 }
 
-void TopControlsManager::UpdateTopControlsState(bool enable_hiding,
-                                                bool enable_showing,
+void TopControlsManager::UpdateTopControlsState(TopControlsState constraints,
+                                                TopControlsState current,
                                                 bool animate) {
+  DCHECK(!(constraints == SHOWN && current == HIDDEN));
+  DCHECK(!(constraints == HIDDEN && current == SHOWN));
+
+  permitted_state_ = constraints;
+
+  // Don't do anything if it doesn't matter which state the controls are in.
+  if (constraints == BOTH && current == BOTH)
+    return;
+
+  // Don't do anything if there is no change in offset.
   float final_controls_position = 0.f;
-
-  if (enable_hiding && enable_showing) {
-    visibility_restriction_ = NONE;
-  } else if (enable_showing || !enable_hiding) {
-    visibility_restriction_ = ALWAYS_SHOWN;
-  } else {
-    visibility_restriction_ = ALWAYS_HIDDEN;
+  if (constraints == HIDDEN || current == HIDDEN) {
     final_controls_position = -top_controls_height_;
   }
+  if (final_controls_position == controls_top_offset_) {
+    return;
+  }
 
-  if (visibility_restriction_ != NONE &&
-      final_controls_position != controls_top_offset_) {
-    ResetAnimations();
-    if (animate) {
-      SetupAnimation(visibility_restriction_ == ALWAYS_SHOWN ?
-          SHOWING_CONTROLS : HIDING_CONTROLS);
-    } else {
-      controls_top_offset_ = final_controls_position;
-    }
-    client_->DidChangeTopControlsPosition();
+  AnimationDirection animation_direction = SHOWING_CONTROLS;
+  if (constraints == HIDDEN || current == HIDDEN)
+    animation_direction = HIDING_CONTROLS;
+  ResetAnimations();
+  if (animate) {
+    SetupAnimation(animation_direction);
+  } else {
+    controls_top_offset_ = final_controls_position;
   }
+  client_->DidChangeTopControlsPosition();
 }
 
 void TopControlsManager::ScrollBegin() {
   ResetAnimations();
   current_scroll_delta_ = 0.f;
   controls_scroll_begin_offset_ = controls_top_offset_;
 }
 
 gfx::Vector2dF TopControlsManager::ScrollBy(
     const gfx::Vector2dF pending_delta) {
-  if (visibility_restriction_ == ALWAYS_SHOWN && pending_delta.y() > 0)
+  if (permitted_state_ == SHOWN && pending_delta.y() > 0)
     return pending_delta;
-  else if (visibility_restriction_ == ALWAYS_HIDDEN && pending_delta.y() < 0)
+  else if (permitted_state_ == HIDDEN && pending_delta.y() < 0)
     return pending_delta;
 
   current_scroll_delta_ += pending_delta.y();
 
   float old_offset = controls_top_offset_;
   SetControlsTopOffset(controls_scroll_begin_offset_ - current_scroll_delta_);
 
   // If the controls are fully visible, treat the current position as the
   // new baseline even if the gesture didn't end.
   if (controls_top_offset_ == 0.f) {
@@ skipping 40 matching lines @@
 }
 
 void TopControlsManager::ResetAnimations() {
   if (top_controls_animation_)
     top_controls_animation_.reset();
 
   animation_direction_ = NO_ANIMATION;
 }
 
 void TopControlsManager::SetupAnimation(AnimationDirection direction) {
+  DCHECK(direction != NO_ANIMATION);
+
+  if (direction == SHOWING_CONTROLS && controls_top_offset_ == 0)
+    return;
+
+  if (direction == HIDING_CONTROLS &&
+      controls_top_offset_ == -top_controls_height_) {
+    return;
+  }
+
+  if (top_controls_animation_ && animation_direction_ == direction)
+    return;
+
   top_controls_animation_ = KeyframedFloatAnimationCurve::Create();
   double start_time =
       (base::TimeTicks::Now() - base::TimeTicks()).InMillisecondsF();
   top_controls_animation_->AddKeyframe(
       FloatKeyframe::Create(start_time, controls_top_offset_,
                             scoped_ptr<TimingFunction>()));
   float max_ending_offset =
       (direction == SHOWING_CONTROLS ? 1 : -1) * top_controls_height_;
   top_controls_animation_->AddKeyframe(
       FloatKeyframe::Create(start_time + kShowHideMaxDurationMs,
                             controls_top_offset_ + max_ending_offset,
                             EaseTimingFunction::Create()));
   animation_direction_ = direction;
+  client_->DidChangeTopControlsPosition();
 }
 
 void TopControlsManager::StartAnimationIfNecessary() {
   if (controls_top_offset_ != 0
       && controls_top_offset_ != -top_controls_height_) {
     AnimationDirection show_controls = NO_ANIMATION;
 
     if (controls_top_offset_ >= -top_controls_show_height_) {
       // If we're showing so much that the hide threshold won't trigger, show.
       show_controls = SHOWING_CONTROLS;
     } else if (controls_top_offset_ <= -top_controls_hide_height_) {
       // If we're showing so little that the show threshold won't trigger, hide.
       show_controls = 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.
       show_controls = current_scroll_delta_ <= 0.f ?
           SHOWING_CONTROLS : HIDING_CONTROLS;
     }
 
-    if (show_controls != NO_ANIMATION &&
-        (!top_controls_animation_ || animation_direction_ != show_controls)) {
+    if (show_controls != NO_ANIMATION)
       SetupAnimation(show_controls);
-      client_->DidChangeTopControlsPosition();
-    }
   }
 }
 
 bool TopControlsManager::IsAnimationCompleteAtTime(base::TimeTicks time) {
   if (!top_controls_animation_)
     return true;
 
   double time_ms = (time - base::TimeTicks()).InMillisecondsF();
   float new_offset = top_controls_animation_->GetValue(time_ms);
 
   if ((animation_direction_ == SHOWING_CONTROLS && new_offset >= 0) ||
       (animation_direction_ == HIDING_CONTROLS
           && new_offset <= -top_controls_height_)) {
     return true;
   }
   return false;
 }
 
 }  // namespace cc