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

ui/compositor/layer_animation_element.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 "ui/compositor/layer_animation_element.h"
 
 #include "base/compiler_specific.h"
 #include "ui/base/animation/tween.h"
 #include "ui/compositor/layer_animation_delegate.h"
 #include "ui/compositor/layer_animator.h"
@@ skipping 214 matching lines @@
     properties.insert(LayerAnimationElement::VISIBILITY);
     return properties;
   }
 
   bool start_;
   const bool target_;
 
   DISALLOW_COPY_AND_ASSIGN(VisibilityTransition);
 };
 
+// BrightnessTransition --------------------------------------------------------
+
+class BrightnessTransition : public LayerAnimationElement {
+ public:
+  BrightnessTransition(float target, base::TimeDelta duration)
+      : LayerAnimationElement(GetProperties(), duration),
+        start_(0.0f),
+        target_(target) {
+  }
+  virtual ~BrightnessTransition() {}
+
+ protected:
+  virtual void OnStart(LayerAnimationDelegate* delegate) OVERRIDE {
+    start_ = delegate->GetBrightnessForAnimation();
+  }
+
+  virtual bool OnProgress(double t, LayerAnimationDelegate* delegate) OVERRIDE {
+    delegate->SetBrightnessFromAnimation(
+        Tween::ValueBetween(t, start_, target_));
+    return true;
+  }
+
+  virtual void OnGetTarget(TargetValue* target) const OVERRIDE {
+    target->brightness = target_;
+  }
+
+  virtual void OnAbort() OVERRIDE {}
+
+ private:
+  static AnimatableProperties GetProperties() {
+    AnimatableProperties properties;
+    properties.insert(LayerAnimationElement::BRIGHTNESS);
+    return properties;
+  }
+
+  float start_;
+  const float target_;
+
+  DISALLOW_COPY_AND_ASSIGN(BrightnessTransition);
+};
+
+// GrayscaleTransition ---------------------------------------------------------
+
+class GrayscaleTransition : public LayerAnimationElement {
+ public:
+  GrayscaleTransition(float target, base::TimeDelta duration)
+      : LayerAnimationElement(GetProperties(), duration),
+        start_(0.0f),
+        target_(target) {
+  }
+  virtual ~GrayscaleTransition() {}
+
+ protected:
+  virtual void OnStart(LayerAnimationDelegate* delegate) OVERRIDE {
+    start_ = delegate->GetGrayscaleForAnimation();
+  }
+
+  virtual bool OnProgress(double t, LayerAnimationDelegate* delegate) OVERRIDE {
+    delegate->SetGrayscaleFromAnimation(
+        Tween::ValueBetween(t, start_, target_));
+    return true;
+  }
+
+  virtual void OnGetTarget(TargetValue* target) const OVERRIDE {
+    target->grayscale = target_;
+  }
+
+  virtual void OnAbort() OVERRIDE {}
+
+ private:
+  static AnimatableProperties GetProperties() {
+    AnimatableProperties properties;
+    properties.insert(LayerAnimationElement::GRAYSCALE);
+    return properties;
+  }
+
+  float start_;
+  const float target_;
+
+  DISALLOW_COPY_AND_ASSIGN(GrayscaleTransition);
+};
+
 }  // namespace
 
 // LayerAnimationElement::TargetValue ------------------------------------------
 
 LayerAnimationElement::TargetValue::TargetValue()
     : opacity(0.0f),
-      visibility(false) {
+      visibility(false),
+      brightness(0.0f),
+      grayscale(0.0f) {
 }
 
 LayerAnimationElement::TargetValue::TargetValue(
     const LayerAnimationDelegate* delegate)
     : bounds(delegate ? delegate->GetBoundsForAnimation() : gfx::Rect()),
       transform(delegate ? delegate->GetTransformForAnimation() : Transform()),
       opacity(delegate ? delegate->GetOpacityForAnimation() : 0.0f),
-      visibility(delegate ? delegate->GetVisibilityForAnimation() : false) {
+      visibility(delegate ? delegate->GetVisibilityForAnimation() : false),
+      brightness(delegate ? delegate->GetBrightnessForAnimation() : 0.0f),
+      grayscale(delegate ? delegate->GetGrayscaleForAnimation() : 0.0f) {
 }
 
 // LayerAnimationElement -------------------------------------------------------
 
 LayerAnimationElement::LayerAnimationElement(
     const AnimatableProperties& properties,
     base::TimeDelta duration)
     : first_frame_(true),
       properties_(properties),
       duration_(GetEffectiveDuration(duration)),
@@ skipping 58 matching lines @@
   return new OpacityTransition(opacity, duration);
 }
 
 // static
 LayerAnimationElement* LayerAnimationElement::CreateVisibilityElement(
     bool visibility, base::TimeDelta duration) {
   return new VisibilityTransition(visibility, duration);
 }
 
 // static
+LayerAnimationElement* LayerAnimationElement::CreateBrightnessElement(
+    float brightness, base::TimeDelta duration) {
+  return new BrightnessTransition(brightness, duration);
+}
+
+// static
+LayerAnimationElement* LayerAnimationElement::CreateGrayscaleElement(
+    float grayscale, base::TimeDelta duration) {
+  return new GrayscaleTransition(grayscale, duration);
+}
+
+// static
 LayerAnimationElement* LayerAnimationElement::CreatePauseElement(
     const AnimatableProperties& properties, base::TimeDelta duration) {
   return new Pause(properties, duration);
 }
 
 }  // namespace ui