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_manager.h"
 #include "cc/trees/blocking_task_runner.h"
 
 namespace cc {
 namespace {
 
 // Maximum bucket size for the UMA stats.
 constexpr int kUmaStatMaxSurfaces = 30;
 
@@ skipping 50 matching lines @@
 SurfaceAggregator::~SurfaceAggregator() {
   // Notify client of all surfaces being removed.
   contained_surfaces_.clear();
   ProcessAddedAndRemovedSurfaces();
 }
 
 SurfaceAggregator::PrewalkResult::PrewalkResult() {}
 
 SurfaceAggregator::PrewalkResult::~PrewalkResult() {}
 
+// static
+void SurfaceAggregator::UnrefHelper(

[danakj, 2017/05/03 16:08:39]

Leave this as a file-static function, not a static method in SurfaceAggregator

[Alex Z., 2017/05/03 18:07:37]

Done.

+    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);
+}
+
 // Create a clip rect for an aggregated quad from the original clip rect and
 // the clip rect from the surface it's on.
 SurfaceAggregator::ClipData SurfaceAggregator::CalculateClipRect(
     const ClipData& surface_clip,
     const ClipData& quad_clip,
     const gfx::Transform& target_transform) {
   ClipData out_clip;
   if (surface_clip.is_clipped)
     out_clip = surface_clip;
 
   if (quad_clip.is_clipped) {
     // TODO(jamesr): This only works if target_transform maps integer
     // rects to integer rects.
     gfx::Rect final_clip =
         MathUtil::MapEnclosingClippedRect(target_transform, quad_clip.rect);
     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);
-}
-
 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) {
   auto 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 439 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());
 
   std::vector<ResourceId> referenced_resources;
   size_t reserve_size = frame.resource_list.size();
   referenced_resources.reserve(reserve_size);
 
   bool invalid_frame = false;
   ResourceProvider::ResourceIdMap empty_map;
@@ skipping 307 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