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 "base/command_line.h"
@@ skipping 77 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 that should be applied to containers in addition to the
+// base transformation containers for slow-close animation.

[Daniel Erat, 2012/02/15 05:50:03]

this comment doesn't make sense to me.  something like "Returns the transform,
based on |base_transform|, that should be applied to containers for the
slow-close animation" would be better.

[alicet1, 2012/02/15 20:48:53]

much better.

+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 that should be applied to containers in addition to the

[Daniel Erat, 2012/02/15 05:50:03]

ditto here

[alicet1, 2012/02/15 20:48:53]

Done.

+// base transformation 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& base_transform) {

[Daniel Erat, 2012/02/15 05:50:03]

|base_transform| doesn't seem right here.  |orig_transform|?

[alicet1, 2012/02/15 20:48:53]

Done.

   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(),
+              base_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& transform) {

[Daniel Erat, 2012/02/15 05:50:03]

s/transform/orig_transform/

[alicet1, 2012/02/15 20:48:53]

Done.

+  window->layer()->SetTransform(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();
@@ skipping 19 matching lines @@
         default:
           NOTREACHED() << "Unhandled container group " << group;
       }
     }
 
     if (matched)
       containers->push_back(window);
   }
 }
 
+void StoreOriginalTransform(PowerButtonController::AnimationType type,
+                            aura::Window* window,
+                            ash::WindowTransformsMap* window_transforms) {

[Daniel Erat, 2012/02/15 05:50:03]

you don't need "ash::" here; this is already in the ash namespace

[alicet1, 2012/02/15 20:48:53]

 removed.

+  if (window_transforms != NULL &&
+      type != PowerButtonController::ANIMATION_RESTORE  &&

[Daniel Erat, 2012/02/15 05:50:03]

hoist these checks out to StartAnimation(), so you just call
StoreOriginalTransform() when appropriate.  i'd remove the NULL check, or just
use DCHECK(window_transforms) instead

[alicet1, 2012/02/15 20:48:53]

removed.

+      type != PowerButtonController::ANIMATION_UNDO_SLOW_CLOSE) {
+    (*window_transforms)[window] = window->layer()->GetTargetTransform();
+  }
+}
+
+ui::Transform RetrieveOriginalTransform(
+    aura::Window* window,
+    ash::WindowTransformsMap* window_transforms) {

[Daniel Erat, 2012/02/15 05:50:03]

make this method take a const ash::WindowTransformsMap& instead

[alicet1, 2012/02/15 20:48:53]

ah yes.

+  if (window_transforms != NULL) {
+    WindowTransformsConstIter it = window_transforms->find(window);
+    if (it != window_transforms->end())
+      return it->second;
+  }
+  return ui::Transform();
+}
+
 // Apply animation |type| to all containers described by |group|.
 void StartAnimation(PowerButtonController::ContainerGroup group,

[Daniel Erat, 2012/02/15 06:07:51]

actually, a better approach would probably be to make StartAnimation(),
StoreOriginalTransform(), and RetrieveOriginalTransform() be private methods of
PowerButtonController.  i originally made StartAnimation just be a function
since it didn't need any state from the class, but that's no longer the case now
that it needs to access the cached original transforms.

[alicet1, 2012/02/15 20:48:53]

done.
left RetrieveOriginalTransform in default namespace as it is only a helper.

-                    PowerButtonController::AnimationType type) {
+                    PowerButtonController::AnimationType type,
+                    ash::WindowTransformsMap* window_transforms) {
   aura::Window::Windows containers;
   GetContainers(group, &containers);
-
+  ui::Transform transform;

[Daniel Erat, 2012/02/15 05:50:03]

this doesn't look like it gets used anywhere... ?

[alicet1, 2012/02/15 20:48:53]

removed.

   for (aura::Window::Windows::const_iterator it = containers.begin();
        it != containers.end(); ++it) {
     aura::Window* window = *it;
+    // Store this away so we can restore.
+    StoreOriginalTransform(type, window, window_transforms);
+
     switch (type) {
       case PowerButtonController::ANIMATION_SLOW_CLOSE:
         StartSlowCloseAnimationForWindow(window);
         break;
       case PowerButtonController::ANIMATION_UNDO_SLOW_CLOSE:
-        StartUndoSlowCloseAnimationForWindow(window);
+        StartUndoSlowCloseAnimationForWindow(
+            window,
+            RetrieveOriginalTransform(window, window_transforms));
         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);
+        RestoreWindow(
+            window,
+            RetrieveOriginalTransform(window, window_transforms));
         break;
       default:
         NOTREACHED() << "Unhandled animation type " << type;
     }
   }
 }
 
 }  // namespace
 
 bool PowerButtonController::TestApi::ContainerGroupIsAnimated(
     ContainerGroup group, AnimationType type) const {
   aura::Window::Windows containers;
   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(
+                RetrieveOriginalTransform(
+                    window, &controller_->window_transforms_)))
           return false;
         break;
       case PowerButtonController::ANIMATION_UNDO_SLOW_CLOSE:
