Fix black background when locking with fullscreen window:

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/window_animations.h"
 #include "ui/aura/client/aura_constants.h"
@@ skipping 102 matching lines @@
   animator->set_preemption_strategy(
       ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
   ui::LayerAnimationSequence* sequence = new ui::LayerAnimationSequence(
       ui::LayerAnimationElement::CreateOpacityElement(
           target_opacity, duration));
   animator->StartAnimation(sequence);
   if (observer)
     sequence->AddObserver(observer);
 }
 
-// Fades |window| in to full opacity over |duration|.
-void FadeInWindow(aura::Window* window,
-                  base::TimeDelta duration,
-                  ui::LayerAnimationObserver* observer) {
+// Fades |window| in to |opacity| over |duration|.

[Daniel Erat, 2012/12/13 05:02:02]

nit: s/Fades |window| in to/Fades |window| to/

[Denis Kuznetsov (DE-MUC), 2012/12/13 17:59:51]

Done.

+void StartOpacityAnimationForWindow(aura::Window* window,
+                                    float opacity,
+                                    base::TimeDelta duration,
+                                    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(1.0, duration));
+      ui::LayerAnimationElement::CreateOpacityElement(opacity, duration));
   animator->StartAnimation(sequence);
   if (observer)
     sequence->AddObserver(observer);
 }
 
 // Makes |window| fully transparent instantaneously.
 void HideWindowImmediately(aura::Window* window,
                            ui::LayerAnimationObserver* observer) {
   window->layer()->SetOpacity(0.0);
   if (observer)
     observer->OnLayerAnimationEnded(NULL);
 }
 
 // Restores |window| to its original position and scale and full opacity
 // instantaneously.
 void RestoreWindow(aura::Window* window, ui::LayerAnimationObserver* observer) {
   window->layer()->SetTransform(gfx::Transform());
   window->layer()->SetOpacity(1.0);
   if (observer)
     observer->OnLayerAnimationEnded(NULL);
 }
 
 void HideWindow(aura::Window* window,
                 base::TimeDelta duration,
                 bool above,
                 ui::LayerAnimationObserver* observer) {
   ui::Layer* layer = window->layer();
   ui::ScopedLayerAnimationSettings settings(layer->GetAnimator());
 
+  settings.SetPreemptionStrategy(
+      ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
   settings.SetTransitionDuration(duration);
 
   settings.SetTweenType(ui::Tween::EASE_OUT);
   SetTransformForScaleAnimation(layer,
       above ? LAYER_SCALE_ANIMATION_ABOVE : LAYER_SCALE_ANIMATION_BELOW);
 
   settings.SetTweenType(ui::Tween::EASE_IN_OUT);
   layer->SetOpacity(0.0f);
 
   // After the animation completes snap the transform back to the identity,
@@ skipping 10 matching lines @@
   // it does not call NotifyEnded().
   if (observer) {
     ui::LayerAnimationSequence* sequence = new ui::LayerAnimationSequence(
         ui::LayerAnimationElement::CreateOpacityElement(
             0.0, base::TimeDelta()));
       sequence->AddObserver(observer);
     layer->GetAnimator()->ScheduleAnimation(sequence);
   }
 }
 
-void ShowWindow(aura::Window* window,
-                base::TimeDelta duration,
-                bool above,
-                ui::LayerAnimationObserver* observer) {
+void TransformWindowToBaseState(aura::Window* window,
+                                base::TimeDelta duration,
+                                ui::LayerAnimationObserver* observer) {
   ui::Layer* layer = window->layer();
   ui::ScopedLayerAnimationSettings settings(layer->GetAnimator());
 
-  // Set initial state of animation
-  settings.SetTransitionDuration(base::TimeDelta());
-  SetTransformForScaleAnimation(layer,
-      above ? LAYER_SCALE_ANIMATION_ABOVE : LAYER_SCALE_ANIMATION_BELOW);
-
   // Animate to target values.
+  settings.SetPreemptionStrategy(
+      ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
   settings.SetTransitionDuration(duration);
 
   settings.SetTweenType(ui::Tween::EASE_OUT);
   layer->SetTransform(gfx::Transform());
 
   settings.SetTweenType(ui::Tween::EASE_IN_OUT);
   layer->SetOpacity(1.0f);
 
   // A bit of a dirty trick: we need to catch the end of the animation we don't
   // control. So we use two facts we know: which animator will be used and the
   // target opacity to add "Do nothing" animation sequence.
   // Unfortunately, we can not just use empty LayerAnimationSequence, because
   // it does not call NotifyEnded().
   if (observer) {
     ui::LayerAnimationSequence* sequence = new ui::LayerAnimationSequence(
         ui::LayerAnimationElement::CreateOpacityElement(
             1.0, base::TimeDelta()));
     sequence->AddObserver(observer);
     layer->GetAnimator()->ScheduleAnimation(sequence);
   }
 }
 
+void ShowWindow(aura::Window* window,
+                base::TimeDelta duration,
+                bool above,
+                ui::LayerAnimationObserver* observer) {
+  ui::Layer* layer = window->layer();
+  ui::ScopedLayerAnimationSettings settings(layer->GetAnimator());
+
+  // Set initial state of animation
+  settings.SetPreemptionStrategy(
+      ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
+  settings.SetTransitionDuration(base::TimeDelta());
+  SetTransformForScaleAnimation(layer,
+      above ? LAYER_SCALE_ANIMATION_ABOVE : LAYER_SCALE_ANIMATION_BELOW);
+
+  TransformWindowToBaseState(window, duration, observer);
+}
+
 // Starts grayscale/brightness animation for |window| over |duration|. Target
 // value for both grayscale and brightness are specified by |target|.
 void StartGrayscaleBrightnessAnimationForWindow(
     aura::Window* window,
     float target,
     base::TimeDelta duration,
     ui::LayerAnimationObserver* observer) {
   ui::LayerAnimator* animator = window->layer()->GetAnimator();
 
-  std::vector<ui::LayerAnimationSequence*> animations =
-      CreateBrightnessGrayscaleAnimationSequence(target, duration);
+  scoped_ptr<ui::LayerAnimationSequence> brightness_sequence(
+      new ui::LayerAnimationSequence());
+  scoped_ptr<ui::LayerAnimationSequence> grayscale_sequence(
+      new ui::LayerAnimationSequence());
+
+  scoped_ptr<ui::LayerAnimationElement> brightness_element(
+      ui::LayerAnimationElement::CreateBrightnessElement(
+          target, duration));
+  brightness_element->set_tween_type(ui::Tween::EASE_IN);
+  brightness_sequence->AddElement(brightness_element.release());
+
+  scoped_ptr<ui::LayerAnimationElement> grayscale_element(
+      ui::LayerAnimationElement::CreateGrayscaleElement(
+          target, duration));
+  grayscale_element->set_tween_type(ui::Tween::EASE_IN);
+  grayscale_sequence->AddElement(grayscale_element.release());
+
+  std::vector<ui::LayerAnimationSequence*> animations;
+  animations.push_back(brightness_sequence.release());
+  animations.push_back(grayscale_sequence.release());
 
   if (observer)
     animations[0]->AddObserver(observer);
 
   animator->set_preemption_strategy(
       ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
 
   animator->StartTogether(animations);
 }
 
@@ skipping 45 matching lines @@
       break;
     case SessionStateAnimator::ANIMATION_FULL_CLOSE:
       if (layer->GetTargetTransform() != GetFastCloseTransform() ||
           layer->GetTargetOpacity() > 0.0001)
         return false;
       break;
     case SessionStateAnimator::ANIMATION_FADE_IN:
       if (layer->GetTargetOpacity() < 0.9999)
         return false;
       break;
+    case SessionStateAnimator::ANIMATION_FADE_OUT:
+      if (layer->GetTargetOpacity() > 0.0001)
+        return false;
+      break;
     case SessionStateAnimator::ANIMATION_HIDE_IMMEDIATELY:
       if (layer->GetTargetOpacity() > 0.0001)
         return false;
       break;
     case SessionStateAnimator::ANIMATION_RESTORE:
       if (layer->opacity() < 0.9999 || layer->transform() != gfx::Transform())
         return false;
       break;
     case SessionStateAnimator::ANIMATION_GRAYSCALE_BRIGHTNESS:
       if ((layer->GetTargetBrightness() < 0.9999) ||
           (layer->GetTargetGrayscale() < 0.9999))
         return false;
       break;
     case SessionStateAnimator::ANIMATION_UNDO_GRAYSCALE_BRIGHTNESS:
       if ((layer->GetTargetBrightness() > 0.0001) ||
           (layer->GetTargetGrayscale() > 0.0001))
         return false;
       break;
     case SessionStateAnimator::ANIMATION_DROP:
+    case SessionStateAnimator::ANIMATION_UNDO_LIFT:
       //ToDo(antim) : check other effects
       if (layer->GetTargetOpacity() < 0.9999)
         return false;
       break;
       //ToDo(antim) : check other effects
     case SessionStateAnimator::ANIMATION_LIFT:
       if (layer->GetTargetOpacity() > 0.0001)
         return false;
       break;
     case SessionStateAnimator::ANIMATION_RAISE_TO_SCREEN:
@@ skipping 53 matching lines @@
 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(100);
+      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(400);
+      return base::TimeDelta::FromMilliseconds(350);
     case ANIMATION_SPEED_UNDO_MOVE_WINDOWS:
-      return base::TimeDelta::FromMilliseconds(600);
+      return base::TimeDelta::FromMilliseconds(500);
     case ANIMATION_SPEED_SHUTDOWN:
       return base::TimeDelta::FromMilliseconds(1000);
     case ANIMATION_SPEED_REVERT_SHUTDOWN:
       return base::TimeDelta::FromMilliseconds(1500);
   }
   // Satisfy compilers that do not understand that we will return from switch
   // above anyway.
   DCHECK(false) << "Unhandled animation speed " << speed;
   return base::TimeDelta();
 }
@@ skipping 38 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_PowerButtonAnimationContainer));
-  }
 }
 
 void SessionStateAnimator::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);
   }
 }
 
 // Apply animation |type| to all containers described by |container_mask|.

