Do not EASE_IN_OUT after fling, rather EASE_OUT.

athena/home/home_card_impl.cc

 // Copyright 2014 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 "athena/home/home_card_impl.h"
 
 #include <cmath>
 #include <limits>
 
 #include "athena/env/public/athena_env.h"
 #include "athena/home/app_list_view_delegate.h"
 #include "athena/home/athena_start_page_view.h"
 #include "athena/home/home_card_constants.h"
 #include "athena/home/minimized_home.h"
 #include "athena/home/public/app_model_builder.h"
 #include "athena/screen/public/screen_manager.h"
 #include "athena/util/container_priorities.h"
 #include "athena/wm/public/window_manager.h"
 #include "ui/app_list/search_provider.h"
 #include "ui/app_list/views/app_list_main_view.h"
 #include "ui/app_list/views/contents_view.h"
 #include "ui/aura/layout_manager.h"
 #include "ui/aura/window.h"
 #include "ui/compositor/layer.h"
 #include "ui/compositor/scoped_layer_animation_settings.h"
+#include "ui/gfx/animation/tween.h"
 #include "ui/views/layout/fill_layout.h"
 #include "ui/views/widget/widget.h"
 #include "ui/views/widget/widget_delegate.h"
 #include "ui/wm/core/shadow_types.h"
 #include "ui/wm/core/visibility_controller.h"
 #include "ui/wm/public/activation_client.h"
 
 namespace athena {
 namespace {
 
@@ skipping 31 matching lines @@
 // Makes sure the homecard is center-aligned horizontally and bottom-aligned
 // vertically.
 class HomeCardLayoutManager : public aura::LayoutManager {
  public:
   HomeCardLayoutManager()
       : home_card_(NULL),
         minimized_layer_(NULL) {}
 
   virtual ~HomeCardLayoutManager() {}
 
-  void Layout(bool animate) {
+  void Layout(bool animate, gfx::Tween::Type tween_type) {
     // |home_card| could be detached from the root window (e.g. when it is being
     // destroyed).
     if (!home_card_ || !home_card_->IsVisible() || !home_card_->GetRootWindow())
       return;
 
     scoped_ptr<ui::ScopedLayerAnimationSettings> settings;
     if (animate) {
       settings.reset(new ui::ScopedLayerAnimationSettings(
           home_card_->layer()->GetAnimator()));
-      settings->SetTweenType(gfx::Tween::EASE_IN_OUT);
+      settings->SetTweenType(tween_type);
     }
     SetChildBoundsDirect(home_card_, GetBoundsForState(
         home_card_->GetRootWindow()->bounds(), HomeCard::Get()->GetState()));
   }
 
   void SetMinimizedLayer(ui::Layer* minimized_layer) {
     minimized_layer_ = minimized_layer;
     UpdateMinimizedHomeBounds();
   }
 
  private:
   void UpdateMinimizedHomeBounds() {
     gfx::Rect minimized_bounds = minimized_layer_->parent()->bounds();
     minimized_bounds.set_y(
         minimized_bounds.bottom() - kHomeCardMinimizedHeight);
     minimized_bounds.set_height(kHomeCardMinimizedHeight);
     minimized_layer_->SetBounds(minimized_bounds);
   }
 
   // aura::LayoutManager:
   virtual void OnWindowResized() OVERRIDE {
-    Layout(false);
+    Layout(false, gfx::Tween::LINEAR);
     UpdateMinimizedHomeBounds();
   }
   virtual void OnWindowAddedToLayout(aura::Window* child) OVERRIDE {
     if (!home_card_) {
       home_card_ = child;
-      Layout(false);
+      Layout(false, gfx::Tween::LINEAR);
     }
   }
   virtual void OnWillRemoveWindowFromLayout(aura::Window* child) OVERRIDE {
     if (home_card_ == child)
       home_card_ = NULL;
   }
   virtual void OnWindowRemovedFromLayout(aura::Window* child) OVERRIDE {
   }
   virtual void OnChildWindowVisibilityChanged(aura::Window* child,
                                               bool visible) OVERRIDE {
     if (home_card_ == child)
-      Layout(false);
+      Layout(false, gfx::Tween::LINEAR);
   }
   virtual void SetChildBounds(aura::Window* child,
                               const gfx::Rect& requested_bounds) OVERRIDE {
     SetChildBoundsDirect(child, requested_bounds);
   }
 
   aura::Window* home_card_;
   ui::Layer* minimized_layer_;
 
   DISALLOW_COPY_AND_ASSIGN(HomeCardLayoutManager);
@@ skipping 20 matching lines @@
                         float progress) {
     // TODO(mukai): not clear the focus, but simply close the virtual keyboard.
     GetFocusManager()->ClearFocus();
     if (from_state == HomeCard::VISIBLE_CENTERED)
       main_view_->SetLayoutState(1.0f - progress);
     else if (to_state == HomeCard::VISIBLE_CENTERED)
       main_view_->SetLayoutState(progress);
     UpdateShadow(true);
   }
 
-  void SetStateWithAnimation(HomeCard::State state) {
+  void SetStateWithAnimation(HomeCard::State state,
+                             gfx::Tween::Type tween_type) {
     UpdateShadow(state != HomeCard::VISIBLE_MINIMIZED);
     if (state == HomeCard::VISIBLE_CENTERED)
       main_view_->RequestFocusOnSearchBox();
     else
       GetWidget()->GetFocusManager()->ClearFocus();
 
     main_view_->SetLayoutStateWithAnimation(
-        (state == HomeCard::VISIBLE_CENTERED) ? 1.0f : 0.0f);
+        (state == HomeCard::VISIBLE_CENTERED) ? 1.0f : 0.0f, tween_type);
   }
 
   void ClearGesture() {
     gesture_manager_.reset();
   }
 
   // views::View:
   virtual void OnGestureEvent(ui::GestureEvent* event) OVERRIDE {
     if (!gesture_manager_ &&
         event->type() == ui::ET_GESTURE_SCROLL_BEGIN) {
@@ skipping 134 matching lines @@
           state_ == VISIBLE_MINIMIZED ? 1.0f : 0.0f);
     }
   }
   if (state_ == HIDDEN) {
     home_card_widget_->Hide();
   } else {
     if (state_ == VISIBLE_MINIMIZED)
       home_card_widget_->ShowInactive();
     else
       home_card_widget_->Show();
-    home_card_view_->SetStateWithAnimation(state);
-    layout_manager_->Layout(true);
+    home_card_view_->SetStateWithAnimation(state, gfx::Tween::EASE_IN_OUT);
+    layout_manager_->Layout(true, gfx::Tween::EASE_IN_OUT);
   }
 }
 
 HomeCard::State HomeCardImpl::GetState() {
   return state_;
 }
 
 void HomeCardImpl::RegisterSearchProvider(
     app_list::SearchProvider* search_provider) {
   DCHECK(!search_provider_);
@@ skipping 22 matching lines @@
                                       const ui::Accelerator& accelerator) {
   DCHECK_EQ(COMMAND_SHOW_HOME_CARD, command_id);
 
   if (state_ == VISIBLE_CENTERED && original_state_ != VISIBLE_BOTTOM)
     SetState(VISIBLE_MINIMIZED);
   else if (state_ == VISIBLE_MINIMIZED)
     SetState(VISIBLE_CENTERED);
   return true;
 }
 
-void HomeCardImpl::OnGestureEnded(State final_state) {
+void HomeCardImpl::OnGestureEnded(State final_state, bool is_fling) {
   home_card_view_->ClearGesture();
   if (state_ != final_state &&
       (state_ == VISIBLE_MINIMIZED || final_state == VISIBLE_MINIMIZED)) {
     SetState(final_state);
     WindowManager::GetInstance()->ToggleOverview();
   } else {
     state_ = final_state;
-    home_card_view_->SetStateWithAnimation(state_);
-    layout_manager_->Layout(true);
+    // When the animation happens after a fling, EASE_IN_OUT would cause weird
+    // slow-down right after the finger release because of slow-in. Therefore
+    // EASE_OUT is better.
+    gfx::Tween::Type tween_type =
+        is_fling ? gfx::Tween::EASE_OUT : gfx::Tween::EASE_IN_OUT;
+    home_card_view_->SetStateWithAnimation(state_, tween_type);
+    layout_manager_->Layout(true, tween_type);
   }
 }
 
 void HomeCardImpl::OnGestureProgressed(
     State from_state, State to_state, float progress) {
   if (from_state == VISIBLE_MINIMIZED || to_state == VISIBLE_MINIMIZED) {
     minimized_home_->layer()->SetVisible(true);
     float opacity =
         (from_state == VISIBLE_MINIMIZED) ? 1.0f - progress : progress;
     minimized_home_->layer()->SetOpacity(opacity);
@@ skipping 48 matching lines @@
   instance = NULL;
 }
 
 // static
 HomeCard* HomeCard::Get() {
   DCHECK(instance);
   return instance;
 }
 
 }  // namespace athena