ui/compositor/layer_unittest.cc

   1 // Copyright (c) 2012 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 "base/basictypes.h"
   6 #include "base/bind.h"
   7 #include "base/compiler_specific.h"
   8 #include "base/files/file_path.h"
   9 #include "base/files/file_util.h"
  10 #include "base/json/json_reader.h"
  11 #include "base/memory/scoped_ptr.h"
  12 #include "base/message_loop/message_loop.h"
  13 #include "base/path_service.h"
  14 #include "base/strings/string_util.h"
  15 #include "base/strings/stringprintf.h"
  16 #include "base/trace_event/trace_event.h"
  17 #include "cc/layers/delegated_frame_provider.h"
  18 #include "cc/layers/delegated_frame_resource_collection.h"
  19 #include "cc/layers/layer.h"
  20 #include "cc/output/copy_output_request.h"
  21 #include "cc/output/copy_output_result.h"
  22 #include "cc/output/delegated_frame_data.h"
  23 #include "cc/test/pixel_test_utils.h"
  24 #include "testing/gtest/include/gtest/gtest.h"
  25 #include "ui/compositor/compositor_observer.h"
  26 #include "ui/compositor/dip_util.h"
  27 #include "ui/compositor/layer.h"
  28 #include "ui/compositor/layer_animation_sequence.h"
  29 #include "ui/compositor/layer_animator.h"
  30 #include "ui/compositor/test/context_factories_for_test.h"
  31 #include "ui/compositor/test/draw_waiter_for_test.h"
  32 #include "ui/compositor/test/test_compositor_host.h"
  33 #include "ui/compositor/test/test_layers.h"
  34 #include "ui/gfx/canvas.h"
  35 #include "ui/gfx/codec/png_codec.h"
  36 #include "ui/gfx/gfx_paths.h"
  37 #include "ui/gfx/skia_util.h"
  38
  39 using cc::MatchesPNGFile;
  40
  41 namespace ui {
  42
  43 namespace {
  44
  45 // There are three test classes in here that configure the Compositor and
  46 // Layer's slightly differently:
  47 // - LayerWithNullDelegateTest uses NullLayerDelegate as the LayerDelegate. This
  48 //   is typically the base class you want to use.
  49 // - LayerWithDelegateTest uses LayerDelegate on the delegates.
  50 // - LayerWithRealCompositorTest when a real compositor is required for testing.
  51 //    - Slow because they bring up a window and run the real compositor. This
  52 //      is typically not what you want.
  53
  54 class ColoredLayer : public Layer, public LayerDelegate {
  55  public:
  56   explicit ColoredLayer(SkColor color)
  57       : Layer(LAYER_TEXTURED),
  58         color_(color) {
  59     set_delegate(this);
  60   }
  61
  62   ~ColoredLayer() override {}
  63
  64   // Overridden from LayerDelegate:
  65   void OnPaintLayer(gfx::Canvas* canvas) override { canvas->DrawColor(color_); }
  66
  67   void OnDelegatedFrameDamage(const gfx::Rect& damage_rect_in_dip) override {}
  68
  69   void OnDeviceScaleFactorChanged(float device_scale_factor) override {}
  70
  71   base::Closure PrepareForLayerBoundsChange() override {
  72     return base::Closure();
  73   }
  74
  75  private:
  76   SkColor color_;
  77 };
  78
  79 class LayerWithRealCompositorTest : public testing::Test {
  80  public:
  81   LayerWithRealCompositorTest() {
  82     if (PathService::Get(gfx::DIR_TEST_DATA, &test_data_directory_)) {
  83       test_data_directory_ = test_data_directory_.AppendASCII("compositor");
  84     } else {
  85       LOG(ERROR) << "Could not open test data directory.";
  86     }
  87   }
  88   ~LayerWithRealCompositorTest() override {}
  89
  90   // Overridden from testing::Test:
  91   void SetUp() override {
  92     bool enable_pixel_output = true;
  93     ui::ContextFactory* context_factory =
  94         InitializeContextFactoryForTests(enable_pixel_output);
  95
  96     const gfx::Rect host_bounds(10, 10, 500, 500);
  97     compositor_host_.reset(
  98         TestCompositorHost::Create(host_bounds, context_factory));
  99     compositor_host_->Show();
 100   }
 101
 102   void TearDown() override {
 103     compositor_host_.reset();
 104     TerminateContextFactoryForTests();
 105   }
 106
 107   Compositor* GetCompositor() { return compositor_host_->GetCompositor(); }
 108
 109   Layer* CreateLayer(LayerType type) {
 110     return new Layer(type);
 111   }
 112
 113   Layer* CreateColorLayer(SkColor color, const gfx::Rect& bounds) {
 114     Layer* layer = new ColoredLayer(color);
 115     layer->SetBounds(bounds);
 116     return layer;
 117   }
 118
 119   Layer* CreateNoTextureLayer(const gfx::Rect& bounds) {
 120     Layer* layer = CreateLayer(LAYER_NOT_DRAWN);
 121     layer->SetBounds(bounds);
 122     return layer;
 123   }
 124
 125   void DrawTree(Layer* root) {
 126     GetCompositor()->SetRootLayer(root);
 127     GetCompositor()->ScheduleDraw();
 128     WaitForSwap();
 129   }
 130
 131   void ReadPixels(SkBitmap* bitmap) {
 132     ReadPixels(bitmap, gfx::Rect(GetCompositor()->size()));
 133   }
 134
 135   void ReadPixels(SkBitmap* bitmap, gfx::Rect source_rect) {
 136     scoped_refptr<ReadbackHolder> holder(new ReadbackHolder);
 137     scoped_ptr<cc::CopyOutputRequest> request =
 138         cc::CopyOutputRequest::CreateBitmapRequest(
 139             base::Bind(&ReadbackHolder::OutputRequestCallback, holder));
 140     request->set_area(source_rect);
 141
 142     GetCompositor()->root_layer()->RequestCopyOfOutput(request.Pass());
 143
 144     // Wait for copy response.  This needs to wait as the compositor could
 145     // be in the middle of a draw right now, and the commit with the
 146     // copy output request may not be done on the first draw.
 147     for (int i = 0; i < 2; i++) {
 148       GetCompositor()->ScheduleFullRedraw();
 149       WaitForDraw();
 150     }
 151
 152     // Waits for the callback to finish run and return result.
 153     holder->WaitForReadback();
 154
 155     *bitmap = holder->result();
 156   }
 157
 158   void WaitForDraw() {
 159     ui::DrawWaiterForTest::WaitForCompositingStarted(GetCompositor());
 160   }
 161
 162   void WaitForSwap() {
 163     DrawWaiterForTest::WaitForCompositingEnded(GetCompositor());
 164   }
 165
 166   void WaitForCommit() {
 167     ui::DrawWaiterForTest::WaitForCommit(GetCompositor());
 168   }
 169
 170   // Invalidates the entire contents of the layer.
 171   void SchedulePaintForLayer(Layer* layer) {
 172     layer->SchedulePaint(
 173         gfx::Rect(0, 0, layer->bounds().width(), layer->bounds().height()));
 174   }
 175
 176   const base::FilePath& test_data_directory() const {
 177     return test_data_directory_;
 178   }
 179
 180  private:
 181   class ReadbackHolder : public base::RefCountedThreadSafe<ReadbackHolder> {
 182    public:
 183     ReadbackHolder() : run_loop_(new base::RunLoop) {}
 184
 185     void OutputRequestCallback(scoped_ptr<cc::CopyOutputResult> result) {
 186       result_ = result->TakeBitmap();
 187       run_loop_->Quit();
 188     }
 189
 190     void WaitForReadback() { run_loop_->Run(); }
 191
 192     const SkBitmap& result() const { return *result_; }
 193
 194    private:
 195     friend class base::RefCountedThreadSafe<ReadbackHolder>;
 196
 197     virtual ~ReadbackHolder() {}
 198
 199     scoped_ptr<SkBitmap> result_;
 200     scoped_ptr<base::RunLoop> run_loop_;
 201   };
 202
 203   scoped_ptr<TestCompositorHost> compositor_host_;
 204
 205   // The root directory for test files.
 206   base::FilePath test_data_directory_;
 207
 208   DISALLOW_COPY_AND_ASSIGN(LayerWithRealCompositorTest);
 209 };
 210
 211 // LayerDelegate that paints colors to the layer.
 212 class TestLayerDelegate : public LayerDelegate {
 213  public:
 214   explicit TestLayerDelegate() { reset(); }
 215   ~TestLayerDelegate() override {}
 216
 217   void AddColor(SkColor color) {
 218     colors_.push_back(color);
 219   }
 220
 221   const gfx::Size& paint_size() const { return paint_size_; }
 222   int color_index() const { return color_index_; }
 223
 224   std::string ToScaleString() const {
 225     return base::StringPrintf("%.1f %.1f", scale_x_, scale_y_);
 226   }
 227
 228   float device_scale_factor() const {
 229     return device_scale_factor_;
 230   }
 231
 232   // Overridden from LayerDelegate:
 233   void OnPaintLayer(gfx::Canvas* canvas) override {
 234     SkISize size = canvas->sk_canvas()->getBaseLayerSize();
 235     paint_size_ = gfx::Size(size.width(), size.height());
 236     canvas->DrawColor(colors_[color_index_]);
 237     color_index_ = (color_index_ + 1) % static_cast<int>(colors_.size());
 238     const SkMatrix& matrix = canvas->sk_canvas()->getTotalMatrix();
 239     scale_x_ = matrix.getScaleX();
 240     scale_y_ = matrix.getScaleY();
 241   }
 242
 243   void OnDelegatedFrameDamage(const gfx::Rect& damage_rect_in_dip) override {}
 244
 245   void OnDeviceScaleFactorChanged(float device_scale_factor) override {
 246     device_scale_factor_ = device_scale_factor;
 247   }
 248
 249   base::Closure PrepareForLayerBoundsChange() override {
 250     return base::Closure();
 251   }
 252
 253   void reset() {
 254     color_index_ = 0;
 255     paint_size_.SetSize(0, 0);
 256     scale_x_ = scale_y_ = 0.0f;
 257     device_scale_factor_ = 0.0f;
 258   }
 259
 260  private:
 261   std::vector<SkColor> colors_;
 262   int color_index_;
 263   gfx::Size paint_size_;
 264   float scale_x_;
 265   float scale_y_;
 266   float device_scale_factor_;
 267
 268   DISALLOW_COPY_AND_ASSIGN(TestLayerDelegate);
 269 };
 270
 271 // LayerDelegate that verifies that a layer was asked to update its canvas.
 272 class DrawTreeLayerDelegate : public LayerDelegate {
 273  public:
 274   DrawTreeLayerDelegate() : painted_(false) {}
 275   ~DrawTreeLayerDelegate() override {}
 276
 277   void Reset() {
 278     painted_ = false;
 279   }
 280
 281   bool painted() const { return painted_; }
 282
 283  private:
 284   // Overridden from LayerDelegate:
 285   void OnPaintLayer(gfx::Canvas* canvas) override {
 286     painted_ = true;
 287     canvas->DrawColor(SK_ColorWHITE);
 288   }
 289   void OnDelegatedFrameDamage(const gfx::Rect& damage_rect_in_dip) override {}
 290   void OnDeviceScaleFactorChanged(float device_scale_factor) override {}
 291   base::Closure PrepareForLayerBoundsChange() override {
 292     return base::Closure();
 293   }
 294
 295   bool painted_;
 296
 297   DISALLOW_COPY_AND_ASSIGN(DrawTreeLayerDelegate);
 298 };
 299
 300 // The simplest possible layer delegate. Does nothing.
 301 class NullLayerDelegate : public LayerDelegate {
 302  public:
 303   NullLayerDelegate() {}
 304   ~NullLayerDelegate() override {}
 305
 306  private:
 307   // Overridden from LayerDelegate:
 308   void OnPaintLayer(gfx::Canvas* canvas) override {}
 309   void OnDelegatedFrameDamage(const gfx::Rect& damage_rect_in_dip) override {}
 310   void OnDeviceScaleFactorChanged(float device_scale_factor) override {}
 311   base::Closure PrepareForLayerBoundsChange() override {
 312     return base::Closure();
 313   }
 314
 315   DISALLOW_COPY_AND_ASSIGN(NullLayerDelegate);
 316 };
 317
 318 // Remembers if it has been notified.
 319 class TestCompositorObserver : public CompositorObserver {
 320  public:
 321   TestCompositorObserver()
 322       : committed_(false), started_(false), ended_(false), aborted_(false) {}
 323
 324   bool committed() const { return committed_; }
 325   bool notified() const { return started_ && ended_; }
 326   bool aborted() const { return aborted_; }
 327
 328   void Reset() {
 329     committed_ = false;
 330     started_ = false;
 331     ended_ = false;
 332     aborted_ = false;
 333   }
 334
 335  private:
 336   void OnCompositingDidCommit(Compositor* compositor) override {
 337     committed_ = true;
 338   }
 339
 340   void OnCompositingStarted(Compositor* compositor,
 341                             base::TimeTicks start_time) override {
 342     started_ = true;
 343   }
 344
 345   void OnCompositingEnded(Compositor* compositor) override { ended_ = true; }
 346
 347   void OnCompositingAborted(Compositor* compositor) override {
 348     aborted_ = true;
 349   }
 350
 351   void OnCompositingLockStateChanged(Compositor* compositor) override {}
 352
 353   void OnCompositingShuttingDown(Compositor* compositor) override {}
 354
 355   bool committed_;
 356   bool started_;
 357   bool ended_;
 358   bool aborted_;
 359
 360   DISALLOW_COPY_AND_ASSIGN(TestCompositorObserver);
 361 };
 362
 363 }  // namespace
 364
 365 TEST_F(LayerWithRealCompositorTest, Draw) {
 366   scoped_ptr<Layer> layer(CreateColorLayer(SK_ColorRED,
 367                                            gfx::Rect(20, 20, 50, 50)));
 368   DrawTree(layer.get());
 369 }
 370
 371 // Create this hierarchy:
 372 // L1 - red
 373 // +-- L2 - blue
 374 // |   +-- L3 - yellow
 375 // +-- L4 - magenta
 376 //
 377 TEST_F(LayerWithRealCompositorTest, Hierarchy) {
 378   scoped_ptr<Layer> l1(CreateColorLayer(SK_ColorRED,
 379                                         gfx::Rect(20, 20, 400, 400)));
 380   scoped_ptr<Layer> l2(CreateColorLayer(SK_ColorBLUE,
 381                                         gfx::Rect(10, 10, 350, 350)));
 382   scoped_ptr<Layer> l3(CreateColorLayer(SK_ColorYELLOW,
 383                                         gfx::Rect(5, 5, 25, 25)));
 384   scoped_ptr<Layer> l4(CreateColorLayer(SK_ColorMAGENTA,
 385                                         gfx::Rect(300, 300, 100, 100)));
 386
 387   l1->Add(l2.get());
 388   l1->Add(l4.get());
 389   l2->Add(l3.get());
 390
 391   DrawTree(l1.get());
 392 }
 393
 394 class LayerWithDelegateTest : public testing::Test {
 395  public:
 396   LayerWithDelegateTest() {}
 397   ~LayerWithDelegateTest() override {}
 398
 399   // Overridden from testing::Test:
 400   void SetUp() override {
 401     bool enable_pixel_output = false;
 402     ui::ContextFactory* context_factory =
 403         InitializeContextFactoryForTests(enable_pixel_output);
 404
 405     const gfx::Rect host_bounds(1000, 1000);
 406     compositor_host_.reset(TestCompositorHost::Create(host_bounds,
 407                                                       context_factory));
 408     compositor_host_->Show();
 409   }
 410
 411   void TearDown() override {
 412     compositor_host_.reset();
 413     TerminateContextFactoryForTests();
 414   }
 415
 416   Compositor* compositor() { return compositor_host_->GetCompositor(); }
 417
 418   virtual Layer* CreateLayer(LayerType type) {
 419     return new Layer(type);
 420   }
 421
 422   Layer* CreateColorLayer(SkColor color, const gfx::Rect& bounds) {
 423     Layer* layer = new ColoredLayer(color);
 424     layer->SetBounds(bounds);
 425     return layer;
 426   }
 427
 428   virtual Layer* CreateNoTextureLayer(const gfx::Rect& bounds) {
 429     Layer* layer = CreateLayer(LAYER_NOT_DRAWN);
 430     layer->SetBounds(bounds);
 431     return layer;
 432   }
 433
 434   void DrawTree(Layer* root) {
 435     compositor()->SetRootLayer(root);
 436     Draw();
 437   }
 438
 439   // Invalidates the entire contents of the layer.
 440   void SchedulePaintForLayer(Layer* layer) {
 441     layer->SchedulePaint(
 442         gfx::Rect(0, 0, layer->bounds().width(), layer->bounds().height()));
 443   }
 444
 445   // Invokes DrawTree on the compositor.
 446   void Draw() {
 447     compositor()->ScheduleDraw();
 448     WaitForDraw();
 449   }
 450
 451   void WaitForDraw() {
 452     DrawWaiterForTest::WaitForCompositingStarted(compositor());
 453   }
 454
 455   void WaitForCommit() {
 456     DrawWaiterForTest::WaitForCommit(compositor());
 457   }
 458
 459  private:
 460   scoped_ptr<TestCompositorHost> compositor_host_;
 461
 462   DISALLOW_COPY_AND_ASSIGN(LayerWithDelegateTest);
 463 };
 464
 465 // L1
 466 //  +-- L2
 467 TEST_F(LayerWithDelegateTest, ConvertPointToLayer_Simple) {
 468   scoped_ptr<Layer> l1(CreateColorLayer(SK_ColorRED,
 469                                         gfx::Rect(20, 20, 400, 400)));
 470   scoped_ptr<Layer> l2(CreateColorLayer(SK_ColorBLUE,
 471                                         gfx::Rect(10, 10, 350, 350)));
 472   l1->Add(l2.get());
 473   DrawTree(l1.get());
 474
 475   gfx::Point point1_in_l2_coords(5, 5);
 476   Layer::ConvertPointToLayer(l2.get(), l1.get(), &point1_in_l2_coords);
 477   gfx::Point point1_in_l1_coords(15, 15);
 478   EXPECT_EQ(point1_in_l1_coords, point1_in_l2_coords);
 479
 480   gfx::Point point2_in_l1_coords(5, 5);
 481   Layer::ConvertPointToLayer(l1.get(), l2.get(), &point2_in_l1_coords);
 482   gfx::Point point2_in_l2_coords(-5, -5);
 483   EXPECT_EQ(point2_in_l2_coords, point2_in_l1_coords);
 484 }
 485
 486 // L1
 487 //  +-- L2
 488 //       +-- L3
 489 TEST_F(LayerWithDelegateTest, ConvertPointToLayer_Medium) {
 490   scoped_ptr<Layer> l1(CreateColorLayer(SK_ColorRED,
 491                                         gfx::Rect(20, 20, 400, 400)));
 492   scoped_ptr<Layer> l2(CreateColorLayer(SK_ColorBLUE,
 493                                         gfx::Rect(10, 10, 350, 350)));
 494   scoped_ptr<Layer> l3(CreateColorLayer(SK_ColorYELLOW,
 495                                         gfx::Rect(10, 10, 100, 100)));
 496   l1->Add(l2.get());
 497   l2->Add(l3.get());
 498   DrawTree(l1.get());
 499
 500   gfx::Point point1_in_l3_coords(5, 5);
 501   Layer::ConvertPointToLayer(l3.get(), l1.get(), &point1_in_l3_coords);
 502   gfx::Point point1_in_l1_coords(25, 25);
 503   EXPECT_EQ(point1_in_l1_coords, point1_in_l3_coords);
 504
 505   gfx::Point point2_in_l1_coords(5, 5);
 506   Layer::ConvertPointToLayer(l1.get(), l3.get(), &point2_in_l1_coords);
 507   gfx::Point point2_in_l3_coords(-15, -15);
 508   EXPECT_EQ(point2_in_l3_coords, point2_in_l1_coords);
 509 }
 510
 511 TEST_F(LayerWithRealCompositorTest, Delegate) {
 512   scoped_ptr<Layer> l1(CreateColorLayer(SK_ColorBLACK,
 513                                         gfx::Rect(20, 20, 400, 400)));
 514   GetCompositor()->SetRootLayer(l1.get());
 515   WaitForDraw();
 516
 517   TestLayerDelegate delegate;
 518   l1->set_delegate(&delegate);
 519   delegate.AddColor(SK_ColorWHITE);
 520   delegate.AddColor(SK_ColorYELLOW);
 521   delegate.AddColor(SK_ColorGREEN);
 522
 523   l1->SchedulePaint(gfx::Rect(0, 0, 400, 400));
 524   WaitForDraw();
 525
 526   EXPECT_EQ(delegate.color_index(), 1);
 527   EXPECT_EQ(delegate.paint_size(), l1->bounds().size());
 528
 529   l1->SchedulePaint(gfx::Rect(10, 10, 200, 200));
 530   WaitForDraw();
 531   EXPECT_EQ(delegate.color_index(), 2);
 532   EXPECT_EQ(delegate.paint_size(), gfx::Size(200, 200));
 533
 534   l1->SchedulePaint(gfx::Rect(5, 5, 50, 50));
 535   WaitForDraw();
 536   EXPECT_EQ(delegate.color_index(), 0);
 537   EXPECT_EQ(delegate.paint_size(), gfx::Size(50, 50));
 538 }
 539
 540 TEST_F(LayerWithRealCompositorTest, DrawTree) {
 541   scoped_ptr<Layer> l1(CreateColorLayer(SK_ColorRED,
 542                                         gfx::Rect(20, 20, 400, 400)));
 543   scoped_ptr<Layer> l2(CreateColorLayer(SK_ColorBLUE,
 544                                         gfx::Rect(10, 10, 350, 350)));
 545   scoped_ptr<Layer> l3(CreateColorLayer(SK_ColorYELLOW,
 546                                         gfx::Rect(10, 10, 100, 100)));
 547   l1->Add(l2.get());
 548   l2->Add(l3.get());
 549
 550   GetCompositor()->SetRootLayer(l1.get());
 551   WaitForDraw();
 552
 553   DrawTreeLayerDelegate d1;
 554   l1->set_delegate(&d1);
 555   DrawTreeLayerDelegate d2;
 556   l2->set_delegate(&d2);
 557   DrawTreeLayerDelegate d3;
 558   l3->set_delegate(&d3);
 559
 560   l2->SchedulePaint(gfx::Rect(5, 5, 5, 5));
 561   WaitForDraw();
 562   EXPECT_FALSE(d1.painted());
 563   EXPECT_TRUE(d2.painted());
 564   EXPECT_FALSE(d3.painted());
 565 }
 566
 567 // Tests no-texture Layers.
 568 // Create this hierarchy:
 569 // L1 - red
 570 // +-- L2 - NO TEXTURE
 571 // |   +-- L3 - yellow
 572 // +-- L4 - magenta
 573 //
 574 TEST_F(LayerWithRealCompositorTest, HierarchyNoTexture) {
 575   scoped_ptr<Layer> l1(CreateColorLayer(SK_ColorRED,
 576                                         gfx::Rect(20, 20, 400, 400)));
 577   scoped_ptr<Layer> l2(CreateNoTextureLayer(gfx::Rect(10, 10, 350, 350)));
 578   scoped_ptr<Layer> l3(CreateColorLayer(SK_ColorYELLOW,
 579                                         gfx::Rect(5, 5, 25, 25)));
 580   scoped_ptr<Layer> l4(CreateColorLayer(SK_ColorMAGENTA,
 581                                         gfx::Rect(300, 300, 100, 100)));
 582
 583   l1->Add(l2.get());
 584   l1->Add(l4.get());
 585   l2->Add(l3.get());
 586
 587   GetCompositor()->SetRootLayer(l1.get());
 588   WaitForDraw();
 589
 590   DrawTreeLayerDelegate d2;
 591   l2->set_delegate(&d2);
 592   DrawTreeLayerDelegate d3;
 593   l3->set_delegate(&d3);
 594
 595   l2->SchedulePaint(gfx::Rect(5, 5, 5, 5));
 596   l3->SchedulePaint(gfx::Rect(5, 5, 5, 5));
 597   WaitForDraw();
 598
 599   // |d2| should not have received a paint notification since it has no texture.
 600   EXPECT_FALSE(d2.painted());
 601   // |d3| should have received a paint notification.
 602   EXPECT_TRUE(d3.painted());
 603 }
 604
 605 class LayerWithNullDelegateTest : public LayerWithDelegateTest {
 606  public:
 607   LayerWithNullDelegateTest() {}
 608   ~LayerWithNullDelegateTest() override {}
 609
 610   void SetUp() override {
 611     LayerWithDelegateTest::SetUp();
 612     default_layer_delegate_.reset(new NullLayerDelegate());
 613   }
 614
 615   Layer* CreateLayer(LayerType type) override {
 616     Layer* layer = new Layer(type);
 617     layer->set_delegate(default_layer_delegate_.get());
 618     return layer;
 619   }
 620
 621   Layer* CreateTextureRootLayer(const gfx::Rect& bounds) {
 622     Layer* layer = CreateTextureLayer(bounds);
 623     compositor()->SetRootLayer(layer);
 624     return layer;
 625   }
 626
 627   Layer* CreateTextureLayer(const gfx::Rect& bounds) {
 628     Layer* layer = CreateLayer(LAYER_TEXTURED);
 629     layer->SetBounds(bounds);
 630     return layer;
 631   }
 632
 633   Layer* CreateNoTextureLayer(const gfx::Rect& bounds) override {
 634     Layer* layer = CreateLayer(LAYER_NOT_DRAWN);
 635     layer->SetBounds(bounds);
 636     return layer;
 637   }
 638
 639  private:
 640   scoped_ptr<NullLayerDelegate> default_layer_delegate_;
 641
 642   DISALLOW_COPY_AND_ASSIGN(LayerWithNullDelegateTest);
 643 };
 644
 645 TEST_F(LayerWithNullDelegateTest, EscapedDebugNames) {
 646   scoped_ptr<Layer> layer(CreateLayer(LAYER_NOT_DRAWN));
 647   std::string name = "\"\'\\/\b\f\n\r\t\n";
 648   layer->set_name(name);
 649   scoped_refptr<base::trace_event::ConvertableToTraceFormat> debug_info =
 650     layer->TakeDebugInfo();
 651   EXPECT_TRUE(!!debug_info.get());
 652   std::string json;
 653   debug_info->AppendAsTraceFormat(&json);
 654   base::JSONReader json_reader;
 655   scoped_ptr<base::Value> debug_info_value(json_reader.ReadToValue(json));
 656   EXPECT_TRUE(!!debug_info_value);
 657   EXPECT_TRUE(debug_info_value->IsType(base::Value::TYPE_DICTIONARY));
 658   base::DictionaryValue* dictionary = 0;
 659   EXPECT_TRUE(debug_info_value->GetAsDictionary(&dictionary));
 660   std::string roundtrip;
 661   EXPECT_TRUE(dictionary->GetString("layer_name", &roundtrip));
 662   EXPECT_EQ(name, roundtrip);
 663 }
 664
 665 void ReturnMailbox(bool* run, uint32 sync_point, bool is_lost) {
 666   *run = true;
 667 }
 668
 669 TEST_F(LayerWithNullDelegateTest, SwitchLayerPreservesCCLayerState) {
 670   scoped_ptr<Layer> l1(CreateLayer(LAYER_SOLID_COLOR));
 671   l1->SetFillsBoundsOpaquely(true);
 672   l1->SetForceRenderSurface(true);
 673   l1->SetVisible(false);
 674
 675   EXPECT_EQ(gfx::Point3F(), l1->cc_layer()->transform_origin());
 676   EXPECT_TRUE(l1->cc_layer()->DrawsContent());
 677   EXPECT_TRUE(l1->cc_layer()->contents_opaque());
 678   EXPECT_TRUE(l1->cc_layer()->force_render_surface());
 679   EXPECT_TRUE(l1->cc_layer()->hide_layer_and_subtree());
 680
 681   cc::Layer* before_layer = l1->cc_layer();
 682
 683   bool callback1_run = false;
 684   cc::TextureMailbox mailbox(gpu::Mailbox::Generate(), 0, 0);
 685   l1->SetTextureMailbox(mailbox,
 686                         cc::SingleReleaseCallback::Create(
 687                             base::Bind(ReturnMailbox, &callback1_run)),
 688                         gfx::Size(1, 1));
 689
 690   EXPECT_NE(before_layer, l1->cc_layer());
 691
 692   EXPECT_EQ(gfx::Point3F(), l1->cc_layer()->transform_origin());
 693   EXPECT_TRUE(l1->cc_layer()->DrawsContent());
 694   EXPECT_TRUE(l1->cc_layer()->contents_opaque());
 695   EXPECT_TRUE(l1->cc_layer()->force_render_surface());
 696   EXPECT_TRUE(l1->cc_layer()->hide_layer_and_subtree());
 697   EXPECT_FALSE(callback1_run);
 698
 699   bool callback2_run = false;
 700   mailbox = cc::TextureMailbox(gpu::Mailbox::Generate(), 0, 0);
 701   l1->SetTextureMailbox(mailbox,
 702                         cc::SingleReleaseCallback::Create(
 703                             base::Bind(ReturnMailbox, &callback2_run)),
 704                         gfx::Size(1, 1));
 705   EXPECT_TRUE(callback1_run);
 706   EXPECT_FALSE(callback2_run);
 707
 708   l1->SetShowSolidColorContent();
 709   EXPECT_EQ(gfx::Point3F(), l1->cc_layer()->transform_origin());
 710   EXPECT_TRUE(l1->cc_layer()->DrawsContent());
 711   EXPECT_TRUE(l1->cc_layer()->contents_opaque());
 712   EXPECT_TRUE(l1->cc_layer()->force_render_surface());
 713   EXPECT_TRUE(l1->cc_layer()->hide_layer_and_subtree());
 714   EXPECT_TRUE(callback2_run);
 715 }
 716
 717 // Various visibile/drawn assertions.
 718 TEST_F(LayerWithNullDelegateTest, Visibility) {
 719   scoped_ptr<Layer> l1(new Layer(LAYER_TEXTURED));
 720   scoped_ptr<Layer> l2(new Layer(LAYER_TEXTURED));
 721   scoped_ptr<Layer> l3(new Layer(LAYER_TEXTURED));
 722   l1->Add(l2.get());
 723   l2->Add(l3.get());
 724
 725   NullLayerDelegate delegate;
 726   l1->set_delegate(&delegate);
 727   l2->set_delegate(&delegate);
 728   l3->set_delegate(&delegate);
 729
 730   // Layers should initially be drawn.
 731   EXPECT_TRUE(l1->IsDrawn());
 732   EXPECT_TRUE(l2->IsDrawn());
 733   EXPECT_TRUE(l3->IsDrawn());
 734   EXPECT_FALSE(l1->cc_layer()->hide_layer_and_subtree());
 735   EXPECT_FALSE(l2->cc_layer()->hide_layer_and_subtree());
 736   EXPECT_FALSE(l3->cc_layer()->hide_layer_and_subtree());
 737
 738   compositor()->SetRootLayer(l1.get());
 739
 740   Draw();
 741
 742   l1->SetVisible(false);
 743   EXPECT_FALSE(l1->IsDrawn());
 744   EXPECT_FALSE(l2->IsDrawn());
 745   EXPECT_FALSE(l3->IsDrawn());
 746   EXPECT_TRUE(l1->cc_layer()->hide_layer_and_subtree());
 747   EXPECT_FALSE(l2->cc_layer()->hide_layer_and_subtree());
 748   EXPECT_FALSE(l3->cc_layer()->hide_layer_and_subtree());
 749
 750   l3->SetVisible(false);
 751   EXPECT_FALSE(l1->IsDrawn());
 752   EXPECT_FALSE(l2->IsDrawn());
 753   EXPECT_FALSE(l3->IsDrawn());
 754   EXPECT_TRUE(l1->cc_layer()->hide_layer_and_subtree());
 755   EXPECT_FALSE(l2->cc_layer()->hide_layer_and_subtree());
 756   EXPECT_TRUE(l3->cc_layer()->hide_layer_and_subtree());
 757
 758   l1->SetVisible(true);
 759   EXPECT_TRUE(l1->IsDrawn());
 760   EXPECT_TRUE(l2->IsDrawn());
 761   EXPECT_FALSE(l3->IsDrawn());
 762   EXPECT_FALSE(l1->cc_layer()->hide_layer_and_subtree());
 763   EXPECT_FALSE(l2->cc_layer()->hide_layer_and_subtree());
 764   EXPECT_TRUE(l3->cc_layer()->hide_layer_and_subtree());
 765 }
 766
 767 // Checks that stacking-related methods behave as advertised.
 768 TEST_F(LayerWithNullDelegateTest, Stacking) {
 769   scoped_ptr<Layer> root(new Layer(LAYER_NOT_DRAWN));
 770   scoped_ptr<Layer> l1(new Layer(LAYER_TEXTURED));
 771   scoped_ptr<Layer> l2(new Layer(LAYER_TEXTURED));
 772   scoped_ptr<Layer> l3(new Layer(LAYER_TEXTURED));
 773   l1->set_name("1");
 774   l2->set_name("2");
 775   l3->set_name("3");
 776   root->Add(l3.get());
 777   root->Add(l2.get());
 778   root->Add(l1.get());
 779
 780   // Layers' children are stored in bottom-to-top order.
 781   EXPECT_EQ("3 2 1", test::ChildLayerNamesAsString(*root.get()));
 782
 783   root->StackAtTop(l3.get());
 784   EXPECT_EQ("2 1 3", test::ChildLayerNamesAsString(*root.get()));
 785
 786   root->StackAtTop(l1.get());
 787   EXPECT_EQ("2 3 1", test::ChildLayerNamesAsString(*root.get()));
 788
 789   root->StackAtTop(l1.get());
 790   EXPECT_EQ("2 3 1", test::ChildLayerNamesAsString(*root.get()));
 791
 792   root->StackAbove(l2.get(), l3.get());
 793   EXPECT_EQ("3 2 1", test::ChildLayerNamesAsString(*root.get()));
 794
 795   root->StackAbove(l1.get(), l3.get());
 796   EXPECT_EQ("3 1 2", test::ChildLayerNamesAsString(*root.get()));
 797
 798   root->StackAbove(l2.get(), l1.get());
 799   EXPECT_EQ("3 1 2", test::ChildLayerNamesAsString(*root.get()));
 800
 801   root->StackAtBottom(l2.get());
 802   EXPECT_EQ("2 3 1", test::ChildLayerNamesAsString(*root.get()));
 803
 804   root->StackAtBottom(l3.get());
 805   EXPECT_EQ("3 2 1", test::ChildLayerNamesAsString(*root.get()));
 806
 807   root->StackAtBottom(l3.get());
 808   EXPECT_EQ("3 2 1", test::ChildLayerNamesAsString(*root.get()));
 809
 810   root->StackBelow(l2.get(), l3.get());
 811   EXPECT_EQ("2 3 1", test::ChildLayerNamesAsString(*root.get()));
 812
 813   root->StackBelow(l1.get(), l3.get());
 814   EXPECT_EQ("2 1 3", test::ChildLayerNamesAsString(*root.get()));
 815
 816   root->StackBelow(l3.get(), l2.get());
 817   EXPECT_EQ("3 2 1", test::ChildLayerNamesAsString(*root.get()));
 818
 819   root->StackBelow(l3.get(), l2.get());
 820   EXPECT_EQ("3 2 1", test::ChildLayerNamesAsString(*root.get()));
 821
 822   root->StackBelow(l3.get(), l1.get());
 823   EXPECT_EQ("2 3 1", test::ChildLayerNamesAsString(*root.get()));
 824 }
 825
 826 // Verifies SetBounds triggers the appropriate painting/drawing.
 827 TEST_F(LayerWithNullDelegateTest, SetBoundsSchedulesPaint) {
 828   scoped_ptr<Layer> l1(CreateTextureLayer(gfx::Rect(0, 0, 200, 200)));
 829   compositor()->SetRootLayer(l1.get());
 830
 831   Draw();
 832
 833   l1->SetBounds(gfx::Rect(5, 5, 200, 200));
 834
 835   // The CompositorDelegate (us) should have been told to draw for a move.
 836   WaitForDraw();
 837
 838   l1->SetBounds(gfx::Rect(5, 5, 100, 100));
 839
 840   // The CompositorDelegate (us) should have been told to draw for a resize.
 841   WaitForDraw();
 842 }
 843
 844 void ExpectRgba(int x, int y, SkColor expected_color, SkColor actual_color) {
 845   EXPECT_EQ(expected_color, actual_color)
 846       << "Pixel error at x=" << x << " y=" << y << "; "
 847       << "actual RGBA=("
 848       << SkColorGetR(actual_color) << ","
 849       << SkColorGetG(actual_color) << ","
 850       << SkColorGetB(actual_color) << ","
 851       << SkColorGetA(actual_color) << "); "
 852       << "expected RGBA=("
 853       << SkColorGetR(expected_color) << ","
 854       << SkColorGetG(expected_color) << ","
 855       << SkColorGetB(expected_color) << ","
 856       << SkColorGetA(expected_color) << ")";
 857 }
 858
 859 // Checks that pixels are actually drawn to the screen with a read back.
 860 TEST_F(LayerWithRealCompositorTest, DrawPixels) {
 861   gfx::Size viewport_size = GetCompositor()->size();
 862
 863   // The window should be some non-trivial size but may not be exactly
 864   // 500x500 on all platforms/bots.
 865   EXPECT_GE(viewport_size.width(), 200);
 866   EXPECT_GE(viewport_size.height(), 200);
 867
 868   int blue_height = 10;
 869
 870   scoped_ptr<Layer> layer(
 871       CreateColorLayer(SK_ColorRED, gfx::Rect(viewport_size)));
 872   scoped_ptr<Layer> layer2(
 873       CreateColorLayer(SK_ColorBLUE,
 874                        gfx::Rect(0, 0, viewport_size.width(), blue_height)));
 875
 876   layer->Add(layer2.get());
 877
 878   DrawTree(layer.get());
 879
 880   SkBitmap bitmap;
 881   ReadPixels(&bitmap, gfx::Rect(viewport_size));
 882   ASSERT_FALSE(bitmap.empty());
 883
 884   SkAutoLockPixels lock(bitmap);
 885   for (int x = 0; x < viewport_size.width(); x++) {
 886     for (int y = 0; y < viewport_size.height(); y++) {
 887       SkColor actual_color = bitmap.getColor(x, y);
 888       SkColor expected_color = y < blue_height ? SK_ColorBLUE : SK_ColorRED;
 889       ExpectRgba(x, y, expected_color, actual_color);
 890     }
 891   }
 892 }
 893
 894 // Checks that drawing a layer with transparent pixels is blended correctly
 895 // with the lower layer.
 896 TEST_F(LayerWithRealCompositorTest, DrawAlphaBlendedPixels) {
 897   gfx::Size viewport_size = GetCompositor()->size();
 898
 899   int test_size = 200;
 900   EXPECT_GE(viewport_size.width(), test_size);
 901   EXPECT_GE(viewport_size.height(), test_size);
 902
 903   // Blue with a wee bit of transparency.
 904   SkColor blue_with_alpha = SkColorSetARGBInline(40, 10, 20, 200);
 905   SkColor blend_color = SkColorSetARGBInline(255, 216, 3, 32);
 906
 907   scoped_ptr<Layer> background_layer(
 908       CreateColorLayer(SK_ColorRED, gfx::Rect(viewport_size)));
 909   scoped_ptr<Layer> foreground_layer(
 910       CreateColorLayer(blue_with_alpha, gfx::Rect(viewport_size)));
 911
 912   // This must be set to false for layers with alpha to be blended correctly.
 913   foreground_layer->SetFillsBoundsOpaquely(false);
 914
 915   background_layer->Add(foreground_layer.get());
 916   DrawTree(background_layer.get());
 917
 918   SkBitmap bitmap;
 919   ReadPixels(&bitmap, gfx::Rect(viewport_size));
 920   ASSERT_FALSE(bitmap.empty());
 921
 922   SkAutoLockPixels lock(bitmap);
 923   for (int x = 0; x < test_size; x++) {
 924     for (int y = 0; y < test_size; y++) {
 925       SkColor actual_color = bitmap.getColor(x, y);
 926       ExpectRgba(x, y, blend_color, actual_color);
 927     }
 928   }
 929 }
 930
 931 // Checks that using the AlphaShape filter applied to a layer with
 932 // transparency, alpha-blends properly with the layer below.
 933 TEST_F(LayerWithRealCompositorTest, DrawAlphaThresholdFilterPixels) {
 934   gfx::Size viewport_size = GetCompositor()->size();
 935
 936   int test_size = 200;
 937   EXPECT_GE(viewport_size.width(), test_size);
 938   EXPECT_GE(viewport_size.height(), test_size);
 939
 940   int blue_height = 10;
 941   SkColor blue_with_alpha = SkColorSetARGBInline(40, 0, 0, 255);
 942   SkColor blend_color = SkColorSetARGBInline(255, 215, 0, 40);
 943
 944   scoped_ptr<Layer> background_layer(
 945       CreateColorLayer(SK_ColorRED, gfx::Rect(viewport_size)));
 946   scoped_ptr<Layer> foreground_layer(
 947       CreateColorLayer(blue_with_alpha, gfx::Rect(viewport_size)));
 948
 949   // Add a shape to restrict the visible part of the layer.
 950   SkRegion shape;
 951   shape.setRect(0, 0, viewport_size.width(), blue_height);
 952   foreground_layer->SetAlphaShape(make_scoped_ptr(new SkRegion(shape)));
 953
 954   foreground_layer->SetFillsBoundsOpaquely(false);
 955
 956   background_layer->Add(foreground_layer.get());
 957   DrawTree(background_layer.get());
 958
 959   SkBitmap bitmap;
 960   ReadPixels(&bitmap, gfx::Rect(viewport_size));
 961   ASSERT_FALSE(bitmap.empty());
 962
 963   SkAutoLockPixels lock(bitmap);
 964   for (int x = 0; x < test_size; x++) {
 965     for (int y = 0; y < test_size; y++) {
 966       SkColor actual_color = bitmap.getColor(x, y);
 967       ExpectRgba(x, y, actual_color,
 968                  y < blue_height ? blend_color : SK_ColorRED);
 969     }
 970   }
 971 }
 972
 973 // Checks the logic around Compositor::SetRootLayer and Layer::SetCompositor.
 974 TEST_F(LayerWithRealCompositorTest, SetRootLayer) {
 975   Compositor* compositor = GetCompositor();
 976   scoped_ptr<Layer> l1(CreateColorLayer(SK_ColorRED,
 977                                         gfx::Rect(20, 20, 400, 400)));
 978   scoped_ptr<Layer> l2(CreateColorLayer(SK_ColorBLUE,
 979                                         gfx::Rect(10, 10, 350, 350)));
 980
 981   EXPECT_EQ(NULL, l1->GetCompositor());
 982   EXPECT_EQ(NULL, l2->GetCompositor());
 983
 984   compositor->SetRootLayer(l1.get());
 985   EXPECT_EQ(compositor, l1->GetCompositor());
 986
 987   l1->Add(l2.get());
 988   EXPECT_EQ(compositor, l2->GetCompositor());
 989
 990   l1->Remove(l2.get());
 991   EXPECT_EQ(NULL, l2->GetCompositor());
 992
 993   l1->Add(l2.get());
 994   EXPECT_EQ(compositor, l2->GetCompositor());
 995
 996   compositor->SetRootLayer(NULL);
 997   EXPECT_EQ(NULL, l1->GetCompositor());
 998   EXPECT_EQ(NULL, l2->GetCompositor());
 999 }
1000
1001 // Checks that compositor observers are notified when:
1002 // - DrawTree is called,
1003 // - After ScheduleDraw is called, or
1004 // - Whenever SetBounds, SetOpacity or SetTransform are called.
1005 // TODO(vollick): could be reorganized into compositor_unittest.cc
1006 TEST_F(LayerWithRealCompositorTest, CompositorObservers) {
1007   scoped_ptr<Layer> l1(CreateColorLayer(SK_ColorRED,
1008                                         gfx::Rect(20, 20, 400, 400)));
1009   scoped_ptr<Layer> l2(CreateColorLayer(SK_ColorBLUE,
1010                                         gfx::Rect(10, 10, 350, 350)));
1011   l1->Add(l2.get());
1012   TestCompositorObserver observer;
1013   GetCompositor()->AddObserver(&observer);
1014
1015   // Explicitly called DrawTree should cause the observers to be notified.
1016   // NOTE: this call to DrawTree sets l1 to be the compositor's root layer.
1017   DrawTree(l1.get());
1018   EXPECT_TRUE(observer.notified());
1019
1020   // ScheduleDraw without any visible change should cause a commit.
1021   observer.Reset();
1022   l1->ScheduleDraw();
1023   WaitForCommit();
1024   EXPECT_TRUE(observer.committed());
1025
1026   // Moving, but not resizing, a layer should alert the observers.
1027   observer.Reset();
1028   l2->SetBounds(gfx::Rect(0, 0, 350, 350));
1029   WaitForSwap();
1030   EXPECT_TRUE(observer.notified());
1031
1032   // So should resizing a layer.
1033   observer.Reset();
1034   l2->SetBounds(gfx::Rect(0, 0, 400, 400));
1035   WaitForSwap();
1036   EXPECT_TRUE(observer.notified());
1037
1038   // Opacity changes should alert the observers.
1039   observer.Reset();
1040   l2->SetOpacity(0.5f);
1041   WaitForSwap();
1042   EXPECT_TRUE(observer.notified());
1043
1044   // So should setting the opacity back.
1045   observer.Reset();
1046   l2->SetOpacity(1.0f);
1047   WaitForSwap();
1048   EXPECT_TRUE(observer.notified());
1049
1050   // Setting the transform of a layer should alert the observers.
1051   observer.Reset();
1052   gfx::Transform transform;
1053   transform.Translate(200.0, 200.0);
1054   transform.Rotate(90.0);
1055   transform.Translate(-200.0, -200.0);
1056   l2->SetTransform(transform);
1057   WaitForSwap();
1058   EXPECT_TRUE(observer.notified());
1059
1060   // A change resulting in an aborted swap buffer should alert the observer
1061   // and also signal an abort.
1062   observer.Reset();
1063   l2->SetOpacity(0.1f);
1064   GetCompositor()->DidAbortSwapBuffers();
1065   WaitForSwap();
1066   EXPECT_TRUE(observer.notified());
1067   EXPECT_TRUE(observer.aborted());
1068
1069   GetCompositor()->RemoveObserver(&observer);
1070
1071   // Opacity changes should no longer alert the removed observer.
1072   observer.Reset();
1073   l2->SetOpacity(0.5f);
1074   WaitForSwap();
1075
1076   EXPECT_FALSE(observer.notified());
1077 }
1078
1079 // Checks that modifying the hierarchy correctly affects final composite.
1080 TEST_F(LayerWithRealCompositorTest, ModifyHierarchy) {
1081   GetCompositor()->SetScaleAndSize(1.0f, gfx::Size(50, 50));
1082
1083   // l0
1084   //  +-l11
1085   //  | +-l21
1086   //  +-l12
1087   scoped_ptr<Layer> l0(CreateColorLayer(SK_ColorRED,
1088                                         gfx::Rect(0, 0, 50, 50)));
1089   scoped_ptr<Layer> l11(CreateColorLayer(SK_ColorGREEN,
1090                                          gfx::Rect(0, 0, 25, 25)));
1091   scoped_ptr<Layer> l21(CreateColorLayer(SK_ColorMAGENTA,
1092                                          gfx::Rect(0, 0, 15, 15)));
1093   scoped_ptr<Layer> l12(CreateColorLayer(SK_ColorBLUE,
1094                                          gfx::Rect(10, 10, 25, 25)));
1095
1096   base::FilePath ref_img1 =
1097       test_data_directory().AppendASCII("ModifyHierarchy1.png");
1098   base::FilePath ref_img2 =
1099       test_data_directory().AppendASCII("ModifyHierarchy2.png");
1100   SkBitmap bitmap;
1101
1102   l0->Add(l11.get());
1103   l11->Add(l21.get());
1104   l0->Add(l12.get());
1105   DrawTree(l0.get());
1106   ReadPixels(&bitmap);
1107   ASSERT_FALSE(bitmap.empty());
1108   // WritePNGFile(bitmap, ref_img1);
1109   EXPECT_TRUE(MatchesPNGFile(bitmap, ref_img1, cc::ExactPixelComparator(true)));
1110
1111   l0->StackAtTop(l11.get());
1112   DrawTree(l0.get());
1113   ReadPixels(&bitmap);
1114   ASSERT_FALSE(bitmap.empty());
1115   // WritePNGFile(bitmap, ref_img2);
1116   EXPECT_TRUE(MatchesPNGFile(bitmap, ref_img2, cc::ExactPixelComparator(true)));
1117
1118   // should restore to original configuration
1119   l0->StackAbove(l12.get(), l11.get());
1120   DrawTree(l0.get());
1121   ReadPixels(&bitmap);
1122   ASSERT_FALSE(bitmap.empty());
1123   EXPECT_TRUE(MatchesPNGFile(bitmap, ref_img1, cc::ExactPixelComparator(true)));
1124
1125   // l11 back to front
1126   l0->StackAtTop(l11.get());
1127   DrawTree(l0.get());
1128   ReadPixels(&bitmap);
1129   ASSERT_FALSE(bitmap.empty());
1130   EXPECT_TRUE(MatchesPNGFile(bitmap, ref_img2, cc::ExactPixelComparator(true)));
1131
1132   // should restore to original configuration
1133   l0->StackAbove(l12.get(), l11.get());
1134   DrawTree(l0.get());
1135   ReadPixels(&bitmap);
1136   ASSERT_FALSE(bitmap.empty());
1137   EXPECT_TRUE(MatchesPNGFile(bitmap, ref_img1, cc::ExactPixelComparator(true)));
1138
1139   // l11 back to front
1140   l0->StackAbove(l11.get(), l12.get());
1141   DrawTree(l0.get());
1142   ReadPixels(&bitmap);
1143   ASSERT_FALSE(bitmap.empty());
1144   EXPECT_TRUE(MatchesPNGFile(bitmap, ref_img2, cc::ExactPixelComparator(true)));
1145 }
1146
1147 // Opacity is rendered correctly.
1148 // Checks that modifying the hierarchy correctly affects final composite.
1149 TEST_F(LayerWithRealCompositorTest, Opacity) {
1150   GetCompositor()->SetScaleAndSize(1.0f, gfx::Size(50, 50));
1151
1152   // l0
1153   //  +-l11
1154   scoped_ptr<Layer> l0(CreateColorLayer(SK_ColorRED,
1155                                         gfx::Rect(0, 0, 50, 50)));
1156   scoped_ptr<Layer> l11(CreateColorLayer(SK_ColorGREEN,
1157                                          gfx::Rect(0, 0, 25, 25)));
1158
1159   base::FilePath ref_img = test_data_directory().AppendASCII("Opacity.png");
1160
1161   l11->SetOpacity(0.75);
1162   l0->Add(l11.get());
1163   DrawTree(l0.get());
1164   SkBitmap bitmap;
1165   ReadPixels(&bitmap);
1166   ASSERT_FALSE(bitmap.empty());
1167   // WritePNGFile(bitmap, ref_img);
1168   EXPECT_TRUE(MatchesPNGFile(bitmap, ref_img, cc::ExactPixelComparator(true)));
1169 }
1170
1171 namespace {
1172
1173 class SchedulePaintLayerDelegate : public LayerDelegate {
1174  public:
1175   SchedulePaintLayerDelegate() : paint_count_(0), layer_(NULL) {}
1176
1177   ~SchedulePaintLayerDelegate() override {}
1178
1179   void set_layer(Layer* layer) {
1180     layer_ = layer;
1181     layer_->set_delegate(this);
1182   }
1183
1184   void SetSchedulePaintRect(const gfx::Rect& rect) {
1185     schedule_paint_rect_ = rect;
1186   }
1187
1188   int GetPaintCountAndClear() {
1189     int value = paint_count_;
1190     paint_count_ = 0;
1191     return value;
1192   }
1193
1194   const gfx::RectF& last_clip_rect() const { return last_clip_rect_; }
1195
1196  private:
1197   // Overridden from LayerDelegate:
1198   void OnPaintLayer(gfx::Canvas* canvas) override {
1199     paint_count_++;
1200     if (!schedule_paint_rect_.IsEmpty()) {
1201       layer_->SchedulePaint(schedule_paint_rect_);
1202       schedule_paint_rect_ = gfx::Rect();
1203     }
1204     SkRect sk_clip_rect;
1205     if (canvas->sk_canvas()->getClipBounds(&sk_clip_rect))
1206       last_clip_rect_ = gfx::SkRectToRectF(sk_clip_rect);
1207   }
1208
1209   void OnDelegatedFrameDamage(const gfx::Rect& damage_rect_in_dip) override {}
1210
1211   void OnDeviceScaleFactorChanged(float device_scale_factor) override {}
1212
1213   base::Closure PrepareForLayerBoundsChange() override {
1214     return base::Closure();
1215   }
1216
1217   int paint_count_;
1218   Layer* layer_;
1219   gfx::Rect schedule_paint_rect_;
1220   gfx::RectF last_clip_rect_;
1221
1222   DISALLOW_COPY_AND_ASSIGN(SchedulePaintLayerDelegate);
1223 };
1224
1225 }  // namespace
1226
1227 // Verifies that if SchedulePaint is invoked during painting the layer is still
1228 // marked dirty.
1229 TEST_F(LayerWithDelegateTest, SchedulePaintFromOnPaintLayer) {
1230   scoped_ptr<Layer> root(CreateColorLayer(SK_ColorRED,
1231                                           gfx::Rect(0, 0, 500, 500)));
1232   SchedulePaintLayerDelegate child_delegate;
1233   scoped_ptr<Layer> child(CreateColorLayer(SK_ColorBLUE,
1234                                            gfx::Rect(0, 0, 200, 200)));
1235   child_delegate.set_layer(child.get());
1236
1237   root->Add(child.get());
1238
1239   SchedulePaintForLayer(root.get());
1240   DrawTree(root.get());
1241   child->SchedulePaint(gfx::Rect(0, 0, 20, 20));
1242   EXPECT_EQ(1, child_delegate.GetPaintCountAndClear());
1243
1244   // Set a rect so that when OnPaintLayer() is invoked SchedulePaint is invoked
1245   // again.
1246   child_delegate.SetSchedulePaintRect(gfx::Rect(10, 10, 30, 30));
1247   WaitForCommit();
1248   EXPECT_EQ(1, child_delegate.GetPaintCountAndClear());
1249
1250   // Because SchedulePaint() was invoked from OnPaintLayer() |child| should
1251   // still need to be painted.
1252   WaitForCommit();
1253   EXPECT_EQ(1, child_delegate.GetPaintCountAndClear());
1254   EXPECT_TRUE(child_delegate.last_clip_rect().Contains(
1255                   gfx::Rect(10, 10, 30, 30)));
1256 }
1257
1258 TEST_F(LayerWithRealCompositorTest, ScaleUpDown) {
1259   scoped_ptr<Layer> root(CreateColorLayer(SK_ColorWHITE,
1260                                           gfx::Rect(10, 20, 200, 220)));
1261   TestLayerDelegate root_delegate;
1262   root_delegate.AddColor(SK_ColorWHITE);
1263   root->set_delegate(&root_delegate);
1264
1265   scoped_ptr<Layer> l1(CreateColorLayer(SK_ColorWHITE,
1266                                         gfx::Rect(10, 20, 140, 180)));
1267   TestLayerDelegate l1_delegate;
1268   l1_delegate.AddColor(SK_ColorWHITE);
1269   l1->set_delegate(&l1_delegate);
1270
1271   GetCompositor()->SetScaleAndSize(1.0f, gfx::Size(500, 500));
1272   GetCompositor()->SetRootLayer(root.get());
1273   root->Add(l1.get());
1274   WaitForDraw();
1275
1276   EXPECT_EQ("10,20 200x220", root->bounds().ToString());
1277   EXPECT_EQ("10,20 140x180", l1->bounds().ToString());
1278   gfx::Size cc_bounds_size = root->cc_layer()->bounds();
1279   EXPECT_EQ("200x220", cc_bounds_size.ToString());
1280   cc_bounds_size = l1->cc_layer()->bounds();
1281   EXPECT_EQ("140x180", cc_bounds_size.ToString());
1282   // No scale change, so no scale notification.
1283   EXPECT_EQ(0.0f, root_delegate.device_scale_factor());
1284   EXPECT_EQ(0.0f, l1_delegate.device_scale_factor());
1285
1286   EXPECT_EQ("200x220", root_delegate.paint_size().ToString());
1287   EXPECT_EQ("140x180", l1_delegate.paint_size().ToString());
1288
1289   // Scale up to 2.0. Changing scale doesn't change the bounds in DIP.
1290   GetCompositor()->SetScaleAndSize(2.0f, gfx::Size(500, 500));
1291   EXPECT_EQ("10,20 200x220", root->bounds().ToString());
1292   EXPECT_EQ("10,20 140x180", l1->bounds().ToString());
1293   // CC layer should still match the UI layer bounds.
1294   cc_bounds_size = root->cc_layer()->bounds();
1295   EXPECT_EQ("200x220", cc_bounds_size.ToString());
1296   cc_bounds_size = l1->cc_layer()->bounds();
1297   EXPECT_EQ("140x180", cc_bounds_size.ToString());
1298   // New scale factor must have been notified.
1299   EXPECT_EQ(2.0f, root_delegate.device_scale_factor());
1300   EXPECT_EQ(2.0f, l1_delegate.device_scale_factor());
1301
1302   // Canvas size must have been scaled down up.
1303   WaitForDraw();
1304   EXPECT_EQ("400x440", root_delegate.paint_size().ToString());
1305   EXPECT_EQ("2.0 2.0", root_delegate.ToScaleString());
1306   EXPECT_EQ("280x360", l1_delegate.paint_size().ToString());
1307   EXPECT_EQ("2.0 2.0", l1_delegate.ToScaleString());
1308
1309   // Scale down back to 1.0f.
1310   GetCompositor()->SetScaleAndSize(1.0f, gfx::Size(500, 500));
1311   EXPECT_EQ("10,20 200x220", root->bounds().ToString());
1312   EXPECT_EQ("10,20 140x180", l1->bounds().ToString());
1313   // CC layer should still match the UI layer bounds.
1314   cc_bounds_size = root->cc_layer()->bounds();
1315   EXPECT_EQ("200x220", cc_bounds_size.ToString());
1316   cc_bounds_size = l1->cc_layer()->bounds();
1317   EXPECT_EQ("140x180", cc_bounds_size.ToString());
1318   // New scale factor must have been notified.
1319   EXPECT_EQ(1.0f, root_delegate.device_scale_factor());
1320   EXPECT_EQ(1.0f, l1_delegate.device_scale_factor());
1321
1322   // Canvas size must have been scaled down too.
1323   WaitForDraw();
1324   EXPECT_EQ("200x220", root_delegate.paint_size().ToString());
1325   EXPECT_EQ("1.0 1.0", root_delegate.ToScaleString());
1326   EXPECT_EQ("140x180", l1_delegate.paint_size().ToString());
1327   EXPECT_EQ("1.0 1.0", l1_delegate.ToScaleString());
1328
1329   root_delegate.reset();
1330   l1_delegate.reset();
1331   // Just changing the size shouldn't notify the scale change nor
1332   // trigger repaint.
1333   GetCompositor()->SetScaleAndSize(1.0f, gfx::Size(1000, 1000));
1334   // No scale change, so no scale notification.
1335   EXPECT_EQ(0.0f, root_delegate.device_scale_factor());
1336   EXPECT_EQ(0.0f, l1_delegate.device_scale_factor());
1337   WaitForDraw();
1338   EXPECT_EQ("0x0", root_delegate.paint_size().ToString());
1339   EXPECT_EQ("0.0 0.0", root_delegate.ToScaleString());
1340   EXPECT_EQ("0x0", l1_delegate.paint_size().ToString());
1341   EXPECT_EQ("0.0 0.0", l1_delegate.ToScaleString());
1342 }
1343
1344 TEST_F(LayerWithRealCompositorTest, ScaleReparent) {
1345   scoped_ptr<Layer> root(CreateColorLayer(SK_ColorWHITE,
1346                                           gfx::Rect(10, 20, 200, 220)));
1347   scoped_ptr<Layer> l1(CreateColorLayer(SK_ColorWHITE,
1348                                         gfx::Rect(10, 20, 140, 180)));
1349   TestLayerDelegate l1_delegate;
1350   l1_delegate.AddColor(SK_ColorWHITE);
1351   l1->set_delegate(&l1_delegate);
1352
1353   GetCompositor()->SetScaleAndSize(1.0f, gfx::Size(500, 500));
1354   GetCompositor()->SetRootLayer(root.get());
1355   WaitForDraw();
1356
1357   root->Add(l1.get());
1358   EXPECT_EQ("10,20 140x180", l1->bounds().ToString());
1359   gfx::Size cc_bounds_size = l1->cc_layer()->bounds();
1360   EXPECT_EQ("140x180", cc_bounds_size.ToString());
1361   EXPECT_EQ(0.0f, l1_delegate.device_scale_factor());
1362
1363   WaitForDraw();
1364   EXPECT_EQ("140x180", l1_delegate.paint_size().ToString());
1365   EXPECT_EQ("1.0 1.0", l1_delegate.ToScaleString());
1366
1367   // Remove l1 from root and change the scale.
1368   root->Remove(l1.get());
1369   EXPECT_EQ(NULL, l1->parent());
1370   EXPECT_EQ(NULL, l1->GetCompositor());
1371   GetCompositor()->SetScaleAndSize(2.0f, gfx::Size(500, 500));
1372   // Sanity check on root and l1.
1373   EXPECT_EQ("10,20 200x220", root->bounds().ToString());
1374   cc_bounds_size = l1->cc_layer()->bounds();
1375   EXPECT_EQ("140x180", cc_bounds_size.ToString());
1376
1377   root->Add(l1.get());
1378   EXPECT_EQ("10,20 140x180", l1->bounds().ToString());
1379   cc_bounds_size = l1->cc_layer()->bounds();
1380   EXPECT_EQ("140x180", cc_bounds_size.ToString());
1381   EXPECT_EQ(2.0f, l1_delegate.device_scale_factor());
1382   WaitForDraw();
1383   EXPECT_EQ("280x360", l1_delegate.paint_size().ToString());
1384   EXPECT_EQ("2.0 2.0", l1_delegate.ToScaleString());
1385 }
1386
1387 // Verifies that when changing bounds on a layer that is invisible, and then
1388 // made visible, the right thing happens:
1389 // - if just a move, then no painting should happen.
1390 // - if a resize, the layer should be repainted.
1391 TEST_F(LayerWithDelegateTest, SetBoundsWhenInvisible) {
1392   scoped_ptr<Layer> root(CreateNoTextureLayer(gfx::Rect(0, 0, 1000, 1000)));
1393
1394   scoped_ptr<Layer> child(CreateLayer(LAYER_TEXTURED));
1395   child->SetBounds(gfx::Rect(0, 0, 500, 500));
1396   DrawTreeLayerDelegate delegate;
1397   child->set_delegate(&delegate);
1398   root->Add(child.get());
1399
1400   // Paint once for initial damage.
1401   child->SetVisible(true);
1402   DrawTree(root.get());
1403
1404   // Reset into invisible state.
1405   child->SetVisible(false);
1406   DrawTree(root.get());
1407   delegate.Reset();
1408
1409   // Move layer.
1410   child->SetBounds(gfx::Rect(200, 200, 500, 500));
1411   child->SetVisible(true);
1412   DrawTree(root.get());
1413   EXPECT_FALSE(delegate.painted());
1414
1415   // Reset into invisible state.
1416   child->SetVisible(false);
1417   DrawTree(root.get());
1418   delegate.Reset();
1419
1420   // Resize layer.
1421   child->SetBounds(gfx::Rect(200, 200, 400, 400));
1422   child->SetVisible(true);
1423   DrawTree(root.get());
1424   EXPECT_TRUE(delegate.painted());
1425 }
1426
1427 static scoped_ptr<cc::DelegatedFrameData> MakeFrameData(gfx::Size size) {
1428   scoped_ptr<cc::DelegatedFrameData> frame_data(new cc::DelegatedFrameData);
1429   scoped_ptr<cc::RenderPass> render_pass(cc::RenderPass::Create());
1430   render_pass->SetNew(
1431       cc::RenderPassId(1, 1), gfx::Rect(size), gfx::Rect(), gfx::Transform());
1432   frame_data->render_pass_list.push_back(render_pass.Pass());
1433   return frame_data.Pass();
1434 }
1435
1436 TEST_F(LayerWithDelegateTest, DelegatedLayer) {
1437   scoped_ptr<Layer> root(CreateNoTextureLayer(gfx::Rect(0, 0, 1000, 1000)));
1438
1439   scoped_ptr<Layer> child(CreateLayer(LAYER_TEXTURED));
1440
1441   child->SetBounds(gfx::Rect(0, 0, 10, 10));
1442   child->SetVisible(true);
1443   root->Add(child.get());
1444   DrawTree(root.get());
1445
1446   scoped_refptr<cc::DelegatedFrameResourceCollection> resource_collection =
1447       new cc::DelegatedFrameResourceCollection;
1448   scoped_refptr<cc::DelegatedFrameProvider> frame_provider;
1449
1450   // Content matches layer size.
1451   frame_provider = new cc::DelegatedFrameProvider(
1452       resource_collection.get(), MakeFrameData(gfx::Size(10, 10)));
1453   child->SetShowDelegatedContent(frame_provider.get(), gfx::Size(10, 10));
1454   EXPECT_EQ(child->cc_layer()->bounds().ToString(),
1455             gfx::Size(10, 10).ToString());
1456
1457   // Content larger than layer.
1458   child->SetBounds(gfx::Rect(0, 0, 5, 5));
1459   EXPECT_EQ(child->cc_layer()->bounds().ToString(),
1460             gfx::Size(5, 5).ToString());
1461
1462   // Content smaller than layer.
1463   child->SetBounds(gfx::Rect(0, 0, 10, 10));
1464   frame_provider = new cc::DelegatedFrameProvider(
1465       resource_collection.get(), MakeFrameData(gfx::Size(5, 5)));
1466   child->SetShowDelegatedContent(frame_provider.get(), gfx::Size(5, 5));
1467   EXPECT_EQ(child->cc_layer()->bounds().ToString(), gfx::Size(5, 5).ToString());
1468
1469   // Hi-DPI content on low-DPI layer.
1470   frame_provider = new cc::DelegatedFrameProvider(
1471       resource_collection.get(), MakeFrameData(gfx::Size(20, 20)));
1472   child->SetShowDelegatedContent(frame_provider.get(), gfx::Size(10, 10));
1473   EXPECT_EQ(child->cc_layer()->bounds().ToString(),
1474             gfx::Size(10, 10).ToString());
1475
1476   // Hi-DPI content on hi-DPI layer.
1477   compositor()->SetScaleAndSize(2.f, gfx::Size(1000, 1000));
1478   EXPECT_EQ(child->cc_layer()->bounds().ToString(),
1479             gfx::Size(10, 10).ToString());
1480
1481   // Low-DPI content on hi-DPI layer.
1482   frame_provider = new cc::DelegatedFrameProvider(
1483       resource_collection.get(), MakeFrameData(gfx::Size(10, 10)));
1484   child->SetShowDelegatedContent(frame_provider.get(), gfx::Size(10, 10));
1485   EXPECT_EQ(child->cc_layer()->bounds().ToString(),
1486             gfx::Size(10, 10).ToString());
1487 }
1488
1489 TEST_F(LayerWithDelegateTest, ExternalContent) {
1490   scoped_ptr<Layer> root(CreateNoTextureLayer(gfx::Rect(0, 0, 1000, 1000)));
1491   scoped_ptr<Layer> child(CreateLayer(LAYER_SOLID_COLOR));
1492
1493   child->SetBounds(gfx::Rect(0, 0, 10, 10));
1494   child->SetVisible(true);
1495   root->Add(child.get());
1496
1497   // The layer is already showing solid color content, so the cc layer won't
1498   // change.
1499   scoped_refptr<cc::Layer> before = child->cc_layer();
1500   child->SetShowSolidColorContent();
1501   EXPECT_TRUE(child->cc_layer());
1502   EXPECT_EQ(before.get(), child->cc_layer());
1503
1504   scoped_refptr<cc::DelegatedFrameResourceCollection> resource_collection =
1505       new cc::DelegatedFrameResourceCollection;
1506   scoped_refptr<cc::DelegatedFrameProvider> frame_provider =
1507       new cc::DelegatedFrameProvider(resource_collection.get(),
1508                                      MakeFrameData(gfx::Size(10, 10)));
1509
1510   // Showing delegated content changes the underlying cc layer.
1511   before = child->cc_layer();
1512   child->SetShowDelegatedContent(frame_provider.get(), gfx::Size(10, 10));
1513   EXPECT_TRUE(child->cc_layer());
1514   EXPECT_NE(before.get(), child->cc_layer());
1515
1516   // Changing to painted content should change the underlying cc layer.
1517   before = child->cc_layer();
1518   child->SetShowSolidColorContent();
1519   EXPECT_TRUE(child->cc_layer());
1520   EXPECT_NE(before.get(), child->cc_layer());
1521 }
1522
1523 // Verifies that layer filters still attached after changing implementation
1524 // layer.
1525 TEST_F(LayerWithDelegateTest, LayerFiltersSurvival) {
1526   scoped_ptr<Layer> layer(CreateLayer(LAYER_TEXTURED));
1527   layer->SetBounds(gfx::Rect(0, 0, 10, 10));
1528   EXPECT_TRUE(layer->cc_layer());
1529   EXPECT_EQ(0u, layer->cc_layer()->filters().size());
1530
1531   layer->SetLayerGrayscale(0.5f);
1532   EXPECT_EQ(layer->layer_grayscale(), 0.5f);
1533   EXPECT_EQ(1u, layer->cc_layer()->filters().size());
1534
1535   scoped_refptr<cc::DelegatedFrameResourceCollection> resource_collection =
1536       new cc::DelegatedFrameResourceCollection;
1537   scoped_refptr<cc::DelegatedFrameProvider> frame_provider =
1538       new cc::DelegatedFrameProvider(resource_collection.get(),
1539                                      MakeFrameData(gfx::Size(10, 10)));
1540
1541   // Showing delegated content changes the underlying cc layer.
1542   scoped_refptr<cc::Layer> before = layer->cc_layer();
1543   layer->SetShowDelegatedContent(frame_provider.get(), gfx::Size(10, 10));
1544   EXPECT_EQ(layer->layer_grayscale(), 0.5f);
1545   EXPECT_TRUE(layer->cc_layer());
1546   EXPECT_NE(before.get(), layer->cc_layer());
1547   EXPECT_EQ(1u, layer->cc_layer()->filters().size());
1548 }
1549
1550 // Tests Layer::AddThreadedAnimation and Layer::RemoveThreadedAnimation.
1551 TEST_F(LayerWithRealCompositorTest, AddRemoveThreadedAnimations) {
1552   scoped_ptr<Layer> root(CreateLayer(LAYER_TEXTURED));
1553   scoped_ptr<Layer> l1(CreateLayer(LAYER_TEXTURED));
1554   scoped_ptr<Layer> l2(CreateLayer(LAYER_TEXTURED));
1555
1556   l1->SetAnimator(LayerAnimator::CreateImplicitAnimator());
1557   l2->SetAnimator(LayerAnimator::CreateImplicitAnimator());
1558
1559   EXPECT_FALSE(l1->HasPendingThreadedAnimations());
1560
1561   // Trigger a threaded animation.
1562   l1->SetOpacity(0.5f);
1563
1564   EXPECT_TRUE(l1->HasPendingThreadedAnimations());
1565
1566   // Ensure we can remove a pending threaded animation.
1567   l1->GetAnimator()->StopAnimating();
1568
1569   EXPECT_FALSE(l1->HasPendingThreadedAnimations());
1570
1571   // Trigger another threaded animation.
1572   l1->SetOpacity(0.2f);
1573
1574   EXPECT_TRUE(l1->HasPendingThreadedAnimations());
1575
1576   root->Add(l1.get());
1577   GetCompositor()->SetRootLayer(root.get());
1578
1579   // Now that l1 is part of a tree, it should have dispatched the pending
1580   // animation.
1581   EXPECT_FALSE(l1->HasPendingThreadedAnimations());
1582
1583   // Ensure that l1 no longer holds on to animations.
1584   l1->SetOpacity(0.1f);
1585   EXPECT_FALSE(l1->HasPendingThreadedAnimations());
1586
1587   // Ensure that adding a layer to an existing tree causes its pending
1588   // animations to get dispatched.
1589   l2->SetOpacity(0.5f);
1590   EXPECT_TRUE(l2->HasPendingThreadedAnimations());
1591
1592   l1->Add(l2.get());
1593   EXPECT_FALSE(l2->HasPendingThreadedAnimations());
1594 }
1595
1596 // Tests that in-progress threaded animations complete when a Layer's
1597 // cc::Layer changes.
1598 TEST_F(LayerWithRealCompositorTest, SwitchCCLayerAnimations) {
1599   scoped_ptr<Layer> root(CreateLayer(LAYER_TEXTURED));
1600   scoped_ptr<Layer> l1(CreateLayer(LAYER_TEXTURED));
1601   GetCompositor()->SetRootLayer(root.get());
1602   root->Add(l1.get());
1603
1604   l1->SetAnimator(LayerAnimator::CreateImplicitAnimator());
1605
1606   EXPECT_FLOAT_EQ(l1->opacity(), 1.0f);
1607
1608   // Trigger a threaded animation.
1609   l1->SetOpacity(0.5f);
1610
1611   // Change l1's cc::Layer.
1612   l1->SwitchCCLayerForTest();
1613
1614   // Ensure that the opacity animation completed.
1615   EXPECT_FLOAT_EQ(l1->opacity(), 0.5f);
1616 }
1617
1618 // Tests that the animators in the layer tree is added to the
1619 // animator-collection when the root-layer is set to the compositor.
1620 TEST_F(LayerWithDelegateTest, RootLayerAnimatorsInCompositor) {
1621   scoped_ptr<Layer> root(CreateLayer(LAYER_SOLID_COLOR));
1622   scoped_ptr<Layer> child(CreateColorLayer(SK_ColorRED, gfx::Rect(10, 10)));
1623   child->SetAnimator(LayerAnimator::CreateImplicitAnimator());
1624   child->SetOpacity(0.5f);
1625   root->Add(child.get());
1626
1627   EXPECT_FALSE(compositor()->layer_animator_collection()->HasActiveAnimators());
1628   compositor()->SetRootLayer(root.get());
1629   EXPECT_TRUE(compositor()->layer_animator_collection()->HasActiveAnimators());
1630 }
1631
1632 // Tests that adding/removing a layer adds/removes the animator from its entire
1633 // subtree from the compositor's animator-collection.
1634 TEST_F(LayerWithDelegateTest, AddRemoveLayerUpdatesAnimatorsFromSubtree) {
1635   scoped_ptr<Layer> root(CreateLayer(LAYER_TEXTURED));
1636   scoped_ptr<Layer> child(CreateLayer(LAYER_TEXTURED));
1637   scoped_ptr<Layer> grandchild(CreateColorLayer(SK_ColorRED,
1638                                                 gfx::Rect(10, 10)));
1639   root->Add(child.get());
1640   child->Add(grandchild.get());
1641   compositor()->SetRootLayer(root.get());
1642
1643   grandchild->SetAnimator(LayerAnimator::CreateImplicitAnimator());
1644   grandchild->SetOpacity(0.5f);
1645   EXPECT_TRUE(compositor()->layer_animator_collection()->HasActiveAnimators());
1646
1647   root->Remove(child.get());
1648   EXPECT_FALSE(compositor()->layer_animator_collection()->HasActiveAnimators());
1649
1650   root->Add(child.get());
1651   EXPECT_TRUE(compositor()->layer_animator_collection()->HasActiveAnimators());
1652 }
1653
1654 TEST_F(LayerWithDelegateTest, DestroyingLayerRemovesTheAnimatorFromCollection) {
1655   scoped_ptr<Layer> root(CreateLayer(LAYER_TEXTURED));
1656   scoped_ptr<Layer> child(CreateLayer(LAYER_TEXTURED));
1657   root->Add(child.get());
1658   compositor()->SetRootLayer(root.get());
1659
1660   child->SetAnimator(LayerAnimator::CreateImplicitAnimator());
1661   child->SetOpacity(0.5f);
1662   EXPECT_TRUE(compositor()->layer_animator_collection()->HasActiveAnimators());
1663
1664   child.reset();
1665   EXPECT_FALSE(compositor()->layer_animator_collection()->HasActiveAnimators());
1666 }
1667
1668 namespace {
1669
1670 std::string Vector2dFTo100thPercisionString(const gfx::Vector2dF& vector) {
1671   return base::StringPrintf("%.2f %0.2f", vector.x(), vector.y());
1672 }
1673
1674 }  // namespace
1675
1676 TEST_F(LayerWithRealCompositorTest, SnapLayerToPixels) {
1677   scoped_ptr<Layer> root(CreateLayer(LAYER_TEXTURED));
1678   scoped_ptr<Layer> c1(CreateLayer(LAYER_TEXTURED));
1679   scoped_ptr<Layer> c11(CreateLayer(LAYER_TEXTURED));
1680
1681   GetCompositor()->SetScaleAndSize(1.25f, gfx::Size(100, 100));
1682   GetCompositor()->SetRootLayer(root.get());
1683   root->Add(c1.get());
1684   c1->Add(c11.get());
1685
1686   root->SetBounds(gfx::Rect(0, 0, 100, 100));
1687   c1->SetBounds(gfx::Rect(1, 1, 10, 10));
1688   c11->SetBounds(gfx::Rect(1, 1, 10, 10));
1689   SnapLayerToPhysicalPixelBoundary(root.get(), c11.get());
1690   // 0.5 at 1.25 scale : (1 - 0.25 + 0.25) / 1.25 = 0.4
1691   EXPECT_EQ("0.40 0.40",
1692             Vector2dFTo100thPercisionString(c11->subpixel_position_offset()));
1693
1694   GetCompositor()->SetScaleAndSize(1.5f, gfx::Size(100, 100));
1695   SnapLayerToPhysicalPixelBoundary(root.get(), c11.get());
1696   // c11 must already be aligned at 1.5 scale.
1697   EXPECT_EQ("0.00 0.00",
1698             Vector2dFTo100thPercisionString(c11->subpixel_position_offset()));
1699
1700   c11->SetBounds(gfx::Rect(2, 2, 10, 10));
1701   SnapLayerToPhysicalPixelBoundary(root.get(), c11.get());
1702   // c11 is now off the pixel.
1703   // 0.5 / 1.5 = 0.333...
1704   EXPECT_EQ("0.33 0.33",
1705             Vector2dFTo100thPercisionString(c11->subpixel_position_offset()));
1706 }
1707
1708 class FrameDamageCheckingDelegate : public TestLayerDelegate {
1709  public:
1710   FrameDamageCheckingDelegate() : delegated_frame_damage_called_(false) {}
1711
1712   void OnDelegatedFrameDamage(const gfx::Rect& damage_rect_in_dip) override {
1713     delegated_frame_damage_called_ = true;
1714     delegated_frame_damage_rect_ = damage_rect_in_dip;
1715   }
1716
1717   const gfx::Rect& delegated_frame_damage_rect() const {
1718     return delegated_frame_damage_rect_;
1719   }
1720   bool delegated_frame_damage_called() const {
1721     return delegated_frame_damage_called_;
1722   }
1723
1724  private:
1725   gfx::Rect delegated_frame_damage_rect_;
1726   bool delegated_frame_damage_called_;
1727
1728   DISALLOW_COPY_AND_ASSIGN(FrameDamageCheckingDelegate);
1729 };
1730
1731 TEST(LayerDelegateTest, DelegatedFrameDamage) {
1732   scoped_ptr<Layer> layer(new Layer(LAYER_TEXTURED));
1733   gfx::Rect damage_rect(2, 1, 5, 3);
1734
1735   FrameDamageCheckingDelegate delegate;
1736   layer->set_delegate(&delegate);
1737   scoped_refptr<cc::DelegatedFrameResourceCollection> resource_collection =
1738       new cc::DelegatedFrameResourceCollection;
1739   scoped_refptr<cc::DelegatedFrameProvider> frame_provider(
1740       new cc::DelegatedFrameProvider(resource_collection.get(),
1741                                      MakeFrameData(gfx::Size(10, 10))));
1742   layer->SetShowDelegatedContent(frame_provider.get(), gfx::Size(10, 10));
1743
1744   EXPECT_FALSE(delegate.delegated_frame_damage_called());
1745   layer->OnDelegatedFrameDamage(damage_rect);
1746   EXPECT_TRUE(delegate.delegated_frame_damage_called());
1747   EXPECT_EQ(damage_rect, delegate.delegated_frame_damage_rect());
1748 }
1749
1750 }  // namespace ui