Add new animations in second implementation.

ash/wm/session_state_animator.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/shell.h"
 #include "ash/shell_window_ids.h"
+#include "ash/wm/workspace/workspace_animations.h"
+#include "ui/aura/client/aura_constants.h"
 #include "ui/aura/root_window.h"
 #include "ui/compositor/layer_animation_sequence.h"
+#include "ui/compositor/layer_animation_observer.h"

[Daniel Erat, 2012/10/22 17:45:48]

keep this list alphabetized

+#include "ui/views/widget/widget.h"
 
 namespace ash {
 namespace internal {
 
 namespace {
 
 // Amount of time taken to scale the snapshot of the screen down to a
 // slightly-smaller size once the user starts holding the power button.  Used
 // for both the pre-lock and pre-shutdown animations.
 const int kSlowCloseAnimMs = 400;
 
 // Amount of time taken to scale the snapshot of the screen back to its original
 // size when the button is released.
 const int kUndoSlowCloseAnimMs = 100;
 
 // Amount of time taken to scale the snapshot down to a point in the center of
 // the screen once the screen has been locked or we've been notified that the
 // system is shutting down.
 const int kFastCloseAnimMs = 150;
 
 // Amount of time taken to make the lock window fade in when the screen is
 // locked.
 const int kLockFadeInAnimMs = 200;
 
 // Slightly-smaller size that we scale the screen down to for the pre-lock and
 // pre-shutdown states.
 const float kSlowCloseSizeRatio = 0.95f;
 
+//ToDo (antrim) : comment
+const float kPartialFadeRatio = 0.3f;
+
 // 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.SetScale(kSlowCloseSizeRatio, kSlowCloseSizeRatio);
   transform.ConcatTranslate(
       floor(0.5 * (1.0 - kSlowCloseSizeRatio) * root_size.width() + 0.5),
       floor(0.5 * (1.0 - kSlowCloseSizeRatio) * root_size.height() + 0.5));
   return transform;
@@ skipping 44 matching lines @@
       new ui::LayerAnimationSequence(
           ui::LayerAnimationElement::CreateTransformElement(
               GetFastCloseTransform(),
               base::TimeDelta::FromMilliseconds(kFastCloseAnimMs))));
   animator->StartAnimation(
       new ui::LayerAnimationSequence(
           ui::LayerAnimationElement::CreateOpacityElement(
               0.0, base::TimeDelta::FromMilliseconds(kFastCloseAnimMs))));
 }
 
+// Fades |window| to a |target_opacity| for a |lengthMs| milliseconds.

[Daniel Erat, 2012/10/22 17:45:48]

s/lengthMs/length_ms/

+void StartPartialFadeAnimation(aura::Window* window, float target_opacity,

[Daniel Erat, 2012/10/22 17:45:48]

one argument per line

+                               int length_ms,

[Daniel Erat, 2012/10/22 17:45:48]

use base::TimeDelta instead of int

+                               ui::LayerAnimationObserver* observer) {
+  ui::LayerAnimator* animator = window->layer()->GetAnimator();
+  animator->set_preemption_strategy(
+      ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
+  ui::LayerAnimationSequence* sequence = new ui::LayerAnimationSequence(
+      ui::LayerAnimationElement::CreateOpacityElement(
+          target_opacity, base::TimeDelta::FromMilliseconds(length_ms)));
+  animator->StartAnimation(sequence);
+  if (observer)
+    sequence->AddObserver(observer);
+}
+
 // Fades |window| in to full opacity.
 void FadeInWindow(aura::Window* window) {
   ui::LayerAnimator* animator = window->layer()->GetAnimator();
   animator->set_preemption_strategy(
       ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
   animator->StartAnimation(
       new ui::LayerAnimationSequence(
           ui::LayerAnimationElement::CreateOpacityElement(
               1.0, base::TimeDelta::FromMilliseconds(kLockFadeInAnimMs))));
 }
 
 // Makes |window| fully transparent instantaneously.
 void HideWindow(aura::Window* window) {
   window->layer()->SetOpacity(0.0);
 }
 
 // Restores |window| to its original position and scale and full opacity
 // instantaneously.
 void RestoreWindow(aura::Window* window) {
   window->layer()->SetTransform(gfx::Transform());
   window->layer()->SetOpacity(1.0);
 }
 
+void LiftUpWindow(aura::Window* window, int length_ms) {

[Daniel Erat, 2012/10/22 17:45:48]

pass in base::TimeDelta here instead of int

+  WorkspaceAnimationDetails details;
+  details.direction = WORKSPACE_ANIMATE_UP;
+  details.animate = true;
+  details.animate_scale = true;
+  details.animate_opacity = true;
+  details.duration = base::TimeDelta::FromMilliseconds(length_ms);
+  HideWorkspace(window, details);
+}
+
+void PutDownWindow(aura::Window* window, int length_ms) {

[Daniel Erat, 2012/10/22 17:45:48]

ditto

+  WorkspaceAnimationDetails details;
+  details.direction = WORKSPACE_ANIMATE_DOWN;
+  details.animate = true;
+  details.animate_scale = true;
+  details.animate_opacity = true;
+  details.duration = base::TimeDelta::FromMilliseconds(length_ms);
+  ShowWorkspace(window, details);
+}
+
+//ToDo(antrim) : comment.
+class ForegroundDropAnimationObserver : public ui::LayerAnimationObserver {
+ public:
+  explicit ForegroundDropAnimationObserver(SessionStateAnimator* animator)
+      : animator_(animator) {
+  }
+  virtual ~ForegroundDropAnimationObserver() {
+  }
+
+ private:
+  // Overridden from ui::LayerAnimationObserver:
+  virtual void OnLayerAnimationEnded(ui::LayerAnimationSequence* seq)
+      OVERRIDE {
+    //Drop foreground once animation is over.

[Daniel Erat, 2012/10/22 17:45:48]

add space between "//" and "Drop"

+    animator_->DropForeground();
+    delete this;
+  }
+
+  virtual void OnLayerAnimationAborted(ui::LayerAnimationSequence* seq)
+      OVERRIDE {
+    //Drop foreground once animation is over.

[Daniel Erat, 2012/10/22 17:45:48]

same here

+    animator_->DropForeground();
+    delete this;
+  }
+
+  virtual void OnLayerAnimationScheduled(ui::LayerAnimationSequence* seq)
+      OVERRIDE {}
+
+  SessionStateAnimator* animator_;
+
+  DISALLOW_COPY_AND_ASSIGN(ForegroundDropAnimationObserver);
+};
+
 }  // namespace
 
 void SessionStateAnimator::TestApi::TriggerHideBlackLayerTimeout() {
       animator_->DropBlackLayer();
       animator_->hide_black_layer_timer_.Stop();
 }
 
 bool SessionStateAnimator::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();
 
     switch (type) {
-      case ANIMATION_SLOW_CLOSE:
+      case ANIMATION_PARTIAL_CLOSE:
         if (layer->GetTargetTransform() != GetSlowCloseTransform())
           return false;
         break;
-      case ANIMATION_UNDO_SLOW_CLOSE:
+      case ANIMATION_UNDO_PARTIAL_CLOSE:
         if (layer->GetTargetTransform() != gfx::Transform())
           return false;
         break;
-      case ANIMATION_FAST_CLOSE:
+      case ANIMATION_FULL_CLOSE:
         if (layer->GetTargetTransform() != GetFastCloseTransform() ||
             layer->GetTargetOpacity() > 0.0001)
           return false;
         break;
       case ANIMATION_FADE_IN:
         if (layer->GetTargetOpacity() < 0.9999)
           return false;
         break;
       case ANIMATION_HIDE:
         if (layer->GetTargetOpacity() > 0.0001)
@@ skipping 80 matching lines @@
   if (container_mask & LOCK_SCREEN_CONTAINERS) {
     containers->push_back(Shell::GetContainer(
         root_window,
         internal::kShellWindowId_LockScreenContainersContainer));
   }
   if (container_mask & LOCK_SCREEN_RELATED_CONTAINERS) {
     containers->push_back(Shell::GetContainer(
         root_window,
         internal::kShellWindowId_LockScreenRelatedContainersContainer));
   }
+  if (container_mask & LOCK_SCREEN_SYSTEM_FOREGROUND) {
+    containers->push_back(Shell::GetContainer(
+        root_window,
+        internal::kShellWindowId_TopmostContainer));
+  }
 }
 
 // Apply animation |type| to all containers described by |container_mask|.
 void SessionStateAnimator::StartAnimation(int container_mask,
                                           AnimationType type) {
   aura::Window::Windows containers;
   GetContainers(container_mask, &containers);
 
   for (aura::Window::Windows::const_iterator it = containers.begin();
        it != containers.end(); ++it) {
     aura::Window* window = *it;
     switch (type) {
-      case ANIMATION_SLOW_CLOSE:
+      case ANIMATION_PARTIAL_CLOSE:
         StartSlowCloseAnimationForWindow(window);
         break;
-      case ANIMATION_UNDO_SLOW_CLOSE:
+      case ANIMATION_UNDO_PARTIAL_CLOSE:
         StartUndoSlowCloseAnimationForWindow(window);
         break;
-      case ANIMATION_FAST_CLOSE:
+      case ANIMATION_FULL_CLOSE:
         StartFastCloseAnimationForWindow(window);
         break;
       case ANIMATION_FADE_IN:
         FadeInWindow(window);
         break;
       case ANIMATION_HIDE:
         HideWindow(window);
         break;
       case ANIMATION_RESTORE:
         RestoreWindow(window);
         break;
+      case ANIMATION_LIFT_UP:
+        LiftUpWindow(window, kSlowCloseAnimMs);
+        break;
+      case ANIMATION_PUT_DOWN:
+        PutDownWindow(window, kSlowCloseAnimMs);
+        break;
+      case ANIMATION_PARTIAL_FADE_IN:
+        StartPartialFadeAnimation(window, kPartialFadeRatio, kSlowCloseAnimMs,
+                                  NULL);
+        break;
+      case ANIMATION_UNDO_PARTIAL_FADE_IN:
+        StartPartialFadeAnimation(window, 0.0, kUndoSlowCloseAnimMs,
+                                  new ForegroundDropAnimationObserver(this));
+        break;
+      case ANIMATION_FULL_FADE_IN:
+        StartPartialFadeAnimation(window, 1.0, kFastCloseAnimMs, NULL);
+        break;
       default:
         NOTREACHED() << "Unhandled animation type " << type;
     }
   }
 }
 
 void SessionStateAnimator::OnRootWindowResized(const aura::RootWindow* root,
                                                const gfx::Size& new_size) {
   if (black_layer_.get())
     black_layer_->SetBounds(gfx::Rect(root->bounds().size()));
@@ skipping 20 matching lines @@
 }
 
 void SessionStateAnimator::ScheduleDropBlackLayer() {
   hide_black_layer_timer_.Stop();
   hide_black_layer_timer_.Start(
       FROM_HERE,
       base::TimeDelta::FromMilliseconds(kUndoSlowCloseAnimMs),
       this, &SessionStateAnimator::DropBlackLayer);
 }
 
+void SessionStateAnimator::CreateForeground() {
+  LOG(ERROR) << "SessionStateAnimator::CreateForeground()";

[Daniel Erat, 2012/10/22 17:45:48]

delete this

+  if (!foreground_.get()) {

[Daniel Erat, 2012/10/22 17:45:48]

nit: little bit cleaner to just do:

  if (foreground_.get())
    return;

  ...

so you don't need to indent the whole body

+    aura::Window* window = Shell::GetContainer(
+        Shell::GetPrimaryRootWindow(),
+        internal::kShellWindowId_TopmostContainer);
+    HideWindow(window);
+    foreground_.reset(new ColoredWindowController(window, "WhiteForeground"));

[Daniel Erat, 2012/10/22 17:45:48]

"SessionStateAnimatorForeground"?

+    foreground_->SetColor(SK_ColorWHITE);
+    foreground_->GetWidget()->Show();
+  }
+}
+
+void SessionStateAnimator::DropForeground() {
+  foreground_.reset();
+}
+
 }  // namespace internal
 }  // namespace ash