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/frame_sink_manager_client.h"
 #include "cc/surfaces/surface.h"
+#include "cc/surfaces/surface_aggregator_client.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/scheduler_test_common.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 {
+class TestClient : public SurfaceFactoryClient,
+                   public SurfaceResourceHolderClient,
+                   public SurfaceAggregatorClient,
+                   public FrameSinkManagerClient {
  public:
-  TestSurfaceFactoryClient() : begin_frame_source_(nullptr) {}
-  ~TestSurfaceFactoryClient() override {}
+  TestClient() {}
+  ~TestClient() override {}
+
+  void ReferencedSurfacesChanged(
+      const LocalSurfaceId& local_surface_id,
+      const std::vector<SurfaceId>* active_referenced_surfaces) override {}
 
   void ReturnResources(const ReturnedResourceArray& resources) override {
-    returned_resources_.insert(
-        returned_resources_.end(), resources.begin(), resources.end());
+    returned_resources_.insert(returned_resources_.end(), resources.begin(),
+                               resources.end());
   }
 
-  void SetBeginFrameSource(BeginFrameSource* begin_frame_source) override {
-    begin_frame_source_ = begin_frame_source;
-  }
+  void WillDrawSurface(const LocalSurfaceId& local_surface_id,
+                       const gfx::Rect& damage_rect) override {}
+
+  void SetBeginFrameSource(BeginFrameSource* begin_frame_source) override {}
 
   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);
+  DISALLOW_COPY_AND_ASSIGN(TestClient);
 };
 
 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_,
+                                    &client_,
+                                    &client_,
+                                    &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 59 matching lines @@
   }
 
   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_;
+  TestClient 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
@@ skipping 409 matching lines @@
   EXPECT_TRUE(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());
 }
 
 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_, &client_, &client_, &client_));
   SurfaceId id2(kArbitraryFrameSinkId, local_surface_id2);
   factory2->SubmitCompositorFrame(local_surface_id2, CompositorFrame(),
                                   SurfaceFactory::DrawCallback());
 
   manager_.RegisterFrameSinkId(kArbitraryFrameSinkId);
 
   // Check that waiting before the sequence is satisfied works.
   manager_.GetSurfaceForId(id2)->AddDestructionDependency(
       SurfaceSequence(kArbitraryFrameSinkId, 4));
   factory2->EvictSurface();
@@ skipping 35 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_, &client_, &client_, &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 101 matching lines @@
   factory_->SubmitCompositorFrame(local_surface_id_, std::move(frame),
                                   SurfaceFactory::DrawCallback());
   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