Introduce the basic animation from minimized to bottom.

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/public/home_card.h"
 
 #include <cmath>
 #include <limits>
 
 #include "athena/common/container_priorities.h"
 #include "athena/home/app_list_view_delegate.h"
 #include "athena/home/athena_start_page_view.h"
 #include "athena/home/minimized_home.h"
 #include "athena/home/public/app_model_builder.h"
 #include "athena/input/public/accelerator_manager.h"
 #include "athena/screen/public/screen_manager.h"
 #include "athena/wm/public/window_manager.h"
 #include "athena/wm/public/window_manager_observer.h"
 #include "base/bind.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_animation_observer.h"
+#include "ui/compositor/scoped_layer_animation_settings.h"
 #include "ui/views/background.h"
 #include "ui/views/layout/box_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/core/window_animations.h"
 #include "ui/wm/public/activation_change_observer.h"
 #include "ui/wm/public/activation_client.h"
 
@@ skipping 46 matching lines @@
 
   virtual ~HomeCardLayoutManager() {}
 
   void Layout() {
     aura::Window* home_card = delegate_->GetNativeWindow();
     // |home_card| could be detached from the root window (e.g. when it is being
     // destroyed).
     if (!home_card || !home_card->GetRootWindow())
       return;
 
-    SetChildBoundsDirect(home_card, GetBoundsForState(
-        home_card->GetRootWindow()->bounds(), delegate_->GetState()));
+    {
+      ui::ScopedLayerAnimationSettings settings(
+          home_card->layer()->GetAnimator());
+      settings.SetTweenType(gfx::Tween::EASE_IN_OUT);
+      SetChildBoundsDirect(home_card, GetBoundsForState(
+          home_card->GetRootWindow()->bounds(), delegate_->GetState()));
+    }
   }
 
  private:
   // aura::LayoutManager:
   virtual void OnWindowResized() OVERRIDE { Layout(); }
   virtual void OnWindowAddedToLayout(aura::Window* child) OVERRIDE { Layout(); }
   virtual void OnWillRemoveWindowFromLayout(aura::Window* child) OVERRIDE {}
   virtual void OnWindowRemovedFromLayout(aura::Window* child) OVERRIDE {
     Layout();
   }
@@ skipping 213 matching lines @@
       app_list::ContentsView* contents_view = main_view_->contents_view();
       contents_view->SetActivePage(contents_view->GetPageIndexForNamedPage(
           app_list::ContentsView::NAMED_PAGE_START));
     }
     wm::SetShadowType(GetWidget()->GetNativeView(),
                       state == HomeCard::VISIBLE_MINIMIZED ?
                       wm::SHADOW_TYPE_NONE :
                       wm::SHADOW_TYPE_RECTANGULAR);
   }
 
