cc: Single-threaded impl-side painting for unit tests

cc/trees/layer_tree_host_unittest.cc

 // Copyright 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/trees/layer_tree_host.h"
 
 #include <algorithm>
 
 #include "base/auto_reset.h"
 #include "base/synchronization/lock.h"
@@ skipping 511 matching lines @@
   virtual void AfterTest() override { EXPECT_EQ(5, num_draws_); }
 
  private:
   int num_draws_;
   const gfx::Size bounds_;
   const gfx::Rect invalid_rect_;
   FakeContentLayerClient client_;
   scoped_refptr<ContentLayer> root_layer_;
 };
 
-SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestSetNextCommitForcesRedraw);
+SINGLE_AND_MULTI_THREAD_BLOCKNOTIFY_TEST_F(
+    LayerTreeHostTestSetNextCommitForcesRedraw);
 
 // Tests that if a layer is not drawn because of some reason in the parent then
 // its damage is preserved until the next time it is drawn.
 class LayerTreeHostTestUndrawnLayersDamageLater : public LayerTreeHostTest {
  public:
   LayerTreeHostTestUndrawnLayersDamageLater()
       : root_layer_(ContentLayer::Create(&client_)) {}
 
   virtual void SetupTree() override {
     root_layer_->SetIsDrawable(true);
@@ skipping 187 matching lines @@
 
   virtual void BeginTest() override {
     layer_tree_host()->SetViewportSize(gfx::Size(20, 20));
     layer_tree_host()->set_background_color(SK_ColorGRAY);
 
     PostSetNeedsCommitToMainThread();
   }
 
   virtual void BeginCommitOnThread(LayerTreeHostImpl* impl) override {
     EXPECT_EQ(frame_count_with_pending_tree_, 0);
-    impl->BlockNotifyReadyToActivateForTesting(true);
+    if (impl->settings().impl_side_painting)
+      impl->BlockNotifyReadyToActivateForTesting(true);
   }
 
   virtual void WillBeginImplFrameOnThread(LayerTreeHostImpl* impl,
                                           const BeginFrameArgs& args) override {
     if (impl->pending_tree())
       frame_count_with_pending_tree_++;
 
     if (frame_count_with_pending_tree_ == 1) {
       EXPECT_EQ(first_frame_time_.ToInternalValue(), 0);
       first_frame_time_ = impl->CurrentBeginFrameArgs().frame_time;
-    } else if (frame_count_with_pending_tree_ == 2) {
+    } else if (frame_count_with_pending_tree_ == 2 &&
+               impl->settings().impl_side_painting) {
       impl->BlockNotifyReadyToActivateForTesting(false);
     }
   }
 
   virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) override {
     if (frame_count_with_pending_tree_ > 1) {
       EXPECT_NE(first_frame_time_.ToInternalValue(), 0);
       EXPECT_NE(first_frame_time_.ToInternalValue(),
                 impl->CurrentBeginFrameArgs().frame_time.ToInternalValue());
       EndTest();
       return;
     }
 
     EXPECT_FALSE(impl->settings().impl_side_painting);
     EndTest();
   }
   virtual void DidActivateTreeOnThread(LayerTreeHostImpl* impl) override {
     if (impl->settings().impl_side_painting)
       EXPECT_NE(frame_count_with_pending_tree_, 1);
   }
 
   virtual void AfterTest() override {}
 
  private:
   int frame_count_with_pending_tree_;
   base::TimeTicks first_frame_time_;
 };
 
-SINGLE_AND_MULTI_THREAD_TEST_F(
+SINGLE_AND_MULTI_THREAD_BLOCKNOTIFY_TEST_F(
     LayerTreeHostTestFrameTimeUpdatesAfterActivationFails);
 
 // This test verifies that LayerTreeHostImpl's current frame time gets
 // updated in consecutive frames when it draws in each frame.
 class LayerTreeHostTestFrameTimeUpdatesAfterDraw : public LayerTreeHostTest {
  public:
   LayerTreeHostTestFrameTimeUpdatesAfterDraw() : frame_(0) {}
 
   virtual void BeginTest() override {
     layer_tree_host()->SetViewportSize(gfx::Size(20, 20));
@@ skipping 1608 matching lines @@
 
     virtual bool FillsBoundsCompletely() const override { return false; }
 
    private:
     Layer* layer_;
   };
 
   LayerTreeHostTestChangeLayerPropertiesInPaintContents() : num_commits_(0) {}
 
   virtual void SetupTree() override {
-    scoped_refptr<ContentLayer> root_layer = ContentLayer::Create(&client_);
+    if (layer_tree_host()->settings().impl_side_painting) {
+      scoped_refptr<PictureLayer> root_layer = PictureLayer::Create(&client_);
+      layer_tree_host()->SetRootLayer(root_layer);
+    } else {
+      scoped_refptr<ContentLayer> root_layer = ContentLayer::Create(&client_);
+      layer_tree_host()->SetRootLayer(root_layer);
+    }
+    Layer* root_layer = layer_tree_host()->root_layer();
     root_layer->SetIsDrawable(true);
     root_layer->SetBounds(gfx::Size(1, 1));
 
-    layer_tree_host()->SetRootLayer(root_layer);
-    client_.set_layer(root_layer.get());
+    client_.set_layer(root_layer);
 
     LayerTreeHostTest::SetupTree();
   }
 
   virtual void BeginTest() override { PostSetNeedsCommitToMainThread(); }
   virtual void AfterTest() override {}
 
-  virtual void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) override {
+  virtual void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) override {
     num_commits_++;
     if (num_commits_ == 1) {
       LayerImpl* root_layer = host_impl->active_tree()->root_layer();
       EXPECT_SIZE_EQ(gfx::Size(1, 1), root_layer->bounds());
     } else {
       LayerImpl* root_layer = host_impl->active_tree()->root_layer();
       EXPECT_SIZE_EQ(gfx::Size(2, 2), root_layer->bounds());
       EndTest();
     }
   }
 
  private:
   SetBoundsClient client_;
   int num_commits_;
 };
 
