cc: Move GpuMemoryBuffer allocation to worker threads.

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 40 matching lines @@
 class BlockingTaskRunner;
 class GpuMemoryBufferManager;
 class IdAllocator;
 class SharedBitmap;
 class SharedBitmapManager;
 class TextureUploader;
 
 // This class is not thread-safe and can only be called from the thread it was
 // created on (in practice, the impl thread).
 class CC_EXPORT ResourceProvider {
+ private:
+  struct Resource;
+
  public:
   typedef unsigned ResourceId;
   typedef std::vector<ResourceId> ResourceIdArray;
   typedef std::set<ResourceId> ResourceIdSet;
   typedef base::hash_map<ResourceId, ResourceId> ResourceIdMap;
   enum TextureHint {
     TextureHintDefault = 0x0,
     TextureHintImmutable = 0x1,
     TextureHintFramebuffer = 0x2,
     TextureHintImmutableFramebuffer =
@@ skipping 180 matching lines @@
   class CC_EXPORT ScopedWriteLockGL {
    public:
     ScopedWriteLockGL(ResourceProvider* resource_provider,
                       ResourceProvider::ResourceId resource_id);
     ~ScopedWriteLockGL();
 
     unsigned texture_id() const { return texture_id_; }
 
    private:
     ResourceProvider* resource_provider_;
-    ResourceProvider::ResourceId resource_id_;
+    ResourceProvider::Resource* resource_;
     unsigned texture_id_;
 
     DISALLOW_COPY_AND_ASSIGN(ScopedWriteLockGL);
   };
 
   class CC_EXPORT ScopedReadLockSoftware {
    public:
     ScopedReadLockSoftware(ResourceProvider* resource_provider,
                            ResourceProvider::ResourceId resource_id);
     ~ScopedReadLockSoftware();
@@ skipping 19 matching lines @@
    public:
     ScopedWriteLockSoftware(ResourceProvider* resource_provider,
                             ResourceProvider::ResourceId resource_id);
     ~ScopedWriteLockSoftware();
 
     SkCanvas* sk_canvas() { return sk_canvas_.get(); }
     bool valid() const { return !!sk_bitmap_.getPixels(); }
 
    private:
     ResourceProvider* resource_provider_;
-    ResourceProvider::ResourceId resource_id_;
+    ResourceProvider::Resource* resource_;
     SkBitmap sk_bitmap_;
     scoped_ptr<SkCanvas> sk_canvas_;
 
     DISALLOW_COPY_AND_ASSIGN(ScopedWriteLockSoftware);
   };
 
   class CC_EXPORT ScopedWriteLockGpuMemoryBuffer {
    public:
     ScopedWriteLockGpuMemoryBuffer(ResourceProvider* resource_provider,
                                    ResourceProvider::ResourceId resource_id);
     ~ScopedWriteLockGpuMemoryBuffer();
 
-    gfx::GpuMemoryBuffer* gpu_memory_buffer() { return gpu_memory_buffer_; }
+    gfx::GpuMemoryBuffer* GetGpuMemoryBuffer();
 
    private:
     ResourceProvider* resource_provider_;
-    ResourceProvider::ResourceId resource_id_;
+    ResourceProvider::Resource* resource_;
+    GpuMemoryBufferManager* gpu_memory_buffer_manager_;
     gfx::GpuMemoryBuffer* gpu_memory_buffer_;
+    gfx::Size size_;
+    ResourceFormat format_;
 
     DISALLOW_COPY_AND_ASSIGN(ScopedWriteLockGpuMemoryBuffer);
   };
 
   class CC_EXPORT ScopedWriteLockGr {
    public:
     ScopedWriteLockGr(ResourceProvider* resource_provider,
                       ResourceProvider::ResourceId resource_id);
     ~ScopedWriteLockGr();
 
     SkSurface* GetSkSurface(bool use_distance_field_text);
 
    private:
     ResourceProvider* resource_provider_;
-    ResourceProvider::ResourceId resource_id_;
+    ResourceProvider::Resource* resource_;
 
     DISALLOW_COPY_AND_ASSIGN(ScopedWriteLockGr);
   };
 
   class Fence : public base::RefCounted<Fence> {
    public:
     Fence() {}
 
     virtual void Set() = 0;
     virtual bool HasPassed() = 0;
@@ skipping 141 matching lines @@
                    BlockingTaskRunner* blocking_main_thread_task_runner,
                    int highp_threshold_min,
                    bool use_rgba_4444_texture_format,
                    size_t id_allocation_chunk_size);
 
   void CleanUpGLIfNeeded();
 
   Resource* GetResource(ResourceId id);
   const Resource* LockForRead(ResourceId id);
   void UnlockForRead(ResourceId id);
-  const Resource* LockForWrite(ResourceId id);
-  void UnlockForWrite(ResourceId id);
-  const Resource* LockForWriteToGpuMemoryBuffer(ResourceId id);
-  void UnlockForWriteToGpuMemoryBuffer(ResourceId id);
-  void LockForWriteToSkSurface(ResourceId id);
-  void UnlockForWriteToSkSurface(ResourceId id);
+  Resource* LockForWrite(ResourceId id);
+  void UnlockForWrite(Resource* resource);
 
   static void PopulateSkBitmapWithResource(SkBitmap* sk_bitmap,
                                            const Resource* resource);
 
   void TransferResource(gpu::gles2::GLES2Interface* gl,
                         ResourceId id,
                         TransferableResource* resource);
   enum DeleteStyle {
     Normal,
     ForShutdown,
@@ skipping 95 matching lines @@
   return format_gl_data_format[format];
 }
 
 inline GLenum GLInternalFormat(ResourceFormat format) {
   return GLDataFormat(format);
 }
 
 }  // namespace cc
 
 #endif  // CC_RESOURCES_RESOURCE_PROVIDER_H_