cc: Force commit on the frame after a copy request

cc/trees/layer_tree_host_unittest_copyrequest.cc

 // Copyright 2013 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/layers/layer_iterator.h"
 #include "cc/output/copy_output_request.h"
 #include "cc/output/copy_output_result.h"
 #include "cc/test/fake_content_layer_client.h"
 #include "cc/test/fake_output_surface.h"
 #include "cc/test/fake_picture_layer.h"
@@ skipping 23 matching lines @@
     grand_child->SetBounds(gfx::Size(5, 5));
     child->AddChild(grand_child);
 
     layer_tree_host()->SetRootLayer(root);
     LayerTreeHostCopyRequestTest::SetupTree();
     client_.set_bounds(root->bounds());
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
-  void DidCommitAndDrawFrame() override { WaitForCallback(); }
+  void DidCommit() override { WaitForCallback(); }
 
   void WaitForCallback() {
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(&LayerTreeHostCopyRequestTestMultipleRequests::NextStep,
                    base::Unretained(this)));
   }
 
   void NextStep() {
     int frame = layer_tree_host()->source_frame_number();
     switch (frame) {
       case 1:
         child->RequestCopyOfOutput(CopyOutputRequest::CreateBitmapRequest(
             base::Bind(&LayerTreeHostCopyRequestTestMultipleRequests::
                            CopyOutputCallback,
                        base::Unretained(this), 0)));
         EXPECT_EQ(0u, callbacks_.size());
         break;
       case 2:
+        // This commit is triggered by the copy request having been completed.
+        break;
+      case 3:
         if (callbacks_.size() < 1u) {
           WaitForCallback();
           return;
         }
         EXPECT_EQ(1u, callbacks_.size());
         EXPECT_EQ(gfx::Size(10, 10).ToString(), callbacks_[0].ToString());
 
         child->RequestCopyOfOutput(CopyOutputRequest::CreateBitmapRequest(
             base::Bind(&LayerTreeHostCopyRequestTestMultipleRequests::
                            CopyOutputCallback,
                        base::Unretained(this), 1)));
         root->RequestCopyOfOutput(CopyOutputRequest::CreateBitmapRequest(
             base::Bind(&LayerTreeHostCopyRequestTestMultipleRequests::
                            CopyOutputCallback,
                        base::Unretained(this), 2)));
         grand_child->RequestCopyOfOutput(CopyOutputRequest::CreateBitmapRequest(
             base::Bind(&LayerTreeHostCopyRequestTestMultipleRequests::
                            CopyOutputCallback,
                        base::Unretained(this), 3)));
         EXPECT_EQ(1u, callbacks_.size());
         break;
-      case 3:
+      case 4:
+        // This commit is triggered by the copy request having been completed.
+        break;
+      case 5:
         if (callbacks_.size() < 4u) {
           WaitForCallback();
           return;
         }
         EXPECT_EQ(4u, callbacks_.size());
 
         // The |child| was copied to a bitmap and passed back in Case 1.
         EXPECT_EQ(gfx::Size(10, 10).ToString(), callbacks_[0].ToString());
 
         // The |child| was copied to a bitmap and passed back in Case 2.
@@ skipping 72 matching lines @@
   use_gl_renderer_ = false;
   RunTest(false, false);
 }
 
 TEST_F(LayerTreeHostCopyRequestTestMultipleRequests,
        SoftwareRenderer_RunMultiThread) {
   use_gl_renderer_ = false;
   RunTest(true, false);
 }
 
+// TODO(crbug.com/564832): Remove this test when the workaround it tests is no
+// longer needed.
+class LayerTreeHostCopyRequestCompletionCausesCommit
+    : public LayerTreeHostCopyRequestTest {
+ protected:
+  void SetupTree() override {
+    root_ = FakePictureLayer::Create(layer_settings(), &client_);
+    root_->SetBounds(gfx::Size(20, 20));
+
+    layer_ = FakePictureLayer::Create(layer_settings(), &client_);
+    layer_->SetBounds(gfx::Size(15, 15));
+    root_->AddChild(layer_);
+
+    layer_tree_host()->SetRootLayer(root_);
+    LayerTreeHostCopyRequestTest::SetupTree();
+    client_.set_bounds(root_->bounds());
+  }
+
+  void BeginTest() override {
+    callback_count_ = 0;
+    PostSetNeedsCommitToMainThread();
+  }
+
+  void DidCommit() override {
+    int frame = layer_tree_host()->source_frame_number();
+    switch (frame) {
+      case 1:
+        layer_->RequestCopyOfOutput(CopyOutputRequest::CreateBitmapRequest(
+            base::Bind(&LayerTreeHostCopyRequestCompletionCausesCommit::
+                           CopyOutputCallback,
+                       base::Unretained(this))));
+        EXPECT_EQ(0, callback_count_);
+        break;
+      case 2:
+        // This commit was triggered by the copy request.
+        break;
+      case 3:
+        // This commit was triggered by the completion of the copy request.
+        EXPECT_EQ(1, callback_count_);
+        EndTest();
+        break;
+    }
+  }
+
+  void CopyOutputCallback(scoped_ptr<CopyOutputResult> result) {
+    EXPECT_FALSE(result->IsEmpty());
+    ++callback_count_;
+  }
+
+  void AfterTest() override {}
+
+  int callback_count_;
+  FakeContentLayerClient client_;
+  scoped_refptr<FakePictureLayer> root_;
+  scoped_refptr<FakePictureLayer> layer_;
+};
+
+SINGLE_AND_MULTI_THREAD_DIRECT_RENDERER_TEST_F(
+    LayerTreeHostCopyRequestCompletionCausesCommit);
+
 class LayerTreeHostCopyRequestTestLayerDestroyed
     : public LayerTreeHostCopyRequestTest {
  protected:
   void SetupTree() override {
     root_ = FakePictureLayer::Create(layer_settings(), &client_);
     root_->SetBounds(gfx::Size(20, 20));
 
     main_destroyed_ = FakePictureLayer::Create(layer_settings(), &client_);
     main_destroyed_->SetBounds(gfx::Size(15, 15));
     root_->AddChild(main_destroyed_);
@@ skipping 232 matching lines @@
     LayerImpl* parent = grand_parent->children()[0].get();
     LayerImpl* copy_layer = parent->children()[0].get();
 
     // |parent| owns a surface, but it was hidden and not part of the copy
     // request so it should not allocate any resource.
     EXPECT_FALSE(renderer->HasAllocatedResourcesForTesting(
         parent->render_surface()->GetRenderPassId()));
 
     // |copy_layer| should have been rendered to a texture since it was needed
     // for a copy request.
-    EXPECT_TRUE(renderer->HasAllocatedResourcesForTesting(
-        copy_layer->render_surface()->GetRenderPassId()));
+    if (did_draw_) {
+      // TODO(crbug.com/564832): Ignore the extra frame that occurs due to copy
+      // completion. This can be removed when the extra commit is removed.
+      EXPECT_FALSE(copy_layer->render_surface());
+    } else {
+      EXPECT_TRUE(renderer->HasAllocatedResourcesForTesting(
+          copy_layer->render_surface()->GetRenderPassId()));
+    }
 
     did_draw_ = true;
   }
 
   void AfterTest() override { EXPECT_TRUE(did_draw_); }
 
   FakeContentLayerClient client_;
   bool did_draw_;
   scoped_refptr<FakePictureLayer> root_;
   scoped_refptr<FakePictureLayer> grand_parent_layer_;
@@ skipping 346 matching lines @@
 
   void BeginTest() override {
     num_textures_without_readback_ = 0;
     num_textures_with_readback_ = 0;
     waited_sync_token_after_readback_.Clear();
     PostSetNeedsCommitToMainThread();
   }
 
   virtual void RequestCopy(Layer* layer) = 0;
 
-  void DidCommitAndDrawFrame() override {
+  void DidCommit() override {
     switch (layer_tree_host()->source_frame_number()) {
       case 1:
         // The layers have been pushed to the impl side. The layer textures have
         // been allocated.
         RequestCopy(copy_layer_.get());
         break;
     }
   }
 
   void SwapBuffersOnThread(LayerTreeHostImpl* impl, bool result) override {
@@ skipping 284 matching lines @@
     client_.set_bounds(root->bounds());
   }
 
   void BeginTest() override {
     num_draws_ = 0;
     copy_happened_ = false;
     draw_happened_ = false;
     PostSetNeedsCommitToMainThread();
   }
 
-  void DidCommitAndDrawFrame() override {
+  void DidCommit() override {
     // Send a copy request after the first commit.
     if (layer_tree_host()->source_frame_number() == 1) {
       child_->RequestCopyOfOutput(
           CopyOutputRequest::CreateBitmapRequest(base::Bind(
               &LayerTreeHostCopyRequestTestMultipleDrawsHiddenCopyRequest::
                   CopyOutputCallback,
               base::Unretained(this))));
     }
   }
 
@@ skipping 73 matching lines @@
   int num_draws_;
   bool copy_happened_;
   bool draw_happened_;
 };
 
 SINGLE_AND_MULTI_THREAD_DIRECT_RENDERER_TEST_F(
     LayerTreeHostCopyRequestTestMultipleDrawsHiddenCopyRequest);
 
 }  // namespace
 }  // namespace cc