Split SurfaceFactoryClient Into Four Interfaces

cc/surfaces/surface_factory_unittest.cc

 // Copyright 2014 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/surfaces/surface_factory.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/macros.h"
 #include "cc/output/compositor_frame.h"
 #include "cc/output/copy_output_request.h"
 #include "cc/output/copy_output_result.h"
 #include "cc/resources/resource_provider.h"
+#include "cc/surfaces/framesink_manager_client.h"
 #include "cc/surfaces/surface.h"
 #include "cc/surfaces/surface_factory_client.h"
 #include "cc/surfaces/surface_info.h"
 #include "cc/surfaces/surface_manager.h"
+#include "cc/surfaces/surface_resource_holder_client.h"
+#include "cc/test/fake_surface_resource_holder_client.h"
 #include "cc/test/scheduler_test_common.h"
+#include "cc/test/stub_surface_factory_client.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/geometry/size.h"
 
 namespace cc {
 namespace {
 
 static constexpr FrameSinkId kArbitraryFrameSinkId(1, 1);
 static constexpr FrameSinkId kAnotherArbitraryFrameSinkId(2, 2);
 static const base::UnguessableToken kArbitraryToken =
     base::UnguessableToken::Create();
 static auto kArbitrarySourceId1 =
     base::UnguessableToken::Deserialize(0xdead, 0xbeef);
 static auto kArbitrarySourceId2 =
     base::UnguessableToken::Deserialize(0xdead, 0xbee0);
 
-class TestSurfaceFactoryClient : public SurfaceFactoryClient {
- public:
-  TestSurfaceFactoryClient() : begin_frame_source_(nullptr) {}
-  ~TestSurfaceFactoryClient() override {}
-
-  void ReturnResources(const ReturnedResourceArray& resources) override {
-    returned_resources_.insert(
-        returned_resources_.end(), resources.begin(), resources.end());
-  }
-
-  void SetBeginFrameSource(BeginFrameSource* begin_frame_source) override {
-    begin_frame_source_ = begin_frame_source;
-  }
-
-  const ReturnedResourceArray& returned_resources() const {
-    return returned_resources_;
-  }
-
-  void clear_returned_resources() { returned_resources_.clear(); }
-
-  BeginFrameSource* begin_frame_source() const { return begin_frame_source_; }
-
- private:
-  ReturnedResourceArray returned_resources_;
-  BeginFrameSource* begin_frame_source_;
-
-  DISALLOW_COPY_AND_ASSIGN(TestSurfaceFactoryClient);
-};
-
 gpu::SyncToken GenTestSyncToken(int id) {
   gpu::SyncToken token;
   token.Set(gpu::CommandBufferNamespace::GPU_IO, 0,
             gpu::CommandBufferId::FromUnsafeValue(id), 1);
   return token;
 }
 
 class SurfaceFactoryTest : public testing::Test, public SurfaceObserver {
  public:
   SurfaceFactoryTest()
-      : factory_(
-            new SurfaceFactory(kArbitraryFrameSinkId, &manager_, &client_)),
+      : factory_(new SurfaceFactory(kArbitraryFrameSinkId,
+                                    &manager_,
+                                    &stub_surface_factory_client_,
+                                    &fake_surface_resource_holder_client_)),
         local_surface_id_(3, kArbitraryToken),
         frame_sync_token_(GenTestSyncToken(4)),
         consumer_sync_token_(GenTestSyncToken(5)) {
     manager_.AddObserver(this);
   }
 
   const SurfaceId& last_created_surface_id() const {
     return last_created_surface_id_;
   }
 
@@ skipping 41 matching lines @@
       unref_array.push_back(resource);
     }
     factory_->UnrefResources(unref_array);
   }
 
   void CheckReturnedResourcesMatchExpected(ResourceId* expected_returned_ids,
                                            int* expected_returned_counts,
                                            size_t expected_resources,
                                            gpu::SyncToken expected_sync_token) {
     const ReturnedResourceArray& actual_resources =
-        client_.returned_resources();
+        fake_surface_resource_holder_client_.returned_resources();
     ASSERT_EQ(expected_resources, actual_resources.size());
     for (size_t i = 0; i < expected_resources; ++i) {
       ReturnedResource resource = actual_resources[i];
       EXPECT_EQ(expected_sync_token, resource.sync_token);
       EXPECT_EQ(expected_returned_ids[i], resource.id);
       EXPECT_EQ(expected_returned_counts[i], resource.count);
     }
-    client_.clear_returned_resources();
+    fake_surface_resource_holder_client_.clear_returned_resources();
   }
 
   void RefCurrentFrameResources() {
     Surface* surface = manager_.GetSurfaceForId(
         SurfaceId(factory_->frame_sink_id(), local_surface_id_));
     factory_->RefResources(surface->GetActiveFrame().resource_list);
   }
 
  protected:
   SurfaceManager manager_;
-  TestSurfaceFactoryClient client_;
+  StubSurfaceFactoryClient stub_surface_factory_client_;
+  FakeSurfaceResourceHolderClient fake_surface_resource_holder_client_;
   std::unique_ptr<SurfaceFactory> factory_;
   LocalSurfaceId local_surface_id_;
   SurfaceId last_created_surface_id_;
   SurfaceInfo last_surface_info_;
 
   // This is the sync token submitted with the frame. It should never be
   // returned to the client.
   const gpu::SyncToken frame_sync_token_;
 
   // This is the sync token returned by the consumer. It should always be
   // returned to the client.
   const gpu::SyncToken consumer_sync_token_;
 };
 
 // Tests submitting a frame with resources followed by one with no resources
 // with no resource provider action in between.
 TEST_F(SurfaceFactoryTest, ResourceLifetimeSimple) {
   ResourceId first_frame_ids[] = {1, 2, 3};
   SubmitCompositorFrameWithResources(first_frame_ids,
                                      arraysize(first_frame_ids));
 
   // All of the resources submitted in the first frame are still in use at this
   // time by virtue of being in the pending frame, so none can be returned to
   // the client yet.
-  EXPECT_EQ(0u, client_.returned_resources().size());
-  client_.clear_returned_resources();
+  EXPECT_EQ(0u,
+            fake_surface_resource_holder_client_.returned_resources().size());
+  fake_surface_resource_holder_client_.clear_returned_resources();
 
   // The second frame references no resources of first frame and thus should
   // make all resources of first frame available to be returned.
   SubmitCompositorFrameWithResources(NULL, 0);
 
   ResourceId expected_returned_ids[] = {1, 2, 3};
   int expected_returned_counts[] = {1, 1, 1};
   // Resources were never consumed so no sync token should be set.
   CheckReturnedResourcesMatchExpected(
       expected_returned_ids, expected_returned_counts,
       arraysize(expected_returned_counts), gpu::SyncToken());
 
   ResourceId third_frame_ids[] = {4, 5, 6};
   SubmitCompositorFrameWithResources(third_frame_ids,
                                      arraysize(third_frame_ids));
 
   // All of the resources submitted in the third frame are still in use at this
   // time by virtue of being in the pending frame, so none can be returned to
   // the client yet.
-  EXPECT_EQ(0u, client_.returned_resources().size());
-  client_.clear_returned_resources();
+  EXPECT_EQ(0u,
+            fake_surface_resource_holder_client_.returned_resources().size());
+  fake_surface_resource_holder_client_.clear_returned_resources();
 
   // The forth frame references no resources of third frame and thus should
   // make all resources of third frame available to be returned.
   ResourceId forth_frame_ids[] = {7, 8, 9};
   SubmitCompositorFrameWithResources(forth_frame_ids,
                                      arraysize(forth_frame_ids));
 
   ResourceId forth_expected_returned_ids[] = {4, 5, 6};
   int forth_expected_returned_counts[] = {1, 1, 1};
   // Resources were never consumed so no sync token should be set.
   CheckReturnedResourcesMatchExpected(
       forth_expected_returned_ids, forth_expected_returned_counts,
       arraysize(forth_expected_returned_counts), gpu::SyncToken());
 }
 
 // Tests submitting a frame with resources followed by one with no resources
 // with the resource provider holding everything alive.
 TEST_F(SurfaceFactoryTest, ResourceLifetimeSimpleWithProviderHoldingAlive) {
   ResourceId first_frame_ids[] = {1, 2, 3};
   SubmitCompositorFrameWithResources(first_frame_ids,
                                      arraysize(first_frame_ids));
 
   // All of the resources submitted in the first frame are still in use at this
   // time by virtue of being in the pending frame, so none can be returned to
   // the client yet.
-  EXPECT_EQ(0u, client_.returned_resources().size());
-  client_.clear_returned_resources();
+  EXPECT_EQ(0u,
+            fake_surface_resource_holder_client_.returned_resources().size());
+  fake_surface_resource_holder_client_.clear_returned_resources();
 
   // Hold on to everything.
   RefCurrentFrameResources();
 
   // The second frame references no resources and thus should make all resources
   // available to be returned as soon as the resource provider releases them.
   SubmitCompositorFrameWithResources(NULL, 0);
 
-  EXPECT_EQ(0u, client_.returned_resources().size());
-  client_.clear_returned_resources();
+  EXPECT_EQ(0u,
+            fake_surface_resource_holder_client_.returned_resources().size());
+  fake_surface_resource_holder_client_.clear_returned_resources();
 
   int release_counts[] = {1, 1, 1};
   UnrefResources(first_frame_ids, release_counts, arraysize(first_frame_ids));
 
   ResourceId expected_returned_ids[] = {1, 2, 3};
   int expected_returned_counts[] = {1, 1, 1};
   CheckReturnedResourcesMatchExpected(
       expected_returned_ids, expected_returned_counts,
       arraysize(expected_returned_counts), consumer_sync_token_);
 }
