Add brightness/grayscale animations and use them for OOBE boot transition

ash/wm/window_animations.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/window_animations.h"
 
 #include <math.h>
 
 #include <algorithm>
 #include <vector>
@@ skipping 51 matching lines @@
                            kWindowAnimation_Vertical_TranslateY);
 
 namespace {
 
 const int kDefaultAnimationDurationForMenuMS = 150;
 
 // Durations for the cross-fade animation, in milliseconds.
 const float kCrossFadeDurationMinMs = 100.f;
 const float kCrossFadeDurationMaxMs = 400.f;
 
+// Durations for the brightness/grayscale fade animation, in milliseconds.
+const int kBrightnessGrayscaleFadeDurationMs = 2000;
+
+// Brightness/grayscale values for hide/show window animations.
+const float kWindowAnimation_HideBrightnessGrayscale = 1.f;
+const float kWindowAnimation_ShowBrightnessGrayscale = 0.f;
+
 const float kWindowAnimation_HideOpacity = 0.f;
 const float kWindowAnimation_ShowOpacity = 1.f;
 const float kWindowAnimation_TranslateFactor = -0.025f;
 const float kWindowAnimation_ScaleFactor = 1.05f;
 const float kWindowAnimation_MinimizeRotate = -5.f;
 
 // Amount windows are scaled during workspace animations.
 const float kWorkspaceScale = .95f;
 
 int64 Round64(float f) {
@@ skipping 376 matching lines @@
   window->layer()->set_delegate(NULL);
 
   // Property sets within this scope will be implicitly animated.
   ui::ScopedLayerAnimationSettings settings(window->layer()->GetAnimator());
   settings.AddObserver(new HidingWindowAnimationObserver(window));
   window->layer()->SetVisible(false);
 
   AddLayerAnimationsForMinimize(window, false);
 }
 
+void AnimateShowHideWindowCommon_BrightnessGrayscale(aura::Window* window,
+                                                     bool show) {
+  window->layer()->set_delegate(window);
+
+  float start_value, end_value;
+  if (show) {
+    start_value = kWindowAnimation_HideBrightnessGrayscale;
+    end_value = kWindowAnimation_ShowBrightnessGrayscale;
+  } else {
+    start_value = kWindowAnimation_ShowBrightnessGrayscale;
+    end_value = kWindowAnimation_HideBrightnessGrayscale;
+  }
+
+  window->layer()->SetLayerBrightness(start_value);
+  window->layer()->SetLayerGrayscale(start_value);
+  if (show) {
+    window->layer()->SetOpacity(kWindowAnimation_ShowOpacity);
+    window->layer()->SetVisible(true);
+  }
+
+  ui::ScopedLayerAnimationSettings settings(window->layer()->GetAnimator());
+  settings.SetTransitionDuration(
+      base::TimeDelta::FromMilliseconds(kBrightnessGrayscaleFadeDurationMs));
+  if (!show)
+    settings.AddObserver(new HidingWindowAnimationObserver(window));
+
+  scoped_ptr<ui::LayerAnimationSequence> brightness_sequence(
+      new ui::LayerAnimationSequence());
+  scoped_ptr<ui::LayerAnimationSequence> grayscale_sequence(
+      new ui::LayerAnimationSequence());
+
+  brightness_sequence->AddElement(
+      ui::LayerAnimationElement::CreateBrightnessElement(
+          end_value,
+          base::TimeDelta::FromMilliseconds(
+              kBrightnessGrayscaleFadeDurationMs)));
+  grayscale_sequence->AddElement(
+      ui::LayerAnimationElement::CreateGrayscaleElement(
+          end_value,
+          base::TimeDelta::FromMilliseconds(
+              kBrightnessGrayscaleFadeDurationMs)));
+
+   std::vector<ui::LayerAnimationSequence*> animations;
+   animations.push_back(brightness_sequence.release());
+   animations.push_back(grayscale_sequence.release());
+   window->layer()->GetAnimator()->ScheduleTogether(animations);
+   if (!show) {
+     window->layer()->SetOpacity(kWindowAnimation_HideOpacity);
+     window->layer()->SetVisible(false);
+   }
+}
+
+void AnimateShowWindow_BrightnessGrayscale(aura::Window* window) {
+  AnimateShowHideWindowCommon_BrightnessGrayscale(window, true);
+}
+
+void AnimateHideWindow_BrightnessGrayscale(aura::Window* window) {
+  AnimateShowHideWindowCommon_BrightnessGrayscale(window, false);
+}
+
 bool AnimateShowWindow(aura::Window* window) {
   if (!HasWindowVisibilityAnimationTransition(window, ANIMATE_SHOW))
     return false;
 
   switch (GetWindowVisibilityAnimationType(window)) {
     case WINDOW_VISIBILITY_ANIMATION_TYPE_DROP:
       AnimateShowWindow_Drop(window);
       return true;
     case WINDOW_VISIBILITY_ANIMATION_TYPE_VERTICAL:
       AnimateShowWindow_Vertical(window);
       return true;
     case WINDOW_VISIBILITY_ANIMATION_TYPE_FADE:
       AnimateShowWindow_Fade(window);
       return true;
     case WINDOW_VISIBILITY_ANIMATION_TYPE_WORKSPACE_SHOW:
       AnimateShowWindow_Workspace(window);
       return true;
     case WINDOW_VISIBILITY_ANIMATION_TYPE_MINIMIZE:
       AnimateShowWindow_Minimize(window);
       return true;
+    case WINDOW_VISIBILITY_ANIMATION_TYPE_BRIGHTNESS_GRAYSCALE:
+        AnimateShowWindow_BrightnessGrayscale(window);
+        return true;
     default:
       NOTREACHED();
       return false;
   }
 }
 
 bool AnimateHideWindow(aura::Window* window) {
   if (!HasWindowVisibilityAnimationTransition(window, ANIMATE_HIDE))
     return false;
 
   switch (GetWindowVisibilityAnimationType(window)) {
     case WINDOW_VISIBILITY_ANIMATION_TYPE_DROP:
       AnimateHideWindow_Drop(window);
       return true;
     case WINDOW_VISIBILITY_ANIMATION_TYPE_VERTICAL:
       AnimateHideWindow_Vertical(window);
       return true;
     case WINDOW_VISIBILITY_ANIMATION_TYPE_FADE:
       AnimateHideWindow_Fade(window);
       return true;
     case WINDOW_VISIBILITY_ANIMATION_TYPE_WORKSPACE_HIDE:
       AnimateHideWindow_Workspace(window);
       return true;
     case WINDOW_VISIBILITY_ANIMATION_TYPE_MINIMIZE:
       AnimateHideWindow_Minimize(window);
       return true;
+    case WINDOW_VISIBILITY_ANIMATION_TYPE_BRIGHTNESS_GRAYSCALE:
+      AnimateHideWindow_BrightnessGrayscale(window);
+      return true;
     default:
       NOTREACHED();
       return false;
   }
 }
 
 // Recreates a fresh layer for |window| and all its child windows. Does not
 // recreate shadows or other non-window layers. Returns the old layer and its
 // children, maintaining the hierarchy.
 Layer* RecreateWindowLayers(Window* window) {
@@ skipping 254 matching lines @@
         AnimateHideWindow(window);
   }
 }
 
 void SetDelayedOldLayerDeletionInCrossFadeForTest(bool value) {
   delayed_old_layer_deletion_in_cross_fade_for_test_ = value;
 }
 
 }  // namespace internal
 }  // namespace ash