ui/compositor/layer_owner_unittest.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "ui/compositor/layer_owner.h"
   6
   7 #include "base/test/null_task_runner.h"
   8 #include "testing/gtest/include/gtest/gtest.h"
   9 #include "ui/compositor/compositor.h"
  10 #include "ui/compositor/layer.h"
  11 #include "ui/compositor/layer_animation_observer.h"
  12 #include "ui/compositor/layer_animator.h"
  13 #include "ui/compositor/scoped_animation_duration_scale_mode.h"
  14 #include "ui/compositor/scoped_layer_animation_settings.h"
  15 #include "ui/compositor/test/context_factories_for_test.h"
  16 #include "ui/gfx/native_widget_types.h"
  17
  18 namespace ui {
  19 namespace {
  20
  21 // An animation observer that confirms upon animation completion, that the
  22 // compositor is not null.
  23 class TestLayerAnimationObserver : public ImplicitAnimationObserver {
  24  public:
  25   TestLayerAnimationObserver(Layer* layer) : layer_(layer) {}
  26   ~TestLayerAnimationObserver() override {}
  27
  28   // ImplicitAnimationObserver:
  29   void OnImplicitAnimationsCompleted() override {
  30     EXPECT_NE(nullptr, layer_->GetCompositor());
  31   }
  32
  33  private:
  34   Layer* layer_;
  35
  36   DISALLOW_COPY_AND_ASSIGN(TestLayerAnimationObserver);
  37 };
  38
  39 // Test fixture for LayerOwner tests that require a ui::Compositor.
  40 class LayerOwnerTestWithCompositor : public testing::Test {
  41  public:
  42   LayerOwnerTestWithCompositor();
  43   ~LayerOwnerTestWithCompositor() override;
  44
  45   void SetUp() override;
  46   void TearDown() override;
  47
  48  protected:
  49   ui::Compositor* compositor() { return compositor_.get(); }
  50
  51  private:
  52   scoped_ptr<ui::Compositor> compositor_;
  53
  54   DISALLOW_COPY_AND_ASSIGN(LayerOwnerTestWithCompositor);
  55 };
  56
  57 LayerOwnerTestWithCompositor::LayerOwnerTestWithCompositor() {
  58 }
  59
  60 LayerOwnerTestWithCompositor::~LayerOwnerTestWithCompositor() {
  61 }
  62
  63 void LayerOwnerTestWithCompositor::SetUp() {
  64   scoped_refptr<base::SingleThreadTaskRunner> task_runner =
  65       new base::NullTaskRunner();
  66
  67   ui::ContextFactory* context_factory =
  68       ui::InitializeContextFactoryForTests(false);
  69
  70   compositor_.reset(new ui::Compositor(context_factory, task_runner));
  71   compositor_->SetAcceleratedWidgetAndStartCompositor(
  72       gfx::kNullAcceleratedWidget);
  73 }
  74
  75 void LayerOwnerTestWithCompositor::TearDown() {
  76   compositor_.reset();
  77   ui::TerminateContextFactoryForTests();
  78 }
  79
  80 }  // namespace
  81
  82 TEST(LayerOwnerTest, RecreateLayerHonorsAnimationTargets) {
  83   LayerOwner owner;
  84   Layer* layer = new Layer(LAYER_SOLID_COLOR);
  85   layer->SetVisible(true);
  86   layer->SetOpacity(1.0f);
  87   layer->SetColor(SK_ColorRED);
  88
  89   owner.SetLayer(layer);
  90
  91   ScopedLayerAnimationSettings settings(layer->GetAnimator());
  92   layer->SetVisible(false);
  93   layer->SetOpacity(0.0f);
  94   layer->SetColor(SK_ColorGREEN);
  95   EXPECT_TRUE(layer->visible());
  96   EXPECT_EQ(1.0f, layer->opacity());
  97   EXPECT_EQ(SK_ColorRED, layer->background_color());
  98
  99   scoped_ptr<Layer> old_layer(owner.RecreateLayer());
 100   EXPECT_FALSE(owner.layer()->visible());
 101   EXPECT_EQ(0.0f, owner.layer()->opacity());
 102   EXPECT_EQ(SK_ColorGREEN, owner.layer()->background_color());
 103 }
 104
 105 // Tests that when a LAYER_SOLID_COLOR which is not backed by a SolidColorLayer
 106 // that opaqueness and color targets are maintained when the
 107 // LayerOwner::RecreateLayers is called.
 108 TEST(LayerOwnerTest, RecreateLayerSolidColorWithChangedCCLayerHonorsTargets) {
 109   SkColor transparent = SK_ColorTRANSPARENT;
 110   LayerOwner owner;
 111   Layer* layer = new Layer(LAYER_SOLID_COLOR);
 112   owner.SetLayer(layer);
 113   layer->SetFillsBoundsOpaquely(false);
 114   layer->SetColor(transparent);
 115   // Changing the backing layer takes LAYER_SOLID_COLOR off of the normal layer
 116   // flow, need to ensure that set values are maintained.
 117   layer->SwitchCCLayerForTest();
 118
 119   EXPECT_FALSE(layer->fills_bounds_opaquely());
 120   EXPECT_EQ(transparent, layer->background_color());
 121   EXPECT_EQ(transparent, layer->GetTargetColor());
 122
 123   scoped_ptr<Layer> old_layer(owner.RecreateLayer());
 124   EXPECT_FALSE(owner.layer()->fills_bounds_opaquely());
 125   EXPECT_EQ(transparent, owner.layer()->background_color());
 126   EXPECT_EQ(transparent, owner.layer()->GetTargetColor());
 127 }
 128
 129 TEST(LayerOwnerTest, RecreateRootLayerWithNullCompositor) {
 130   LayerOwner owner;
 131   Layer* layer = new Layer;
 132   owner.SetLayer(layer);
 133
 134   scoped_ptr<Layer> layer_copy = owner.RecreateLayer();
 135
 136   EXPECT_EQ(nullptr, owner.layer()->GetCompositor());
 137   EXPECT_EQ(nullptr, layer_copy->GetCompositor());
 138 }
 139
 140 TEST_F(LayerOwnerTestWithCompositor, RecreateRootLayerWithCompositor) {
 141   LayerOwner owner;
 142   Layer* layer = new Layer;
 143   owner.SetLayer(layer);
 144
 145   compositor()->SetRootLayer(layer);
 146
 147   scoped_ptr<Layer> layer_copy = owner.RecreateLayer();
 148
 149   EXPECT_EQ(compositor(), owner.layer()->GetCompositor());
 150   EXPECT_EQ(owner.layer(), compositor()->root_layer());
 151   EXPECT_EQ(nullptr, layer_copy->GetCompositor());
 152 }
 153
 154 // Tests that recreating the root layer, while one of its children is animating,
 155 // properly updates the compositor. So that compositor is not null for observers
 156 // of animations being cancelled.
 157 TEST_F(LayerOwnerTestWithCompositor, RecreateRootLayerDuringAnimation) {
 158   LayerOwner owner;
 159   Layer* layer = new Layer;
 160   owner.SetLayer(layer);
 161   compositor()->SetRootLayer(layer);
 162
 163   scoped_ptr<Layer> child(new Layer);
 164   child->SetBounds(gfx::Rect(0, 0, 100, 100));
 165   layer->Add(child.get());
 166
 167   // This observer checks that the compositor of |child| is not null upon
 168   // animation completion.
 169   scoped_ptr<TestLayerAnimationObserver> observer(
 170       new TestLayerAnimationObserver(child.get()));
 171   scoped_ptr<ui::ScopedAnimationDurationScaleMode> long_duration_animation(
 172       new ui::ScopedAnimationDurationScaleMode(
 173           ui::ScopedAnimationDurationScaleMode::SLOW_DURATION));
 174   {
 175     ui::ScopedLayerAnimationSettings animation(child->GetAnimator());
 176     animation.SetTransitionDuration(base::TimeDelta::FromMilliseconds(1000));
 177     animation.AddObserver(observer.get());
 178     gfx::Transform transform;
 179     transform.Scale(0.5f, 0.5f);
 180     child->SetTransform(transform);
 181   }
 182
 183   scoped_ptr<Layer> layer_copy = owner.RecreateLayer();
 184 }
 185
 186 // Tests that recreating a non-root layer, while one of its children is
 187 // animating, properly updates the compositor. So that compositor is not null
 188 // for observers of animations being cancelled.
 189 TEST_F(LayerOwnerTestWithCompositor, RecreateNonRootLayerDuringAnimation) {
 190   scoped_ptr<Layer> root_layer(new Layer);
 191   compositor()->SetRootLayer(root_layer.get());
 192
 193   LayerOwner owner;
 194   Layer* layer = new Layer;
 195   owner.SetLayer(layer);
 196   root_layer->Add(layer);
 197
 198   scoped_ptr<Layer> child(new Layer);
 199   child->SetBounds(gfx::Rect(0, 0, 100, 100));
 200   layer->Add(child.get());
 201
 202   // This observer checks that the compositor of |child| is not null upon
 203   // animation completion.
 204   scoped_ptr<TestLayerAnimationObserver> observer(
 205       new TestLayerAnimationObserver(child.get()));
 206   scoped_ptr<ui::ScopedAnimationDurationScaleMode> long_duration_animation(
 207       new ui::ScopedAnimationDurationScaleMode(
 208           ui::ScopedAnimationDurationScaleMode::SLOW_DURATION));
 209   {
 210     ui::ScopedLayerAnimationSettings animation(child->GetAnimator());
 211     animation.SetTransitionDuration(base::TimeDelta::FromMilliseconds(1000));
 212     animation.AddObserver(observer.get());
 213     gfx::Transform transform;
 214     transform.Scale(0.5f, 0.5f);
 215     child->SetTransform(transform);
 216   }
 217
 218   scoped_ptr<Layer> layer_copy = owner.RecreateLayer();
 219 }
 220
 221 }  // namespace ui