1// Copyright 2011 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 "cc/layers/layer.h"
6
7#include "cc/animation/keyframed_animation_curve.h"
8#include "cc/base/math_util.h"
9#include "cc/layers/layer_impl.h"
10#include "cc/resources/layer_painter.h"
11#include "cc/test/animation_test_common.h"
12#include "cc/test/fake_impl_proxy.h"
13#include "cc/test/fake_layer_tree_host_client.h"
14#include "cc/test/fake_layer_tree_host_impl.h"
15#include "cc/test/geometry_test_utils.h"
16#include "cc/test/layer_test_common.h"
17#include "cc/trees/layer_tree_host.h"
18#include "cc/trees/single_thread_proxy.h"
19#include "testing/gmock/include/gmock/gmock.h"
20#include "testing/gtest/include/gtest/gtest.h"
21#include "ui/gfx/transform.h"
22
23using ::testing::AnyNumber;
24using ::testing::AtLeast;
25using ::testing::Mock;
26using ::testing::StrictMock;
27using ::testing::_;
28
29#define EXPECT_SET_NEEDS_FULL_TREE_SYNC(expect, code_to_test) do {        \
30    EXPECT_CALL(*layer_tree_host_, SetNeedsFullTreeSync()).Times((expect)); \
31    code_to_test;                                                         \
32    Mock::VerifyAndClearExpectations(layer_tree_host_.get());           \
33  } while (false)
34
35
36namespace cc {
37namespace {
38
39class MockLayerTreeHost : public LayerTreeHost {
40 public:
41  explicit MockLayerTreeHost(FakeLayerTreeHostClient* client)
42      : LayerTreeHost(client, NULL, LayerTreeSettings()) {
43    InitializeSingleThreaded(client);
44  }
45
46  MOCK_METHOD0(SetNeedsCommit, void());
47  MOCK_METHOD0(SetNeedsUpdateLayers, void());
48  MOCK_METHOD0(SetNeedsFullTreeSync, void());
49};
50
51class MockLayerPainter : public LayerPainter {
52 public:
53  virtual void Paint(SkCanvas* canvas,
54                     gfx::Rect content_rect,
55                     gfx::RectF* opaque) OVERRIDE {}
56};
57
58
59class LayerTest : public testing::Test {
60 public:
61  LayerTest()
62      : host_impl_(&proxy_),
63        fake_client_(FakeLayerTreeHostClient::DIRECT_3D) {}
64
65 protected:
66  virtual void SetUp() OVERRIDE {
67    layer_tree_host_.reset(new StrictMock<MockLayerTreeHost>(&fake_client_));
68  }
69
70  virtual void TearDown() OVERRIDE {
71    Mock::VerifyAndClearExpectations(layer_tree_host_.get());
72    EXPECT_CALL(*layer_tree_host_, SetNeedsFullTreeSync()).Times(AnyNumber());
73    parent_ = NULL;
74    child1_ = NULL;
75    child2_ = NULL;
76    child3_ = NULL;
77    grand_child1_ = NULL;
78    grand_child2_ = NULL;
79    grand_child3_ = NULL;
80
81    layer_tree_host_->SetRootLayer(NULL);
82    layer_tree_host_.reset();
83  }
84
85  void VerifyTestTreeInitialState() const {
86    ASSERT_EQ(3U, parent_->children().size());
87    EXPECT_EQ(child1_, parent_->children()[0]);
88    EXPECT_EQ(child2_, parent_->children()[1]);
89    EXPECT_EQ(child3_, parent_->children()[2]);
90    EXPECT_EQ(parent_.get(), child1_->parent());
91    EXPECT_EQ(parent_.get(), child2_->parent());
92    EXPECT_EQ(parent_.get(), child3_->parent());
93
94    ASSERT_EQ(2U, child1_->children().size());
95    EXPECT_EQ(grand_child1_, child1_->children()[0]);
96    EXPECT_EQ(grand_child2_, child1_->children()[1]);
97    EXPECT_EQ(child1_.get(), grand_child1_->parent());
98    EXPECT_EQ(child1_.get(), grand_child2_->parent());
99
100    ASSERT_EQ(1U, child2_->children().size());
101    EXPECT_EQ(grand_child3_, child2_->children()[0]);
102    EXPECT_EQ(child2_.get(), grand_child3_->parent());
103
104    ASSERT_EQ(0U, child3_->children().size());
105  }
106
107  void CreateSimpleTestTree() {
108    parent_ = Layer::Create();
109    child1_ = Layer::Create();
110    child2_ = Layer::Create();
111    child3_ = Layer::Create();
112    grand_child1_ = Layer::Create();
113    grand_child2_ = Layer::Create();
114    grand_child3_ = Layer::Create();
115
116    EXPECT_CALL(*layer_tree_host_, SetNeedsFullTreeSync()).Times(AnyNumber());
117    layer_tree_host_->SetRootLayer(parent_);
118
119    parent_->AddChild(child1_);
120    parent_->AddChild(child2_);
121    parent_->AddChild(child3_);
122    child1_->AddChild(grand_child1_);
123    child1_->AddChild(grand_child2_);
124    child2_->AddChild(grand_child3_);
125
126    Mock::VerifyAndClearExpectations(layer_tree_host_.get());
127
128    VerifyTestTreeInitialState();
129  }
130
131  FakeImplProxy proxy_;
132  FakeLayerTreeHostImpl host_impl_;
133
134  FakeLayerTreeHostClient fake_client_;
135  scoped_ptr<StrictMock<MockLayerTreeHost> > layer_tree_host_;
136  scoped_refptr<Layer> parent_;
137  scoped_refptr<Layer> child1_;
138  scoped_refptr<Layer> child2_;
139  scoped_refptr<Layer> child3_;
140  scoped_refptr<Layer> grand_child1_;
141  scoped_refptr<Layer> grand_child2_;
142  scoped_refptr<Layer> grand_child3_;
143};
144
145TEST_F(LayerTest, BasicCreateAndDestroy) {
146  scoped_refptr<Layer> test_layer = Layer::Create();
147  ASSERT_TRUE(test_layer.get());
148
149  EXPECT_CALL(*layer_tree_host_, SetNeedsCommit()).Times(0);
150  test_layer->SetLayerTreeHost(layer_tree_host_.get());
151  Mock::VerifyAndClearExpectations(layer_tree_host_.get());
152
153  EXPECT_CALL(*layer_tree_host_, SetNeedsCommit()).Times(0);
154  test_layer->SetLayerTreeHost(NULL);
155}
156
157TEST_F(LayerTest, AddAndRemoveChild) {
158  scoped_refptr<Layer> parent = Layer::Create();
159  scoped_refptr<Layer> child = Layer::Create();
160
161  // Upon creation, layers should not have children or parent.
162  ASSERT_EQ(0U, parent->children().size());
163  EXPECT_FALSE(child->parent());
164
165  EXPECT_SET_NEEDS_FULL_TREE_SYNC(1, layer_tree_host_->SetRootLayer(parent));
166  EXPECT_SET_NEEDS_FULL_TREE_SYNC(1, parent->AddChild(child));
167
168  ASSERT_EQ(1U, parent->children().size());
169  EXPECT_EQ(child.get(), parent->children()[0]);
170  EXPECT_EQ(parent.get(), child->parent());
171  EXPECT_EQ(parent.get(), child->RootLayer());
172
173  EXPECT_SET_NEEDS_FULL_TREE_SYNC(AtLeast(1), child->RemoveFromParent());
174}
175
176TEST_F(LayerTest, AddSameChildTwice) {
177  EXPECT_CALL(*layer_tree_host_, SetNeedsFullTreeSync()).Times(AtLeast(1));
178
179  scoped_refptr<Layer> parent = Layer::Create();
180  scoped_refptr<Layer> child = Layer::Create();
181
182  layer_tree_host_->SetRootLayer(parent);
183
184  ASSERT_EQ(0u, parent->children().size());
185
186  parent->AddChild(child);
187  ASSERT_EQ(1u, parent->children().size());
188  EXPECT_EQ(parent.get(), child->parent());
189
190  parent->AddChild(child);
191  ASSERT_EQ(1u, parent->children().size());
192  EXPECT_EQ(parent.get(), child->parent());
193}
194
195TEST_F(LayerTest, InsertChild) {
196  scoped_refptr<Layer> parent = Layer::Create();
197  scoped_refptr<Layer> child1 = Layer::Create();
198  scoped_refptr<Layer> child2 = Layer::Create();
199  scoped_refptr<Layer> child3 = Layer::Create();
200  scoped_refptr<Layer> child4 = Layer::Create();
201
202  EXPECT_SET_NEEDS_FULL_TREE_SYNC(1, layer_tree_host_->SetRootLayer(parent));
203
204  ASSERT_EQ(0U, parent->children().size());
205
206  // Case 1: inserting to empty list.
207  EXPECT_SET_NEEDS_FULL_TREE_SYNC(1, parent->InsertChild(child3, 0));
208  ASSERT_EQ(1U, parent->children().size());
209  EXPECT_EQ(child3, parent->children()[0]);
210  EXPECT_EQ(parent.get(), child3->parent());
211
212  // Case 2: inserting to beginning of list
213  EXPECT_SET_NEEDS_FULL_TREE_SYNC(1, parent->InsertChild(child1, 0));
214  ASSERT_EQ(2U, parent->children().size());
215  EXPECT_EQ(child1, parent->children()[0]);
216  EXPECT_EQ(child3, parent->children()[1]);
217  EXPECT_EQ(parent.get(), child1->parent());
218
219  // Case 3: inserting to middle of list
220  EXPECT_SET_NEEDS_FULL_TREE_SYNC(1, parent->InsertChild(child2, 1));
221  ASSERT_EQ(3U, parent->children().size());
222  EXPECT_EQ(child1, parent->children()[0]);
223  EXPECT_EQ(child2, parent->children()[1]);
224  EXPECT_EQ(child3, parent->children()[2]);
225  EXPECT_EQ(parent.get(), child2->parent());
226
227  // Case 4: inserting to end of list
228  EXPECT_SET_NEEDS_FULL_TREE_SYNC(1, parent->InsertChild(child4, 3));
229
230  ASSERT_EQ(4U, parent->children().size());
231  EXPECT_EQ(child1, parent->children()[0]);
232  EXPECT_EQ(child2, parent->children()[1]);
233  EXPECT_EQ(child3, parent->children()[2]);
234  EXPECT_EQ(child4, parent->children()[3]);
235  EXPECT_EQ(parent.get(), child4->parent());
236
237  EXPECT_SET_NEEDS_FULL_TREE_SYNC(1, layer_tree_host_->SetRootLayer(NULL));
238}
239
240TEST_F(LayerTest, InsertChildPastEndOfList) {
241  scoped_refptr<Layer> parent = Layer::Create();
242  scoped_refptr<Layer> child1 = Layer::Create();
243  scoped_refptr<Layer> child2 = Layer::Create();
244
245  ASSERT_EQ(0U, parent->children().size());
246
247  // insert to an out-of-bounds index
248  parent->InsertChild(child1, 53);
249
250  ASSERT_EQ(1U, parent->children().size());
251  EXPECT_EQ(child1, parent->children()[0]);
252
253  // insert another child to out-of-bounds, when list is not already empty.
254  parent->InsertChild(child2, 2459);
255
256  ASSERT_EQ(2U, parent->children().size());
257  EXPECT_EQ(child1, parent->children()[0]);
258  EXPECT_EQ(child2, parent->children()[1]);
259}
260
261TEST_F(LayerTest, InsertSameChildTwice) {
262  scoped_refptr<Layer> parent = Layer::Create();
263  scoped_refptr<Layer> child1 = Layer::Create();
264  scoped_refptr<Layer> child2 = Layer::Create();
265
266  EXPECT_SET_NEEDS_FULL_TREE_SYNC(1, layer_tree_host_->SetRootLayer(parent));
267
268  ASSERT_EQ(0U, parent->children().size());
269
270  EXPECT_SET_NEEDS_FULL_TREE_SYNC(1, parent->InsertChild(child1, 0));
271  EXPECT_SET_NEEDS_FULL_TREE_SYNC(1, parent->InsertChild(child2, 1));
272
273  ASSERT_EQ(2U, parent->children().size());
274  EXPECT_EQ(child1, parent->children()[0]);
275  EXPECT_EQ(child2, parent->children()[1]);
276
277  // Inserting the same child again should cause the child to be removed and
278  // re-inserted at the new location.
279  EXPECT_SET_NEEDS_FULL_TREE_SYNC(AtLeast(1), parent->InsertChild(child1, 1));
280
281  // child1 should now be at the end of the list.
282  ASSERT_EQ(2U, parent->children().size());
283  EXPECT_EQ(child2, parent->children()[0]);
284  EXPECT_EQ(child1, parent->children()[1]);
285
286  EXPECT_SET_NEEDS_FULL_TREE_SYNC(1, layer_tree_host_->SetRootLayer(NULL));
287}
288
289TEST_F(LayerTest, ReplaceChildWithNewChild) {
290  CreateSimpleTestTree();
291  scoped_refptr<Layer> child4 = Layer::Create();
292
293  EXPECT_FALSE(child4->parent());
294
295  EXPECT_SET_NEEDS_FULL_TREE_SYNC(
296      AtLeast(1), parent_->ReplaceChild(child2_.get(), child4));
297  EXPECT_FALSE(parent_->NeedsDisplayForTesting());
298  EXPECT_FALSE(child1_->NeedsDisplayForTesting());
299  EXPECT_FALSE(child2_->NeedsDisplayForTesting());
300  EXPECT_FALSE(child3_->NeedsDisplayForTesting());
301  EXPECT_FALSE(child4->NeedsDisplayForTesting());
302
303  ASSERT_EQ(static_cast<size_t>(3), parent_->children().size());
304  EXPECT_EQ(child1_, parent_->children()[0]);
305  EXPECT_EQ(child4, parent_->children()[1]);
306  EXPECT_EQ(child3_, parent_->children()[2]);
307  EXPECT_EQ(parent_.get(), child4->parent());
308
309  EXPECT_FALSE(child2_->parent());
310}
311
312TEST_F(LayerTest, ReplaceChildWithNewChildThatHasOtherParent) {
313  CreateSimpleTestTree();
314
315  // create another simple tree with test_layer and child4.
316  scoped_refptr<Layer> test_layer = Layer::Create();
317  scoped_refptr<Layer> child4 = Layer::Create();
318  test_layer->AddChild(child4);
319  ASSERT_EQ(1U, test_layer->children().size());
320  EXPECT_EQ(child4, test_layer->children()[0]);
321  EXPECT_EQ(test_layer.get(), child4->parent());
322
323  EXPECT_SET_NEEDS_FULL_TREE_SYNC(
324      AtLeast(1), parent_->ReplaceChild(child2_.get(), child4));
325
326  ASSERT_EQ(3U, parent_->children().size());
327  EXPECT_EQ(child1_, parent_->children()[0]);
328  EXPECT_EQ(child4, parent_->children()[1]);
329  EXPECT_EQ(child3_, parent_->children()[2]);
330  EXPECT_EQ(parent_.get(), child4->parent());
331
332  // test_layer should no longer have child4,
333  // and child2 should no longer have a parent.
334  ASSERT_EQ(0U, test_layer->children().size());
335  EXPECT_FALSE(child2_->parent());
336}
337
338TEST_F(LayerTest, ReplaceChildWithSameChild) {
339  CreateSimpleTestTree();
340
341  // SetNeedsFullTreeSync / SetNeedsCommit should not be called because its the
342  // same child.
343  EXPECT_CALL(*layer_tree_host_, SetNeedsCommit()).Times(0);
344  EXPECT_CALL(*layer_tree_host_, SetNeedsFullTreeSync()).Times(0);
345  parent_->ReplaceChild(child2_.get(), child2_);
346
347  VerifyTestTreeInitialState();
348}
349
350TEST_F(LayerTest, RemoveAllChildren) {
351  CreateSimpleTestTree();
352
353  EXPECT_SET_NEEDS_FULL_TREE_SYNC(AtLeast(3), parent_->RemoveAllChildren());
354
355  ASSERT_EQ(0U, parent_->children().size());
356  EXPECT_FALSE(child1_->parent());
357  EXPECT_FALSE(child2_->parent());
358  EXPECT_FALSE(child3_->parent());
359}
360
361TEST_F(LayerTest, SetChildren) {
362  scoped_refptr<Layer> old_parent = Layer::Create();
363  scoped_refptr<Layer> new_parent = Layer::Create();
364
365  scoped_refptr<Layer> child1 = Layer::Create();
366  scoped_refptr<Layer> child2 = Layer::Create();
367
368  LayerList new_children;
369  new_children.push_back(child1);
370  new_children.push_back(child2);
371
372  // Set up and verify initial test conditions: child1 has a parent, child2 has
373  // no parent.
374  old_parent->AddChild(child1);
375  ASSERT_EQ(0U, new_parent->children().size());
376  EXPECT_EQ(old_parent.get(), child1->parent());
377  EXPECT_FALSE(child2->parent());
378
379  EXPECT_SET_NEEDS_FULL_TREE_SYNC(
380      1, layer_tree_host_->SetRootLayer(new_parent));
381
382  EXPECT_SET_NEEDS_FULL_TREE_SYNC(
383      AtLeast(1), new_parent->SetChildren(new_children));
384
385  ASSERT_EQ(2U, new_parent->children().size());
386  EXPECT_EQ(new_parent.get(), child1->parent());
387  EXPECT_EQ(new_parent.get(), child2->parent());
388
389  EXPECT_SET_NEEDS_FULL_TREE_SYNC(1, layer_tree_host_->SetRootLayer(NULL));
390}
391
392TEST_F(LayerTest, HasAncestor) {
393  scoped_refptr<Layer> parent = Layer::Create();
394  EXPECT_FALSE(parent->HasAncestor(parent));
395
396  scoped_refptr<Layer> child = Layer::Create();
397  parent->AddChild(child);
398
399  EXPECT_FALSE(child->HasAncestor(child));
400  EXPECT_TRUE(child->HasAncestor(parent));
401  EXPECT_FALSE(parent->HasAncestor(child));
402
403  scoped_refptr<Layer> child_child = Layer::Create();
404  child->AddChild(child_child);
405
406  EXPECT_FALSE(child_child->HasAncestor(child_child));
407  EXPECT_TRUE(child_child->HasAncestor(parent));
408  EXPECT_TRUE(child_child->HasAncestor(child));
409  EXPECT_FALSE(parent->HasAncestor(child));
410  EXPECT_FALSE(parent->HasAncestor(child_child));
411}
412
413TEST_F(LayerTest, GetRootLayerAfterTreeManipulations) {
414  CreateSimpleTestTree();
415
416  // For this test we don't care about SetNeedsFullTreeSync calls.
417  EXPECT_CALL(*layer_tree_host_, SetNeedsFullTreeSync()).Times(AnyNumber());
418
419  scoped_refptr<Layer> child4 = Layer::Create();
420
421  EXPECT_EQ(parent_.get(), parent_->RootLayer());
422  EXPECT_EQ(parent_.get(), child1_->RootLayer());
423  EXPECT_EQ(parent_.get(), child2_->RootLayer());
424  EXPECT_EQ(parent_.get(), child3_->RootLayer());
425  EXPECT_EQ(child4.get(),   child4->RootLayer());
426  EXPECT_EQ(parent_.get(), grand_child1_->RootLayer());
427  EXPECT_EQ(parent_.get(), grand_child2_->RootLayer());
428  EXPECT_EQ(parent_.get(), grand_child3_->RootLayer());
429
430  child1_->RemoveFromParent();
431
432  // |child1| and its children, grand_child1 and grand_child2 are now on a
433  // separate subtree.
434  EXPECT_EQ(parent_.get(), parent_->RootLayer());
435  EXPECT_EQ(child1_.get(), child1_->RootLayer());
436  EXPECT_EQ(parent_.get(), child2_->RootLayer());
437  EXPECT_EQ(parent_.get(), child3_->RootLayer());
438  EXPECT_EQ(child4.get(), child4->RootLayer());
439  EXPECT_EQ(child1_.get(), grand_child1_->RootLayer());
440  EXPECT_EQ(child1_.get(), grand_child2_->RootLayer());
441  EXPECT_EQ(parent_.get(), grand_child3_->RootLayer());
442
443  grand_child3_->AddChild(child4);
444
445  EXPECT_EQ(parent_.get(), parent_->RootLayer());
446  EXPECT_EQ(child1_.get(), child1_->RootLayer());
447  EXPECT_EQ(parent_.get(), child2_->RootLayer());
448  EXPECT_EQ(parent_.get(), child3_->RootLayer());
449  EXPECT_EQ(parent_.get(), child4->RootLayer());
450  EXPECT_EQ(child1_.get(), grand_child1_->RootLayer());
451  EXPECT_EQ(child1_.get(), grand_child2_->RootLayer());
452  EXPECT_EQ(parent_.get(), grand_child3_->RootLayer());
453
454  child2_->ReplaceChild(grand_child3_.get(), child1_);
455
456  // |grand_child3| gets orphaned and the child1 subtree gets planted back into
457  // the tree under child2.
458  EXPECT_EQ(parent_.get(), parent_->RootLayer());
459  EXPECT_EQ(parent_.get(), child1_->RootLayer());
460  EXPECT_EQ(parent_.get(), child2_->RootLayer());
461  EXPECT_EQ(parent_.get(), child3_->RootLayer());
462  EXPECT_EQ(grand_child3_.get(), child4->RootLayer());
463  EXPECT_EQ(parent_.get(), grand_child1_->RootLayer());
464  EXPECT_EQ(parent_.get(), grand_child2_->RootLayer());
465  EXPECT_EQ(grand_child3_.get(), grand_child3_->RootLayer());
466}
467
468TEST_F(LayerTest, CheckSetNeedsDisplayCausesCorrectBehavior) {
469  // The semantics for SetNeedsDisplay which are tested here:
470  //   1. sets NeedsDisplay flag appropriately.
471  //   2. indirectly calls SetNeedsUpdate, exactly once for each call to
472  //      SetNeedsDisplay.
473
474  scoped_refptr<Layer> test_layer = Layer::Create();
475  EXPECT_SET_NEEDS_FULL_TREE_SYNC(
476      1, layer_tree_host_->SetRootLayer(test_layer));
477  EXPECT_SET_NEEDS_COMMIT(1, test_layer->SetIsDrawable(true));
478
479  gfx::Size test_bounds = gfx::Size(501, 508);
480
481  gfx::RectF dirty1 = gfx::RectF(10.f, 15.f, 1.f, 2.f);
482  gfx::RectF dirty2 = gfx::RectF(20.f, 25.f, 3.f, 4.f);
483  gfx::RectF empty_dirty_rect = gfx::RectF(40.f, 45.f, 0.f, 0.f);
484  gfx::RectF out_of_bounds_dirty_rect = gfx::RectF(400.f, 405.f, 500.f, 502.f);
485
486  // Before anything, test_layer should not be dirty.
487  EXPECT_FALSE(test_layer->NeedsDisplayForTesting());
488
489  // This is just initialization, but SetNeedsCommit behavior is verified anyway
490  // to avoid warnings.
491  EXPECT_SET_NEEDS_COMMIT(1, test_layer->SetBounds(test_bounds));
492  EXPECT_FALSE(test_layer->NeedsDisplayForTesting());
493
494  // The real test begins here.
495  test_layer->ResetNeedsDisplayForTesting();
496  EXPECT_FALSE(test_layer->NeedsDisplayForTesting());
497
498  // Case 1: Layer should accept dirty rects that go beyond its bounds.
499  test_layer->ResetNeedsDisplayForTesting();
500  EXPECT_FALSE(test_layer->NeedsDisplayForTesting());
501  EXPECT_SET_NEEDS_UPDATE(
502      1, test_layer->SetNeedsDisplayRect(out_of_bounds_dirty_rect));
503  EXPECT_TRUE(test_layer->NeedsDisplayForTesting());
504  test_layer->ResetNeedsDisplayForTesting();
505
506  // Case 2: SetNeedsDisplay() without the dirty rect arg.
507  test_layer->ResetNeedsDisplayForTesting();
508  EXPECT_FALSE(test_layer->NeedsDisplayForTesting());
509  EXPECT_SET_NEEDS_UPDATE(1, test_layer->SetNeedsDisplay());
510  EXPECT_TRUE(test_layer->NeedsDisplayForTesting());
511  test_layer->ResetNeedsDisplayForTesting();
512
513  // Case 3: SetNeedsDisplay() with an empty rect.
514  test_layer->ResetNeedsDisplayForTesting();
515  EXPECT_FALSE(test_layer->NeedsDisplayForTesting());
516  EXPECT_SET_NEEDS_COMMIT(0, test_layer->SetNeedsDisplayRect(gfx::Rect()));
517  EXPECT_FALSE(test_layer->NeedsDisplayForTesting());
518
519  // Case 4: SetNeedsDisplay() with a non-drawable layer
520  EXPECT_SET_NEEDS_COMMIT(1, test_layer->SetIsDrawable(false));
521  test_layer->ResetNeedsDisplayForTesting();
522  EXPECT_FALSE(test_layer->NeedsDisplayForTesting());
523  EXPECT_SET_NEEDS_UPDATE(0, test_layer->SetNeedsDisplayRect(dirty1));
524  EXPECT_TRUE(test_layer->NeedsDisplayForTesting());
525}
526
527TEST_F(LayerTest, CheckPropertyChangeCausesCorrectBehavior) {
528  scoped_refptr<Layer> test_layer = Layer::Create();
529  EXPECT_SET_NEEDS_FULL_TREE_SYNC(
530      1, layer_tree_host_->SetRootLayer(test_layer));
531  EXPECT_SET_NEEDS_COMMIT(1, test_layer->SetIsDrawable(true));
532
533  scoped_refptr<Layer> dummy_layer1 = Layer::Create();
534  scoped_refptr<Layer> dummy_layer2 = Layer::Create();
535
536  // sanity check of initial test condition
537  EXPECT_FALSE(test_layer->NeedsDisplayForTesting());
538
539  // Next, test properties that should call SetNeedsCommit (but not
540  // SetNeedsDisplay). All properties need to be set to new values in order for
541  // SetNeedsCommit to be called.
542  EXPECT_SET_NEEDS_COMMIT(1, test_layer->SetAnchorPoint(
543      gfx::PointF(1.23f, 4.56f)));
544  EXPECT_SET_NEEDS_COMMIT(1, test_layer->SetAnchorPointZ(0.7f));
545  EXPECT_SET_NEEDS_COMMIT(1, test_layer->SetBackgroundColor(SK_ColorLTGRAY));
546  EXPECT_SET_NEEDS_COMMIT(1, test_layer->SetMasksToBounds(true));
547  EXPECT_SET_NEEDS_COMMIT(1, test_layer->SetOpacity(0.5f));
548  EXPECT_SET_NEEDS_COMMIT(1, test_layer->SetBlendMode(SkXfermode::kHue_Mode));
549  EXPECT_SET_NEEDS_COMMIT(1, test_layer->SetIsRootForIsolatedGroup(true));
550  EXPECT_SET_NEEDS_COMMIT(1, test_layer->SetContentsOpaque(true));
551  EXPECT_SET_NEEDS_COMMIT(1, test_layer->SetPosition(gfx::PointF(4.f, 9.f)));
552  EXPECT_SET_NEEDS_COMMIT(1, test_layer->SetSublayerTransform(
553      gfx::Transform(0.0, 0.0, 0.0, 0.0, 0.0, 0.0)));
554  EXPECT_SET_NEEDS_COMMIT(1, test_layer->SetScrollable(true));
555  EXPECT_SET_NEEDS_COMMIT(1, test_layer->SetUserScrollable(true, false));
556  EXPECT_SET_NEEDS_COMMIT(1, test_layer->SetScrollOffset(
557      gfx::Vector2d(10, 10)));
558  EXPECT_SET_NEEDS_COMMIT(1, test_layer->SetShouldScrollOnMainThread(true));
559  EXPECT_SET_NEEDS_COMMIT(1, test_layer->SetNonFastScrollableRegion(
560      Region(gfx::Rect(1, 1, 2, 2))));
561  EXPECT_SET_NEEDS_COMMIT(1, test_layer->SetHaveWheelEventHandlers(true));
562  EXPECT_SET_NEEDS_COMMIT(1, test_layer->SetTransform(
563      gfx::Transform(0.0, 0.0, 0.0, 0.0, 0.0, 0.0)));
564  EXPECT_SET_NEEDS_COMMIT(1, test_layer->SetDoubleSided(false));
565  EXPECT_SET_NEEDS_COMMIT(1, test_layer->SetTouchEventHandlerRegion(
566      gfx::Rect(10, 10)));
567  EXPECT_SET_NEEDS_COMMIT(1, test_layer->SetDrawCheckerboardForMissingTiles(
568      !test_layer->DrawCheckerboardForMissingTiles()));
569  EXPECT_SET_NEEDS_COMMIT(1, test_layer->SetForceRenderSurface(true));
570  EXPECT_SET_NEEDS_COMMIT(1, test_layer->SetHideLayerAndSubtree(true));
571
572  EXPECT_SET_NEEDS_FULL_TREE_SYNC(1, test_layer->SetMaskLayer(
573      dummy_layer1.get()));
574  EXPECT_SET_NEEDS_FULL_TREE_SYNC(1, test_layer->SetReplicaLayer(
575      dummy_layer2.get()));
576
577  // The above tests should not have caused a change to the needs_display flag.
578  EXPECT_FALSE(test_layer->NeedsDisplayForTesting());
579
580  // As layers are removed from the tree, they will cause a tree sync.
581  EXPECT_CALL(*layer_tree_host_, SetNeedsFullTreeSync()).Times((AnyNumber()));
582}
583
584TEST_F(LayerTest, PushPropertiesAccumulatesUpdateRect) {
585  scoped_refptr<Layer> test_layer = Layer::Create();
586  scoped_ptr<LayerImpl> impl_layer =
587      LayerImpl::Create(host_impl_.active_tree(), 1);
588
589  EXPECT_SET_NEEDS_FULL_TREE_SYNC(1,
590                                  layer_tree_host_->SetRootLayer(test_layer));
591
592  test_layer->SetNeedsDisplayRect(gfx::RectF(0.f, 0.f, 5.f, 5.f));
593  test_layer->PushPropertiesTo(impl_layer.get());
594  EXPECT_FLOAT_RECT_EQ(gfx::RectF(0.f, 0.f, 5.f, 5.f),
595                       impl_layer->update_rect());
596
597  // The LayerImpl's update_rect() should be accumulated here, since we did not
598  // do anything to clear it.
599  test_layer->SetNeedsDisplayRect(gfx::RectF(10.f, 10.f, 5.f, 5.f));
600  test_layer->PushPropertiesTo(impl_layer.get());
601  EXPECT_FLOAT_RECT_EQ(gfx::RectF(0.f, 0.f, 15.f, 15.f),
602                       impl_layer->update_rect());
603
604  // If we do clear the LayerImpl side, then the next update_rect() should be
605  // fresh without accumulation.
606  impl_layer->ResetAllChangeTrackingForSubtree();
607  test_layer->SetNeedsDisplayRect(gfx::RectF(10.f, 10.f, 5.f, 5.f));
608  test_layer->PushPropertiesTo(impl_layer.get());
609  EXPECT_FLOAT_RECT_EQ(gfx::RectF(10.f, 10.f, 5.f, 5.f),
610                       impl_layer->update_rect());
611}
612
613TEST_F(LayerTest, PushPropertiesCausesLayerPropertyChangedForTransform) {
614  scoped_refptr<Layer> test_layer = Layer::Create();
615  scoped_ptr<LayerImpl> impl_layer =
616      LayerImpl::Create(host_impl_.active_tree(), 1);
617
618  EXPECT_SET_NEEDS_FULL_TREE_SYNC(1,
619                                  layer_tree_host_->SetRootLayer(test_layer));
620
621  gfx::Transform transform;
622  transform.Rotate(45.0);
623  EXPECT_SET_NEEDS_COMMIT(1, test_layer->SetTransform(transform));
624
625  EXPECT_FALSE(impl_layer->LayerPropertyChanged());
626
627  test_layer->PushPropertiesTo(impl_layer.get());
628
629  EXPECT_TRUE(impl_layer->LayerPropertyChanged());
630}
631
632TEST_F(LayerTest, PushPropertiesCausesLayerPropertyChangedForOpacity) {
633  scoped_refptr<Layer> test_layer = Layer::Create();
634  scoped_ptr<LayerImpl> impl_layer =
635      LayerImpl::Create(host_impl_.active_tree(), 1);
636
637  EXPECT_SET_NEEDS_FULL_TREE_SYNC(1,
638                                  layer_tree_host_->SetRootLayer(test_layer));
639
640  EXPECT_SET_NEEDS_COMMIT(1, test_layer->SetOpacity(0.5f));
641
642  EXPECT_FALSE(impl_layer->LayerPropertyChanged());
643
644  test_layer->PushPropertiesTo(impl_layer.get());
645
646  EXPECT_TRUE(impl_layer->LayerPropertyChanged());
647}
648
649TEST_F(LayerTest,
650       PushPropsDoesntCauseLayerPropertyChangedDuringImplOnlyTransformAnim) {
651  scoped_refptr<Layer> test_layer = Layer::Create();
652  scoped_ptr<LayerImpl> impl_layer =
653      LayerImpl::Create(host_impl_.active_tree(), 1);
654
655  EXPECT_SET_NEEDS_FULL_TREE_SYNC(1,
656                                  layer_tree_host_->SetRootLayer(test_layer));
657
658  scoped_ptr<AnimationRegistrar> registrar = AnimationRegistrar::Create();
659  impl_layer->layer_animation_controller()->SetAnimationRegistrar(
660      registrar.get());
661
662  AddAnimatedTransformToController(impl_layer->layer_animation_controller(),
663                                   1.0,
664                                   0,
665                                   100);
666
667  gfx::Transform transform;
668  transform.Rotate(45.0);
669  EXPECT_SET_NEEDS_COMMIT(1, test_layer->SetTransform(transform));
670
671  EXPECT_FALSE(impl_layer->LayerPropertyChanged());
672  test_layer->PushPropertiesTo(impl_layer.get());
673  EXPECT_TRUE(impl_layer->LayerPropertyChanged());
674
675  impl_layer->ResetAllChangeTrackingForSubtree();
676  AddAnimatedTransformToController(impl_layer->layer_animation_controller(),
677                                   1.0,
678                                   0,
679                                   100);
680  impl_layer->layer_animation_controller()->GetAnimation(Animation::Transform)->
681      set_is_impl_only(true);
682  transform.Rotate(45.0);
683  EXPECT_SET_NEEDS_COMMIT(1, test_layer->SetTransform(transform));
684
685  EXPECT_FALSE(impl_layer->LayerPropertyChanged());
686  test_layer->PushPropertiesTo(impl_layer.get());
687  EXPECT_FALSE(impl_layer->LayerPropertyChanged());
688}
689
690TEST_F(LayerTest,
691       PushPropsDoesntCauseLayerPropertyChangedDuringImplOnlyOpacityAnim) {
692  scoped_refptr<Layer> test_layer = Layer::Create();
693  scoped_ptr<LayerImpl> impl_layer =
694      LayerImpl::Create(host_impl_.active_tree(), 1);
695
696  EXPECT_SET_NEEDS_FULL_TREE_SYNC(1,
697                                  layer_tree_host_->SetRootLayer(test_layer));
698
699  scoped_ptr<AnimationRegistrar> registrar = AnimationRegistrar::Create();
700  impl_layer->layer_animation_controller()->SetAnimationRegistrar(
701      registrar.get());
702
703  AddOpacityTransitionToController(impl_layer->layer_animation_controller(),
704                                   1.0,
705                                   0.3f,
706                                   0.7f,
707                                   false);
708
709  EXPECT_SET_NEEDS_COMMIT(1, test_layer->SetOpacity(0.5f));
710
711  EXPECT_FALSE(impl_layer->LayerPropertyChanged());
712  test_layer->PushPropertiesTo(impl_layer.get());
713  EXPECT_TRUE(impl_layer->LayerPropertyChanged());
714
715  impl_layer->ResetAllChangeTrackingForSubtree();
716  AddOpacityTransitionToController(impl_layer->layer_animation_controller(),
717                                   1.0,
718                                   0.3f,
719                                   0.7f,
720                                   false);
721  impl_layer->layer_animation_controller()->GetAnimation(Animation::Opacity)->
722      set_is_impl_only(true);
723  EXPECT_SET_NEEDS_COMMIT(1, test_layer->SetOpacity(0.75f));
724
725  EXPECT_FALSE(impl_layer->LayerPropertyChanged());
726  test_layer->PushPropertiesTo(impl_layer.get());
727  EXPECT_FALSE(impl_layer->LayerPropertyChanged());
728}
729
730TEST_F(LayerTest,
731       PushPropsDoesntCauseLayerPropertyChangedDuringImplOnlyFilterAnim) {
732  scoped_refptr<Layer> test_layer = Layer::Create();
733  scoped_ptr<LayerImpl> impl_layer =
734      LayerImpl::Create(host_impl_.active_tree(), 1);
735
736  EXPECT_SET_NEEDS_FULL_TREE_SYNC(1,
737                                  layer_tree_host_->SetRootLayer(test_layer));
738
739  scoped_ptr<AnimationRegistrar> registrar = AnimationRegistrar::Create();
740  impl_layer->layer_animation_controller()->SetAnimationRegistrar(
741      registrar.get());
742
743  AddAnimatedFilterToController(
744      impl_layer->layer_animation_controller(), 1.0, 1.f, 2.f);
745
746  FilterOperations filters;
747  filters.Append(FilterOperation::CreateBlurFilter(2.f));
748  EXPECT_SET_NEEDS_COMMIT(1, test_layer->SetFilters(filters));
749
750  EXPECT_FALSE(impl_layer->LayerPropertyChanged());
751  test_layer->PushPropertiesTo(impl_layer.get());
752  EXPECT_TRUE(impl_layer->LayerPropertyChanged());
753
754  impl_layer->ResetAllChangeTrackingForSubtree();
755  AddAnimatedFilterToController(
756      impl_layer->layer_animation_controller(), 1.0, 1.f, 2.f);
757  impl_layer->layer_animation_controller()->GetAnimation(Animation::Filter)->
758      set_is_impl_only(true);
759  filters.Append(FilterOperation::CreateSepiaFilter(0.5f));
760  EXPECT_SET_NEEDS_COMMIT(1, test_layer->SetFilters(filters));
761
762  EXPECT_FALSE(impl_layer->LayerPropertyChanged());
763  test_layer->PushPropertiesTo(impl_layer.get());
764  EXPECT_FALSE(impl_layer->LayerPropertyChanged());
765}
766
767TEST_F(LayerTest, MaskAndReplicaHasParent) {
768  scoped_refptr<Layer> parent = Layer::Create();
769  scoped_refptr<Layer> child = Layer::Create();
770  scoped_refptr<Layer> mask = Layer::Create();
771  scoped_refptr<Layer> replica = Layer::Create();
772  scoped_refptr<Layer> replica_mask = Layer::Create();
773  scoped_refptr<Layer> mask_replacement = Layer::Create();
774  scoped_refptr<Layer> replica_replacement = Layer::Create();
775  scoped_refptr<Layer> replica_mask_replacement = Layer::Create();
776
777  parent->AddChild(child);
778  child->SetMaskLayer(mask.get());
779  child->SetReplicaLayer(replica.get());
780  replica->SetMaskLayer(replica_mask.get());
781
782  EXPECT_EQ(parent, child->parent());
783  EXPECT_EQ(child, mask->parent());
784  EXPECT_EQ(child, replica->parent());
785  EXPECT_EQ(replica, replica_mask->parent());
786
787  replica->SetMaskLayer(replica_mask_replacement.get());
788  EXPECT_EQ(NULL, replica_mask->parent());
789  EXPECT_EQ(replica, replica_mask_replacement->parent());
790
791  child->SetMaskLayer(mask_replacement.get());
792  EXPECT_EQ(NULL, mask->parent());
793  EXPECT_EQ(child, mask_replacement->parent());
794
795  child->SetReplicaLayer(replica_replacement.get());
796  EXPECT_EQ(NULL, replica->parent());
797  EXPECT_EQ(child, replica_replacement->parent());
798
799  EXPECT_EQ(replica, replica->mask_layer()->parent());
800}
801
802class LayerTreeHostFactory {
803 public:
804  LayerTreeHostFactory()
805      : client_(FakeLayerTreeHostClient::DIRECT_3D) {}
806
807  scoped_ptr<LayerTreeHost> Create() {
808    return LayerTreeHost::CreateSingleThreaded(&client_,
809                                               &client_,
810                                               NULL,
811                                               LayerTreeSettings()).Pass();
812  }
813
814  scoped_ptr<LayerTreeHost> Create(LayerTreeSettings settings) {
815    return LayerTreeHost::CreateSingleThreaded(&client_,
816                                               &client_,
817                                               NULL,
818                                               settings).Pass();
819  }
820
821 private:
822  FakeLayerTreeHostClient client_;
823};
824
825void AssertLayerTreeHostMatchesForSubtree(Layer* layer, LayerTreeHost* host) {
826  EXPECT_EQ(host, layer->layer_tree_host());
827
828  for (size_t i = 0; i < layer->children().size(); ++i)
829    AssertLayerTreeHostMatchesForSubtree(layer->children()[i].get(), host);
830
831  if (layer->mask_layer())
832    AssertLayerTreeHostMatchesForSubtree(layer->mask_layer(), host);
833
834  if (layer->replica_layer())
835    AssertLayerTreeHostMatchesForSubtree(layer->replica_layer(), host);
836}
837
838TEST(LayerLayerTreeHostTest, EnteringTree) {
839  scoped_refptr<Layer> parent = Layer::Create();
840  scoped_refptr<Layer> child = Layer::Create();
841  scoped_refptr<Layer> mask = Layer::Create();
842  scoped_refptr<Layer> replica = Layer::Create();
843  scoped_refptr<Layer> replica_mask = Layer::Create();
844
845  // Set up a detached tree of layers. The host pointer should be nil for these
846  // layers.
847  parent->AddChild(child);
848  child->SetMaskLayer(mask.get());
849  child->SetReplicaLayer(replica.get());
850  replica->SetMaskLayer(replica_mask.get());
851
852  AssertLayerTreeHostMatchesForSubtree(parent.get(), NULL);
853
854  LayerTreeHostFactory factory;
855  scoped_ptr<LayerTreeHost> layer_tree_host = factory.Create();
856  // Setting the root layer should set the host pointer for all layers in the
857  // tree.
858  layer_tree_host->SetRootLayer(parent.get());
859
860  AssertLayerTreeHostMatchesForSubtree(parent.get(), layer_tree_host.get());
861
862  // Clearing the root layer should also clear out the host pointers for all
863  // layers in the tree.
864  layer_tree_host->SetRootLayer(NULL);
865
866  AssertLayerTreeHostMatchesForSubtree(parent.get(), NULL);
867}
868
869TEST(LayerLayerTreeHostTest, AddingLayerSubtree) {
870  scoped_refptr<Layer> parent = Layer::Create();
871  LayerTreeHostFactory factory;
872  scoped_ptr<LayerTreeHost> layer_tree_host = factory.Create();
873
874  layer_tree_host->SetRootLayer(parent.get());
875
876  EXPECT_EQ(parent->layer_tree_host(), layer_tree_host.get());
877
878  // Adding a subtree to a layer already associated with a host should set the
879  // host pointer on all layers in that subtree.
880  scoped_refptr<Layer> child = Layer::Create();
881  scoped_refptr<Layer> grand_child = Layer::Create();
882  child->AddChild(grand_child);
883
884  // Masks, replicas, and replica masks should pick up the new host too.
885  scoped_refptr<Layer> child_mask = Layer::Create();
886  child->SetMaskLayer(child_mask.get());
887  scoped_refptr<Layer> child_replica = Layer::Create();
888  child->SetReplicaLayer(child_replica.get());
889  scoped_refptr<Layer> child_replica_mask = Layer::Create();
890  child_replica->SetMaskLayer(child_replica_mask.get());
891
892  parent->AddChild(child);
893  AssertLayerTreeHostMatchesForSubtree(parent.get(), layer_tree_host.get());
894
895  layer_tree_host->SetRootLayer(NULL);
896}
897
898TEST(LayerLayerTreeHostTest, ChangeHost) {
899  scoped_refptr<Layer> parent = Layer::Create();
900  scoped_refptr<Layer> child = Layer::Create();
901  scoped_refptr<Layer> mask = Layer::Create();
902  scoped_refptr<Layer> replica = Layer::Create();
903  scoped_refptr<Layer> replica_mask = Layer::Create();
904
905  // Same setup as the previous test.
906  parent->AddChild(child);
907  child->SetMaskLayer(mask.get());
908  child->SetReplicaLayer(replica.get());
909  replica->SetMaskLayer(replica_mask.get());
910
911  LayerTreeHostFactory factory;
912  scoped_ptr<LayerTreeHost> first_layer_tree_host = factory.Create();
913  first_layer_tree_host->SetRootLayer(parent.get());
914
915  AssertLayerTreeHostMatchesForSubtree(parent.get(),
916                                       first_layer_tree_host.get());
917
918  // Now re-root the tree to a new host (simulating what we do on a context lost
919  // event). This should update the host pointers for all layers in the tree.
920  scoped_ptr<LayerTreeHost> second_layer_tree_host = factory.Create();
921  second_layer_tree_host->SetRootLayer(parent.get());
922
923  AssertLayerTreeHostMatchesForSubtree(parent.get(),
924                                       second_layer_tree_host.get());
925
926  second_layer_tree_host->SetRootLayer(NULL);
927}
928
929TEST(LayerLayerTreeHostTest, ChangeHostInSubtree) {
930  scoped_refptr<Layer> first_parent = Layer::Create();
931  scoped_refptr<Layer> first_child = Layer::Create();
932  scoped_refptr<Layer> second_parent = Layer::Create();
933  scoped_refptr<Layer> second_child = Layer::Create();
934  scoped_refptr<Layer> second_grand_child = Layer::Create();
935
936  // First put all children under the first parent and set the first host.
937  first_parent->AddChild(first_child);
938  second_child->AddChild(second_grand_child);
939  first_parent->AddChild(second_child);
940
941  LayerTreeHostFactory factory;
942  scoped_ptr<LayerTreeHost> first_layer_tree_host = factory.Create();
943  first_layer_tree_host->SetRootLayer(first_parent.get());
944
945  AssertLayerTreeHostMatchesForSubtree(first_parent.get(),
946                                       first_layer_tree_host.get());
947
948  // Now reparent the subtree starting at second_child to a layer in a different
949  // tree.
950  scoped_ptr<LayerTreeHost> second_layer_tree_host = factory.Create();
951  second_layer_tree_host->SetRootLayer(second_parent.get());
952
953  second_parent->AddChild(second_child);
954
955  // The moved layer and its children should point to the new host.
956  EXPECT_EQ(second_layer_tree_host.get(), second_child->layer_tree_host());
957  EXPECT_EQ(second_layer_tree_host.get(),
958            second_grand_child->layer_tree_host());
959
960  // Test over, cleanup time.
961  first_layer_tree_host->SetRootLayer(NULL);
962  second_layer_tree_host->SetRootLayer(NULL);
963}
964
965TEST(LayerLayerTreeHostTest, ReplaceMaskAndReplicaLayer) {
966  scoped_refptr<Layer> parent = Layer::Create();
967  scoped_refptr<Layer> mask = Layer::Create();
968  scoped_refptr<Layer> replica = Layer::Create();
969  scoped_refptr<Layer> mask_child = Layer::Create();
970  scoped_refptr<Layer> replica_child = Layer::Create();
971  scoped_refptr<Layer> mask_replacement = Layer::Create();
972  scoped_refptr<Layer> replica_replacement = Layer::Create();
973
974  parent->SetMaskLayer(mask.get());
975  parent->SetReplicaLayer(replica.get());
976  mask->AddChild(mask_child);
977  replica->AddChild(replica_child);
978
979  LayerTreeHostFactory factory;
980  scoped_ptr<LayerTreeHost> layer_tree_host = factory.Create();
981  layer_tree_host->SetRootLayer(parent.get());
982
983  AssertLayerTreeHostMatchesForSubtree(parent.get(), layer_tree_host.get());
984
985  // Replacing the mask should clear out the old mask's subtree's host pointers.
986  parent->SetMaskLayer(mask_replacement.get());
987  EXPECT_EQ(NULL, mask->layer_tree_host());
988  EXPECT_EQ(NULL, mask_child->layer_tree_host());
989
990  // Same for replacing a replica layer.
991  parent->SetReplicaLayer(replica_replacement.get());
992  EXPECT_EQ(NULL, replica->layer_tree_host());
993  EXPECT_EQ(NULL, replica_child->layer_tree_host());
994
995  // Test over, cleanup time.
996  layer_tree_host->SetRootLayer(NULL);
997}
998
999TEST(LayerLayerTreeHostTest, DestroyHostWithNonNullRootLayer) {
1000  scoped_refptr<Layer> root = Layer::Create();
1001  scoped_refptr<Layer> child = Layer::Create();
1002  root->AddChild(child);
1003  LayerTreeHostFactory factory;
1004  scoped_ptr<LayerTreeHost> layer_tree_host = factory.Create();
1005  layer_tree_host->SetRootLayer(root);
1006}
1007
1008static bool AddTestAnimation(Layer* layer) {
1009  scoped_ptr<KeyframedFloatAnimationCurve> curve =
1010      KeyframedFloatAnimationCurve::Create();
1011  curve->AddKeyframe(FloatKeyframe::Create(0.0,
1012                                           0.3f,
1013                                           scoped_ptr<TimingFunction>()));
1014  curve->AddKeyframe(FloatKeyframe::Create(1.0,
1015                                           0.7f,
1016                                           scoped_ptr<TimingFunction>()));
1017  scoped_ptr<Animation> animation =
1018      Animation::Create(curve.PassAs<AnimationCurve>(),
1019                        0,
1020                        0,
1021                        Animation::Opacity);
1022
1023  return layer->AddAnimation(animation.Pass());
1024}
1025
1026TEST(LayerLayerTreeHostTest, ShouldNotAddAnimationWithoutAnimationRegistrar) {
1027  scoped_refptr<Layer> layer = Layer::Create();
1028
1029  // Case 1: without a LayerTreeHost and without an AnimationRegistrar, the
1030  // animation should not be accepted.
1031  EXPECT_FALSE(AddTestAnimation(layer.get()));
1032
1033  scoped_ptr<AnimationRegistrar> registrar = AnimationRegistrar::Create();
1034  layer->layer_animation_controller()->SetAnimationRegistrar(registrar.get());
1035
1036  // Case 2: with an AnimationRegistrar, the animation should be accepted.
1037  EXPECT_TRUE(AddTestAnimation(layer.get()));
1038
1039  LayerTreeSettings settings;
1040  settings.accelerated_animation_enabled = false;
1041  LayerTreeHostFactory factory;
1042  scoped_ptr<LayerTreeHost> layer_tree_host = factory.Create(settings);
1043  layer_tree_host->SetRootLayer(layer);
1044  AssertLayerTreeHostMatchesForSubtree(layer.get(), layer_tree_host.get());
1045
1046  // Case 3: with a LayerTreeHost where accelerated animation is disabled, the
1047  // animation should be rejected.
1048  EXPECT_FALSE(AddTestAnimation(layer.get()));
1049}
1050
1051TEST_F(LayerTest, SafeOpaqueBackgroundColor) {
1052  LayerTreeHostFactory factory;
1053  scoped_ptr<LayerTreeHost> layer_tree_host = factory.Create();
1054
1055  scoped_refptr<Layer> layer = Layer::Create();
1056  layer_tree_host->SetRootLayer(layer);
1057
1058  for (int contents_opaque = 0; contents_opaque < 2; ++contents_opaque) {
1059    for (int layer_opaque = 0; layer_opaque < 2; ++layer_opaque) {
1060      for (int host_opaque = 0; host_opaque < 2; ++host_opaque) {
1061        layer->SetContentsOpaque(!!contents_opaque);
1062        layer->SetBackgroundColor(layer_opaque ? SK_ColorRED
1063                                               : SK_ColorTRANSPARENT);
1064        layer_tree_host->set_background_color(
1065            host_opaque ? SK_ColorRED : SK_ColorTRANSPARENT);
1066
1067        SkColor safe_color = layer->SafeOpaqueBackgroundColor();
1068        if (contents_opaque) {
1069          EXPECT_EQ(SkColorGetA(safe_color), 255u)
1070              << "Flags: " << contents_opaque << ", " << layer_opaque << ", "
1071              << host_opaque << "\n";
1072        } else {
1073          EXPECT_NE(SkColorGetA(safe_color), 255u)
1074              << "Flags: " << contents_opaque << ", " << layer_opaque << ", "
1075              << host_opaque << "\n";
1076        }
1077      }
1078    }
1079  }
1080}
1081
1082}  // namespace
1083}  // namespace cc
1084