@@ skipping 11 matching lines @@
   // This references id 7 again.
   SubmitCompositorFrameWithResources(first_frame_ids,
                                      arraysize(first_frame_ids));
 
   // This removes it again.
   SubmitCompositorFrameWithResources(NULL, 0);
 
   // Now it should be returned.
   // We don't care how many entries are in the returned array for 7, so long as
   // the total returned count matches the submitted count.
-  const ReturnedResourceArray& returned = client_.returned_resources();
+  const ReturnedResourceArray& returned =
+      fake_surface_resource_holder_client_.returned_resources();
   size_t return_count = 0;
   for (size_t i = 0; i < returned.size(); ++i) {
     EXPECT_EQ(7u, returned[i].id);
     return_count += returned[i].count;
   }
   EXPECT_EQ(2u, return_count);
 }
 
 // Tests having resources referenced multiple times, as if referenced by
 // multiple providers.
@@ skipping 12 matching lines @@
 
   // Ref resources from the second frame 3 times.
   RefCurrentFrameResources();
   RefCurrentFrameResources();
   RefCurrentFrameResources();
 
   // Submit a frame with no resources to remove all current frame refs from
   // submitted resources.
   SubmitCompositorFrameWithResources(NULL, 0);
 
-  EXPECT_EQ(0u, client_.returned_resources().size());
-  client_.clear_returned_resources();
+  EXPECT_EQ(0u,
+            fake_surface_resource_holder_client_.returned_resources().size());
+  fake_surface_resource_holder_client_.clear_returned_resources();
 
   // Expected current refs:
   //  3 -> 2
   //  4 -> 2 + 3 = 5
   //  5 -> 3
   {
     SCOPED_TRACE("unref all 3");
     ResourceId ids_to_unref[] = {3, 4, 5};
     int counts[] = {1, 1, 1};
     UnrefResources(ids_to_unref, counts, arraysize(ids_to_unref));
 
-    EXPECT_EQ(0u, client_.returned_resources().size());
-    client_.clear_returned_resources();
+    EXPECT_EQ(0u,
+              fake_surface_resource_holder_client_.returned_resources().size());
+    fake_surface_resource_holder_client_.clear_returned_resources();
 
     UnrefResources(ids_to_unref, counts, arraysize(ids_to_unref));
 
     ResourceId expected_returned_ids[] = {3};
     int expected_returned_counts[] = {1};
     CheckReturnedResourcesMatchExpected(
         expected_returned_ids, expected_returned_counts,
         arraysize(expected_returned_counts), consumer_sync_token_);
   }
 
