cc: Make LayerTreeTests use a DelegatingRenderer and Display.

cc/layers/texture_layer_unittest.cc

 // Copyright 2012 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/texture_layer.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 16 matching lines @@
 #include "cc/layers/texture_layer_impl.h"
 #include "cc/output/context_provider.h"
 #include "cc/resources/returned_resource.h"
 #include "cc/test/fake_impl_task_runner_provider.h"
 #include "cc/test/fake_layer_tree_host_client.h"
 #include "cc/test/fake_layer_tree_host_impl.h"
 #include "cc/test/fake_output_surface.h"
 #include "cc/test/layer_test_common.h"
 #include "cc/test/layer_tree_test.h"
 #include "cc/test/stub_layer_tree_host_single_thread_client.h"
+#include "cc/test/test_delegating_output_surface.h"
 #include "cc/test/test_task_graph_runner.h"
 #include "cc/test/test_web_graphics_context_3d.h"
 #include "cc/trees/blocking_task_runner.h"
 #include "cc/trees/layer_tree_host.h"
 #include "cc/trees/layer_tree_impl.h"
 #include "cc/trees/single_thread_proxy.h"
 #include "gpu/GLES2/gl2extchromium.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ skipping 577 matching lines @@
                    main_thread_task_runner_.get());
 
   stop_capture.Signal();
   Wait(main_thread_);
 
   Mock::VerifyAndClearExpectations(&test_data_.mock_callback_);
 }
 
 class TextureLayerImplWithMailboxThreadedCallback : public LayerTreeTest {
  public:
-  TextureLayerImplWithMailboxThreadedCallback()
-      : callback_count_(0),
-        commit_count_(0) {}
+  TextureLayerImplWithMailboxThreadedCallback() = default;
+
+  std::unique_ptr<TestDelegatingOutputSurface> CreateDelegatingOutputSurface(
+      scoped_refptr<ContextProvider> compositor_context_provider,
+      scoped_refptr<ContextProvider> worker_context_provider) override {
+    bool synchronous_composite =
+        !HasImplThread() &&
+        !layer_tree_host()->settings().single_thread_proxy_scheduler;
+    // Allow relaim resources for this test so that mailboxes in the display
+    // will be returned inside the commit that replaces them.
+    bool force_disable_reclaim_resources = false;
+    return base::MakeUnique<TestDelegatingOutputSurface>(
+        compositor_context_provider, std::move(worker_context_provider),
+        CreateDisplayOutputSurface(compositor_context_provider),
+        shared_bitmap_manager(), gpu_memory_buffer_manager(),
+        layer_tree_host()->settings().renderer_settings, ImplThreadTaskRunner(),
+        synchronous_composite, force_disable_reclaim_resources);
+  }
 
   // Make sure callback is received on main and doesn't block the impl thread.
-  void ReleaseCallback(const gpu::SyncToken& sync_token, bool lost_resource) {
+  void ReleaseCallback(char mailbox_char,
+                       const gpu::SyncToken& sync_token,
+                       bool lost_resource) {
     EXPECT_EQ(true, main_thread_.CalledOnValidThread());
     EXPECT_FALSE(lost_resource);
     ++callback_count_;
   }
 
   void SetMailbox(char mailbox_char) {
     EXPECT_EQ(true, main_thread_.CalledOnValidThread());
     std::unique_ptr<SingleReleaseCallback> callback =
         SingleReleaseCallback::Create(base::Bind(
             &TextureLayerImplWithMailboxThreadedCallback::ReleaseCallback,
-            base::Unretained(this)));
+            base::Unretained(this), mailbox_char));
     layer_->SetTextureMailbox(
         TextureMailbox(MailboxFromChar(mailbox_char),
                        SyncTokenFromUInt(static_cast<uint32_t>(mailbox_char)),
                        GL_TEXTURE_2D),
         std::move(callback));
+    // Damage the layer so we send a new frame with the new mailbox to the
+    // Display compositor.
+    layer_->SetNeedsDisplay();
   }
 
   void BeginTest() override {
     EXPECT_EQ(true, main_thread_.CalledOnValidThread());
 
     gfx::Size bounds(100, 100);
     root_ = Layer::Create();
     root_->SetBounds(bounds);
 
     layer_ = TextureLayer::CreateForMailbox(nullptr);
@@ skipping 30 matching lines @@
         layer_->SetBounds(gfx::Size());
         SetMailbox('4');
         break;
       case 3:
         EXPECT_EQ(3, callback_count_);
         // Case #4: release mailbox that was committed but never drawn. The
         // old mailbox should be released during the next commit.
         layer_->SetTextureMailbox(TextureMailbox(), nullptr);
         break;
       case 4:
-        // With impl painting, the texture mailbox will still be on the impl
-        // thread when the commit finishes, because the layer is not drawble
-        // when it has no texture mailbox, and thus does not block the commit
-        // on activation. So, we wait for activation.
-        // TODO(danakj): fix this. crbug.com/277953
-        layer_tree_host()->SetNeedsCommit();
-        break;
-      case 5:
         EXPECT_EQ(4, callback_count_);
         // Restore a mailbox for the next step.
         SetMailbox('5');
         break;
-      case 6:
+      case 5:
         // Case #5: remove layer from tree. Callback should *not* be called, the
         // mailbox is returned to the main thread.
         EXPECT_EQ(4, callback_count_);
         layer_->RemoveFromParent();
         break;
-      case 7:
-        // With impl painting, the texture mailbox will still be on the impl
-        // thread when the commit finishes, because the layer is not around to
-        // block the commit on activation anymore. So, we wait for activation.
-        // TODO(danakj): fix this. crbug.com/277953
-        layer_tree_host()->SetNeedsCommit();
-        break;
-      case 8:
+      case 6:
         EXPECT_EQ(4, callback_count_);
         // Resetting the mailbox will call the callback now.
         layer_->SetTextureMailbox(TextureMailbox(), nullptr);
         EXPECT_EQ(5, callback_count_);
         EndTest();
         break;
       default:
         NOTREACHED();
         break;
     }
   }
 
   void AfterTest() override {}
 
  private:
   base::ThreadChecker main_thread_;
-  int callback_count_;
-  int commit_count_;
+  int callback_count_ = 0;
+  int commit_count_ = 0;
   scoped_refptr<Layer> root_;
   scoped_refptr<TextureLayer> layer_;
 };
 
 SINGLE_AND_MULTI_THREAD_DIRECT_RENDERER_TEST_F(
     TextureLayerImplWithMailboxThreadedCallback);
 
 
 class TextureLayerMailboxIsActivatedDuringCommit : public LayerTreeTest {
  protected:
@@ skipping 689 matching lines @@
   int callback_count_;
   scoped_refptr<Layer> root_;
   scoped_refptr<TextureLayer> layer_;
 };
 
 SINGLE_AND_MULTI_THREAD_DIRECT_RENDERER_TEST_F(
     TextureLayerWithMailboxImplThreadDeleted);
 
 }  // namespace
 }  // namespace cc