[Daniel Erat, 2012/12/13 05:02:02]

nit: delete this comment; it should be in the header instead of here

[Denis Kuznetsov (DE-MUC), 2012/12/13 17:59:51]

Done.

 void SessionStateAnimator::StartAnimationWithCallback(
     int container_mask,
     AnimationType type,
     AnimationSpeed speed,
     base::Callback<void(void)>& 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(

[Daniel Erat, 2012/12/13 05:02:02]

this is almost exactly the same as StartAnimationWithCallback().  can
StartAnimationWithCallback() just construct an observer and pass it to this
method?  (i was thinking that maybe it couldn't because this SAWC() creates a
separate observer for each container, but SAWO() passes the same observer to
each container, so presumably it's okay to do that.)

+    int container_mask,
+    AnimationType type,
+    AnimationSpeed speed,
+    ui::LayerAnimationObserver* 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::RootWindow* root_window = Shell::GetPrimaryRootWindow();
   RunAnimationForWindow(root_window, type, speed, NULL);
 }
 
 void SessionStateAnimator::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;
     case ANIMATION_UNDO_PARTIAL_CLOSE:
       StartUndoSlowCloseAnimationForWindow(window, duration, observer);
       break;
     case ANIMATION_FULL_CLOSE:
       StartFastCloseAnimationForWindow(window, duration, observer);
       break;
     case ANIMATION_FADE_IN:
-      FadeInWindow(window, duration, observer);
+      StartOpacityAnimationForWindow(window, 1.0, duration, observer);
+      break;
+    case ANIMATION_FADE_OUT:
+      StartOpacityAnimationForWindow(window, 0.0, duration, observer);
       break;
     case ANIMATION_HIDE_IMMEDIATELY:
       DCHECK_EQ(speed, ANIMATION_SPEED_IMMEDIATE);
       HideWindowImmediately(window, observer);
       break;
     case ANIMATION_RESTORE:
       DCHECK_EQ(speed, ANIMATION_SPEED_IMMEDIATE);
       RestoreWindow(window, observer);
       break;
     case ANIMATION_LIFT:
       HideWindow(window, duration, true, observer);
       break;
     case ANIMATION_DROP:
       ShowWindow(window, duration, true, observer);
       break;
+    case ANIMATION_UNDO_LIFT:
+      TransformWindowToBaseState(window, duration, observer);
+      break;
     case ANIMATION_RAISE_TO_SCREEN:
       ShowWindow(window, duration, false, observer);
       break;
     case ANIMATION_LOWER_BELOW_SCREEN:
       HideWindow(window, duration, false, observer);
       break;
     case ANIMATION_PARTIAL_FADE_IN:
       StartPartialFadeAnimation(
           window, kPartialFadeRatio, duration, observer);
       break;
@@ skipping 26 matching lines @@
   foreground_->SetColor(SK_ColorWHITE);
   foreground_->GetWidget()->Show();
 }
 
 void SessionStateAnimator::DropForeground() {
   foreground_.reset();
 }
 
 }  // namespace internal
 }  // namespace ash