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

blimp/client/core/compositor/blimp_compositor.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 "blimp/client/core/compositor/blimp_compositor.h"
 
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
@@ skipping 174 matching lines @@
 
   if (flush_pending_update) {
     // Always request a commit when queuing the promise to make sure that any
     // frames pending draws are cleared from the pipeline.
     host_->QueueSwapPromise(base::MakeUnique<FrameTrackingSwapPromise>(
         std::move(copy_request), weak_ptr_factory_.GetWeakPtr(),
         base::ThreadTaskRunnerHandle::Get()));
     host_->SetNeedsCommit();
   } else if (local_frame_id_.is_valid()) {
     // Make a copy request for the surface directly.
-    surface_factory_->RequestCopyOfSurface(std::move(copy_request));
+    surface_factory_->RequestCopyOfSurface(local_frame_id_,
+                                           std::move(copy_request));
   }
 }
 
 void BlimpCompositor::UpdateLayerTreeHost() {
   // UpdateLayerTreeHost marks the end of reporting of any deltas from the impl
   // thread. So send a client state update if the local state was modified now.
   FlushClientState();
 
   if (pending_frame_update_) {
     compositor_state_deserializer_->DeserializeCompositorUpdate(
@@ skipping 111 matching lines @@
   DCHECK(bound_to_proxy_);
 
   cc::RenderPass* root_pass = frame.render_pass_list.back().get();
   gfx::Size surface_size = root_pass->output_rect.size();
 
   if (!local_frame_id_.is_valid() || current_surface_size_ != surface_size) {
     DestroyDelegatedContent();
     DCHECK(layer_->children().empty());
 
     local_frame_id_ = surface_id_allocator_->GenerateId();
+    surface_factory_->Create(local_frame_id_);
     current_surface_size_ = surface_size;
 
     // manager must outlive compositors using it.
     cc::SurfaceManager* surface_manager =
         GetEmbedderDeps()->GetSurfaceManager();
     scoped_refptr<cc::SurfaceLayer> content_layer = cc::SurfaceLayer::Create(
         base::Bind(&SatisfyCallback, base::Unretained(surface_manager)),
         base::Bind(&RequireCallback, base::Unretained(surface_manager)));
     content_layer->SetSurfaceId(
         cc::SurfaceId(surface_factory_->frame_sink_id(), local_frame_id_), 1.f,
         surface_size);
     content_layer->SetBounds(current_surface_size_);
     content_layer->SetIsDrawable(true);
     content_layer->SetContentsOpaque(true);
 
     layer_->AddChild(content_layer);
   }
 
   surface_factory_->SubmitCompositorFrame(
       local_frame_id_, std::move(frame),
       base::Bind(&BlimpCompositor::SubmitCompositorFrameAck,
                  weak_ptr_factory_.GetWeakPtr()));
 
   for (auto& copy_request : copy_requests_for_next_swap_) {
-    surface_factory_->RequestCopyOfSurface(std::move(copy_request));
+    surface_factory_->RequestCopyOfSurface(local_frame_id_,
+                                           std::move(copy_request));
   }
   copy_requests_for_next_swap_.clear();
 }
 
 void BlimpCompositor::SubmitCompositorFrameAck() {
   compositor_dependencies_->GetCompositorTaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(&BlimpCompositorFrameSinkProxyClient::SubmitCompositorFrameAck,
                  proxy_client_));
 }
@@ skipping 51 matching lines @@
   return compositor_dependencies_->GetEmbedderDependencies();
 }
 
 void BlimpCompositor::DestroyDelegatedContent() {
   if (!local_frame_id_.is_valid())
     return;
 
   // Remove any references for the surface layer that uses this
   // |local_frame_id_|.
   layer_->RemoveAllChildren();
-  surface_factory_->EvictSurface();
+  surface_factory_->Destroy(local_frame_id_);
   local_frame_id_ = cc::LocalFrameId();
 }
 
 std::unique_ptr<cc::LayerTreeHostInProcess>
 BlimpCompositor::CreateLayerTreeHost() {
   DCHECK(animation_host_);
   std::unique_ptr<cc::LayerTreeHostInProcess> host;
 
   cc::LayerTreeHostInProcess::InitParams params;
   params.client = this;
@@ skipping 26 matching lines @@
   // Destroy the old LayerTreeHost state.
   host_.reset();
 
   // Cancel any outstanding CompositorFrameSink requests.  That way if we get an
   // async callback related to the old request we know to drop it.
   compositor_frame_sink_request_pending_ = false;
 }
 
 }  // namespace client
 }  // namespace blimp