[cc]Replace use of SurfaceFactory with CompositorFrameSinkSupport in tests

cc/surfaces/surface_manager_ref_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 <unordered_map>
 #include <vector>
 
 #include "base/memory/ptr_util.h"
+#include "cc/surfaces/compositor_frame_sink_support.h"
 #include "cc/surfaces/surface.h"
-#include "cc/surfaces/surface_factory.h"
-#include "cc/surfaces/surface_factory_client.h"
 #include "cc/surfaces/surface_id.h"
 #include "cc/surfaces/surface_manager.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using testing::ElementsAre;
 using testing::IsEmpty;
 using testing::SizeIs;
 using testing::UnorderedElementsAre;
 
 namespace cc {
 
 namespace {
 
 constexpr FrameSinkId kFrameSink1(1, 0);
 constexpr FrameSinkId kFrameSink2(2, 0);
 constexpr FrameSinkId kFrameSink3(3, 0);
 
-class StubSurfaceFactoryClient : public SurfaceFactoryClient {
- public:
-  void ReturnResources(const ReturnedResourceArray& resources) override {}
-  void SetBeginFrameSource(BeginFrameSource* begin_frame_source) override {}
-};
-
 }  // namespace
 
 // Tests for reference tracking in SurfaceManager.
 class SurfaceManagerRefTest : public testing::Test {
  public:
   SurfaceManager& manager() { return *manager_; }
 
   // Creates a new Surface with the provided |frame_sink_id| and |local_id|.
-  // Will first create a SurfaceFactory for |frame_sink_id| if necessary.
+  // Will first create a Surfacesupport for |frame_sink_id| if necessary.
   SurfaceId CreateSurface(const FrameSinkId& frame_sink_id, uint32_t local_id) {
     LocalSurfaceId local_surface_id(local_id,
                                     base::UnguessableToken::Deserialize(0, 1u));
-    GetFactory(frame_sink_id)
-        .SubmitCompositorFrame(local_surface_id, CompositorFrame(),
-                               SurfaceFactory::DrawCallback());
+    GetCompositorFrameSinkSupport(frame_sink_id)
+        .SubmitCompositorFrame(local_surface_id, CompositorFrame());
     return SurfaceId(frame_sink_id, local_surface_id);
   }
 
   // Destroy Surface with |surface_id|.
   void DestroySurface(const SurfaceId& surface_id) {
-    GetFactory(surface_id.frame_sink_id()).EvictSurface();
+    GetCompositorFrameSinkSupport(surface_id.frame_sink_id()).EvictFrame();
   }
 
-  SurfaceFactory& GetFactory(const FrameSinkId& frame_sink_id) {
-    auto& factory_ptr = factories_[frame_sink_id];
-    if (!factory_ptr)
-      factory_ptr = base::MakeUnique<SurfaceFactory>(frame_sink_id,
-                                                     manager_.get(), &client_);
-    return *factory_ptr;
+  CompositorFrameSinkSupport& GetCompositorFrameSinkSupport(
+      const FrameSinkId& frame_sink_id) {
+    auto& support_ptr = supports_[frame_sink_id];
+    if (!support_ptr) {
+      constexpr bool is_root = false;
+      constexpr bool handles_frame_sink_id_invalidation = true;
+      constexpr bool needs_sync_points = true;
+      support_ptr = CompositorFrameSinkSupport::Create(
+          nullptr, manager_.get(), frame_sink_id, is_root,
+          handles_frame_sink_id_invalidation, needs_sync_points);
+    }
+    return *support_ptr;
+  }
+
+  void DestroyCompositorFrameSinkSupport(const FrameSinkId& frame_sink_id) {
+    auto support_ptr = supports_.find(frame_sink_id);
+    ASSERT_NE(support_ptr, supports_.end());
+    supports_.erase(support_ptr);
   }
 
   void RemoveSurfaceReference(const SurfaceId& parent_id,
                               const SurfaceId& child_id) {
     manager_->RemoveSurfaceReferences({SurfaceReference(parent_id, child_id)});
   }
 
   void AddSurfaceReference(const SurfaceId& parent_id,
                            const SurfaceId& child_id) {
     manager_->AddSurfaceReferences({SurfaceReference(parent_id, child_id)});
@@ skipping 21 matching lines @@
   }
 
  protected:
   // testing::Test:
   void SetUp() override {
     // Start each test with a fresh SurfaceManager instance.
     manager_ = base::MakeUnique<SurfaceManager>(
         SurfaceManager::LifetimeType::REFERENCES);
   }
   void TearDown() override {
-    for (auto& factory : factories_)
-      factory.second->EvictSurface();
-    factories_.clear();
+    for (auto& support : supports_)
+      support.second->EvictFrame();
+    supports_.clear();
     manager_.reset();
   }
 
   std::unordered_map<FrameSinkId,
-                     std::unique_ptr<SurfaceFactory>,
+                     std::unique_ptr<CompositorFrameSinkSupport>,
                      FrameSinkIdHash>
-      factories_;
+      supports_;
   std::unique_ptr<SurfaceManager> manager_;
-  StubSurfaceFactoryClient client_;
 };
 
 TEST_F(SurfaceManagerRefTest, AddReference) {
   SurfaceId id1 = CreateSurface(kFrameSink1, 1);
   AddSurfaceReference(manager().GetRootSurfaceId(), id1);
 
   EXPECT_THAT(GetReferencesFor(id1),
               UnorderedElementsAre(manager().GetRootSurfaceId()));
   EXPECT_THAT(GetReferencesFrom(id1), IsEmpty());
 }
@@ skipping 327 matching lines @@
   manager().AssignTemporaryReference(id1, kFrameSink1);
   ASSERT_THAT(GetAllTempReferences(), UnorderedElementsAre(id1));
 
   // Adding a real surface reference will remove the temporary reference.
   AddSurfaceReference(parent_id, id1);
   ASSERT_THAT(GetAllTempReferences(), IsEmpty());
   ASSERT_THAT(GetReferencesFor(id1), UnorderedElementsAre(parent_id));
 
   // When |kFrameSink1| is invalidated it shouldn't change the surface
   // references.
-  manager().InvalidateFrameSinkId(kFrameSink1);
+  DestroyCompositorFrameSinkSupport(kFrameSink1);
   ASSERT_THAT(GetReferencesFor(id1), UnorderedElementsAre(parent_id));
 }
 
 TEST_F(SurfaceManagerRefTest, CheckDropTemporaryReferenceWorks) {
   const SurfaceId id1 = CreateSurface(kFrameSink1, 1);
   ASSERT_THAT(GetAllTempReferences(), UnorderedElementsAre(id1));
 
   // An example of why this could happen is the window server doesn't know the
   // owner, maybe it has crashed and been cleanup already, and asks to drop the
   // temporary reference.
@@ skipping 14 matching lines @@
   ASSERT_THAT(GetAllTempReferences(), UnorderedElementsAre(id1a, id1b));
 
   // Assign |id1a| to |kFrameSink1|. This doesn't change the temporary
   // reference, it just assigns as owner to it.
   manager().AssignTemporaryReference(id1a, kFrameSink1);
   ASSERT_THAT(GetAllTempReferences(), UnorderedElementsAre(id1a, id1b));
 
   // If the parent client crashes then the CompositorFrameSink connection will
   // be closed and the FrameSinkId invalidated. The temporary reference
   // |kFrameSink1| owns to |id2a| will be removed.
-  manager().InvalidateFrameSinkId(kFrameSink1);
+  DestroyCompositorFrameSinkSupport(kFrameSink1);
   ASSERT_THAT(GetAllTempReferences(), UnorderedElementsAre(id1b));
 
   // If the parent has crashed then the window server will have already removed
   // it from the ServerWindow hierarchy and won't have an owner for |id2b|. The
   // window server will ask to drop the reference instead.
   manager().DropTemporaryReference(id1b);
   ASSERT_THAT(GetAllTempReferences(), IsEmpty());
 }
 
 }  // namespace cc