cc: Rename DirectRasterWorkerPool to GpuRasterWorkerPool

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 411 matching lines @@
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
                "ResourceProvider::RasterBuffer::UnlockForWrite");
 
   if (locked_canvas_) {
     locked_canvas_->restoreToCount(canvas_save_count_);
     locked_canvas_ = NULL;
   }
   return DoUnlockForWrite();
 }
 
-ResourceProvider::DirectRasterBuffer::DirectRasterBuffer(
+ResourceProvider::GpuRasterBuffer::GpuRasterBuffer(
     const Resource* resource,
     ResourceProvider* resource_provider,
-    bool use_distance_field_text )
+    bool use_distance_field_text)
     : RasterBuffer(resource, resource_provider),
       surface_generation_id_(0u),
-      use_distance_field_text_(use_distance_field_text) {}
+      use_distance_field_text_(use_distance_field_text) {
+}
 
-ResourceProvider::DirectRasterBuffer::~DirectRasterBuffer() {}
+ResourceProvider::GpuRasterBuffer::~GpuRasterBuffer() {
+}
 
-SkCanvas* ResourceProvider::DirectRasterBuffer::DoLockForWrite() {
+SkCanvas* ResourceProvider::GpuRasterBuffer::DoLockForWrite() {
   if (!surface_)
     surface_ = CreateSurface();
   surface_generation_id_ = surface_ ? surface_->generationID() : 0u;
   return surface_ ? surface_->getCanvas() : NULL;
 }
 
-bool ResourceProvider::DirectRasterBuffer::DoUnlockForWrite() {
+bool ResourceProvider::GpuRasterBuffer::DoUnlockForWrite() {
   // 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::DirectRasterBuffer::CreateSurface() {
+skia::RefPtr<SkSurface> ResourceProvider::GpuRasterBuffer::CreateSurface() {
   skia::RefPtr<SkSurface> surface;
   switch (resource()->type) {
     case GLTexture: {
       DCHECK(resource()->gl_id);
       class GrContext* gr_context = resource_provider()->GrContext();
       if (gr_context) {
         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;
         desc.fTextureHandle = resource()->gl_id;
         skia::RefPtr<GrTexture> gr_texture =
             skia::AdoptRef(gr_context->wrapBackendTexture(desc));
         SkSurface::TextRenderMode text_render_mode =
             use_distance_field_text_ ? SkSurface::kDistanceField_TextRenderMode
                                      : SkSurface::kStandard_TextRenderMode;
         surface = skia::AdoptRef(SkSurface::NewRenderTargetDirect(
             gr_texture->asRenderTarget(), text_render_mode));
       }
       break;
     }
     case Bitmap: {

[reveman, 2014/06/30 13:20:15]

You'll have to remove this case for the the name to be correct. I think we
should remove the switch statement completely and just DCHECK_EQ(GLTexture,
resource()->type).

[sohanjg, 2014/06/30 15:02:35]

Done.

       DCHECK(resource()->pixels);
       DCHECK_EQ(RGBA_8888, resource()->format);
       SkImageInfo image_info = SkImageInfo::MakeN32Premul(
           resource()->size.width(), resource()->size.height());
       surface = skia::AdoptRef(SkSurface::NewRasterDirect(
           image_info, resource()->pixels, image_info.minRowBytes()));
       break;
     }
     default:
       NOTREACHED();
@@ skipping 344 matching lines @@
 void ResourceProvider::DeleteResourceInternal(ResourceMap::iterator it,
                                               DeleteStyle style) {
   TRACE_EVENT0("cc", "ResourceProvider::DeleteResourceInternal");
   Resource* resource = &it->second;
   bool lost_resource = resource->lost;
 
   DCHECK(resource->exported_count == 0 || style != Normal);
   if (style == ForShutdown && resource->exported_count > 0)
     lost_resource = true;
 
-  resource->direct_raster_buffer.reset();
+  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();
     DCHECK(gl);
     GLC(gl, gl->DestroyImageCHROMIUM(resource->image_id));
   }
   if (resource->gl_upload_query_id) {
@@ skipping 890 matching lines @@
   if (!to_return.empty())
     child_info->return_callback.Run(to_return);
 
   if (child_info->marked_for_deletion &&
       child_info->parent_to_child_map.empty()) {
     DCHECK(child_info->child_to_parent_map.empty());
     children_.erase(child_it);
   }
 }
 
-SkCanvas* ResourceProvider::MapDirectRasterBuffer(ResourceId id) {
-  // Resource needs to be locked for write since DirectRasterBuffer writes
+SkCanvas* ResourceProvider::MapGpuRasterBuffer(ResourceId id) {
+  // Resource needs to be locked for write since GpuRasterBuffer writes
   // directly to it.
   LockForWrite(id);
   Resource* resource = GetResource(id);
-  if (!resource->direct_raster_buffer.get()) {
-    resource->direct_raster_buffer.reset(
-        new DirectRasterBuffer(resource, this, use_distance_field_text_));
+  if (!resource->gpu_raster_buffer.get()) {
+    resource->gpu_raster_buffer.reset(
+        new GpuRasterBuffer(resource, this, use_distance_field_text_));
   }
-  return resource->direct_raster_buffer->LockForWrite();
+  return resource->gpu_raster_buffer->LockForWrite();
 }
 
-void ResourceProvider::UnmapDirectRasterBuffer(ResourceId id) {
+void ResourceProvider::UnmapGpuRasterBuffer(ResourceId id) {
   Resource* resource = GetResource(id);
-  DCHECK(resource->direct_raster_buffer.get());
-  resource->direct_raster_buffer->UnlockForWrite();
+  DCHECK(resource->gpu_raster_buffer.get());
+  resource->gpu_raster_buffer->UnlockForWrite();
   UnlockForWrite(id);
 }
 
 SkCanvas* ResourceProvider::MapImageRasterBuffer(ResourceId id) {
   Resource* resource = GetResource(id);
   AcquireImage(resource);
   if (!resource->image_raster_buffer.get())
     resource->image_raster_buffer.reset(new ImageRasterBuffer(resource, this));
   return resource->image_raster_buffer->LockForWrite();
 }
@@ skipping 497 matching lines @@
   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;
 }
 
 }  // namespace cc