+  void SetStateWithAnimation(HomeCard::State from_state,
+                             HomeCard::State to_state) {
+    if ((from_state == HomeCard::VISIBLE_MINIMIZED &&
+         to_state == HomeCard::VISIBLE_BOTTOM) ||
+        (from_state == HomeCard::VISIBLE_BOTTOM &&
+         to_state == HomeCard::VISIBLE_MINIMIZED)) {
+      minimized_view_->SetVisible(true);
+      bottom_view_->SetVisible(true);
+      {
+        ui::ScopedLayerAnimationSettings settings(
+            minimized_view_->layer()->GetAnimator());
+        settings.SetTweenType(gfx::Tween::EASE_IN_OUT);
+        settings.SetTransitionDuration(base::TimeDelta::FromSeconds(5));

[sadrul, 2014/08/15 15:36:21]

That's ... pretty long! Was for debugging, perhaps?

[Jun Mukai, 2014/08/15 16:35:07]

Ugh, removed. That is for debugging. Thanks for catching.

+        settings.AddObserver(new AnimationObserver(this, to_state));
+        minimized_view_->layer()->SetOpacity(
+            (to_state == HomeCard::VISIBLE_MINIMIZED) ? 1.0f : 0.0f);

[sadrul, 2014/08/15 15:36:21]

Do you need to set the opacity to 0/1 beforehand to make sure it does animate?

[Jun Mukai, 2014/08/15 16:35:08]

Not sure what you mean, but if you meant the pattern of: SetOpacity(0); {
ScopedLayerAnimationSettings; ...; SetOpacity(1); }, I don't think we should.

In case of touch swipe, minimized view is in intermediate opacity (see line 309
above), and the animation should start from the current opacity.

[sadrul, 2014/08/15 16:37:26]

Sounds good.

+      }
+    } else {
+      // TODO(mukai): Take care of other transition.
+      SetState(to_state);
+    }
+  }
+
   void ClearGesture() {
     gesture_manager_.reset();
   }
 
   // views::View:
   virtual void Layout() OVERRIDE {
     for (int i = 0; i < child_count(); ++i) {
       views::View* child = child_at(i);
       if (child->visible()) {
         if (child == minimized_view_) {
@@ skipping 13 matching lines @@
       gesture_manager_.reset(new HomeCardGestureManager(
           gesture_delegate_,
           GetWidget()->GetNativeWindow()->GetRootWindow()->bounds()));
     }
 
     if (gesture_manager_)
       gesture_manager_->ProcessGestureEvent(event);
   }
 
  private:
+  class AnimationObserver : public ui::ImplicitAnimationObserver {

[sadrul, 2014/08/15 15:36:22]

You should use ui::ClosureAnimationObserver!

[Jun Mukai, 2014/08/15 16:35:08]

Done!

+   public:
+    AnimationObserver(HomeCardView* view, HomeCard::State target_state)
+        : view_(view),
+          target_state_(target_state) {}
+    virtual ~AnimationObserver() {}
+
+   private:
+    // ui::ImplicitAnimationObserver:
+    virtual void OnImplicitAnimationsCompleted() OVERRIDE {
+      view_->SetState(target_state_);
+      delete this;
+    }
+
+    HomeCardView* view_;
+    HomeCard::State target_state_;
+
+    DISALLOW_COPY_AND_ASSIGN(AnimationObserver);
+  };
+
   virtual views::View* GetContentsView() OVERRIDE {
     return this;
   }
 
   app_list::AppListMainView* main_view_;
   views::View* bottom_view_;
   views::View* minimized_view_;
   scoped_ptr<HomeCardGestureManager> gesture_manager_;
   HomeCardGestureManager::Delegate* gesture_delegate_;
 
@@ skipping 130 matching lines @@
   AcceleratorManager::Get()->RegisterAccelerators(
       accelerator_data, arraysize(accelerator_data), this);
 }
 
 void HomeCardImpl::SetState(HomeCard::State state) {
   if (state_ == state)
     return;
 
   // Update |state_| before changing the visibility of the widgets, so that
   // LayoutManager callbacks get the correct state.
+  HomeCard::State old_state = state_;
   state_ = state;
   original_state_ = state;
   if (state_ == HIDDEN) {
     home_card_widget_->Hide();
   } else {
     if (state_ == VISIBLE_CENTERED)
       home_card_widget_->Show();
     else
       home_card_widget_->ShowInactive();
-    home_card_view_->SetState(state);
+    home_card_view_->SetStateWithAnimation(old_state, state);
     layout_manager_->Layout();
   }
 }
 
 HomeCard::State HomeCardImpl::GetState() {
   return state_;
 }
 
 void HomeCardImpl::RegisterSearchProvider(
     app_list::SearchProvider* search_provider) {
@@ skipping 32 matching lines @@
 
   return home_card_widget_ ? home_card_widget_->GetNativeWindow() : NULL;
 }
 
 void HomeCardImpl::OnGestureEnded(State final_state) {
   home_card_view_->ClearGesture();
   if (state_ != final_state &&
       (state_ == VISIBLE_MINIMIZED || final_state == VISIBLE_MINIMIZED)) {
     WindowManager::GetInstance()->ToggleOverview();
   } else {
+    HomeCard::State old_state = state_;
     state_ = final_state;
-    home_card_view_->SetState(final_state);
+    home_card_view_->SetStateWithAnimation(old_state, final_state);
     layout_manager_->Layout();
   }
 }
 
 void HomeCardImpl::OnGestureProgressed(
     State from_state, State to_state, float progress) {
   home_card_view_->SetStateProgress(from_state, to_state, progress);
 
   gfx::Rect screen_bounds =
       home_card_widget_->GetNativeWindow()->GetRootWindow()->bounds();
@@ skipping 38 matching lines @@
   instance = NULL;
 }
 
 // static
 HomeCard* HomeCard::Get() {
   DCHECK(instance);
   return instance;
 }
 
 }  // namespace athena