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|.
+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,

[sky, 2012/12/12 20:35:56]

Add a comment for this. How about naming SetToInitialState

[Denis Kuznetsov (DE-MUC), 2012/12/13 18:11:24]

Added comment.
I don't like BaseState, but I think Initial is worse : 'Initial' state means
that there is some single process and it has starting state. Here we have lots
of animation, so it is not clear what the initial state is.

+                                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(

[sky, 2012/12/12 20:35:56]

Why do you need this (say question on 162)?

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

This method can be called directly (without ShowWindow call), e.g. when
cancelling initial lock animation.

+      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());

[sky, 2012/12/12 20:35:56]

Why do you need a ScopedLayerAnimationSettings here and resetting the preemption
strategy on 233? If you need the values immediately set can't you set them
without wrapping in a ScopedLayerAnimationSettings.

+
+  // 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);

[sky, 2012/12/12 20:35:56]

This means you'll have two ScopedLayerAnimationSettings in effect, right? One on
230 and the other on 198. We should avoid doing that.

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

As TransformWindowToBaseState can be called outside from ShowWindow, it needs
it's own ScopedLayerAnimationSettings.
Some legacy code sets layer animation strategy explicitly, so I need to make
sure correct strategy in this method.

I am going to fix this (direct setting of animator's stragegy) in a separate
cleanup CL.

+}
+
 // 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|.
 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(

[sky, 2012/12/12 20:35:56]

Is this used?

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

Yes, SessionStateControllerImpl2 uses it.

+    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