-        if (layer->GetTargetTransform() != ui::Transform())
-          return false;
+        if (layer->GetTargetTransform() !=
+            RetrieveOriginalTransform(
+                window, &controller_->window_transforms_))
+        return false;
         break;
       case PowerButtonController::ANIMATION_FAST_CLOSE:
-        if (layer->GetTargetTransform() != GetFastCloseTransform() ||
+        if (layer->GetTargetTransform() != GetFastCloseTransform(

[Daniel Erat, 2012/02/15 05:50:03]

improve the indenting here:

  if (layer->Get... !=
      GetFastCloseTransform(...) ||

or something similar

[alicet1, 2012/02/15 20:48:53]

Done.

+                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() != RetrieveOriginalTransform(

[Daniel Erat, 2012/02/15 05:50:03]

ditto

[alicet1, 2012/02/15 20:48:53]

Done.

+                window, &controller_->window_transforms_))
           return false;
         break;
       default:
         NOTREACHED() << "Unhandled animation type " << type;
         return false;
     }
   }
   return true;
 }
 
 bool PowerButtonController::TestApi::BackgroundLayerIsVisible() const {
   return controller_->background_layer_.get() &&
          controller_->background_layer_->visible();
 }
 
+void PowerButtonController::TestApi::GetContainerWindows(
+    ContainerGroup group,
+    aura::Window::Windows* containers) {
+  GetContainers(group, containers);
+}
+
 PowerButtonController::PowerButtonController()
     : logged_in_as_non_guest_(false),
       locked_(false),
       power_button_down_(false),
       lock_button_down_(false),
       shutting_down_(false),
       has_legacy_power_button_(
           CommandLine::ForCurrentProcess()->HasSwitch(
               switches::kAuraLegacyPowerButton)) {
 }
 
 PowerButtonController::~PowerButtonController() {
 }
 
 void PowerButtonController::OnLoginStateChange(bool logged_in, bool is_guest) {
   logged_in_as_non_guest_ = logged_in && !is_guest;
 }
 
 void PowerButtonController::OnLockStateChange(bool locked) {
   if (shutting_down_ || locked_ == locked)
     return;
 
   locked_ = locked;
   if (locked) {
-    StartAnimation(SCREEN_LOCKER_CONTAINERS, ANIMATION_FADE_IN);
+    StartAnimation(SCREEN_LOCKER_CONTAINERS, ANIMATION_FADE_IN, NULL);
     lock_timer_.Stop();
     lock_fail_timer_.Stop();
 
     if (!has_legacy_power_button_ && power_button_down_) {
       lock_to_shutdown_timer_.Stop();
       lock_to_shutdown_timer_.Start(
           FROM_HERE,
           base::TimeDelta::FromMilliseconds(kLockToShutdownTimeoutMs),
           this, &PowerButtonController::OnLockToShutdownTimeout);
     }
   } else {
     StartAnimation(ALL_BUT_SCREEN_LOCKER_AND_RELATED_CONTAINERS,
-                   ANIMATION_RESTORE);
+                   ANIMATION_RESTORE, &window_transforms_);

[Daniel Erat, 2012/02/15 05:50:03]

nit: one param per line unless they all fit on a single line (ditto for later
function calls)

[alicet1, 2012/02/15 20:48:53]

removed.

altho, style guide said when calling a function, collapsing args maybe ok...
http://dev.chromium.org/developers/coding-style#TOC-Code-formatting

     HideBackgroundLayer();
   }
 }
 
 void PowerButtonController::OnStartingLock() {
   if (shutting_down_ || locked_)
     return;
 
   // Ensure that the background layer is visible -- if the screen was locked via
   // the wrench menu, we won't have already shown the background as part of the
   // slow-close animation.
   ShowBackgroundLayer();
 
   StartAnimation(ALL_BUT_SCREEN_LOCKER_AND_RELATED_CONTAINERS,
-                 ANIMATION_FAST_CLOSE);
+                 ANIMATION_FAST_CLOSE, &window_transforms_);
 
   // Hide the screen locker containers so we can make them fade in later.
