Remove the concept of OutputSurface from ResourceProvider.

cc/raster/staging_buffer_pool.cc

 // Copyright 2016 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/raster/staging_buffer_pool.h"
 
 #include <memory>
 
 #include "base/memory/ptr_util.h"
 #include "base/strings/stringprintf.h"
@@ skipping 102 matching lines @@
   base::trace_event::MemoryAllocatorDumpGuid shared_buffer_guid =
       gfx::GetGpuMemoryBufferGUIDForTracing(tracing_process_id, buffer_id);
   pmd->CreateSharedGlobalAllocatorDump(shared_buffer_guid);
 
   // By creating an edge with a higher |importance| (w.r.t. browser-side dumps)
   // the tracing UI will account the effective size of the buffer to the child.
   const int kImportance = 2;
   pmd->AddOwnershipEdge(buffer_dump->guid(), shared_buffer_guid, kImportance);
 }
 
-// static
-std::unique_ptr<StagingBufferPool> StagingBufferPool::Create(
-    base::SequencedTaskRunner* task_runner,
-    ResourceProvider* resource_provider,
-    bool use_partial_raster,
-    int max_staging_buffer_usage_in_bytes) {
-  return base::WrapUnique(
-      new StagingBufferPool(task_runner, resource_provider, use_partial_raster,
-                            max_staging_buffer_usage_in_bytes));
-}
-
 StagingBufferPool::StagingBufferPool(base::SequencedTaskRunner* task_runner,
+                                     ContextProvider* worker_context_provider,
                                      ResourceProvider* resource_provider,
                                      bool use_partial_raster,
                                      int max_staging_buffer_usage_in_bytes)
     : task_runner_(task_runner),
+      worker_context_provider_(worker_context_provider),
       resource_provider_(resource_provider),
       use_partial_raster_(use_partial_raster),
       max_staging_buffer_usage_in_bytes_(max_staging_buffer_usage_in_bytes),
       staging_buffer_usage_in_bytes_(0),
       free_staging_buffer_usage_in_bytes_(0),
       staging_buffer_expiration_delay_(
           base::TimeDelta::FromMilliseconds(kStagingBufferExpirationDelayMs)),
       reduce_memory_usage_pending_(false),
       weak_ptr_factory_(this) {
+  DCHECK(worker_context_provider_);
   base::trace_event::MemoryDumpManager::GetInstance()->RegisterDumpProvider(
       this, "cc::StagingBufferPool", base::ThreadTaskRunnerHandle::Get());
   reduce_memory_usage_callback_ = base::Bind(
       &StagingBufferPool::ReduceMemoryUsage, weak_ptr_factory_.GetWeakPtr());
 }
 
 StagingBufferPool::~StagingBufferPool() {
   base::trace_event::MemoryDumpManager::GetInstance()->UnregisterDumpProvider(
       this);
 }
@@ skipping 78 matching lines @@
   free_staging_buffer_usage_in_bytes_ -= buffer_usage_in_bytes;
 }
 
 std::unique_ptr<StagingBuffer> StagingBufferPool::AcquireStagingBuffer(
     const Resource* resource,
     uint64_t previous_content_id) {
   base::AutoLock lock(lock_);
 
   std::unique_ptr<StagingBuffer> staging_buffer;
 
-  ContextProvider* context_provider =
-      resource_provider_->output_surface()->worker_context_provider();
-  DCHECK(context_provider);
-
-  ContextProvider::ScopedContextLock scoped_context(context_provider);
+  ContextProvider::ScopedContextLock scoped_context(worker_context_provider_);
 
   gpu::gles2::GLES2Interface* gl = scoped_context.ContextGL();
   DCHECK(gl);
 
   // Check if any busy buffers have become available.
   if (resource_provider_->use_sync_query()) {
     while (!busy_buffers_.empty()) {
       if (!CheckForQueryResult(gl, busy_buffers_.front()->query_id))
         break;
 
@@ skipping 124 matching lines @@
   // buffer should be released.
   base::TimeTicks reduce_memory_usage_time =
       GetUsageTimeForLRUBuffer() + staging_buffer_expiration_delay_;
   task_runner_->PostDelayedTask(FROM_HERE, reduce_memory_usage_callback_,
                                 reduce_memory_usage_time - current_time);
 }
 
 void StagingBufferPool::ReleaseBuffersNotUsedSince(base::TimeTicks time) {
   lock_.AssertAcquired();
 
-  ContextProvider* context_provider =
-      resource_provider_->output_surface()->worker_context_provider();
-  DCHECK(context_provider);
-
   {
-    ContextProvider::ScopedContextLock scoped_context(context_provider);
+    ContextProvider::ScopedContextLock scoped_context(worker_context_provider_);
 
     gpu::gles2::GLES2Interface* gl = scoped_context.ContextGL();
     DCHECK(gl);
 
     // Note: Front buffer is guaranteed to be LRU so we can stop releasing
     // buffers as soon as we find a buffer that has been used since |time|.
     while (!free_buffers_.empty()) {
       if (free_buffers_.front()->last_usage > time)
         return;
 
       free_buffers_.front()->DestroyGLResources(gl);
       MarkStagingBufferAsBusy(free_buffers_.front().get());
       RemoveStagingBuffer(free_buffers_.front().get());
       free_buffers_.pop_front();
     }
 
     while (!busy_buffers_.empty()) {
       if (busy_buffers_.front()->last_usage > time)
         return;
 
       busy_buffers_.front()->DestroyGLResources(gl);
       RemoveStagingBuffer(busy_buffers_.front().get());
       busy_buffers_.pop_front();
     }
   }
 }
 
 }  // namespace cc