Make power button controller restore to original transformation on the layer.

ash/wm/power_button_controller.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/power_button_controller.h"
 
 #include "ash/ash_switches.h"
 #include "ash/shell.h"
 #include "ash/shell_window_ids.h"
 #include "ash/wm/root_window_event_filter.h"
@@ skipping 78 matching lines @@
 
 // Is |window| a container that holds other windows that should be shown while
 // the screen is locked?
 bool IsRelatedContainer(aura::Window* window) {
   for (size_t i = 0; i < arraysize(kRelatedContainerIds); ++i)
     if (window->id() == kRelatedContainerIds[i])
       return true;
   return false;
 }
 
-// Returns the transform that should be applied to containers for the slow-close
-// animation.
-ui::Transform GetSlowCloseTransform() {
+// Returns the transform, based on |base_transform|, that should be applied
+// to containers for slow-close animation.
+ui::Transform GetSlowCloseTransform(const ui::Transform& base_transform) {
   gfx::Size root_size = aura::RootWindow::GetInstance()->bounds().size();
-  ui::Transform transform;
-  transform.SetScale(kSlowCloseSizeRatio, kSlowCloseSizeRatio);
+  ui::Transform transform(base_transform);
+  transform.ConcatScale(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;
 }
 
-// Returns the transform that should be applied to containers for the fast-close
-// animation.
-ui::Transform GetFastCloseTransform() {
+// Returns the transform, based on |base_transform|, that should be applied
+// to containers for fast-close animation.
+ui::Transform GetFastCloseTransform(const ui::Transform& base_transform) {
   gfx::Size root_size = aura::RootWindow::GetInstance()->bounds().size();
-  ui::Transform transform;
-  transform.SetScale(0.0, 0.0);
+  ui::Transform transform(base_transform);
+  transform.ConcatScale(0.0, 0.0);
   transform.ConcatTranslate(floor(0.5 * root_size.width() + 0.5),
                             floor(0.5 * root_size.height() + 0.5));
   return transform;
 }
 
 // Slowly shrinks |window| to a slightly-smaller size.
 void StartSlowCloseAnimationForWindow(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::CreateTransformElement(
-              GetSlowCloseTransform(),
+              GetSlowCloseTransform(window->layer()->GetTargetTransform()),
               base::TimeDelta::FromMilliseconds(kSlowCloseAnimMs))));
 }
 
 // Quickly undoes the effects of the slow-close animation on |window|.
-void StartUndoSlowCloseAnimationForWindow(aura::Window* window) {
+void StartUndoSlowCloseAnimationForWindow(aura::Window* window,
+                                          const ui::Transform& orig_transform) {
   ui::LayerAnimator* animator = window->layer()->GetAnimator();
   animator->set_preemption_strategy(
       ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
   animator->StartAnimation(
       new ui::LayerAnimationSequence(
           ui::LayerAnimationElement::CreateTransformElement(
-              ui::Transform(),
+              orig_transform,
               base::TimeDelta::FromMilliseconds(kUndoSlowCloseAnimMs))));
 }
 
 // Quickly shrinks |window| down to a point in the center of the screen and
 // fades it out to 0 opacity.
 void StartFastCloseAnimationForWindow(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::CreateTransformElement(
-              GetFastCloseTransform(),
+              GetFastCloseTransform(window->layer()->GetTargetTransform()),
               base::TimeDelta::FromMilliseconds(kFastCloseAnimMs))));
   animator->StartAnimation(
       new ui::LayerAnimationSequence(
           ui::LayerAnimationElement::CreateOpacityElement(
               0.0, base::TimeDelta::FromMilliseconds(kFastCloseAnimMs))));
 }
 
 // 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(ui::Transform());
+void RestoreWindow(aura::Window* window,
+                   const ui::Transform& orig_transform) {
+  window->layer()->SetTransform(orig_transform);
   window->layer()->SetOpacity(1.0);
 }
 
-// Fills |containers| with the containers described by |group|.
-void GetContainers(PowerButtonController::ContainerGroup group,
-                   aura::Window::Windows* containers) {
-  containers->clear();
-
-  aura::Window* root = aura::RootWindow::GetInstance();
-  for (aura::Window::Windows::const_iterator it = root->children().begin();
-       it != root->children().end(); ++it) {
-    aura::Window* window = *it;
-
-    bool matched = true;
-    if (group != PowerButtonController::ALL_CONTAINERS) {
-      bool is_screen_locker = IsScreenLockerContainer(window);
-      bool is_related = IsRelatedContainer(window);
-
-      switch (group) {
-        case PowerButtonController::SCREEN_LOCKER_CONTAINERS:
-          matched = is_screen_locker;
-          break;
-        case PowerButtonController::SCREEN_LOCKER_AND_RELATED_CONTAINERS:
-          matched = is_screen_locker || is_related;
-          break;
-        case PowerButtonController::
-            ALL_BUT_SCREEN_LOCKER_AND_RELATED_CONTAINERS:
-          matched = !is_screen_locker && !is_related;
-          break;
-        default:
-          NOTREACHED() << "Unhandled container group " << group;
-      }
-    }
-
-    if (matched)
-      containers->push_back(window);
-  }
-}
-
-// Apply animation |type| to all containers described by |group|.
-void StartAnimation(PowerButtonController::ContainerGroup group,
-                    PowerButtonController::AnimationType type) {
-  aura::Window::Windows containers;
-  GetContainers(group, &containers);
-
-  for (aura::Window::Windows::const_iterator it = containers.begin();
-       it != containers.end(); ++it) {
-    aura::Window* window = *it;
-    switch (type) {
-      case PowerButtonController::ANIMATION_SLOW_CLOSE:
-        StartSlowCloseAnimationForWindow(window);
-        break;
-      case PowerButtonController::ANIMATION_UNDO_SLOW_CLOSE:
-        StartUndoSlowCloseAnimationForWindow(window);
-        break;
-      case PowerButtonController::ANIMATION_FAST_CLOSE:
-        StartFastCloseAnimationForWindow(window);
-        break;
-      case PowerButtonController::ANIMATION_FADE_IN:
-        FadeInWindow(window);
-        break;
-      case PowerButtonController::ANIMATION_HIDE:
-        HideWindow(window);
-        break;
-      case PowerButtonController::ANIMATION_RESTORE:
-        RestoreWindow(window);
-        break;
-      default:
-        NOTREACHED() << "Unhandled animation type " << type;
-    }
-  }
-}
-
 }  // namespace
 
 bool PowerButtonController::TestApi::ContainerGroupIsAnimated(
     ContainerGroup group, AnimationType type) const {
   aura::Window::Windows containers;
-  GetContainers(group, &containers);
+  controller_->GetContainers(group, &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 PowerButtonController::ANIMATION_SLOW_CLOSE:
-        if (layer->GetTargetTransform() != GetSlowCloseTransform())
+        if (layer->GetTargetTransform() !=
+            GetSlowCloseTransform(
+                controller_->RetrieveOriginalTransform(window)))
           return false;
         break;
       case PowerButtonController::ANIMATION_UNDO_SLOW_CLOSE:
-        if (layer->GetTargetTransform() != ui::Transform())
-          return false;
+        if (layer->GetTargetTransform() !=
+            controller_->RetrieveOriginalTransform(window))
+        return false;
         break;
       case PowerButtonController::ANIMATION_FAST_CLOSE:
-        if (layer->GetTargetTransform() != GetFastCloseTransform() ||
+        if (layer->GetTargetTransform() !=
+            GetFastCloseTransform(layer->GetTargetTransform()) ||
             layer->GetTargetOpacity() > 0.0001)
           return false;
         break;
       case PowerButtonController::ANIMATION_FADE_IN:
         if (layer->GetTargetOpacity() < 0.9999)
           return false;
         break;
       case PowerButtonController::ANIMATION_HIDE:
         if (layer->GetTargetOpacity() > 0.0001)
           return false;
         break;
       case PowerButtonController::ANIMATION_RESTORE:
-        if (layer->opacity() < 0.9999 || layer->transform() != ui::Transform())
+        if (layer->opacity() < 0.9999 ||
+            layer->transform() !=
+            controller_->RetrieveOriginalTransform(window))
           return false;
         break;
       default:
         NOTREACHED() << "Unhandled animation type " << type;
         return false;
     }
   }
   return true;
 }
 
