[Night Light] Backend ui::Layer work

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 <utility>
 
 #include "base/compiler_specific.h"
 #include "base/macros.h"
@@ skipping 236 matching lines @@
 
   void OnAbort(LayerAnimationDelegate* delegate) override {}
 
  private:
   SkColor start_;
   const SkColor target_;
 
   DISALLOW_COPY_AND_ASSIGN(ColorTransition);
 };
 
+// TemperatureTransition -------------------------------------------------------
+
+class TemperatureTransition : public LayerAnimationElement {
+ public:
+  TemperatureTransition(float target, base::TimeDelta duration)
+      : LayerAnimationElement(TEMPERATURE, duration),
+        start_(0.0f),
+        target_(target) {}
+  ~TemperatureTransition() override {}
+
+ protected:
+  void OnStart(LayerAnimationDelegate* delegate) override {
+    start_ = delegate->GetTemperatureFromAnimation();
+  }
+
+  bool OnProgress(double t, LayerAnimationDelegate* delegate) override {
+    delegate->SetTemperatureFromAnimation(
+        gfx::Tween::FloatValueBetween(t, start_, target_));
+    return true;
+  }
+
+  void OnGetTarget(TargetValue* target) const override {
+    target->temperature = target_;
+  }
+
+  void OnAbort(LayerAnimationDelegate* delegate) override {}
+
+ private:
+  float start_;
+  const float target_;
+
+  DISALLOW_COPY_AND_ASSIGN(TemperatureTransition);
+};
+
 // ThreadedLayerAnimationElement -----------------------------------------------
 
 class ThreadedLayerAnimationElement : public LayerAnimationElement {
  public:
   ThreadedLayerAnimationElement(AnimatableProperties properties,
                                 base::TimeDelta duration)
       : LayerAnimationElement(properties, duration) {
   }
   ~ThreadedLayerAnimationElement() override {}
 
@@ skipping 168 matching lines @@
 
 LayerAnimationElement::TargetValue::TargetValue(
     const LayerAnimationDelegate* delegate)
     : bounds(delegate ? delegate->GetBoundsForAnimation() : gfx::Rect()),
       transform(delegate ? delegate->GetTransformForAnimation()
                          : gfx::Transform()),
       opacity(delegate ? delegate->GetOpacityForAnimation() : 0.0f),
       visibility(delegate ? delegate->GetVisibilityForAnimation() : false),
       brightness(delegate ? delegate->GetBrightnessForAnimation() : 0.0f),
       grayscale(delegate ? delegate->GetGrayscaleForAnimation() : 0.0f),
-      color(delegate ? delegate->GetColorForAnimation() : SK_ColorTRANSPARENT) {
-}
+      color(delegate ? delegate->GetColorForAnimation() : SK_ColorTRANSPARENT),
+      temperature(delegate ? delegate->GetTemperatureFromAnimation() : 0.0f) {}
 
 // LayerAnimationElement -------------------------------------------------------
 
 LayerAnimationElement::LayerAnimationElement(AnimatableProperties properties,
                                              base::TimeDelta duration)
     : first_frame_(true),
       properties_(properties),
       duration_(GetEffectiveDuration(duration)),
       tween_type_(gfx::Tween::LINEAR),
       animation_id_(cc::AnimationIdProvider::NextAnimationId()),
@@ skipping 222 matching lines @@
   return base::MakeUnique<Pause>(properties, duration);
 }
 
 // static
 std::unique_ptr<LayerAnimationElement>
 LayerAnimationElement::CreateColorElement(SkColor color,
                                           base::TimeDelta duration) {
   return base::MakeUnique<ColorTransition>(color, duration);
 }
 
+// static
+std::unique_ptr<LayerAnimationElement>
+LayerAnimationElement::CreateTemperatureElement(float temperature,
+                                                base::TimeDelta duration) {
+  return base::MakeUnique<TemperatureTransition>(temperature, duration);
+}
+
 }  // namespace ui