cc: Refactor ResourceProvider.

cc/resources/image_copy_raster_worker_pool.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/resources/image_copy_raster_worker_pool.h"
 
 #include <algorithm>
 
 #include "base/debug/trace_event.h"
 #include "cc/debug/traced_value.h"
 #include "cc/resources/resource_pool.h"
 #include "cc/resources/scoped_resource.h"
+#include "gpu/command_buffer/client/gles2_interface.h"
+
+using gpu::gles2::GLES2Interface;
 
 namespace cc {
 
 // static
 scoped_ptr<RasterWorkerPool> ImageCopyRasterWorkerPool::Create(
     base::SequencedTaskRunner* task_runner,
     TaskGraphRunner* task_graph_runner,
     ResourceProvider* resource_provider,
     ResourcePool* resource_pool) {
   return make_scoped_ptr<RasterWorkerPool>(new ImageCopyRasterWorkerPool(
       task_runner, task_graph_runner, resource_provider, resource_pool));
 }
 
 ImageCopyRasterWorkerPool::ImageCopyRasterWorkerPool(

[danakj, 2014/07/10 17:01:43]

We can pass the ContextProvider to this class, then we don't have to dig it out
of the ResourceProvider.

[sohanjg, 2014/07/11 16:43:32]

Done.

     base::SequencedTaskRunner* task_runner,
     TaskGraphRunner* task_graph_runner,
     ResourceProvider* resource_provider,
     ResourcePool* resource_pool)
     : task_runner_(task_runner),
       task_graph_runner_(task_graph_runner),
       namespace_token_(task_graph_runner->GetNamespaceToken()),
       resource_provider_(resource_provider),
       resource_pool_(resource_pool),
       has_performed_copy_since_last_flush_(false),
@@ skipping 182 matching lines @@
       "rasterizing",
       "state",
       TracedValue::FromValue(StateAsValue().release()));
   client_->DidFinishRunningTasksRequiredForActivation();
 }
 
 void ImageCopyRasterWorkerPool::FlushCopies() {
   if (!has_performed_copy_since_last_flush_)
     return;
 
-  resource_provider_->ShallowFlushIfSupported();
+  GLES2Interface* gl = resource_provider_->ContextGL();
+  if (gl)
+    gl->ShallowFlushCHROMIUM();
+
   has_performed_copy_since_last_flush_ = false;
 }
 
 scoped_ptr<base::Value> ImageCopyRasterWorkerPool::StateAsValue() const {
   scoped_ptr<base::DictionaryValue> state(new base::DictionaryValue);
 
   state->SetInteger("pending_count", raster_task_states_.size());
   state->SetBoolean("tasks_required_for_activation_pending",
                     raster_tasks_required_for_activation_pending_);
   state->Set("staging_state", StagingStateAsValue().release());
@@ skipping 11 matching lines @@
                             resource_pool_->total_resource_count() -
                                 resource_pool_->acquired_resource_count());
   staging_state->SetInteger("bytes_pending_copy",
                             resource_pool_->total_memory_usage_bytes() -
                                 resource_pool_->acquired_memory_usage_bytes());
 
   return staging_state.PassAs<base::Value>();
 }
 
 }  // namespace cc