Revert of Remove SurfaceFactory::Create and SurfaceFactory::Destroy

cc/surfaces/display_unittest.cc

 // Copyright 2015 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/display.h"
 
 #include <utility>
 
 #include "base/test/null_task_runner.h"
 #include "cc/output/compositor_frame.h"
@@ skipping 88 matching lines @@
 class DisplayTest : public testing::Test {
  public:
   DisplayTest()
       : factory_(kArbitraryFrameSinkId, &manager_, &surface_factory_client_),
         task_runner_(new base::NullTaskRunner) {
     manager_.RegisterFrameSinkId(kArbitraryFrameSinkId);
   }
 
   ~DisplayTest() override {
     manager_.InvalidateFrameSinkId(kArbitraryFrameSinkId);
-    factory_.EvictSurface();
   }
 
   void SetUpDisplay(const RendererSettings& settings,
                     std::unique_ptr<TestWebGraphicsContext3D> context) {
     std::unique_ptr<BeginFrameSource> begin_frame_source(
         new StubBeginFrameSource);
 
     std::unique_ptr<FakeOutputSurface> output_surface;
     if (context) {
       auto provider = TestContextProvider::Create(std::move(context));
@@ skipping 70 matching lines @@
   EXPECT_FALSE(scheduler_->damaged);
   EXPECT_FALSE(scheduler_->display_resized_);
   EXPECT_TRUE(scheduler_->has_new_root_surface);
 
   scheduler_->ResetDamageForTest();
   display_->Resize(gfx::Size(100, 100));
   EXPECT_FALSE(scheduler_->damaged);
   EXPECT_TRUE(scheduler_->display_resized_);
   EXPECT_FALSE(scheduler_->has_new_root_surface);
 
+  factory_.Create(local_frame_id);
+
   // First draw from surface should have full damage.
   RenderPassList pass_list;
   std::unique_ptr<RenderPass> pass = RenderPass::Create();
   pass->output_rect = gfx::Rect(0, 0, 100, 100);
   pass->damage_rect = gfx::Rect(10, 10, 1, 1);
   pass->id = RenderPassId(1, 1);
   pass_list.push_back(std::move(pass));
 
   scheduler_->ResetDamageForTest();
   SubmitCompositorFrame(&pass_list, local_frame_id);
@@ skipping 196 matching lines @@
     scheduler_->swapped = false;
     display_->DrawAndSwap();
     EXPECT_TRUE(scheduler_->swapped);
     EXPECT_EQ(6u, output_surface_->num_sent_frames());
     EXPECT_EQ(gfx::Size(100, 100),
               software_output_device_->viewport_pixel_size());
     EXPECT_EQ(gfx::Rect(0, 0, 100, 100),
               software_output_device_->damage_rect());
     EXPECT_EQ(0u, output_surface_->last_sent_frame()->latency_info.size());
   }
+
+  factory_.Destroy(local_frame_id);
 }
 
 class MockedContext : public TestWebGraphicsContext3D {
  public:
   MOCK_METHOD0(shallowFinishCHROMIUM, void());
 };
 
 TEST_F(DisplayTest, Finish) {
   LocalFrameId local_frame_id(id_allocator_.GenerateId());
 
   RendererSettings settings;
   settings.partial_swap_enabled = true;
   settings.finish_rendering_on_resize = true;
 
   std::unique_ptr<MockedContext> context(new MockedContext());
   MockedContext* context_ptr = context.get();
   EXPECT_CALL(*context_ptr, shallowFinishCHROMIUM()).Times(0);
 
   SetUpDisplay(settings, std::move(context));
 
   StubDisplayClient client;
   display_->Initialize(&client, &manager_);
 
   display_->SetLocalFrameId(local_frame_id, 1.f);
 
   display_->Resize(gfx::Size(100, 100));
+  factory_.Create(local_frame_id);
 
   {
     RenderPassList pass_list;
     std::unique_ptr<RenderPass> pass = RenderPass::Create();
     pass->output_rect = gfx::Rect(0, 0, 100, 100);
     pass->damage_rect = gfx::Rect(10, 10, 1, 1);
     pass->id = RenderPassId(1, 1);
     pass_list.push_back(std::move(pass));
 
     SubmitCompositorFrame(&pass_list, local_frame_id);
@@ skipping 25 matching lines @@
     SubmitCompositorFrame(&pass_list, local_frame_id);
   }
 
   display_->DrawAndSwap();
 
   testing::Mock::VerifyAndClearExpectations(context_ptr);
 
   EXPECT_CALL(*context_ptr, shallowFinishCHROMIUM());
   display_->Resize(gfx::Size(250, 250));
   testing::Mock::VerifyAndClearExpectations(context_ptr);
+
+  factory_.Destroy(local_frame_id);
 }
 
 class CountLossDisplayClient : public StubDisplayClient {
  public:
   CountLossDisplayClient() = default;
 
   void DisplayOutputSurfaceLost() override { ++loss_count_; }
 
   int loss_count() const { return loss_count_; }
 
@@ skipping 10 matching lines @@
   // Verify DidLoseOutputSurface callback is hooked up correctly.
   EXPECT_EQ(0, client.loss_count());
   output_surface_->context_provider()->ContextGL()->LoseContextCHROMIUM(
       GL_GUILTY_CONTEXT_RESET_ARB, GL_INNOCENT_CONTEXT_RESET_ARB);
   output_surface_->context_provider()->ContextGL()->Flush();
   EXPECT_EQ(1, client.loss_count());
 }
 
 }  // namespace
 }  // namespace cc