ash: Create new containers for PowerButtonController.

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 51 matching lines @@
 
 // Additional time (beyond kFastCloseAnimMs) to wait after starting the
 // fast-close shutdown animation before actually requesting shutdown, to give
 // the animation time to finish.
 const int kShutdownRequestDelayMs = 50;
 
 // Slightly-smaller size that we scale the screen down to for the pre-lock and
 // pre-shutdown states.
 const float kSlowCloseSizeRatio = 0.95f;
 
-// Containers holding screen locker windows.
-const int kScreenLockerContainerIds[] = {
-  internal::kShellWindowId_LockScreenContainer,
-  internal::kShellWindowId_LockSystemModalContainer,
-};
-
-// Containers holding additional windows that should be shown while the screen
-// is locked.
-const int kRelatedContainerIds[] = {
-  internal::kShellWindowId_StatusContainer,
-  internal::kShellWindowId_MenuContainer,
-  internal::kShellWindowId_DragImageAndTooltipContainer,
-  internal::kShellWindowId_SettingBubbleContainer,
-  internal::kShellWindowId_OverlayContainer,
-};
-
-// Is |window| a container that holds screen locker windows?
-bool IsScreenLockerContainer(aura::Window* window) {
-  for (size_t i = 0; i < arraysize(kScreenLockerContainerIds); ++i)
-    if (window->id() == kScreenLockerContainerIds[i])
-      return true;
-  return false;
-}
-
-// 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, based on |base_transform|, that should be applied
-// to containers for slow-close animation.
-ui::Transform GetSlowCloseTransform(const ui::Transform& base_transform) {
+// Returns the transform that should be applied to containers for the slow-close
+// animation.
+ui::Transform GetSlowCloseTransform() {
   gfx::Size root_size = Shell::GetRootWindow()->bounds().size();
-  ui::Transform transform(base_transform);
-  transform.ConcatScale(kSlowCloseSizeRatio, kSlowCloseSizeRatio);
+  ui::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;
 }
 
-// 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) {
+// Returns the transform that should be applied to containers for the fast-close
+// animation.
+ui::Transform GetFastCloseTransform() {
   gfx::Size root_size = Shell::GetRootWindow()->bounds().size();
-  ui::Transform transform(base_transform);
-  transform.ConcatScale(0.0, 0.0);
+  ui::Transform transform;
+  transform.SetScale(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(window->layer()->GetTargetTransform()),
+              GetSlowCloseTransform(),
               base::TimeDelta::FromMilliseconds(kSlowCloseAnimMs))));
 }
 
 // Quickly undoes the effects of the slow-close animation on |window|.
-void StartUndoSlowCloseAnimationForWindow(aura::Window* window,
-                                          const ui::Transform& orig_transform) {
+void StartUndoSlowCloseAnimationForWindow(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(
-              orig_transform,
+              ui::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(window->layer()->GetTargetTransform()),
+              GetFastCloseTransform(),
               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,
-                   const ui::Transform& orig_transform) {
-  window->layer()->SetTransform(orig_transform);
+void RestoreWindow(aura::Window* window) {
+  window->layer()->SetTransform(ui::Transform());
   window->layer()->SetOpacity(1.0);
 }
 
+// Fills |containers| with the containers described by |group|.
+void GetContainers(PowerButtonController::ContainerGroup group,

[Daniel Erat, 2012/02/23 02:13:16]

Most of the changes to this file are just a revert of
http://codereview.chromium.org/9348089 ; I rewrote this function, though.

+                   aura::Window::Windows* containers) {
+  aura::Window* non_lock_screen_containers =
+      Shell::GetInstance()->GetContainer(
+          internal::kShellWindowId_NonLockScreenContainersContainer);
+  aura::Window* lock_screen_containers =
+      Shell::GetInstance()->GetContainer(
+          internal::kShellWindowId_LockScreenContainersContainer);
+  aura::Window* lock_screen_related_containers =
+      Shell::GetInstance()->GetContainer(
+          internal::kShellWindowId_LockScreenRelatedContainersContainer);
+
+  containers->clear();
+  switch (group) {
+    case PowerButtonController::ALL_CONTAINERS:
+      containers->push_back(non_lock_screen_containers);
+      containers->push_back(lock_screen_containers);
+      containers->push_back(lock_screen_related_containers);
+      break;
+    case PowerButtonController::SCREEN_LOCKER_CONTAINERS:
+      containers->push_back(lock_screen_containers);
+      break;
+    case PowerButtonController::SCREEN_LOCKER_AND_RELATED_CONTAINERS:
+      containers->push_back(lock_screen_containers);
+      containers->push_back(lock_screen_related_containers);
+      break;
+    case PowerButtonController::ALL_BUT_SCREEN_LOCKER_AND_RELATED_CONTAINERS:
+      containers->push_back(non_lock_screen_containers);
+      break;
+    default:
+      NOTREACHED() << "Unhandled container group " << group;
+  }
+}
+
+// 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;
-  controller_->GetContainers(group, &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(
-                controller_->RetrieveOriginalTransform(window)))
+        if (layer->GetTargetTransform() != GetSlowCloseTransform())
           return false;
         break;
       case PowerButtonController::ANIMATION_UNDO_SLOW_CLOSE:
-        if (layer->GetTargetTransform() !=
-            controller_->RetrieveOriginalTransform(window))
-        return false;
+        if (layer->GetTargetTransform() != ui::Transform())
+          return false;
         break;
       case PowerButtonController::ANIMATION_FAST_CLOSE:
-        if (layer->GetTargetTransform() !=
-            GetFastCloseTransform(layer->GetTargetTransform()) ||
+        if (layer->GetTargetTransform() != GetFastCloseTransform() ||
             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() !=
-            controller_->RetrieveOriginalTransform(window))
+        if (layer->opacity() < 0.9999 || layer->transform() != ui::Transform())
           return false;
         break;
       default:
         NOTREACHED() << "Unhandled animation type " << type;
         return false;
     }
   }
   return true;
 }
 
@@ skipping 157 matching lines @@
       lock_timer_.Stop();
     }
   }
 }
 
 void PowerButtonController::RequestShutdown() {
   if (!shutting_down_)
     StartShutdownAnimationAndRequestShutdown();
 }
 
-// Fills |containers| with the containers described by |group|.
-void PowerButtonController::GetContainers(ContainerGroup group,
-                                          aura::Window::Windows* containers) {
-  containers->clear();
-
-  aura::Window* root = Shell::GetRootWindow();
-  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::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),
@@ skipping 82 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