@@ skipping 30 matching lines @@
 }
 
 TEST_F(SurfaceFactoryTest, ResourceLifetime) {
   ResourceId first_frame_ids[] = {1, 2, 3};
   SubmitCompositorFrameWithResources(first_frame_ids,
                                      arraysize(first_frame_ids));
 
   // All of the resources submitted in the first frame are still in use at this
   // time by virtue of being in the pending frame, so none can be returned to
   // the client yet.
-  EXPECT_EQ(0u, client_.returned_resources().size());
-  client_.clear_returned_resources();
+  EXPECT_EQ(0u,
+            fake_surface_resource_holder_client_.returned_resources().size());
+  fake_surface_resource_holder_client_.clear_returned_resources();
 
   // The second frame references some of the same resources, but some different
   // ones. We expect to receive back resource 1 with a count of 1 since it was
   // only referenced by the first frame.
   ResourceId second_frame_ids[] = {2, 3, 4};
   SubmitCompositorFrameWithResources(second_frame_ids,
                                      arraysize(second_frame_ids));
 
   {
     SCOPED_TRACE("second frame");
@@ skipping 21 matching lines @@
         arraysize(expected_returned_counts), gpu::SyncToken());
   }
 
   // Simulate a ResourceProvider taking a ref on all of the resources.
   RefCurrentFrameResources();
 
   ResourceId fourth_frame_ids[] = {12, 13};
   SubmitCompositorFrameWithResources(fourth_frame_ids,
                                      arraysize(fourth_frame_ids));
 
