cc: Rename DirectRasterWorkerPool to GpuRasterWorkerPool

cc/resources/resource_provider.h

 // 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.
 
 #ifndef CC_RESOURCES_RESOURCE_PROVIDER_H_
 #define CC_RESOURCES_RESOURCE_PROVIDER_H_
 
 #include <deque>
 #include <set>
 #include <string>
@@ skipping 301 matching lines @@
     virtual bool HasPassed() = 0;
 
    protected:
     friend class base::RefCounted<Fence>;
     virtual ~Fence() {}
 
    private:
     DISALLOW_COPY_AND_ASSIGN(Fence);
   };
 
-  // Returns a canvas for direct rasterization.
+  // Returns a canvas for gpu rasterization.
   // Call Unmap before the resource can be read or used for compositing.
   // It is used for direct gpu rasterization.
-  SkCanvas* MapDirectRasterBuffer(ResourceId id);
-  void UnmapDirectRasterBuffer(ResourceId id);
+  SkCanvas* MapGpuRasterBuffer(ResourceId id);
+  void UnmapGpuRasterBuffer(ResourceId id);
 
   // Returns a canvas backed by an image buffer. UnmapImageRasterBuffer
   // returns true if canvas was written to while mapped.
   // Rasterizing to the canvas writes the content into the image buffer,
   // which is internally bound to the underlying resource when read.
   // Call Unmap before the resource can be read or used for compositing.
   // It is used by ImageRasterWorkerPool.
   SkCanvas* MapImageRasterBuffer(ResourceId id);
   bool UnmapImageRasterBuffer(ResourceId id);
 
@@ skipping 31 matching lines @@
 
   // Indicates if we can currently lock this resource for write.
   bool CanLockForWrite(ResourceId id);
 
   // Copy pixels from source to destination.
   void CopyResource(ResourceId source_id, ResourceId dest_id);
 
   static GLint GetActiveTextureUnit(gpu::gles2::GLES2Interface* gl);
 
  private:
-  class DirectRasterBuffer;
+  class GpuRasterBuffer;
   class ImageRasterBuffer;
   class PixelRasterBuffer;
 
   struct Resource {
     enum Origin { Internal, External, Delegated };
 
     Resource();
     ~Resource();
     Resource(unsigned texture_id,
              const gfx::Size& size,
@@ skipping 49 matching lines @@
     GLenum filter;
     unsigned image_id;
     unsigned bound_image_id;
     GLenum texture_pool;
     GLint wrap_mode;
     TextureUsageHint hint;
     ResourceType type;
     ResourceFormat format;
     SharedBitmapId shared_bitmap_id;
     SharedBitmap* shared_bitmap;
-    linked_ptr<DirectRasterBuffer> direct_raster_buffer;
+    linked_ptr<GpuRasterBuffer> gpu_raster_buffer;
     linked_ptr<ImageRasterBuffer> image_raster_buffer;
     linked_ptr<PixelRasterBuffer> pixel_raster_buffer;
   };
   typedef base::hash_map<ResourceId, Resource> ResourceMap;
 
   class RasterBuffer {
    public:
     virtual ~RasterBuffer();
 
     SkCanvas* LockForWrite();
     // Returns true if canvas was written to while locked.
     bool UnlockForWrite();
 
    protected:
     RasterBuffer(const Resource* resource, ResourceProvider* resource_provider);
     const Resource* resource() const { return resource_; }
     ResourceProvider* resource_provider() const { return resource_provider_; }
 
     virtual SkCanvas* DoLockForWrite() = 0;
     virtual bool DoUnlockForWrite() = 0;
 
    private:
     const Resource* resource_;
     ResourceProvider* resource_provider_;
     SkCanvas* locked_canvas_;
     int canvas_save_count_;
   };
 
-  class DirectRasterBuffer : public RasterBuffer {
+  class GpuRasterBuffer : public RasterBuffer {
    public:
-    DirectRasterBuffer(const Resource* resource,
-                       ResourceProvider* resource_provider,
-                       bool use_distance_field_text);
-    virtual ~DirectRasterBuffer();
+    GpuRasterBuffer(const Resource* resource,
+                    ResourceProvider* resource_provider,
+                    bool use_distance_field_text);
+    virtual ~GpuRasterBuffer();
 
    protected:
     virtual SkCanvas* DoLockForWrite() OVERRIDE;
     virtual bool DoUnlockForWrite() OVERRIDE;
     skia::RefPtr<SkSurface> CreateSurface();
 
    private:
     skia::RefPtr<SkSurface> surface_;
     uint32_t surface_generation_id_;
     const bool use_distance_field_text_;
 
-    DISALLOW_COPY_AND_ASSIGN(DirectRasterBuffer);
+    DISALLOW_COPY_AND_ASSIGN(GpuRasterBuffer);
   };
 
   class BitmapRasterBuffer : public RasterBuffer {
    public:
     virtual ~BitmapRasterBuffer();
 
    protected:
     BitmapRasterBuffer(const Resource* resource,
                        ResourceProvider* resource_provider);
 
@@ skipping 197 matching lines @@
   return format_gl_data_format[format];
 }
 
 inline GLenum GLInternalFormat(ResourceFormat format) {
   return GLDataFormat(format);
 }
 
 }  // namespace cc
 
 #endif  // CC_RESOURCES_RESOURCE_PROVIDER_H_