[cc]Replace use of SurfaceFactory with CompositorFrameSinkSupport in tests

cc/surfaces/surface_manager_unittest.cc

 // Copyright 2016 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 <stddef.h>
 
 #include "cc/scheduler/begin_frame_source.h"
-#include "cc/surfaces/surface_factory_client.h"
+#include "cc/surfaces/compositor_frame_sink_support.h"
 #include "cc/surfaces/surface_manager.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace cc {
 
-class FakeSurfaceFactoryClient : public SurfaceFactoryClient {
+class FakeSurfaceFactoryClient : public CompositorFrameSinkSupport {

[Fady Samuel, 2017/04/03 22:33:25]

Can we get rid of this entirely?

[Alex Z., 2017/04/04 14:10:33]

Done.

  public:
-  explicit FakeSurfaceFactoryClient(const FrameSinkId& frame_sink_id)
-      : source_(nullptr), manager_(nullptr), frame_sink_id_(frame_sink_id) {}
-
   FakeSurfaceFactoryClient(const FrameSinkId& frame_sink_id,
                            SurfaceManager* manager)
-      : source_(nullptr), manager_(nullptr), frame_sink_id_(frame_sink_id) {
+      : CompositorFrameSinkSupport(nullptr,
+                                   manager,
+                                   frame_sink_id,
+                                   false /* is_root */,
+                                   false /* handles_frame_sink_id_validation */,
+                                   true /* needs_sync_points */),
+        source_(nullptr),
+        manager_(nullptr),
+        frame_sink_id_(frame_sink_id) {
     DCHECK(manager);
     Register(manager);
   }
 
-  ~FakeSurfaceFactoryClient() override {
-    if (manager_) {
-      Unregister();
-    }
-    EXPECT_EQ(nullptr, source_);
-  }
+  ~FakeSurfaceFactoryClient() override {}
 
   BeginFrameSource* source() { return source_; }
   const FrameSinkId& frame_sink_id() { return frame_sink_id_; }
 
   void Register(SurfaceManager* manager) {
     EXPECT_EQ(nullptr, manager_);
     manager_ = manager;
     manager_->RegisterSurfaceFactoryClient(frame_sink_id_, this);
   }
 
@@ skipping 31 matching lines @@
   ~SurfaceManagerTest() override {
     for (size_t i = 0; i < MAX_FRAME_SINK; ++i)
       manager_.InvalidateFrameSinkId(FrameSinkId(i, i));
   }
 
  protected:
   SurfaceManager manager_;
 };
 
 TEST_F(SurfaceManagerTest, SingleClients) {
-  FakeSurfaceFactoryClient client(FrameSinkId(1, 1));
-  FakeSurfaceFactoryClient other_client(FrameSinkId(2, 2));
+  FakeSurfaceFactoryClient client(FrameSinkId(1, 1), &manager_);
+  FakeSurfaceFactoryClient other_client(FrameSinkId(2, 2), &manager_);
   StubBeginFrameSource source;
 
   EXPECT_EQ(nullptr, client.source());
   EXPECT_EQ(nullptr, other_client.source());
-  client.Register(&manager_);
-  other_client.Register(&manager_);
-  EXPECT_EQ(nullptr, client.source());
-  EXPECT_EQ(nullptr, other_client.source());
 
   // Test setting unsetting BFS
   manager_.RegisterBeginFrameSource(&source, client.frame_sink_id());
   EXPECT_EQ(&source, client.source());
   EXPECT_EQ(nullptr, other_client.source());
   manager_.UnregisterBeginFrameSource(&source);
   EXPECT_EQ(nullptr, client.source());
   EXPECT_EQ(nullptr, other_client.source());
 
   // Set BFS for other namespace
@@ skipping 157 matching lines @@
 
 // In practice, registering and unregistering both parent/child relationships
 // and SurfaceFactoryClients can happen in any ordering with respect to
 // each other.  These following tests verify that all the data structures
 // are properly set up and cleaned up under the four permutations of orderings
 // of this nesting.
 
 class SurfaceManagerOrderingTest : public SurfaceManagerTest {
  public:
   SurfaceManagerOrderingTest()
-      : client_a_(FrameSinkId(1, 1)),
-        client_b_(FrameSinkId(2, 2)),
-        client_c_(FrameSinkId(3, 3)),
-        hierarchy_registered_(false),
+      : hierarchy_registered_(false),
         clients_registered_(false),
         bfs_registered_(false) {
     AssertCorrectBFSState();
   }
 
   ~SurfaceManagerOrderingTest() override {
     EXPECT_FALSE(hierarchy_registered_);
     EXPECT_FALSE(clients_registered_);
     EXPECT_FALSE(bfs_registered_);
     AssertCorrectBFSState();
   }
 
   void RegisterHierarchy() {
     DCHECK(!hierarchy_registered_);
     hierarchy_registered_ = true;
-    manager_.RegisterFrameSinkHierarchy(client_a_.frame_sink_id(),
-                                        client_b_.frame_sink_id());
-    manager_.RegisterFrameSinkHierarchy(client_b_.frame_sink_id(),
-                                        client_c_.frame_sink_id());
+    manager_.RegisterFrameSinkHierarchy(frame_sink_id_a_, frame_sink_id_b_);
+    manager_.RegisterFrameSinkHierarchy(frame_sink_id_b_, frame_sink_id_c_);
     AssertCorrectBFSState();
   }
   void UnregisterHierarchy() {
     DCHECK(hierarchy_registered_);
     hierarchy_registered_ = false;
-    manager_.UnregisterFrameSinkHierarchy(client_a_.frame_sink_id(),
-                                          client_b_.frame_sink_id());
-    manager_.UnregisterFrameSinkHierarchy(client_b_.frame_sink_id(),
-                                          client_c_.frame_sink_id());
+    manager_.UnregisterFrameSinkHierarchy(frame_sink_id_a_, frame_sink_id_b_);
+    manager_.UnregisterFrameSinkHierarchy(frame_sink_id_b_, frame_sink_id_c_);
     AssertCorrectBFSState();
   }
 
   void RegisterClients() {
     DCHECK(!clients_registered_);
     clients_registered_ = true;
-    client_a_.Register(&manager_);
-    client_b_.Register(&manager_);
-    client_c_.Register(&manager_);
+    client_a_ =
+        base::MakeUnique<FakeSurfaceFactoryClient>(frame_sink_id_a_, &manager_);
+    client_b_ =
+        base::MakeUnique<FakeSurfaceFactoryClient>(frame_sink_id_b_, &manager_);
+    client_c_ =
+        base::MakeUnique<FakeSurfaceFactoryClient>(frame_sink_id_c_, &manager_);
     AssertCorrectBFSState();
   }
 
   void UnregisterClients() {
     DCHECK(clients_registered_);
     clients_registered_ = false;
-    client_a_.Unregister();
-    client_b_.Unregister();
-    client_c_.Unregister();
+    client_a_.reset();
+    client_b_.reset();
+    client_c_.reset();
     AssertCorrectBFSState();
   }
 
   void RegisterBFS() {
     DCHECK(!bfs_registered_);
     bfs_registered_ = true;
-    manager_.RegisterBeginFrameSource(&source_, client_a_.frame_sink_id());
+    manager_.RegisterBeginFrameSource(&source_, frame_sink_id_a_);
     AssertCorrectBFSState();
   }
   void UnregisterBFS() {
     DCHECK(bfs_registered_);
     bfs_registered_ = false;
     manager_.UnregisterBeginFrameSource(&source_);
     AssertCorrectBFSState();
   }
 
   void AssertEmptyBFS() {
-    EXPECT_EQ(nullptr, client_a_.source());
-    EXPECT_EQ(nullptr, client_b_.source());
-    EXPECT_EQ(nullptr, client_c_.source());
+    EXPECT_TRUE(client_a_.get() == nullptr || client_a_->source() == nullptr);
+    EXPECT_TRUE(client_b_.get() == nullptr || client_b_->source() == nullptr);
+    EXPECT_TRUE(client_c_.get() == nullptr || client_c_->source() == nullptr);
   }
 
   void AssertAllValidBFS() {
-    EXPECT_EQ(&source_, client_a_.source());
-    EXPECT_EQ(&source_, client_b_.source());
-    EXPECT_EQ(&source_, client_c_.source());
+    EXPECT_EQ(&source_, client_a_->source());
+    EXPECT_EQ(&source_, client_b_->source());
+    EXPECT_EQ(&source_, client_c_->source());
   }
 
  protected:
   void AssertCorrectBFSState() {
     if (!clients_registered_ || !bfs_registered_) {
       AssertEmptyBFS();
       return;
     }
     if (!hierarchy_registered_) {
       // A valid but not attached to anything.
-      EXPECT_EQ(&source_, client_a_.source());
-      EXPECT_EQ(nullptr, client_b_.source());
-      EXPECT_EQ(nullptr, client_c_.source());
+      EXPECT_EQ(&source_, client_a_->source());
+      EXPECT_TRUE(client_b_.get() == nullptr || client_b_->source() == nullptr);
+      EXPECT_TRUE(client_c_.get() == nullptr || client_c_->source() == nullptr);
       return;
     }
 
     AssertAllValidBFS();
   }
 
   StubBeginFrameSource source_;
   // A -> B -> C hierarchy, with A always having the BFS.
-  FakeSurfaceFactoryClient client_a_;
-  FakeSurfaceFactoryClient client_b_;
-  FakeSurfaceFactoryClient client_c_;
+  std::unique_ptr<FakeSurfaceFactoryClient> client_a_;
+  std::unique_ptr<FakeSurfaceFactoryClient> client_b_;
+  std::unique_ptr<FakeSurfaceFactoryClient> client_c_;
+
+  const FrameSinkId frame_sink_id_a_ = FrameSinkId(1, 1);
+  const FrameSinkId frame_sink_id_b_ = FrameSinkId(2, 2);
+  const FrameSinkId frame_sink_id_c_ = FrameSinkId(3, 3);
 
   bool hierarchy_registered_;
   bool clients_registered_;
   bool bfs_registered_;
 };
 
 enum RegisterOrder { REGISTER_HIERARCHY_FIRST, REGISTER_CLIENTS_FIRST };
 enum UnregisterOrder { UNREGISTER_HIERARCHY_FIRST, UNREGISTER_CLIENTS_FIRST };
 enum BFSOrder { BFS_FIRST, BFS_SECOND, BFS_THIRD };
 
@@ skipping 63 matching lines @@
 }
 
 INSTANTIATE_TEST_CASE_P(
     SurfaceManagerOrderingParamTestInstantiation,
     SurfaceManagerOrderingParamTest,
     ::testing::Combine(::testing::ValuesIn(kRegisterOrderList),
                        ::testing::ValuesIn(kUnregisterOrderList),
                        ::testing::ValuesIn(kBFSOrderList)));
 
 }  // namespace cc