-  EXPECT_EQ(0u, client_.returned_resources().size());
+  EXPECT_EQ(0u,
+            fake_surface_resource_holder_client_.returned_resources().size());
 
   RefCurrentFrameResources();
 
   // All resources are still being used by the external reference, so none can
   // be returned to the client.
-  EXPECT_EQ(0u, client_.returned_resources().size());
+  EXPECT_EQ(0u,
+            fake_surface_resource_holder_client_.returned_resources().size());
 
   // Release resources associated with the first RefCurrentFrameResources() call
   // first.
   {
     ResourceId ids_to_unref[] = {10, 11, 12, 13};
     int counts[] = {1, 1, 1, 1};
     UnrefResources(ids_to_unref, counts, arraysize(ids_to_unref));
   }
 
   {
     SCOPED_TRACE("fourth frame, first unref");
     ResourceId expected_returned_ids[] = {10, 11};
     int expected_returned_counts[] = {1, 1};
     CheckReturnedResourcesMatchExpected(
         expected_returned_ids, expected_returned_counts,
         arraysize(expected_returned_counts), consumer_sync_token_);
   }
 
   {
     ResourceId ids_to_unref[] = {12, 13};
     int counts[] = {1, 1};
     UnrefResources(ids_to_unref, counts, arraysize(ids_to_unref));
   }
 
   // Resources 12 and 13 are still in use by the current frame, so they
   // shouldn't be available to be returned.
