Remove SurfaceFactory::Create and SurfaceFactory::Destroy

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/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 "cc/surfaces/surface_sequence_generator.h"
 #include "testing/gtest/include/gtest/gtest.h"
-
 namespace cc {
 namespace {
 
 constexpr FrameSinkId kFrameSink1(1, 0);
 constexpr FrameSinkId kFrameSink2(2, 0);
 constexpr FrameSinkId kFrameSink3(3, 0);
 const LocalFrameId kLocalFrame1(1, base::UnguessableToken::Create());
 const LocalFrameId kLocalFrame2(2, base::UnguessableToken::Create());
 
+class EmptySurfaceFactoryClient : public SurfaceFactoryClient {

[danakj, 2016/11/12 00:27:22]

Stub is the word for this, rather than Empty

[Saman Sami, 2016/11/14 23:39:01]

Done.

+ public:
+  void ReturnResources(const ReturnedResourceArray& resources) override {}
+  void SetBeginFrameSource(BeginFrameSource* begin_frame_source) override {}
+};
+
 // Tests for reference tracking in SurfaceManager.
 class SurfaceManagerRefTest : public testing::Test {
  public:
   SurfaceManager& manager() { return *manager_; }
 
   // Creates a new Surface with the provided SurfaceId. Will first create the
   // SurfaceFactory for |frame_sink_id| if necessary.
   SurfaceId CreateSurface(const FrameSinkId& frame_sink_id,
                           const LocalFrameId& local_frame_id) {
-    GetFactory(frame_sink_id).Create(local_frame_id);
+    GetFactory(frame_sink_id)
+        .SubmitCompositorFrame(local_frame_id, CompositorFrame(),
+                               SurfaceFactory::DrawCallback());
     return SurfaceId(frame_sink_id, local_frame_id);
   }
 
   // Destroy Surface with |surface_id|.
   void DestroySurface(const SurfaceId& surface_id) {
-    GetFactory(surface_id.frame_sink_id()).Destroy(surface_id.local_frame_id());
+    GetFactory(surface_id.frame_sink_id()).EvictFrame();
   }
 
  protected:
   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(), nullptr);
+                                                     manager_.get(), &client_);
     return *factory_ptr;
   }
 
   // testing::Test:
   void SetUp() override {
     // Start each test with a fresh SurfaceManager instance.
     manager_ = base::MakeUnique<SurfaceManager>();
   }
   void TearDown() override {
     factories_.clear();
     manager_.reset();
   }
 
   std::unordered_map<FrameSinkId,
                      std::unique_ptr<SurfaceFactory>,
                      FrameSinkIdHash>
       factories_;
   std::unique_ptr<SurfaceManager> manager_;
+  EmptySurfaceFactoryClient client_;
 };
 
 }  // namespace
 
 TEST_F(SurfaceManagerRefTest, AddReference) {
   SurfaceId id1 = CreateSurface(kFrameSink1, kLocalFrame1);
   manager().AddSurfaceReference(manager().GetRootSurfaceId(), id1);
 
   EXPECT_EQ(manager().GetSurfaceReferenceCount(id1), 1u);
   EXPECT_EQ(manager().GetReferencedSurfaceCount(id1), 0u);
@@ skipping 206 matching lines @@
   SurfaceId id2 = CreateSurface(kFrameSink2, kLocalFrame1);
 
   // Removing non-existent reference should be ignored.
   manager().AddSurfaceReference(id1, id2);
   manager().RemoveSurfaceReference(id2, id1);
   EXPECT_EQ(manager().GetReferencedSurfaceCount(id1), 1u);
   EXPECT_EQ(manager().GetSurfaceReferenceCount(id2), 1u);
 }
 
 }  // namespace cc