@@ skipping 142 matching lines @@
       lock_timer_.Stop();
     }
   }
 }
 
 void PowerButtonController::OnRootWindowResized(const gfx::Size& new_size) {
   if (background_layer_.get())
     background_layer_->SetBounds(gfx::Rect(new_size));
 }
 
+// Fills |containers| with the containers described by |group|.
+void PowerButtonController::GetContainers(ContainerGroup group,
+                                          aura::Window::Windows* containers) {
+  containers->clear();
+
+  aura::Window* root = aura::RootWindow::GetInstance();
+  for (aura::Window::Windows::const_iterator it = root->children().begin();
+       it != root->children().end(); ++it) {
+    aura::Window* window = *it;
+
+    bool matched = true;
+    if (group != ALL_CONTAINERS) {
+      bool is_screen_locker = IsScreenLockerContainer(window);
+      bool is_related = IsRelatedContainer(window);
+
+      switch (group) {
+        case SCREEN_LOCKER_CONTAINERS:
+          matched = is_screen_locker;
+          break;
+        case SCREEN_LOCKER_AND_RELATED_CONTAINERS:
+          matched = is_screen_locker || is_related;
+          break;
+        case ALL_BUT_SCREEN_LOCKER_AND_RELATED_CONTAINERS:
+          matched = !is_screen_locker && !is_related;
+          break;
+        default:
+          NOTREACHED() << "Unhandled container group " << group;
+      }
+    }
+
+    if (matched)
+      containers->push_back(window);
+  }
+}
+
 void PowerButtonController::OnLockTimeout() {
   delegate_->RequestLockScreen();
   lock_fail_timer_.Start(
       FROM_HERE,
       base::TimeDelta::FromMilliseconds(kLockFailTimeoutMs),
       this, &PowerButtonController::OnLockFailTimeout);
 }
 
 void PowerButtonController::OnLockFailTimeout() {
   DCHECK(!locked_);
@@ skipping 58 matching lines @@
     root_layer->Add(background_layer_.get());
     root_layer->StackAtBottom(background_layer_.get());
   }
   background_layer_->SetVisible(true);
 }
 
 void PowerButtonController::HideBackgroundLayer() {
   background_layer_.reset();
 }
 