-  EXPECT_EQ(0u, client_.returned_resources().size());
+  EXPECT_EQ(0u,
+            fake_surface_resource_holder_client_.returned_resources().size());
 
   // If we submit an empty frame, however, they should become available.
   SubmitCompositorFrameWithResources(NULL, 0u);
 
   {
     SCOPED_TRACE("fourth frame, second unref");
     ResourceId expected_returned_ids[] = {12, 13};
     int expected_returned_counts[] = {2, 2};
     CheckReturnedResourcesMatchExpected(
         expected_returned_ids, expected_returned_counts,
@@ skipping 52 matching lines @@
   CompositorFrame frame;
   frame.resource_list.push_back(resource);
   uint32_t execute_count = 0;
   factory_->SubmitCompositorFrame(local_surface_id, std::move(frame),
                                   base::Bind(&DrawCallback, &execute_count),
                                   SurfaceFactory::WillDrawCallback());
   EXPECT_EQ(last_created_surface_id().local_surface_id(), local_surface_id);
   local_surface_id_ = LocalSurfaceId();
 
   EXPECT_TRUE(manager_.GetSurfaceForId(id));
-  EXPECT_TRUE(client_.returned_resources().empty());
+  EXPECT_TRUE(
+      fake_surface_resource_holder_client_.returned_resources().empty());
   factory_->EvictSurface();
   EXPECT_FALSE(manager_.GetSurfaceForId(id));
-  EXPECT_FALSE(client_.returned_resources().empty());
+  EXPECT_FALSE(
+      fake_surface_resource_holder_client_.returned_resources().empty());
   EXPECT_EQ(1u, execute_count);
 }
 
 // Tests doing an EvictSurface which has unregistered dependency.
 TEST_F(SurfaceFactoryTest, EvictSurfaceDependencyUnRegistered) {
   LocalSurfaceId local_surface_id(7, kArbitraryToken);
 
   TransferableResource resource;
   resource.id = 1;
   resource.mailbox_holder.texture_target = GL_TEXTURE_2D;
   CompositorFrame frame;
   frame.resource_list.push_back(resource);
   uint32_t execute_count = 0;
   factory_->SubmitCompositorFrame(local_surface_id, std::move(frame),
                                   base::Bind(&DrawCallback, &execute_count),
                                   SurfaceFactory::WillDrawCallback());
   EXPECT_EQ(last_created_surface_id().local_surface_id(), local_surface_id);
   local_surface_id_ = LocalSurfaceId();
 
   SurfaceId surface_id(kArbitraryFrameSinkId, local_surface_id);
   Surface* surface = manager_.GetSurfaceForId(surface_id);
   surface->AddDestructionDependency(
       SurfaceSequence(kAnotherArbitraryFrameSinkId, 4));
 
   EXPECT_TRUE(manager_.GetSurfaceForId(surface_id));
-  EXPECT_TRUE(client_.returned_resources().empty());
+  EXPECT_TRUE(
+      fake_surface_resource_holder_client_.returned_resources().empty());
   factory_->EvictSurface();
   EXPECT_FALSE(manager_.GetSurfaceForId(surface_id));
-  EXPECT_FALSE(client_.returned_resources().empty());
+  EXPECT_FALSE(
+      fake_surface_resource_holder_client_.returned_resources().empty());
   EXPECT_EQ(1u, execute_count);
 }
 
 // Tests doing an EvictSurface which has registered dependency.
 TEST_F(SurfaceFactoryTest, EvictSurfaceDependencyRegistered) {
   LocalSurfaceId local_surface_id(7, kArbitraryToken);
 
   TransferableResource resource;
   resource.id = 1;
   resource.mailbox_holder.texture_target = GL_TEXTURE_2D;
   CompositorFrame frame;
   frame.resource_list.push_back(resource);
   uint32_t execute_count = 0;
   factory_->SubmitCompositorFrame(local_surface_id, std::move(frame),
                                   base::Bind(&DrawCallback, &execute_count),
                                   SurfaceFactory::WillDrawCallback());
   EXPECT_EQ(last_created_surface_id().local_surface_id(), local_surface_id);
   local_surface_id_ = LocalSurfaceId();
 
   manager_.RegisterFrameSinkId(kAnotherArbitraryFrameSinkId);
 
   SurfaceId surface_id(kArbitraryFrameSinkId, local_surface_id);
   Surface* surface = manager_.GetSurfaceForId(surface_id);
   surface->AddDestructionDependency(
       SurfaceSequence(kAnotherArbitraryFrameSinkId, 4));
 
   EXPECT_TRUE(manager_.GetSurfaceForId(surface_id));
-  EXPECT_TRUE(client_.returned_resources().empty());
+  EXPECT_TRUE(
+      fake_surface_resource_holder_client_.returned_resources().empty());
   factory_->EvictSurface();
   EXPECT_TRUE(manager_.GetSurfaceForId(surface_id));
-  EXPECT_TRUE(client_.returned_resources().empty());
+  EXPECT_TRUE(
+      fake_surface_resource_holder_client_.returned_resources().empty());
   EXPECT_EQ(0u, execute_count);
 
   manager_.SatisfySequence(SurfaceSequence(kAnotherArbitraryFrameSinkId, 4));
   EXPECT_FALSE(manager_.GetSurfaceForId(surface_id));
-  EXPECT_FALSE(client_.returned_resources().empty());
+  EXPECT_FALSE(
+      fake_surface_resource_holder_client_.returned_resources().empty());
 }
 
 TEST_F(SurfaceFactoryTest, DestroySequence) {
   LocalSurfaceId local_surface_id2(5, kArbitraryToken);
-  std::unique_ptr<SurfaceFactory> factory2(
-      new SurfaceFactory(kArbitraryFrameSinkId, &manager_, &client_));
+  std::unique_ptr<SurfaceFactory> factory2(new SurfaceFactory(
+      kArbitraryFrameSinkId, &manager_, &stub_surface_factory_client_,
+      &fake_surface_resource_holder_client_));
   SurfaceId id2(kArbitraryFrameSinkId, local_surface_id2);
   factory2->SubmitCompositorFrame(local_surface_id2, CompositorFrame(),
                                   SurfaceFactory::DrawCallback(),
                                   SurfaceFactory::WillDrawCallback());
 
   manager_.RegisterFrameSinkId(kArbitraryFrameSinkId);
 
   // Check that waiting before the sequence is satisfied works.
   manager_.GetSurfaceForId(id2)->AddDestructionDependency(
       SurfaceSequence(kArbitraryFrameSinkId, 4));
@@ skipping 38 matching lines @@
   manager_.InvalidateFrameSinkId(frame_sink_id);
 
   // Verify that the invalidated namespace caused the unsatisfied sequence
   // to be ignored.
   EXPECT_FALSE(manager_.GetSurfaceForId(id));
 }
 
 TEST_F(SurfaceFactoryTest, DestroyCycle) {
   LocalSurfaceId local_surface_id2(5, kArbitraryToken);
   SurfaceId id2(kArbitraryFrameSinkId, local_surface_id2);
-  std::unique_ptr<SurfaceFactory> factory2(
-      new SurfaceFactory(kArbitraryFrameSinkId, &manager_, &client_));
+  std::unique_ptr<SurfaceFactory> factory2(new SurfaceFactory(
+      kArbitraryFrameSinkId, &manager_, &stub_surface_factory_client_,
+      &fake_surface_resource_holder_client_));
   manager_.RegisterFrameSinkId(kAnotherArbitraryFrameSinkId);
   // Give id2 a frame that references local_surface_id_.
   {
     std::unique_ptr<RenderPass> render_pass(RenderPass::Create());
     CompositorFrame frame;
     frame.render_pass_list.push_back(std::move(render_pass));
     frame.metadata.referenced_surfaces.push_back(
         SurfaceId(factory_->frame_sink_id(), local_surface_id_));
     factory2->SubmitCompositorFrame(local_surface_id2, std::move(frame),
                                     SurfaceFactory::DrawCallback(),
@@ skipping 105 matching lines @@
                                   SurfaceFactory::DrawCallback(),
                                   SurfaceFactory::WillDrawCallback());
   SurfaceId expected_surface_id(factory_->frame_sink_id(), local_surface_id_);
   EXPECT_EQ(expected_surface_id, last_surface_info_.id());
   EXPECT_EQ(2.5f, last_surface_info_.device_scale_factor());
   EXPECT_EQ(gfx::Size(7, 8), last_surface_info_.size_in_pixels());
 }
 
 }  // namespace
 }  // namespace cc