-SINGLE_THREAD_TEST_F(LayerTreeHostTestChangeLayerPropertiesInPaintContents);
+SINGLE_AND_MULTI_THREAD_TEST_F(
+    LayerTreeHostTestChangeLayerPropertiesInPaintContents);
 
 class MockIOSurfaceWebGraphicsContext3D : public TestWebGraphicsContext3D {
  public:
   MockIOSurfaceWebGraphicsContext3D() {
     test_capabilities_.gpu.iosurface = true;
     test_capabilities_.gpu.texture_rectangle = true;
   }
 
   virtual GLuint createTexture() override {
     return 1;
@@ skipping 2622 matching lines @@
   int activation_count_;
   bool visible_;
 
   FakeContentLayerClient client_;
   scoped_refptr<FakePictureLayer> picture_layer_;
 };
 
 // TODO(vmpstr): Enable with single thread impl-side painting.
 MULTI_THREAD_TEST_F(LayerTreeHostTestActivateOnInvisible);
 
+// Do a synchronous composite and assert that the swap promise succeeds.
+class LayerTreeHostTestSynchronousCompositeSwapPromise
+    : public LayerTreeHostTest {
+ public:
+  LayerTreeHostTestSynchronousCompositeSwapPromise() : commit_count_(0) {}
+
+  virtual void InitializeSettings(LayerTreeSettings* settings) override {
+    settings->single_thread_proxy_scheduler = false;
+  }
+
+  virtual void BeginTest() override {
+    // Successful composite.
+    scoped_ptr<SwapPromise> swap_promise0(
+        new TestSwapPromise(&swap_promise_result_[0]));
+    layer_tree_host()->QueueSwapPromise(swap_promise0.Pass());
+    layer_tree_host()->Composite(gfx::FrameTime::Now());
+
+    // Fail to swap (no damage).
+    scoped_ptr<SwapPromise> swap_promise1(
+        new TestSwapPromise(&swap_promise_result_[1]));
+    layer_tree_host()->QueueSwapPromise(swap_promise1.Pass());
+    layer_tree_host()->SetNeedsCommit();
+    layer_tree_host()->Composite(gfx::FrameTime::Now());
+
+    // Fail to draw (not visible).
+    scoped_ptr<SwapPromise> swap_promise2(
+        new TestSwapPromise(&swap_promise_result_[2]));
+    layer_tree_host()->QueueSwapPromise(swap_promise2.Pass());
+    layer_tree_host()->SetNeedsDisplayOnAllLayers();
+    layer_tree_host()->SetVisible(false);
+    layer_tree_host()->Composite(gfx::FrameTime::Now());
+
+    EndTest();
+  }
+
+  virtual void DidCommit() override {
+    commit_count_++;
+    ASSERT_LE(commit_count_, 3);
+  }
+
+  virtual void AfterTest() override {
+    EXPECT_EQ(3, commit_count_);
+
+    // Initial swap promise should have succeded.
+    {
+      base::AutoLock lock(swap_promise_result_[0].lock);
+      EXPECT_TRUE(swap_promise_result_[0].did_swap_called);
+      EXPECT_FALSE(swap_promise_result_[0].did_not_swap_called);
+      EXPECT_TRUE(swap_promise_result_[0].dtor_called);
+    }
+
+    // Second swap promise fails to swap.
+    {
+      base::AutoLock lock(swap_promise_result_[1].lock);
+      EXPECT_FALSE(swap_promise_result_[1].did_swap_called);
+      EXPECT_TRUE(swap_promise_result_[1].did_not_swap_called);
+      EXPECT_EQ(SwapPromise::SWAP_FAILS, swap_promise_result_[1].reason);
+      EXPECT_TRUE(swap_promise_result_[1].dtor_called);
+    }
+
+    // Third swap promises also fails to swap (and draw).
+    {
+      base::AutoLock lock(swap_promise_result_[2].lock);
+      EXPECT_FALSE(swap_promise_result_[2].did_swap_called);
+      EXPECT_TRUE(swap_promise_result_[2].did_not_swap_called);
+      EXPECT_EQ(SwapPromise::SWAP_FAILS, swap_promise_result_[2].reason);
+      EXPECT_TRUE(swap_promise_result_[2].dtor_called);
+    }
+  }
+
+  int commit_count_;
+  TestSwapPromiseResult swap_promise_result_[3];
+};
+
+// Impl-side painting is not supported for synchronous compositing.
+SINGLE_THREAD_NOIMPL_TEST_F(LayerTreeHostTestSynchronousCompositeSwapPromise);
+
 }  // namespace cc