+// Apply animation |type| to all containers described by |group|.
+void PowerButtonController::StartAnimation(ContainerGroup group,
+                                           AnimationType type) {
+  aura::Window::Windows containers;
+  GetContainers(group, &containers);
+  for (aura::Window::Windows::const_iterator it = containers.begin();
+       it != containers.end(); ++it) {
+    aura::Window* window = *it;
+
+    // Store this away so we can restore.
+    if (type != ANIMATION_RESTORE && type != ANIMATION_UNDO_SLOW_CLOSE)
+      container_transforms_[window] = window->layer()->GetTargetTransform();
+
+    switch (type) {
+      case ANIMATION_SLOW_CLOSE:
+        StartSlowCloseAnimationForWindow(window);
+        break;
+      case ANIMATION_UNDO_SLOW_CLOSE:
+        StartUndoSlowCloseAnimationForWindow(
+            window,
+            RetrieveOriginalTransform(window));
+        break;
+      case ANIMATION_FAST_CLOSE:
+        StartFastCloseAnimationForWindow(window);
+        break;
+      case ANIMATION_FADE_IN:
+        FadeInWindow(window);
+        break;
+      case ANIMATION_HIDE:
+        HideWindow(window);
+        break;
+      case ANIMATION_RESTORE:
+        RestoreWindow(window, RetrieveOriginalTransform(window));
+        break;
+      default:
+        NOTREACHED() << "Unhandled animation type " << type;
+    }
+  }
+}
+
+ui::Transform PowerButtonController::RetrieveOriginalTransform(
+    aura::Window* window) {
+  WindowTransformsMap::const_iterator it = container_transforms_.find(window);
+  if (it != container_transforms_.end())
+    return it->second;
+  return ui::Transform();
+}
+
 }  // namespace ash