Remove the concept of OutputSurface from ResourceProvider.

cc/trees/layer_tree_host_impl.cc

 // Copyright 2011 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/trees/layer_tree_host_impl.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 2178 matching lines @@
 }
 
 void LayerTreeHostImpl::CreateResourceAndRasterBufferProvider(
     std::unique_ptr<RasterBufferProvider>* raster_buffer_provider,
     std::unique_ptr<ResourcePool>* resource_pool) {
   DCHECK(GetTaskRunner());
   // TODO(vmpstr): Make this a DCHECK (or remove) when crbug.com/419086 is
   // resolved.
   CHECK(resource_provider_);
 
-  ContextProvider* context_provider = output_surface_->context_provider();
-  if (!context_provider) {
+  ContextProvider* compositor_context_provider =
+      output_surface_->context_provider();
+  if (!compositor_context_provider) {
     *resource_pool =
         ResourcePool::Create(resource_provider_.get(), GetTaskRunner());
 
     *raster_buffer_provider =
         BitmapRasterBufferProvider::Create(resource_provider_.get());
     return;
   }
 
+  ContextProvider* worker_context_provider =
+      output_surface_->worker_context_provider();
   if (use_gpu_rasterization_) {
-    DCHECK(resource_provider_->output_surface()->worker_context_provider());
+    DCHECK(worker_context_provider);
 
     *resource_pool =
         ResourcePool::Create(resource_provider_.get(), GetTaskRunner());
 
     int msaa_sample_count = use_msaa_ ? RequestedMSAASampleCount() : 0;
 
-    *raster_buffer_provider = GpuRasterBufferProvider::Create(
-        context_provider, resource_provider_.get(),
-        settings_.use_distance_field_text, msaa_sample_count);
+    *raster_buffer_provider = base::MakeUnique<GpuRasterBufferProvider>(
+        compositor_context_provider, worker_context_provider,
+        resource_provider_.get(), settings_.use_distance_field_text,
+        msaa_sample_count);
     return;
   }
 
   DCHECK(GetRendererCapabilities().using_image);
 
   bool use_zero_copy = settings_.use_zero_copy;
   // TODO(reveman): Remove this when mojo supports worker contexts.
   // crbug.com/522440
-  if (!resource_provider_->output_surface()->worker_context_provider()) {
+  if (!worker_context_provider) {
     LOG(ERROR)
         << "Forcing zero-copy tile initialization as worker context is missing";
     use_zero_copy = true;
   }
 
   if (use_zero_copy) {
     *resource_pool = ResourcePool::CreateForGpuMemoryBufferResources(
         resource_provider_.get(), GetTaskRunner());
 
     *raster_buffer_provider = ZeroCopyRasterBufferProvider::Create(
         resource_provider_.get(),
         settings_.renderer_settings.preferred_tile_format);
     return;
   }
 
   *resource_pool =
       ResourcePool::Create(resource_provider_.get(), GetTaskRunner());
 
   const int max_copy_texture_chromium_size =
-      context_provider->ContextCapabilities().max_copy_texture_chromium_size;
+      compositor_context_provider->ContextCapabilities()
+          .max_copy_texture_chromium_size;
 
-  *raster_buffer_provider = OneCopyRasterBufferProvider::Create(
-      GetTaskRunner(), context_provider, resource_provider_.get(),
-      max_copy_texture_chromium_size, settings_.use_partial_raster,
-      settings_.max_staging_buffer_usage_in_bytes,
+  *raster_buffer_provider = base::MakeUnique<OneCopyRasterBufferProvider>(
+      GetTaskRunner(), compositor_context_provider, worker_context_provider,
+      resource_provider_.get(), max_copy_texture_chromium_size,
+      settings_.use_partial_raster, settings_.max_staging_buffer_usage_in_bytes,
       settings_.renderer_settings.preferred_tile_format);
 }
 
 void LayerTreeHostImpl::SetLayerTreeMutator(LayerTreeMutator* mutator) {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("compositor-worker"),
                "LayerTreeHostImpl::SetLayerTreeMutator");
   mutator_ = mutator;
 }
 
 void LayerTreeHostImpl::CleanUpTileManagerAndUIResources() {
@@ skipping 36 matching lines @@
 
   ReleaseOutputSurface();
   if (!output_surface->BindToClient(this)) {
     // Avoid recreating tree resources because we might not have enough
     // information to do this yet (eg. we don't have a TileManager at this
     // point).
     return false;
   }
 
   output_surface_ = output_surface;
-  resource_provider_ = ResourceProvider::Create(
-      output_surface_, shared_bitmap_manager_, gpu_memory_buffer_manager_,
+  resource_provider_ = base::MakeUnique<ResourceProvider>(
+      output_surface_->context_provider(), shared_bitmap_manager_,
+      gpu_memory_buffer_manager_,
       task_runner_provider_->blocking_main_thread_task_runner(),
       settings_.renderer_settings.highp_threshold_min,
       settings_.renderer_settings.texture_id_allocation_chunk_size,
+      output_surface_->capabilities().delegated_sync_points_required,
       settings_.renderer_settings.use_gpu_memory_buffer_resources,
       settings_.use_image_texture_targets);
 
   CreateAndSetRenderer();
 
   // Since the new renderer may be capable of MSAA, update status here.
   UpdateGpuRasterizationStatus();
 
   CreateTileManagerResources();
   RecreateTreeResources();
@@ skipping 1680 matching lines @@
     const {
   return fixed_raster_scale_attempted_scale_change_history_.count() >=
          kFixedRasterScaleAttemptedScaleChangeThreshold;
 }
 
 void LayerTreeHostImpl::SetFixedRasterScaleAttemptedToChangeScale() {
   fixed_raster_scale_attempted_scale_change_history_.set(0);
 }
 
 }  // namespace cc