cc: Refactor ResourceProvider.

cc/resources/resource_provider.cc

 // Copyright 2012 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/resource_provider.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "base/containers/hash_tables.h"
@@ skipping 116 matching lines @@
   src.copyTo(&dst_bitmap, dst_colorType, &allocator);
   // TODO(kaanb): The GL pipeline assumes a 4-byte alignment for the
   // bitmap data. This check will be removed once crbug.com/293728 is fixed.
   CHECK_EQ(0u, dst_bitmap.rowBytes() % 4);
 }
 
 class ScopedSetActiveTexture {
  public:
   ScopedSetActiveTexture(GLES2Interface* gl, GLenum unit)
       : gl_(gl), unit_(unit) {
-    DCHECK_EQ(GL_TEXTURE0, ResourceProvider::GetActiveTextureUnit(gl_));
+    DCHECK_EQ(GL_TEXTURE0, ResourceHelper::GetActiveTextureUnit(gl_));
 
     if (unit_ != GL_TEXTURE0)
       GLC(gl_, gl_->ActiveTexture(unit_));
   }
 
   ~ScopedSetActiveTexture() {
     // Active unit being GL_TEXTURE0 is effectively the ground state.
     if (unit_ != GL_TEXTURE0)
       GLC(gl_, gl_->ActiveTexture(GL_TEXTURE0));
   }
@@ skipping 304 matching lines @@
   // generationID returns a non-zero, unique value corresponding to the content
   // of surface. Hence, a change since DoLockForWrite was called means the
   // surface has changed.
   return surface_ ? surface_generation_id_ != surface_->generationID() : false;
 }
 
 skia::RefPtr<SkSurface> ResourceProvider::GpuRasterBuffer::CreateSurface() {
   DCHECK_EQ(GLTexture, resource()->type);
   DCHECK(resource()->gl_id);
 
-  class GrContext* gr_context = resource_provider()->GrContext();
+  class GrContext* gr_context =
+      resource_provider()->GetResourceHelper()->GrContext();
   // TODO(alokp): Implement TestContextProvider::GrContext().
   if (!gr_context)
     return skia::RefPtr<SkSurface>();
 
   GrBackendTextureDesc desc;
   desc.fFlags = kRenderTarget_GrBackendTextureFlag;
   desc.fWidth = resource()->size.width();
   desc.fHeight = resource()->size.height();
   desc.fConfig = ToGrPixelConfig(resource()->format);
   desc.fOrigin = kTopLeft_GrSurfaceOrigin;
@@ skipping 116 matching lines @@
     size_t id_allocation_chunk_size,
     bool use_distance_field_text) {
   scoped_ptr<ResourceProvider> resource_provider(
       new ResourceProvider(output_surface,
                            shared_bitmap_manager,
                            highp_threshold_min,
                            use_rgba_4444_texture_format,
                            id_allocation_chunk_size,
                            use_distance_field_text));
 
-  if (resource_provider->ContextGL())
+  if (resource_provider->GetResourceHelper()->ContextGL())
     resource_provider->InitializeGL();
   else
     resource_provider->InitializeSoftware();
 
   DCHECK_NE(InvalidType, resource_provider->default_resource_type());
   return resource_provider.Pass();
 }
 
 ResourceProvider::~ResourceProvider() {
   while (!children_.empty())
@@ skipping 131 matching lines @@
   Resource resource(0,
                     gfx::Size(),
                     Resource::Internal,
                     GL_TEXTURE_RECTANGLE_ARB,
                     GL_LINEAR,
                     GL_TEXTURE_POOL_UNMANAGED_CHROMIUM,
                     GL_CLAMP_TO_EDGE,
                     TextureUsageAny,
                     RGBA_8888);
   LazyCreate(&resource);
-  GLES2Interface* gl = ContextGL();
+  GLES2Interface* gl = resource_helper_->ContextGL();
   DCHECK(gl);
   gl->BindTexture(GL_TEXTURE_RECTANGLE_ARB, resource.gl_id);
   gl->TexImageIOSurface2DCHROMIUM(
       GL_TEXTURE_RECTANGLE_ARB, size.width(), size.height(), io_surface_id, 0);
   resource.allocated = true;
   resources_[id] = resource;
   return id;
 }
 
 ResourceProvider::ResourceId ResourceProvider::CreateResourceFromTextureMailbox(
@@ skipping 67 matching lines @@
   DCHECK(resource->exported_count == 0 || style != Normal);
   if (style == ForShutdown && resource->exported_count > 0)
     lost_resource = true;
 
   resource->gpu_raster_buffer.reset();
   resource->image_raster_buffer.reset();
   resource->pixel_raster_buffer.reset();
 
   if (resource->image_id) {
     DCHECK(resource->origin == Resource::Internal);
-    GLES2Interface* gl = ContextGL();
+    GLES2Interface* gl = resource_helper_->ContextGL();
     DCHECK(gl);
     GLC(gl, gl->DestroyImageCHROMIUM(resource->image_id));
   }
   if (resource->gl_upload_query_id) {
     DCHECK(resource->origin == Resource::Internal);
-    GLES2Interface* gl = ContextGL();
+    GLES2Interface* gl = resource_helper_->ContextGL();
     DCHECK(gl);
     GLC(gl, gl->DeleteQueriesEXT(1, &resource->gl_upload_query_id));
   }
   if (resource->gl_read_lock_query_id) {
     DCHECK(resource->origin == Resource::Internal);
-    GLES2Interface* gl = ContextGL();
+    GLES2Interface* gl = resource_helper_->ContextGL();
     DCHECK(gl);
     GLC(gl, gl->DeleteQueriesEXT(1, &resource->gl_read_lock_query_id));
   }
   if (resource->gl_pixel_buffer_id) {
     DCHECK(resource->origin == Resource::Internal);
-    GLES2Interface* gl = ContextGL();
+    GLES2Interface* gl = resource_helper_->ContextGL();
     DCHECK(gl);
     GLC(gl, gl->DeleteBuffers(1, &resource->gl_pixel_buffer_id));
   }
   if (resource->origin == Resource::External) {
     DCHECK(resource->mailbox.IsValid());
     GLuint sync_point = resource->mailbox.sync_point();
     if (resource->type == GLTexture) {
       DCHECK(resource->mailbox.IsTexture());
       lost_resource |= lost_output_surface_;
-      GLES2Interface* gl = ContextGL();
+      GLES2Interface* gl = resource_helper_->ContextGL();
       DCHECK(gl);
       if (resource->gl_id) {
         GLC(gl, gl->DeleteTextures(1, &resource->gl_id));
         resource->gl_id = 0;
         if (!lost_resource)
           sync_point = gl->InsertSyncPointCHROMIUM();
       }
     } else {
       DCHECK(resource->mailbox.IsSharedMemory());
       base::SharedMemory* shared_memory = resource->mailbox.shared_memory();
       if (resource->pixels && shared_memory) {
         DCHECK(shared_memory->memory() == resource->pixels);
         resource->pixels = NULL;
         delete resource->shared_bitmap;
         resource->shared_bitmap = NULL;
       }
     }
     resource->release_callback.Run(sync_point, lost_resource);
   }
   if (resource->gl_id) {
-    GLES2Interface* gl = ContextGL();
+    GLES2Interface* gl = resource_helper_->ContextGL();
     DCHECK(gl);
     GLC(gl, gl->DeleteTextures(1, &resource->gl_id));
     resource->gl_id = 0;
   }
   if (resource->shared_bitmap) {
     DCHECK(resource->origin != Resource::External);
     DCHECK_EQ(Bitmap, resource->type);
     delete resource->shared_bitmap;
     resource->pixels = NULL;
   }
@@ skipping 19 matching lines @@
   DCHECK(!resource->lock_for_read_count);
   DCHECK(resource->origin == Resource::Internal);
   DCHECK_EQ(resource->exported_count, 0);
   DCHECK(ReadLockFenceHasPassed(resource));
   LazyAllocate(resource);
 
   if (resource->type == GLTexture) {
     DCHECK(resource->gl_id);
     DCHECK(!resource->pending_set_pixels);
     DCHECK_EQ(resource->target, static_cast<GLenum>(GL_TEXTURE_2D));
-    GLES2Interface* gl = ContextGL();
+    GLES2Interface* gl = resource_helper_->ContextGL();
     DCHECK(gl);
     DCHECK(texture_uploader_.get());
     gl->BindTexture(GL_TEXTURE_2D, resource->gl_id);
     texture_uploader_->Upload(image,
                               image_rect,
                               source_rect,
                               dest_offset,
                               resource->format,
                               resource->size);
   } else {
@@ skipping 69 matching lines @@
 
   base::TimeDelta upload_one_texture_time =
       base::TimeDelta::FromMicroseconds(
           base::Time::kMicrosecondsPerSecond * kTextureUploadTickRate) /
       uploads_per_tick;
 
   size_t total_uploads = NumBlockingUploads() + uploads_per_tick;
   return gfx::FrameTime::Now() + upload_one_texture_time * total_uploads;
 }
 
-void ResourceProvider::Flush() {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  GLES2Interface* gl = ContextGL();
-  if (gl)
-    gl->Flush();
-}
-
-void ResourceProvider::Finish() {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  GLES2Interface* gl = ContextGL();
-  if (gl)
-    gl->Finish();
-}
-
-bool ResourceProvider::ShallowFlushIfSupported() {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  GLES2Interface* gl = ContextGL();
-  if (!gl)
-    return false;
-
-  gl->ShallowFlushCHROMIUM();
-  return true;
-}
-
 ResourceProvider::Resource* ResourceProvider::GetResource(ResourceId id) {
   DCHECK(thread_checker_.CalledOnValidThread());
   ResourceMap::iterator it = resources_.find(id);
   CHECK(it != resources_.end());
   return &it->second;
 }
 
 const ResourceProvider::Resource* ResourceProvider::LockForRead(ResourceId id) {
   Resource* resource = GetResource(id);
   DCHECK(!resource->locked_for_write ||
          resource->set_pixels_completion_forced) <<
       "locked for write: " << resource->locked_for_write <<
       " pixels completion forced: " << resource->set_pixels_completion_forced;
   DCHECK_EQ(resource->exported_count, 0);
   // Uninitialized! Call SetPixels or LockForWrite first.
   DCHECK(resource->allocated);
 
   LazyCreate(resource);
 
   if (resource->type == GLTexture && !resource->gl_id) {
     DCHECK(resource->origin != Resource::Internal);
     DCHECK(resource->mailbox.IsTexture());
-    GLES2Interface* gl = ContextGL();
+    GLES2Interface* gl = resource_helper_->ContextGL();
     DCHECK(gl);
     if (resource->mailbox.sync_point()) {
       GLC(gl, gl->WaitSyncPointCHROMIUM(resource->mailbox.sync_point()));
       resource->mailbox.set_sync_point(0);
     }
     resource->gl_id = texture_id_allocator_->NextId();
     GLC(gl, gl->BindTexture(resource->target, resource->gl_id));
     GLC(gl,
         gl->ConsumeTextureCHROMIUM(resource->mailbox.target(),
                                    resource->mailbox.name()));
@@ skipping 147 matching lines @@
   ResourceProvider::PopulateSkBitmapWithResource(
       &sk_bitmap_, resource_provider->LockForWrite(resource_id));
   DCHECK(valid());
   sk_canvas_.reset(new SkCanvas(sk_bitmap_));
 }
 
 ResourceProvider::ScopedWriteLockSoftware::~ScopedWriteLockSoftware() {
   resource_provider_->UnlockForWrite(resource_id_);
 }
 
-ResourceProvider::ScopedGpuRaster::ScopedGpuRaster(
-    ResourceProvider* resource_provider)
-    : resource_provider_(resource_provider) {
-  resource_provider_->BeginGpuRaster();
-}
-
-ResourceProvider::ScopedGpuRaster::~ScopedGpuRaster() {
-  resource_provider_->EndGpuRaster();
-}
-
 ResourceProvider::ResourceProvider(OutputSurface* output_surface,
                                    SharedBitmapManager* shared_bitmap_manager,
                                    int highp_threshold_min,
                                    bool use_rgba_4444_texture_format,
                                    size_t id_allocation_chunk_size,
                                    bool use_distance_field_text)
     : output_surface_(output_surface),
       shared_bitmap_manager_(shared_bitmap_manager),
       lost_output_surface_(false),
       highp_threshold_min_(highp_threshold_min),
       next_id_(1),
       next_child_(1),
       default_resource_type_(InvalidType),
       use_texture_storage_ext_(false),
       use_texture_usage_hint_(false),
       use_compressed_texture_etc1_(false),
       max_texture_size_(0),
       best_texture_format_(RGBA_8888),
       use_rgba_4444_texture_format_(use_rgba_4444_texture_format),
       id_allocation_chunk_size_(id_allocation_chunk_size),
       use_sync_query_(false),
-      use_distance_field_text_(use_distance_field_text) {
+      use_distance_field_text_(use_distance_field_text),
+      resource_helper_(new ResourceHelper(output_surface)) {
   DCHECK(output_surface_->HasClient());
   DCHECK(id_allocation_chunk_size_);
 }
 
 void ResourceProvider::InitializeSoftware() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK_NE(Bitmap, default_resource_type_);
 
   CleanUpGLIfNeeded();
 
@@ skipping 14 matching lines @@
 
   const ContextProvider::Capabilities& caps =
       output_surface_->context_provider()->ContextCapabilities();
 
   bool use_bgra = caps.gpu.texture_format_bgra8888;
   use_texture_storage_ext_ = caps.gpu.texture_storage;
   use_texture_usage_hint_ = caps.gpu.texture_usage;
   use_compressed_texture_etc1_ = caps.gpu.texture_format_etc1;
   use_sync_query_ = caps.gpu.sync_query;
 
-  GLES2Interface* gl = ContextGL();
+  GLES2Interface* gl = resource_helper_->ContextGL();
   DCHECK(gl);
 
   texture_uploader_ = TextureUploader::Create(gl);
   max_texture_size_ = 0;  // Context expects cleared value.
   GLC(gl, gl->GetIntegerv(GL_MAX_TEXTURE_SIZE, &max_texture_size_));
   best_texture_format_ = PlatformColor::BestTextureFormat(use_bgra);
 
   texture_id_allocator_.reset(
       new TextureIdAllocator(gl, id_allocation_chunk_size_));
   buffer_id_allocator_.reset(
       new BufferIdAllocator(gl, id_allocation_chunk_size_));
 }
 
 void ResourceProvider::CleanUpGLIfNeeded() {
-  GLES2Interface* gl = ContextGL();
+  GLES2Interface* gl = resource_helper_->ContextGL();
   if (default_resource_type_ != GLTexture) {
     // We are not in GL mode, but double check before returning.
     DCHECK(!gl);
     DCHECK(!texture_uploader_);
     return;
   }
 
   DCHECK(gl);
 #if DCHECK_IS_ON
   // Check that all GL resources has been deleted.
   for (ResourceMap::const_iterator itr = resources_.begin();
        itr != resources_.end();
        ++itr) {
     DCHECK_NE(GLTexture, itr->second.type);
   }
 #endif  // DCHECK_IS_ON
 
   texture_uploader_.reset();
   texture_id_allocator_.reset();
   buffer_id_allocator_.reset();
-  Finish();
+  GetResourceHelper()->Finish();

[danakj, 2014/07/09 16:01:33]

can we just call gl->Finish() directly?

[sohanjg, 2014/07/10 15:11:06]

Done.

 }
 
 int ResourceProvider::CreateChild(const ReturnCallback& return_callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   Child child_info;
   child_info.return_callback = return_callback;
 
   int child = next_child_++;
   children_[child] = child_info;
@@ skipping 34 matching lines @@
   DCHECK(thread_checker_.CalledOnValidThread());
   ChildMap::const_iterator it = children_.find(child);
   DCHECK(it != children_.end());
   DCHECK(!it->second.marked_for_deletion);
   return it->second.child_to_parent_map;
 }
 
 void ResourceProvider::PrepareSendToParent(const ResourceIdArray& resources,
                                            TransferableResourceArray* list) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  GLES2Interface* gl = ContextGL();
+  GLES2Interface* gl = resource_helper_->ContextGL();
   bool need_sync_point = false;
   for (ResourceIdArray::const_iterator it = resources.begin();
        it != resources.end();
        ++it) {
     TransferableResource resource;
     TransferResource(gl, *it, &resource);
     if (!resource.mailbox_holder.sync_point && !resource.is_software)
       need_sync_point = true;
     ++resources_.find(*it)->second.exported_count;
     list->push_back(resource);
   }
   if (need_sync_point) {
     GLuint sync_point = gl->InsertSyncPointCHROMIUM();
     for (TransferableResourceArray::iterator it = list->begin();
          it != list->end();
          ++it) {
       if (!it->mailbox_holder.sync_point)
         it->mailbox_holder.sync_point = sync_point;
     }
   }
 }
 
 void ResourceProvider::ReceiveFromChild(
     int child, const TransferableResourceArray& resources) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  GLES2Interface* gl = ContextGL();
+  GLES2Interface* gl = resource_helper_->ContextGL();
   Child& child_info = children_.find(child)->second;
   DCHECK(!child_info.marked_for_deletion);
   for (TransferableResourceArray::const_iterator it = resources.begin();
        it != resources.end();
        ++it) {
     ResourceIdMap::iterator resource_in_map_it =
         child_info.child_to_parent_map.find(it->id);
     if (resource_in_map_it != child_info.child_to_parent_map.end()) {
       Resource& resource = resources_[resource_in_map_it->second];
       resource.marked_for_deletion = false;
@@ skipping 81 matching lines @@
   const ResourceMap::iterator& a_it = a.second;
   const ResourceMap::iterator& b_it = b.second;
   const Resource& a_resource = a_it->second;
   const Resource& b_resource = b_it->second;
   return a_resource.child_id < b_resource.child_id;
 }
 
 void ResourceProvider::ReceiveReturnsFromParent(
     const ReturnedResourceArray& resources) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  GLES2Interface* gl = ContextGL();
+  GLES2Interface* gl = resource_helper_->ContextGL();
 
   int child_id = 0;
   ResourceIdArray resources_for_child;
 
   std::vector<std::pair<ReturnedResource, ResourceMap::iterator> >
       sorted_resources;
 
   for (ReturnedResourceArray::const_iterator it = resources.begin();
        it != resources.end();
        ++it) {
@@ skipping 138 matching lines @@
     const ResourceIdArray& unused) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(child_it != children_.end());
   Child* child_info = &child_it->second;
 
   if (unused.empty() && !child_info->marked_for_deletion)
     return;
 
   ReturnedResourceArray to_return;
 
-  GLES2Interface* gl = ContextGL();
+  GLES2Interface* gl = resource_helper_->ContextGL();
   bool need_sync_point = false;
   for (size_t i = 0; i < unused.size(); ++i) {
     ResourceId local_id = unused[i];
 
     ResourceMap::iterator it = resources_.find(local_id);
     CHECK(it != resources_.end());
     Resource& resource = it->second;
 
     DCHECK(!resource.locked_for_write);
     DCHECK_EQ(0u, child_info->in_use_resources.count(local_id));
@@ skipping 124 matching lines @@
 void ResourceProvider::AcquirePixelBuffer(Resource* resource) {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
                "ResourceProvider::AcquirePixelBuffer");
 
   DCHECK(resource->origin == Resource::Internal);
   DCHECK_EQ(resource->exported_count, 0);
   DCHECK(!resource->image_id);
   DCHECK_NE(ETC1, resource->format);
 
   DCHECK_EQ(GLTexture, resource->type);
-  GLES2Interface* gl = ContextGL();
+  GLES2Interface* gl = resource_helper_->ContextGL();
   DCHECK(gl);
   if (!resource->gl_pixel_buffer_id)
     resource->gl_pixel_buffer_id = buffer_id_allocator_->NextId();
   gl->BindBuffer(GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM,
                  resource->gl_pixel_buffer_id);
   unsigned bytes_per_pixel = BitsPerPixel(resource->format) / 8;
   gl->BufferData(GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM,
                  resource->size.height() *
                      RoundUp(bytes_per_pixel * resource->size.width(), 4u),
                  NULL,
@@ skipping 17 matching lines @@
   // as each new query has a unique submit count.
   if (resource->pending_set_pixels) {
     DCHECK(resource->set_pixels_completion_forced);
     resource->pending_set_pixels = false;
     resource->locked_for_write = false;
   }
 
   DCHECK_EQ(GLTexture, resource->type);
   if (!resource->gl_pixel_buffer_id)
     return;
-  GLES2Interface* gl = ContextGL();
+  GLES2Interface* gl = resource_helper_->ContextGL();
   DCHECK(gl);
   gl->BindBuffer(GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM,
                  resource->gl_pixel_buffer_id);
   gl->BufferData(
       GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM, 0, NULL, GL_DYNAMIC_DRAW);
   gl->BindBuffer(GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM, 0);
 }
 
 uint8_t* ResourceProvider::MapPixelBuffer(const Resource* resource,
                                           int* stride) {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
                "ResourceProvider::MapPixelBuffer");
 
   DCHECK(resource->origin == Resource::Internal);
   DCHECK_EQ(resource->exported_count, 0);
   DCHECK(!resource->image_id);
 
   *stride = 0;
   DCHECK_EQ(GLTexture, resource->type);
-  GLES2Interface* gl = ContextGL();
+  GLES2Interface* gl = resource_helper_->ContextGL();
   DCHECK(gl);
   DCHECK(resource->gl_pixel_buffer_id);
   gl->BindBuffer(GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM,
                  resource->gl_pixel_buffer_id);
   uint8_t* image = static_cast<uint8_t*>(gl->MapBufferCHROMIUM(
       GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM, GL_WRITE_ONLY));
   gl->BindBuffer(GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM, 0);
   // Buffer is required to be 4-byte aligned.
   CHECK(!(reinterpret_cast<intptr_t>(image) & 3));
   return image;
 }
 
 void ResourceProvider::UnmapPixelBuffer(const Resource* resource) {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
                "ResourceProvider::UnmapPixelBuffer");
 
   DCHECK(resource->origin == Resource::Internal);
   DCHECK_EQ(resource->exported_count, 0);
   DCHECK(!resource->image_id);
 
   DCHECK_EQ(GLTexture, resource->type);
-  GLES2Interface* gl = ContextGL();
+  GLES2Interface* gl = resource_helper_->ContextGL();
   DCHECK(gl);
   DCHECK(resource->gl_pixel_buffer_id);
   gl->BindBuffer(GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM,
                  resource->gl_pixel_buffer_id);
   gl->UnmapBufferCHROMIUM(GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM);
   gl->BindBuffer(GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM, 0);
 }
 
 GLenum ResourceProvider::BindForSampling(
     ResourceProvider::ResourceId resource_id,
     GLenum unit,
     GLenum filter) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  GLES2Interface* gl = ContextGL();
+  GLES2Interface* gl = resource_helper_->ContextGL();
   ResourceMap::iterator it = resources_.find(resource_id);
   DCHECK(it != resources_.end());
   Resource* resource = &it->second;
   DCHECK(resource->lock_for_read_count);
   DCHECK(!resource->locked_for_write || resource->set_pixels_completion_forced);
 
   ScopedSetActiveTexture scoped_active_tex(gl, unit);
   GLenum target = resource->target;
   GLC(gl, gl->BindTexture(target, resource->gl_id));
   if (filter != resource->filter) {
@@ skipping 20 matching lines @@
   DCHECK(resource->gl_id || resource->allocated);
   DCHECK(ReadLockFenceHasPassed(resource));
   DCHECK(!resource->image_id);
 
   bool allocate = !resource->allocated;
   resource->allocated = true;
   LockForWrite(id);
 
   DCHECK_EQ(GLTexture, resource->type);
   DCHECK(resource->gl_id);
-  GLES2Interface* gl = ContextGL();
+  GLES2Interface* gl = resource_helper_->ContextGL();
   DCHECK(gl);
   DCHECK(resource->gl_pixel_buffer_id);
   DCHECK_EQ(resource->target, static_cast<GLenum>(GL_TEXTURE_2D));
   gl->BindTexture(GL_TEXTURE_2D, resource->gl_id);
   gl->BindBuffer(GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM,
                  resource->gl_pixel_buffer_id);
   if (!resource->gl_upload_query_id)
     gl->GenQueriesEXT(1, &resource->gl_upload_query_id);
   gl->BeginQueryEXT(GL_ASYNC_PIXEL_UNPACK_COMPLETED_CHROMIUM,
                     resource->gl_upload_query_id);
@@ skipping 28 matching lines @@
 void ResourceProvider::ForceSetPixelsToComplete(ResourceId id) {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
                "ResourceProvider::ForceSetPixelsToComplete");
 
   Resource* resource = GetResource(id);
   DCHECK(resource->locked_for_write);
   DCHECK(resource->pending_set_pixels);
   DCHECK(!resource->set_pixels_completion_forced);
 
   if (resource->gl_id) {
-    GLES2Interface* gl = ContextGL();
+    GLES2Interface* gl = resource_helper_->ContextGL();
     GLC(gl, gl->BindTexture(GL_TEXTURE_2D, resource->gl_id));
     GLC(gl, gl->WaitAsyncTexImage2DCHROMIUM(GL_TEXTURE_2D));
     GLC(gl, gl->BindTexture(GL_TEXTURE_2D, 0));
   }
 
   resource->set_pixels_completion_forced = true;
 }
 
 bool ResourceProvider::DidSetPixelsComplete(ResourceId id) {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
                "ResourceProvider::DidSetPixelsComplete");
 
   Resource* resource = GetResource(id);
   DCHECK(resource->locked_for_write);
   DCHECK(resource->pending_set_pixels);
 
   if (resource->gl_id) {
-    GLES2Interface* gl = ContextGL();
+    GLES2Interface* gl = resource_helper_->ContextGL();
     DCHECK(gl);
     DCHECK(resource->gl_upload_query_id);
     GLuint complete = 1;
     gl->GetQueryObjectuivEXT(
         resource->gl_upload_query_id, GL_QUERY_RESULT_AVAILABLE_EXT, &complete);
     if (!complete)
       return false;
   }
 
   resource->pending_set_pixels = false;
@@ skipping 16 matching lines @@
     return;
 
   if (resource->gl_id)
     return;
 
   DCHECK(resource->texture_pool);
   DCHECK(resource->origin == Resource::Internal);
   DCHECK(!resource->mailbox.IsValid());
   resource->gl_id = texture_id_allocator_->NextId();
 
-  GLES2Interface* gl = ContextGL();
+  GLES2Interface* gl = resource_helper_->ContextGL();
   DCHECK(gl);
 
   // Create and set texture properties. Allocation is delayed until needed.
   GLC(gl, gl->BindTexture(resource->target, resource->gl_id));
   GLC(gl,
       gl->TexParameteri(resource->target, GL_TEXTURE_MIN_FILTER, GL_LINEAR));
   GLC(gl,
       gl->TexParameteri(resource->target, GL_TEXTURE_MAG_FILTER, GL_LINEAR));
   GLC(gl,
       gl->TexParameteri(
@@ skipping 17 matching lines @@
 }
 
 void ResourceProvider::LazyAllocate(Resource* resource) {
   DCHECK(resource);
   LazyCreate(resource);
 
   DCHECK(resource->gl_id || resource->allocated);
   if (resource->allocated || !resource->gl_id)
     return;
   resource->allocated = true;
-  GLES2Interface* gl = ContextGL();
+  GLES2Interface* gl = resource_helper_->ContextGL();
   gfx::Size& size = resource->size;
   DCHECK_EQ(resource->target, static_cast<GLenum>(GL_TEXTURE_2D));
   ResourceFormat format = resource->format;
   GLC(gl, gl->BindTexture(GL_TEXTURE_2D, resource->gl_id));
   if (use_texture_storage_ext_ && IsFormatSupportedForStorage(format) &&
       resource->hint != TextureUsageFramebuffer) {
     GLenum storage_format = TextureToStorageFormat(format);
     GLC(gl,
         gl->TexStorage2DEXT(
             GL_TEXTURE_2D, 1, storage_format, size.width(), size.height()));
   } else {
     // ETC1 does not support preallocation.
     if (format != ETC1) {
       GLC(gl,
           gl->TexImage2D(GL_TEXTURE_2D,
                          0,
                          GLInternalFormat(format),
                          size.width(),
                          size.height(),
                          0,
                          GLDataFormat(format),
                          GLDataType(format),
                          NULL));
     }
   }
 }
 
 void ResourceProvider::BindImageForSampling(Resource* resource) {
-  GLES2Interface* gl = ContextGL();
+  GLES2Interface* gl = resource_helper_->ContextGL();
   DCHECK(resource->gl_id);
   DCHECK(resource->image_id);
 
   // Release image currently bound to texture.
   if (resource->bound_image_id)
     gl->ReleaseTexImage2DCHROMIUM(resource->target, resource->bound_image_id);
   gl->BindTexImage2DCHROMIUM(resource->target, resource->image_id);
   resource->bound_image_id = resource->image_id;
   resource->dirty_image = false;
 }
 
 void ResourceProvider::EnableReadLockFences(ResourceProvider::ResourceId id,
                                             bool enable) {
   Resource* resource = GetResource(id);
   resource->enable_read_lock_fences = enable;
 }
 
 void ResourceProvider::AcquireImage(Resource* resource) {
   DCHECK(resource->origin == Resource::Internal);
   DCHECK_EQ(resource->exported_count, 0);
 
   if (resource->type != GLTexture)
     return;
 
   if (resource->image_id)
     return;
 
   resource->allocated = true;
-  GLES2Interface* gl = ContextGL();
+  GLES2Interface* gl = resource_helper_->ContextGL();
   DCHECK(gl);
   resource->image_id =
       gl->CreateImageCHROMIUM(resource->size.width(),
                               resource->size.height(),
                               TextureToStorageFormat(resource->format),
                               GL_IMAGE_MAP_CHROMIUM);
   DCHECK(resource->image_id);
 }
 
 void ResourceProvider::ReleaseImage(Resource* resource) {
   DCHECK(resource->origin == Resource::Internal);
   DCHECK_EQ(resource->exported_count, 0);
 
   if (!resource->image_id)
     return;
 
-  GLES2Interface* gl = ContextGL();
+  GLES2Interface* gl = resource_helper_->ContextGL();
   DCHECK(gl);
   gl->DestroyImageCHROMIUM(resource->image_id);
   resource->image_id = 0;
   resource->bound_image_id = 0;
   resource->dirty_image = false;
   resource->allocated = false;
 }
 
 uint8_t* ResourceProvider::MapImage(const Resource* resource, int* stride) {
   DCHECK(ReadLockFenceHasPassed(resource));
   DCHECK(resource->origin == Resource::Internal);
   DCHECK_EQ(resource->exported_count, 0);
 
   if (resource->type == GLTexture) {
     DCHECK(resource->image_id);
-    GLES2Interface* gl = ContextGL();
+    GLES2Interface* gl = resource_helper_->ContextGL();
     DCHECK(gl);
     // MapImageCHROMIUM should be called prior to GetImageParameterivCHROMIUM.
     uint8_t* pixels =
         static_cast<uint8_t*>(gl->MapImageCHROMIUM(resource->image_id));
     gl->GetImageParameterivCHROMIUM(
         resource->image_id, GL_IMAGE_ROWBYTES_CHROMIUM, stride);
     return pixels;
   }
   DCHECK_EQ(Bitmap, resource->type);
   *stride = 0;
   return resource->pixels;
 }
 
 void ResourceProvider::UnmapImage(const Resource* resource) {
   DCHECK(resource->origin == Resource::Internal);
   DCHECK_EQ(resource->exported_count, 0);
 
   if (resource->image_id) {
-    GLES2Interface* gl = ContextGL();
+    GLES2Interface* gl = resource_helper_->ContextGL();
     DCHECK(gl);
     gl->UnmapImageCHROMIUM(resource->image_id);
   }
 }
 
 void ResourceProvider::CopyResource(ResourceId source_id, ResourceId dest_id) {
   TRACE_EVENT0("cc", "ResourceProvider::CopyResource");
 
   Resource* source_resource = GetResource(source_id);
   DCHECK(!source_resource->lock_for_read_count);
   DCHECK(source_resource->origin == Resource::Internal);
   DCHECK_EQ(source_resource->exported_count, 0);
   DCHECK(source_resource->allocated);
   LazyCreate(source_resource);
 
   Resource* dest_resource = GetResource(dest_id);
   DCHECK(!dest_resource->locked_for_write);
   DCHECK(!dest_resource->lock_for_read_count);
   DCHECK(dest_resource->origin == Resource::Internal);
   DCHECK_EQ(dest_resource->exported_count, 0);
   LazyCreate(dest_resource);
 
   DCHECK_EQ(source_resource->type, dest_resource->type);
   DCHECK_EQ(source_resource->format, dest_resource->format);
   DCHECK(source_resource->size == dest_resource->size);
 
   if (source_resource->type == GLTexture) {
-    GLES2Interface* gl = ContextGL();
+    GLES2Interface* gl = resource_helper_->ContextGL();
     DCHECK(gl);
     if (source_resource->image_id && source_resource->dirty_image) {
       gl->BindTexture(source_resource->target, source_resource->gl_id);
       BindImageForSampling(source_resource);
     }
     DCHECK(use_sync_query_) << "CHROMIUM_sync_query extension missing";
     if (!source_resource->gl_read_lock_query_id)
       gl->GenQueriesEXT(1, &source_resource->gl_read_lock_query_id);
     gl->BeginQueryEXT(GL_COMMANDS_COMPLETED_CHROMIUM,
                       source_resource->gl_read_lock_query_id);
@@ skipping 13 matching lines @@
   } else {
     DCHECK_EQ(Bitmap, source_resource->type);
     DCHECK_EQ(RGBA_8888, source_resource->format);
     LazyAllocate(dest_resource);
 
     size_t bytes = SharedBitmap::CheckedSizeInBytes(source_resource->size);
     memcpy(dest_resource->pixels, source_resource->pixels, bytes);
   }
 }
 
-GLint ResourceProvider::GetActiveTextureUnit(GLES2Interface* gl) {
-  GLint active_unit = 0;
-  gl->GetIntegerv(GL_ACTIVE_TEXTURE, &active_unit);
-  return active_unit;
-}
-
-GLES2Interface* ResourceProvider::ContextGL() const {
-  ContextProvider* context_provider = output_surface_->context_provider();
-  return context_provider ? context_provider->ContextGL() : NULL;
-}
-
-class GrContext* ResourceProvider::GrContext() const {
-  ContextProvider* context_provider = output_surface_->context_provider();
-  return context_provider ? context_provider->GrContext() : NULL;
-}
-
-void ResourceProvider::BeginGpuRaster() {
-  GLES2Interface* gl = ContextGL();
-  DCHECK(gl);
-
-  // TODO(alokp): Use a trace macro to push/pop markers.
-  // Using push/pop functions directly incurs cost to evaluate function
-  // arguments even when tracing is disabled.
-  gl->PushGroupMarkerEXT(0, "GpuRasterization");
-
-  class GrContext* gr_context = GrContext();
-  if (gr_context)
-    gr_context->resetContext();
-}
-
-void ResourceProvider::EndGpuRaster() {
-  GLES2Interface* gl = ContextGL();
-  DCHECK(gl);
-
-  class GrContext* gr_context = GrContext();
-  if (gr_context)
-    gr_context->flush();
-
-  // TODO(alokp): Use a trace macro to push/pop markers.
-  // Using push/pop functions directly incurs cost to evaluate function
-  // arguments even when tracing is disabled.
-  gl->PopGroupMarkerEXT();
-}
-
 }  // namespace cc