Remove SurfaceFactory And SurfaceFactoryClient

cc/surfaces/surface_aggregator.cc

 // Copyright 2014 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/surface_aggregator.h"
 
 #include <stddef.h>
 
 #include <map>
 
 #include "base/bind.h"
 #include "base/containers/adapters.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/stl_util.h"
 #include "base/trace_event/trace_event.h"
 #include "cc/base/math_util.h"
 #include "cc/output/compositor_frame.h"
 #include "cc/quads/draw_quad.h"
 #include "cc/quads/render_pass_draw_quad.h"
 #include "cc/quads/shared_quad_state.h"
 #include "cc/quads/solid_color_draw_quad.h"
 #include "cc/quads/surface_draw_quad.h"
 #include "cc/quads/texture_draw_quad.h"
 #include "cc/resources/resource_provider.h"
+#include "cc/surfaces/compositor_frame_sink_support.h"
 #include "cc/surfaces/surface.h"
-#include "cc/surfaces/surface_factory.h"
 #include "cc/surfaces/surface_manager.h"
 #include "cc/trees/blocking_task_runner.h"
 
 namespace cc {
 namespace {
 
 // Maximum bucket size for the UMA stats.
 constexpr int kUmaStatMaxSurfaces = 30;
 
 const char kUmaValidSurface[] =
@@ skipping 74 matching lines @@
     if (out_clip.is_clipped)
       out_clip.rect.Intersect(final_clip);
     else
       out_clip.rect = final_clip;
     out_clip.is_clipped = true;
   }
 
   return out_clip;
 }
 
-static void UnrefHelper(base::WeakPtr<SurfaceFactory> surface_factory,
-                        const ReturnedResourceArray& resources,
-                        BlockingTaskRunner* main_thread_task_runner) {
-  if (surface_factory)
-    surface_factory->UnrefResources(resources);
+static void UnrefHelper(
+    base::WeakPtr<CompositorFrameSinkSupport> compositor_frame_sink_support,
+    const ReturnedResourceArray& resources,
+    BlockingTaskRunner* main_thread_task_runner) {
+  if (compositor_frame_sink_support)
+    compositor_frame_sink_support->UnrefResources(resources);
 }
 
 int SurfaceAggregator::RemapPassId(int surface_local_pass_id,
                                    const SurfaceId& surface_id) {
   auto key = std::make_pair(surface_id, surface_local_pass_id);
   auto it = render_pass_allocator_map_.find(key);
   if (it != render_pass_allocator_map_.end()) {
     it->second.in_use = true;
     return it->second.id;
   }
 
   RenderPassInfo render_pass_info;
   render_pass_info.id = next_render_pass_id_++;
   render_pass_allocator_map_[key] = render_pass_info;
   return render_pass_info.id;
 }
 
 int SurfaceAggregator::ChildIdForSurface(Surface* surface) {
   SurfaceToResourceChildIdMap::iterator it =
       surface_id_to_resource_child_id_.find(surface->surface_id());
   if (it == surface_id_to_resource_child_id_.end()) {
-    int child_id =
-        provider_->CreateChild(base::Bind(&UnrefHelper, surface->factory()));
-    if (surface->factory()) {
+    int child_id = provider_->CreateChild(
+        base::Bind(&UnrefHelper, surface->compositor_frame_sink_support()));
+    if (surface->compositor_frame_sink_support()) {
       provider_->SetChildNeedsSyncTokens(
-          child_id, surface->factory()->needs_sync_points());
+          child_id,
+          surface->compositor_frame_sink_support()->needs_sync_points());
     }
     surface_id_to_resource_child_id_[surface->surface_id()] = child_id;
     return child_id;
   } else {
     return it->second;
   }
 }
 
 gfx::Rect SurfaceAggregator::DamageRectForSurface(
     const Surface* surface,
@@ skipping 438 matching lines @@
     return gfx::Rect();
   }
   contained_surfaces_[surface_id] = surface->frame_index();
   if (!surface->HasActiveFrame())
     return gfx::Rect();
   const CompositorFrame& frame = surface->GetActiveFrame();
   int child_id = 0;
   // TODO(jbauman): hack for unit tests that don't set up rp
   if (provider_) {
     child_id = ChildIdForSurface(surface);
-    if (surface->factory())
-      surface->factory()->RefResources(frame.resource_list);
+    if (surface->compositor_frame_sink_support())
+      surface->compositor_frame_sink_support()->RefResources(
+          frame.resource_list);
     provider_->ReceiveFromChild(child_id, frame.resource_list);
   }
   CHECK(debug_weak_this.get());
 
   ResourceIdSet referenced_resources;
   size_t reserve_size = frame.resource_list.size();
   referenced_resources.reserve(reserve_size);
 
   bool invalid_frame = false;
   ResourceProvider::ResourceIdMap empty_map;
@@ skipping 121 matching lines @@
 
   CHECK(debug_weak_this.get());
   for (const auto& surface_id : frame.metadata.referenced_surfaces) {
     if (!contained_surfaces_.count(surface_id)) {
       result->undrawn_surfaces.insert(surface_id);
       PrewalkTree(surface_id, false, 0, result);
     }
   }
 
   CHECK(debug_weak_this.get());
-  if (surface->factory()) {
-    surface->factory()->WillDrawSurface(
+  if (surface->compositor_frame_sink_support()) {
+    surface->compositor_frame_sink_support()->WillDrawSurface(
         surface->surface_id().local_surface_id(), damage_rect);
   }
 
   CHECK(debug_weak_this.get());
   for (const auto& render_pass : frame.render_pass_list) {
     if (!render_pass->copy_requests.empty()) {
       int remapped_pass_id = RemapPassId(render_pass->id, surface_id);
       copy_request_passes_.insert(remapped_pass_id);
     }
   }
@@ skipping 160 matching lines @@
 }
 
 void SurfaceAggregator::SetOutputColorSpace(
     const gfx::ColorSpace& blending_color_space,
     const gfx::ColorSpace& output_color_space) {
   blending_color_space_ = blending_color_space;
   output_color_space_ = output_color_space;
 }
 
 }  // namespace cc