Update Layer::GetTargetColor to account for animation state

ui/compositor/layer_unittest.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 "base/basictypes.h"
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/json/json_reader.h"
@@ skipping 11 matching lines @@
 #include "cc/output/delegated_frame_data.h"
 #include "cc/test/pixel_test_utils.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/compositor/compositor_observer.h"
 #include "ui/compositor/dip_util.h"
 #include "ui/compositor/layer.h"
 #include "ui/compositor/layer_animation_sequence.h"
 #include "ui/compositor/layer_animator.h"
 #include "ui/compositor/paint_context.h"
 #include "ui/compositor/paint_recorder.h"
+#include "ui/compositor/scoped_animation_duration_scale_mode.h"
+#include "ui/compositor/scoped_layer_animation_settings.h"
 #include "ui/compositor/test/context_factories_for_test.h"
 #include "ui/compositor/test/draw_waiter_for_test.h"
 #include "ui/compositor/test/test_compositor_host.h"
 #include "ui/compositor/test/test_layers.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/codec/png_codec.h"
 #include "ui/gfx/gfx_paths.h"
 #include "ui/gfx/skia_util.h"
 
 using cc::MatchesPNGFile;
@@ skipping 1555 matching lines @@
   // Trigger a threaded animation.
   l1->SetOpacity(0.5f);
 
   // Change l1's cc::Layer.
   l1->SwitchCCLayerForTest();
 
   // Ensure that the opacity animation completed.
   EXPECT_FLOAT_EQ(l1->opacity(), 0.5f);
 }
 
+// Tests that when a LAYER_SOLID_COLOR has its CC layer switched, that
+// opaqueness and color set while not animating, are maintained.
+TEST_F(LayerWithRealCompositorTest, SwitchCCLayerSolidColorNotAnimating) {
+  SkColor transparent = SK_ColorTRANSPARENT;
+  scoped_ptr<Layer> root(CreateLayer(LAYER_SOLID_COLOR));
+  GetCompositor()->SetRootLayer(root.get());
+  root->SetFillsBoundsOpaquely(false);
+  root->SetColor(transparent);
+
+  EXPECT_FALSE(root->fills_bounds_opaquely());
+  EXPECT_FALSE(
+      root->GetAnimator()->IsAnimatingProperty(LayerAnimationElement::COLOR));
+  EXPECT_EQ(transparent, root->background_color());
+  EXPECT_EQ(transparent, root->GetTargetColor());
+
+  // Changing the underlying layer should not affect targets.
+  root->SwitchCCLayerForTest();
+
+  EXPECT_FALSE(root->fills_bounds_opaquely());
+  EXPECT_FALSE(
+      root->GetAnimator()->IsAnimatingProperty(LayerAnimationElement::COLOR));
+  EXPECT_EQ(transparent, root->background_color());
+  EXPECT_EQ(transparent, root->GetTargetColor());
+}
+
+// Tests that when a LAYER_SOLID_COLOR has its CC layer switched during an
+// animation of its opaquness and color, that both the current values, and the
+// targets are maintained.
+TEST_F(LayerWithRealCompositorTest, SwitchCCLayerSolidColorWhileAnimating) {
+  SkColor transparent = SK_ColorTRANSPARENT;
+  scoped_ptr<Layer> root(CreateLayer(LAYER_SOLID_COLOR));
+  GetCompositor()->SetRootLayer(root.get());
+  root->SetColor(SK_ColorBLACK);
+
+  EXPECT_TRUE(root->fills_bounds_opaquely());
+  EXPECT_EQ(SK_ColorBLACK, root->GetTargetColor());
+
+  scoped_ptr<ui::ScopedAnimationDurationScaleMode> long_duration_animation(
+      new ui::ScopedAnimationDurationScaleMode(
+          ui::ScopedAnimationDurationScaleMode::SLOW_DURATION));
+  {
+    ui::ScopedLayerAnimationSettings animation(root->GetAnimator());
+    animation.SetTransitionDuration(base::TimeDelta::FromMilliseconds(1000));
+    root->SetFillsBoundsOpaquely(false);
+    root->SetColor(transparent);
+  }
+
+  EXPECT_TRUE(root->fills_bounds_opaquely());
+  EXPECT_TRUE(
+      root->GetAnimator()->IsAnimatingProperty(LayerAnimationElement::COLOR));
+  EXPECT_EQ(SK_ColorBLACK, root->background_color());
+  EXPECT_EQ(transparent, root->GetTargetColor());
+
+  // Changing the underlying layer should not affect targets.
+  root->SwitchCCLayerForTest();
+
+  EXPECT_TRUE(root->fills_bounds_opaquely());
+  EXPECT_TRUE(
+      root->GetAnimator()->IsAnimatingProperty(LayerAnimationElement::COLOR));
+  EXPECT_EQ(SK_ColorBLACK, root->background_color());
+  EXPECT_EQ(transparent, root->GetTargetColor());
+
+  // End all animations.
+  root->GetAnimator()->StopAnimating();
+  EXPECT_FALSE(root->fills_bounds_opaquely());
+  EXPECT_FALSE(
+      root->GetAnimator()->IsAnimatingProperty(LayerAnimationElement::COLOR));
+  EXPECT_EQ(transparent, root->background_color());
+  EXPECT_EQ(transparent, root->GetTargetColor());
+}
+
 // Tests that the animators in the layer tree is added to the
 // animator-collection when the root-layer is set to the compositor.
 TEST_F(LayerWithDelegateTest, RootLayerAnimatorsInCompositor) {
   scoped_ptr<Layer> root(CreateLayer(LAYER_SOLID_COLOR));
   scoped_ptr<Layer> child(CreateColorLayer(SK_ColorRED, gfx::Rect(10, 10)));
   child->SetAnimator(LayerAnimator::CreateImplicitAnimator());
   child->SetOpacity(0.5f);
   root->Add(child.get());
 
   EXPECT_FALSE(compositor()->layer_animator_collection()->HasActiveAnimators());
@@ skipping 113 matching lines @@
                                      MakeFrameData(gfx::Size(10, 10))));
   layer->SetShowDelegatedContent(frame_provider.get(), gfx::Size(10, 10));
 
   EXPECT_FALSE(delegate.delegated_frame_damage_called());
   layer->OnDelegatedFrameDamage(damage_rect);
   EXPECT_TRUE(delegate.delegated_frame_damage_called());
   EXPECT_EQ(damage_rect, delegate.delegated_frame_damage_rect());
 }
 
 }  // namespace ui