Added quick lock mechanism while in Touchview

ash/wm/session_state_animator_impl.cc

 // Copyright (c) 2012 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 "ash/wm/session_state_animator.h"
+#include "ash/wm/session_state_animator_impl.h"
+
+#include <vector>
 
 #include "ash/shell.h"
 #include "ash/shell_window_ids.h"
 #include "ash/wm/window_animations.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/window_event_dispatcher.h"
 #include "ui/compositor/layer_animation_observer.h"
 #include "ui/compositor/layer_animation_sequence.h"
 #include "ui/compositor/scoped_layer_animation_settings.h"
 #include "ui/views/widget/widget.h"
 
 namespace ash {
 namespace {
 
 // Slightly-smaller size that we scale the screen down to for the pre-lock and
 // pre-shutdown states.
 const float kSlowCloseSizeRatio = 0.95f;
 
 // Maximum opacity of white layer when animating pre-shutdown state.
 const float kPartialFadeRatio = 0.3f;
 
 // Minimum size. Not zero as it causes numeric issues.
 const float kMinimumScale = 1e-4f;
 
+// Returns the primary root window's container.
+aura::Window* GetBackground() {
+  aura::Window* root_window = Shell::GetPrimaryRootWindow();
+  return Shell::GetContainer(root_window,
+                             kShellWindowId_DesktopBackgroundContainer);
+}
+
 // Returns the transform that should be applied to containers for the slow-close
 // animation.
 gfx::Transform GetSlowCloseTransform() {
   gfx::Size root_size = Shell::GetPrimaryRootWindow()->bounds().size();
   gfx::Transform transform;
   transform.Translate(
       floor(0.5 * (1.0 - kSlowCloseSizeRatio) * root_size.width() + 0.5),
       floor(0.5 * (1.0 - kSlowCloseSizeRatio) * root_size.height() + 0.5));
   transform.Scale(kSlowCloseSizeRatio, kSlowCloseSizeRatio);
- return transform;
+  return transform;
 }
 
 // Returns the transform that should be applied to containers for the fast-close
 // animation.
 gfx::Transform GetFastCloseTransform() {
   gfx::Size root_size = Shell::GetPrimaryRootWindow()->bounds().size();
   gfx::Transform transform;
+
   transform.Translate(floor(0.5 * root_size.width() + 0.5),
                       floor(0.5 * root_size.height() + 0.5));
   transform.Scale(kMinimumScale, kMinimumScale);
   return transform;
 }
 
 // Slowly shrinks |window| to a slightly-smaller size.
 void StartSlowCloseAnimationForWindow(aura::Window* window,
                                       base::TimeDelta duration,
                                       ui::LayerAnimationObserver* observer) {
@@ skipping 218 matching lines @@
   animator->set_preemption_strategy(
       ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
 
   animator->StartTogether(animations);
 }
 
 // Animation observer that will drop animated foreground once animation is
 // finished. It is used in when undoing shutdown animation.
 class CallbackAnimationObserver : public ui::LayerAnimationObserver {
  public:
-  explicit CallbackAnimationObserver(base::Callback<void(void)> &callback)
+  explicit CallbackAnimationObserver(base::Closure callback)
       : callback_(callback) {
   }
   virtual ~CallbackAnimationObserver() {
   }
 
  private:
   // Overridden from ui::LayerAnimationObserver:
   virtual void OnLayerAnimationEnded(ui::LayerAnimationSequence* seq)
       OVERRIDE {
     // Drop foreground once animation is over.
     callback_.Run();
     delete this;
   }
 
   virtual void OnLayerAnimationAborted(ui::LayerAnimationSequence* seq)
       OVERRIDE {
     // Drop foreground once animation is over.
     callback_.Run();
     delete this;
   }
 
   virtual void OnLayerAnimationScheduled(ui::LayerAnimationSequence* seq)
       OVERRIDE {}
 
-  base::Callback<void(void)> callback_;
+  base::Closure callback_;
 
   DISALLOW_COPY_AND_ASSIGN(CallbackAnimationObserver);
 };
 
 
 bool IsLayerAnimated(ui::Layer* layer,
                      SessionStateAnimator::AnimationType type) {
   switch (type) {
     case SessionStateAnimator::ANIMATION_PARTIAL_CLOSE:
       if (layer->GetTargetTransform() != GetSlowCloseTransform())
@@ skipping 57 matching lines @@
       break;
     default:
       NOTREACHED() << "Unhandled animation type " << type;
       return false;
   }
   return true;
 }
 
 }  // namespace
 
-bool SessionStateAnimator::TestApi::ContainersAreAnimated(
+// This observer is intended to use in cases when some action has to be taken
+// once some animation successfully completes (i.e. it was not aborted).
+// Observer will count a number of sequences it is attached to, and a number of
+// finished sequences (either Ended or Aborted). Once these two numbers are
+// equal, observer will delete itself, calling callback passed to constructor if
+// there were no aborted animations.
+// This way it can be either used to wait for some animation to be finished in
+// multiple layers, to wait once a sequence of animations is finished in one
+// layer or the mixture of both.
+class SessionStateAnimatorImpl::AnimationSequence
+  : public SessionStateAnimator::AnimationSequence,
+    public ui::LayerAnimationObserver {
+ public:
+  explicit AnimationSequence(
+      SessionStateAnimatorImpl* animator,
+      base::Closure callback)
+      : SessionStateAnimator::AnimationSequence(callback),
+        animator_(animator),
+        sequences_attached_(0),
+        sequences_completed_(0) {
+  }
+
+  // SessionStateAnimator::AnimationSequence:
+  virtual void StartAnimation(
+      int container_mask,
+      SessionStateAnimator::AnimationType type,
+      SessionStateAnimator::AnimationSpeed speed) OVERRIDE {
+    animator_->StartAnimationInSequence(container_mask, type, speed, this);
+  }
+
+ private:
+  virtual ~AnimationSequence() {}
+
+  // ui::LayerAnimationObserver:
+  virtual void OnLayerAnimationEnded(
+      ui::LayerAnimationSequence* sequence) OVERRIDE {
+    sequences_completed_++;
+    if (sequences_completed_ == sequences_attached_)
+      OnAnimationCompleted();
+  }
+
+  virtual void OnLayerAnimationAborted(
+      ui::LayerAnimationSequence* sequence) OVERRIDE {
+    sequences_completed_++;
+    if (sequences_completed_ == sequences_attached_)
+      OnAnimationAborted();
+  }
+
+  virtual void OnLayerAnimationScheduled(
+      ui::LayerAnimationSequence* sequence) OVERRIDE {}
+
+  virtual void OnAttachedToSequence(
+      ui::LayerAnimationSequence* sequence) OVERRIDE {
+    LayerAnimationObserver::OnAttachedToSequence(sequence);
+    sequences_attached_++;
+  }
+
+  SessionStateAnimatorImpl* animator_;  // not owned
+
+  // Number of sequences this observer was attached to.
+  int sequences_attached_;
+
+  // Number of sequences either ended or aborted.
+  int sequences_completed_;
+
+  DISALLOW_COPY_AND_ASSIGN(AnimationSequence);
+};
+
+bool SessionStateAnimatorImpl::TestApi::ContainersAreAnimated(
     int container_mask, AnimationType type) const {
   aura::Window::Windows containers;
   animator_->GetContainers(container_mask, &containers);
   for (aura::Window::Windows::const_iterator it = containers.begin();
        it != containers.end(); ++it) {
     aura::Window* window = *it;
     ui::Layer* layer = window->layer();
     if (!IsLayerAnimated(layer, type))
       return false;
   }
   return true;
 }
 
-bool SessionStateAnimator::TestApi::RootWindowIsAnimated(AnimationType type)
+bool SessionStateAnimatorImpl::TestApi::RootWindowIsAnimated(AnimationType type)
     const {
   aura::Window* root_window = Shell::GetPrimaryRootWindow();
   ui::Layer* layer = root_window->layer();
   return IsLayerAnimated(layer, type);
 }
 
-const int SessionStateAnimator::kAllLockScreenContainersMask =
-    SessionStateAnimator::LOCK_SCREEN_BACKGROUND |
-    SessionStateAnimator::LOCK_SCREEN_CONTAINERS |
-    SessionStateAnimator::LOCK_SCREEN_RELATED_CONTAINERS;
-
-const int SessionStateAnimator::kAllContainersMask =
-    SessionStateAnimator::kAllLockScreenContainersMask |
-    SessionStateAnimator::DESKTOP_BACKGROUND |
-    SessionStateAnimator::LAUNCHER |
-    SessionStateAnimator::NON_LOCK_SCREEN_CONTAINERS;
-
-SessionStateAnimator::SessionStateAnimator() {
+SessionStateAnimatorImpl::SessionStateAnimatorImpl() {
 }
 
-SessionStateAnimator::~SessionStateAnimator() {
-}
-
-base::TimeDelta SessionStateAnimator::GetDuration(AnimationSpeed speed) {
-  switch (speed) {
-    case ANIMATION_SPEED_IMMEDIATE:
-      return base::TimeDelta();
-    case ANIMATION_SPEED_UNDOABLE:
-      return base::TimeDelta::FromMilliseconds(400);
-    case ANIMATION_SPEED_REVERT:
-      return base::TimeDelta::FromMilliseconds(150);
-    case ANIMATION_SPEED_FAST:
-      return base::TimeDelta::FromMilliseconds(150);
-    case ANIMATION_SPEED_SHOW_LOCK_SCREEN:
-      return base::TimeDelta::FromMilliseconds(200);
-    case ANIMATION_SPEED_MOVE_WINDOWS:
-      return base::TimeDelta::FromMilliseconds(350);
-    case ANIMATION_SPEED_UNDO_MOVE_WINDOWS:
-      return base::TimeDelta::FromMilliseconds(350);
-    case ANIMATION_SPEED_SHUTDOWN:
-      return base::TimeDelta::FromMilliseconds(1000);
-    case ANIMATION_SPEED_REVERT_SHUTDOWN:
-      return base::TimeDelta::FromMilliseconds(500);
-  }
-  // Satisfy compilers that do not understand that we will return from switch
-  // above anyway.
-  DCHECK(false) << "Unhandled animation speed " << speed;
-  return base::TimeDelta();
+SessionStateAnimatorImpl::~SessionStateAnimatorImpl() {
 }
 
 // Fills |containers| with the containers described by |container_mask|.
-void SessionStateAnimator::GetContainers(int container_mask,
-                                         aura::Window::Windows* containers) {
+void SessionStateAnimatorImpl::GetContainers(int container_mask,
+    aura::Window::Windows* containers) {
   aura::Window* root_window = Shell::GetPrimaryRootWindow();
   containers->clear();
 
+  if (container_mask & ROOT_CONTAINER) {
+    containers->push_back(Shell::GetPrimaryRootWindow());
+  }
+
   if (container_mask & DESKTOP_BACKGROUND) {
     containers->push_back(Shell::GetContainer(
         root_window, kShellWindowId_DesktopBackgroundContainer));
   }
   if (container_mask & LAUNCHER) {
     containers->push_back(
         Shell::GetContainer(root_window, kShellWindowId_ShelfContainer));
   }
   if (container_mask & NON_LOCK_SCREEN_CONTAINERS) {
     // TODO(antrim): Figure out a way to eliminate a need to exclude launcher
@@ skipping 17 matching lines @@
   if (container_mask & LOCK_SCREEN_CONTAINERS) {
     containers->push_back(Shell::GetContainer(
         root_window, kShellWindowId_LockScreenContainersContainer));
   }
   if (container_mask & LOCK_SCREEN_RELATED_CONTAINERS) {
     containers->push_back(Shell::GetContainer(
         root_window, kShellWindowId_LockScreenRelatedContainersContainer));
   }
 }
 
-void SessionStateAnimator::StartAnimation(int container_mask,
-                                          AnimationType type,
-                                          AnimationSpeed speed) {
+void SessionStateAnimatorImpl::StartAnimation(int container_mask,
+                                              AnimationType type,
+                                              AnimationSpeed speed) {
   aura::Window::Windows containers;
   GetContainers(container_mask, &containers);
   for (aura::Window::Windows::const_iterator it = containers.begin();
        it != containers.end(); ++it) {
     RunAnimationForWindow(*it, type, speed, NULL);
   }
 }
 
-void SessionStateAnimator::StartAnimationWithCallback(
+void SessionStateAnimatorImpl::StartAnimationWithCallback(
     int container_mask,
     AnimationType type,
     AnimationSpeed speed,
-    base::Callback<void(void)>& callback) {
+    base::Closure callback) {
   aura::Window::Windows containers;
   GetContainers(container_mask, &containers);
   for (aura::Window::Windows::const_iterator it = containers.begin();
        it != containers.end(); ++it) {
     ui::LayerAnimationObserver* observer =
         new CallbackAnimationObserver(callback);
     RunAnimationForWindow(*it, type, speed, observer);
   }
 }
 
-void SessionStateAnimator::StartAnimationWithObserver(
+SessionStateAnimator::AnimationSequence*
+    SessionStateAnimatorImpl::BeginAnimationSequence(base::Closure callback) {
+  return new AnimationSequence(this, callback);
+}
+
+bool SessionStateAnimatorImpl::IsBackgroundHidden() const {
+  return !GetBackground()->IsVisible();
+}
+
+void SessionStateAnimatorImpl::ShowBackground() {
+  ui::ScopedLayerAnimationSettings settings(
+      GetBackground()->layer()->GetAnimator());
+  settings.SetTransitionDuration(base::TimeDelta());
+  GetBackground()->Show();
+}
+
+void SessionStateAnimatorImpl::HideBackground() {
+  ui::ScopedLayerAnimationSettings settings(
+      GetBackground()->layer()->GetAnimator());
+  settings.SetTransitionDuration(base::TimeDelta());
+  GetBackground()->Hide();
+}
+
+void SessionStateAnimatorImpl::StartAnimationInSequence(
     int container_mask,
     AnimationType type,
     AnimationSpeed speed,
-    ui::LayerAnimationObserver* observer) {
+    AnimationSequence* observer) {
   aura::Window::Windows containers;
   GetContainers(container_mask, &containers);
   for (aura::Window::Windows::const_iterator it = containers.begin();
        it != containers.end(); ++it) {
     RunAnimationForWindow(*it, type, speed, observer);
   }
 }
 
-void SessionStateAnimator::StartGlobalAnimation(AnimationType type,
-                                                AnimationSpeed speed) {
-  aura::Window* root_window = Shell::GetPrimaryRootWindow();
-  RunAnimationForWindow(root_window, type, speed, NULL);
-}
-
-void SessionStateAnimator::RunAnimationForWindow(
+void SessionStateAnimatorImpl::RunAnimationForWindow(
     aura::Window* window,
     AnimationType type,
     AnimationSpeed speed,
     ui::LayerAnimationObserver* observer) {
   base::TimeDelta duration = GetDuration(speed);
 
   switch (type) {
     case ANIMATION_PARTIAL_CLOSE:
       StartSlowCloseAnimationForWindow(window, duration, observer);
       break;
@@ skipping 47 matching lines @@
           window, 1.0, duration, gfx::Tween::EASE_IN, observer);
       break;
     case ANIMATION_UNDO_GRAYSCALE_BRIGHTNESS:
       StartGrayscaleBrightnessAnimationForWindow(
           window, 0.0, duration, gfx::Tween::EASE_IN_OUT, observer);
       break;
   }
 }
 
 }  // namespace ash