-  StartAnimation(SCREEN_LOCKER_CONTAINERS, ANIMATION_HIDE);
+  StartAnimation(SCREEN_LOCKER_CONTAINERS, ANIMATION_HIDE, NULL);

[Daniel Erat, 2012/02/15 05:50:03]

it'd be simpler to always pass &window_transforms_ instead of passing NULL if
the animation doesn't require it

[alicet1, 2012/02/15 20:48:53]

removed. since startanimation is now part of the class.

 }
 
 void PowerButtonController::OnPowerButtonEvent(
     bool down, const base::TimeTicks& timestamp) {
   power_button_down_ = down;
 
   if (shutting_down_)
     return;
 
   if (has_legacy_power_button_) {
     // If power button releases won't get reported correctly because we're not
     // running on official hardware, just lock the screen or shut down
     // immediately.
     if (down) {
       ShowBackgroundLayer();
       if (logged_in_as_non_guest_ && !locked_) {
         StartAnimation(ALL_BUT_SCREEN_LOCKER_AND_RELATED_CONTAINERS,
-                       ANIMATION_SLOW_CLOSE);
+                       ANIMATION_SLOW_CLOSE, &window_transforms_);
         OnLockTimeout();
       } else {
         OnShutdownTimeout();
       }
     }
   } else {  // !has_legacy_power_button_
     if (down) {
       // If we already have a pending request to lock the screen, wait.
       if (lock_fail_timer_.IsRunning())
         return;
 
       if (logged_in_as_non_guest_ && !locked_)
         StartLockTimer();
       else
         StartShutdownTimer();
     } else {  // Button is up.
       if (lock_timer_.IsRunning() || shutdown_timer_.IsRunning())
         StartAnimation(
             locked_ ? SCREEN_LOCKER_AND_RELATED_CONTAINERS : ALL_CONTAINERS,
-            ANIMATION_UNDO_SLOW_CLOSE);
+            ANIMATION_UNDO_SLOW_CLOSE, &window_transforms_);
 
       // Drop the background layer after the undo animation finishes.
       if (lock_timer_.IsRunning() ||
           (shutdown_timer_.IsRunning() && !logged_in_as_non_guest_)) {
         hide_background_layer_timer_.Stop();
         hide_background_layer_timer_.Start(
             FROM_HERE,
             base::TimeDelta::FromMilliseconds(kUndoSlowCloseAnimMs),
             this, &PowerButtonController::HideBackgroundLayer);
       }
@@ skipping 17 matching lines @@
   // buttons to be present, so this is just making sure that we don't do
   // something completely stupid if that assumption changes later).
   if (locked_ || lock_fail_timer_.IsRunning() || power_button_down_)
     return;
 
   if (down) {
     StartLockTimer();
   } else {
     if (lock_timer_.IsRunning()) {
       StartAnimation(ALL_BUT_SCREEN_LOCKER_AND_RELATED_CONTAINERS,
-                     ANIMATION_UNDO_SLOW_CLOSE);
+                     ANIMATION_UNDO_SLOW_CLOSE,
+                     &window_transforms_);
       hide_background_layer_timer_.Stop();
       hide_background_layer_timer_.Start(
           FROM_HERE,
           base::TimeDelta::FromMilliseconds(kUndoSlowCloseAnimMs),
           this, &PowerButtonController::HideBackgroundLayer);
       lock_timer_.Stop();
     }
   }
 }
 
 void PowerButtonController::OnRootWindowResized(const gfx::Size& new_size) {
   if (background_layer_.get())
     background_layer_->SetBounds(gfx::Rect(new_size));
 }
 
 void PowerButtonController::OnLockTimeout() {
   delegate_->RequestLockScreen();
   lock_fail_timer_.Start(
       FROM_HERE,
       base::TimeDelta::FromMilliseconds(kLockFailTimeoutMs),
       this, &PowerButtonController::OnLockFailTimeout);
 }
 
 void PowerButtonController::OnLockFailTimeout() {
   DCHECK(!locked_);
-  LOG(ERROR) << "Screen lock request timed out";
   StartAnimation(ALL_BUT_SCREEN_LOCKER_AND_RELATED_CONTAINERS,
-                 ANIMATION_RESTORE);
+                 ANIMATION_RESTORE, &window_transforms_);
   HideBackgroundLayer();
 }
 
 void PowerButtonController::OnLockToShutdownTimeout() {
   DCHECK(locked_);
   StartShutdownTimer();
 }
 
 void PowerButtonController::OnShutdownTimeout() {
   DCHECK(!shutting_down_);
   shutting_down_ = true;
   aura::RootWindow::GetInstance()->ShowCursor(false);
-  StartAnimation(ALL_CONTAINERS, ANIMATION_FAST_CLOSE);
+  StartAnimation(ALL_CONTAINERS, ANIMATION_FAST_CLOSE, &window_transforms_);
   real_shutdown_timer_.Start(
       FROM_HERE,
       base::TimeDelta::FromMilliseconds(kFastCloseAnimMs),
       this, &PowerButtonController::OnRealShutdownTimeout);
 }
 
 void PowerButtonController::OnRealShutdownTimeout() {
   DCHECK(shutting_down_);
   delegate_->RequestShutdown();
 }
 
 void PowerButtonController::StartLockTimer() {
   ShowBackgroundLayer();
   StartAnimation(ALL_BUT_SCREEN_LOCKER_AND_RELATED_CONTAINERS,
-                 ANIMATION_SLOW_CLOSE);
+                 ANIMATION_SLOW_CLOSE, &window_transforms_);
   lock_timer_.Stop();
   lock_timer_.Start(FROM_HERE,
                     base::TimeDelta::FromMilliseconds(kSlowCloseAnimMs),
                     this, &PowerButtonController::OnLockTimeout);
 }
 
 void PowerButtonController::StartShutdownTimer() {
   ShowBackgroundLayer();
-  StartAnimation(ALL_CONTAINERS, ANIMATION_SLOW_CLOSE);
+  StartAnimation(ALL_CONTAINERS, ANIMATION_SLOW_CLOSE, &window_transforms_);
   shutdown_timer_.Stop();
   shutdown_timer_.Start(
       FROM_HERE,
       base::TimeDelta::FromMilliseconds(kShutdownTimeoutMs),
       this, &PowerButtonController::OnShutdownTimeout);
 }
 
 void PowerButtonController::ShowBackgroundLayer() {
   if (hide_background_layer_timer_.IsRunning())
     hide_background_layer_timer_.Stop();
 
   if (!background_layer_.get()) {
     background_layer_.reset(new ui::Layer(ui::Layer::LAYER_SOLID_COLOR));
     background_layer_->SetColor(SK_ColorBLACK);
 
     ui::Layer* root_layer = aura::RootWindow::GetInstance()->layer();
     background_layer_->SetBounds(root_layer->bounds());
     root_layer->Add(background_layer_.get());
     root_layer->StackAtBottom(background_layer_.get());
   }
   background_layer_->SetVisible(true);
 }
 
 void PowerButtonController::HideBackgroundLayer() {
   background_layer_.reset();
 }
 
 }  // namespace ash