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

ui/compositor/layer.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.h"
 
 #include <algorithm>
 
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
@@ skipping 38 matching lines @@
       compositor_(NULL),
       parent_(NULL),
       visible_(true),
       force_render_surface_(false),
       fills_bounds_opaquely_(true),
       layer_updated_externally_(false),
       opacity_(1.0f),
       background_blur_radius_(0),
       layer_saturation_(0.0f),
       layer_brightness_(0.0f),
+      layer_grayscale_(0.0f),
       layer_inverted_(false),
       layer_mask_(NULL),
       layer_mask_back_link_(NULL),
       delegate_(NULL),
       scale_content_(true),
       device_scale_factor_(1.0f) {
   CreateWebLayer();
 }
 
 Layer::Layer(LayerType type)
@@ skipping 108 matching lines @@
     SetAnimator(LayerAnimator::CreateDefaultAnimator());
   return animator_.get();
 }
 
 void Layer::SetTransform(const ui::Transform& transform) {
   GetAnimator()->SetTransform(transform);
 }
 
 Transform Layer::GetTargetTransform() const {
   if (animator_.get() && animator_->IsAnimatingProperty(
-      LayerAnimationElement::TRANSFORM))
+      LayerAnimationElement::TRANSFORM)) {
     return animator_->GetTargetTransform();
+  }
   return transform_;
 }
 
 void Layer::SetBounds(const gfx::Rect& bounds) {
   GetAnimator()->SetBounds(bounds);
 }
 
 gfx::Rect Layer::GetTargetBounds() const {
   if (animator_.get() && animator_->IsAnimatingProperty(
-      LayerAnimationElement::BOUNDS))
+      LayerAnimationElement::BOUNDS)) {
     return animator_->GetTargetBounds();
+  }
   return bounds_;
 }
 
 void Layer::SetMasksToBounds(bool masks_to_bounds) {
   web_layer_.setMasksToBounds(masks_to_bounds);
 }
 
 bool Layer::GetMasksToBounds() const {
   return web_layer_.masksToBounds();
 }
@@ skipping 12 matching lines @@
   }
   web_layer_.setBackgroundFilters(filters);
 }
 
 void Layer::SetLayerSaturation(float saturation) {
   layer_saturation_ = saturation;
   SetLayerFilters();
 }
 
 void Layer::SetLayerBrightness(float brightness) {
-  layer_brightness_ = brightness;
-  SetLayerFilters();
+  GetAnimator()->SetBrightness(brightness);
+}
+
+float Layer::GetTargetBrightness() const {
+  if (animator_.get() && animator_->IsAnimatingProperty(
+      LayerAnimationElement::BRIGHTNESS)) {
+    return animator_->GetTargetBrightness();
+  }
+  return layer_brightness();
+}
+
+void Layer::SetLayerGrayscale(float grayscale) {
+  GetAnimator()->SetGrayscale(grayscale);
+}
+
+float Layer::GetTargetGrayscale() const {
+  if (animator_.get() && animator_->IsAnimatingProperty(
+      LayerAnimationElement::GRAYSCALE)) {
+    return animator_->GetTargetGrayscale();
+  }
+  return layer_grayscale();
 }
 
 void Layer::SetLayerInverted(bool inverted) {
   layer_inverted_ = inverted;
   SetLayerFilters();
 }
 
 void Layer::SetMaskLayer(Layer* layer_mask) {
   // The provided mask should not have a layer mask itself.
   DCHECK(!layer_mask ||
@@ skipping 19 matching lines @@
 void Layer::SetLayerFilters() {
   WebKit::WebFilterOperations filters;
   if (layer_saturation_) {
     filters.append(WebKit::WebFilterOperation::createSaturateFilter(
         layer_saturation_));
   }
   if (layer_brightness_) {
     filters.append(WebKit::WebFilterOperation::createBrightnessFilter(
         layer_brightness_));
   }
+  if (layer_grayscale_) {
+    filters.append(WebKit::WebFilterOperation::createGrayscaleFilter(
+        layer_grayscale_));
+  }
   if (layer_inverted_)
     filters.append(WebKit::WebFilterOperation::createInvertFilter(1.0));
 
   web_layer_.setFilters(filters);
 }
 
 float Layer::GetTargetOpacity() const {
   if (animator_.get() && animator_->IsAnimatingProperty(
       LayerAnimationElement::OPACITY))
     return animator_->GetTargetOpacity();
@@ skipping 314 matching lines @@
 
 void Layer::SetVisibilityImmediately(bool visible) {
   if (visible_ == visible)
     return;
 
   visible_ = visible;
   // TODO(piman): Expose a visibility flag on WebLayer.
   web_layer_.setOpacity(visible_ ? opacity_ : 0.f);
 }
 
+void Layer::SetBrightnessImmediately(float brightness) {
+  layer_brightness_ = brightness;
+  SetLayerFilters();
+}
+
+void Layer::SetGrayscaleImmediately(float grayscale) {
+  layer_grayscale_ = grayscale;
+  SetLayerFilters();
+}
+
 void Layer::SetBoundsFromAnimation(const gfx::Rect& bounds) {
   SetBoundsImmediately(bounds);
 }
 
 void Layer::SetTransformFromAnimation(const Transform& transform) {
   SetTransformImmediately(transform);
 }
 
 void Layer::SetOpacityFromAnimation(float opacity) {
   SetOpacityImmediately(opacity);
 }
 
 void Layer::SetVisibilityFromAnimation(bool visibility) {
   SetVisibilityImmediately(visibility);
 }
 
+void Layer::SetBrightnessFromAnimation(float brightness) {
+  SetBrightnessImmediately(brightness);
+}
+void Layer::SetGrayscaleFromAnimation(float grayscale) {
+  SetGrayscaleImmediately(grayscale);
+}
+
 void Layer::ScheduleDrawForAnimation() {
   ScheduleDraw();
 }
 
 const gfx::Rect& Layer::GetBoundsForAnimation() const {
   return bounds();
 }
 
 const Transform& Layer::GetTransformForAnimation() const {
   return transform();
 }
 
 float Layer::GetOpacityForAnimation() const {
   return opacity();
 }
 
 bool Layer::GetVisibilityForAnimation() const {
   return visible();
 }
 
+float Layer::GetBrightnessForAnimation() const {
+  return layer_brightness();
+}
+
+float Layer::GetGrayscaleForAnimation() const {
+  return layer_grayscale();
+}
+
 void Layer::CreateWebLayer() {
   if (type_ == LAYER_SOLID_COLOR)
     web_layer_ = WebKit::WebSolidColorLayer::create();
   else
     web_layer_ = WebKit::WebContentLayer::create(this);
   web_layer_.setAnchorPoint(WebKit::WebFloatPoint(0.f, 0.f));
   web_layer_.setOpaque(true);
   web_layer_is_accelerated_ = false;
   show_debug_borders_ = CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kUIShowLayerBorders);
@@ skipping 53 matching lines @@
     return;
   unsigned int color = 0xFF000000;
   color |= web_layer_is_accelerated_ ? 0x0000FF00 : 0x00FF0000;
   bool opaque = fills_bounds_opaquely_ && (GetCombinedOpacity() == 1.f);
   if (!opaque)
     color |= 0xFF;
   web_layer_.setDebugBorderColor(color);
 }
 
 }  // namespace ui