cc: Allocate resources on worker context.

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 <stddef.h>
 #include <stdint.h>
 
@@ skipping 187 matching lines @@
   // Receives resources from a child, moving them from mailboxes. Resource IDs
   // passed are in the child namespace, and will be translated to the parent
   // namespace, added to the child->parent map.
   // This adds the resources to the working set in the ResourceProvider without
   // declaring which resources are in use. Use DeclareUsedResourcesFromChild
   // after calling this method to do that. All calls to ReceiveFromChild should
   // be followed by a DeclareUsedResourcesFromChild.
   // NOTE: if the sync_token is set on any TransferableResource, this will
   // wait on it.
   void ReceiveFromChild(
-      int child, const TransferableResourceArray& transferable_resources);
+      int child,
+      const TransferableResourceArray& transferable_resources);
 
   // Once a set of resources have been received, they may or may not be used.
   // This declares what set of resources are currently in use from the child,
   // releasing any other resources back to the child.
   void DeclareUsedResourcesFromChild(int child,
                                      const ResourceIdSet& resources_from_child);
 
   // Receives resources from the parent, moving them from mailboxes. Resource
   // IDs passed are in the child namespace.
   // NOTE: if the sync_token is set on any TransferableResource, this will
@@ skipping 21 matching lines @@
     ~ScopedReadLockGL();
 
     unsigned texture_id() const { return texture_id_; }
     GLenum target() const { return target_; }
     const gfx::Size& size() const { return size_; }
     const gfx::ColorSpace& color_space() const { return color_space_; }
 
    private:
     ResourceProvider* resource_provider_;
     ResourceId resource_id_;
+
     unsigned texture_id_;
     GLenum target_;
     gfx::Size size_;
     gfx::ColorSpace color_space_;
 
     DISALLOW_COPY_AND_ASSIGN(ScopedReadLockGL);
   };
 
   class CC_EXPORT ScopedSamplerGL {
    public:
@@ skipping 17 matching lines @@
     GLenum unit_;
     GLenum target_;
 
     DISALLOW_COPY_AND_ASSIGN(ScopedSamplerGL);
   };
 
   class CC_EXPORT ScopedWriteLockGL {
    public:
     ScopedWriteLockGL(ResourceProvider* resource_provider,
                       ResourceId resource_id,
-                      bool create_mailbox);
+                      bool async_worker_context_enabled);
     ~ScopedWriteLockGL();
 
     unsigned texture_id() const { return texture_id_; }
     GLenum target() const { return target_; }
     ResourceFormat format() const { return format_; }
     const gfx::Size& size() const { return size_; }
+
     // Will return the invalid color space unless
     // |enable_color_correct_rasterization| is true.
     const gfx::ColorSpace& color_space_for_raster() const {
-      return color_space_;
+      return color_space_for_raster_;
     }
 
-    const TextureMailbox& mailbox() const { return mailbox_; }
-
     void set_sync_token(const gpu::SyncToken& sync_token) {
+      set_sync_token_ = true;
       sync_token_ = sync_token;
-      has_sync_token_ = true;
     }
 
-    void set_synchronized(bool synchronized) { synchronized_ = synchronized; }
+    // Creates a texture id, allocating if necessary, on the given context. The
+    // texture id must be deleted by the caller.
+    unsigned ConsumeTexture(gpu::gles2::GLES2Interface* gl);
 
    private:
     ResourceProvider* resource_provider_;
     ResourceId resource_id_;
+    bool async_worker_context_enabled_;
+
+    ResourceType type_;
     unsigned texture_id_;
+    std::unique_ptr<gfx::GpuMemoryBuffer> gpu_memory_buffer_;
+    gfx::BufferUsage usage_;
+    unsigned image_id_;
+    unsigned bound_image_id_;
+    bool dirty_image_;
     GLenum target_;
     ResourceFormat format_;
     gfx::Size size_;
-    TextureMailbox mailbox_;
+    gfx::ColorSpace color_space_;
+    gfx::ColorSpace color_space_for_raster_;
+    TextureHint hint_;
+    bool allocated_;
+    gpu::Mailbox mailbox_;
     gpu::SyncToken sync_token_;
-    bool has_sync_token_;
-    bool synchronized_;
+    bool set_sync_token_;
+
     base::ThreadChecker thread_checker_;
-    gfx::ColorSpace color_space_;
 
     DISALLOW_COPY_AND_ASSIGN(ScopedWriteLockGL);
   };
 
-  class CC_EXPORT ScopedTextureProvider {
-   public:
-    ScopedTextureProvider(gpu::gles2::GLES2Interface* gl,
-                          ScopedWriteLockGL* resource_lock,
-                          bool use_mailbox);
-    ~ScopedTextureProvider();
-
-    unsigned texture_id() const { return texture_id_; }
-
-   private:
-    gpu::gles2::GLES2Interface* gl_;
-    bool use_mailbox_;
-    unsigned texture_id_;
-
-    DISALLOW_COPY_AND_ASSIGN(ScopedTextureProvider);
-  };
-
-  class CC_EXPORT ScopedSkSurfaceProvider {
-   public:
-    ScopedSkSurfaceProvider(ContextProvider* context_provider,
-                            ScopedWriteLockGL* resource_lock,
-                            bool use_mailbox,
-                            bool use_distance_field_text,
-                            bool can_use_lcd_text,
-                            int msaa_sample_count);
-    ~ScopedSkSurfaceProvider();
-
-    SkSurface* sk_surface() { return sk_surface_.get(); }
-
-   private:
-    ScopedTextureProvider texture_provider_;
-    sk_sp<SkSurface> sk_surface_;
-
-    DISALLOW_COPY_AND_ASSIGN(ScopedSkSurfaceProvider);
-  };
-
   class CC_EXPORT ScopedReadLockSoftware {
    public:
     ScopedReadLockSoftware(ResourceProvider* resource_provider,
                            ResourceId resource_id);
     ~ScopedReadLockSoftware();
 
     const SkBitmap* sk_bitmap() const {
       DCHECK(valid());
       return &sk_bitmap_;
     }
@@ skipping 36 matching lines @@
     bool valid() const { return !!sk_bitmap_.getPixels(); }
     // Will return the invalid color space unless
     // |enable_color_correct_rasterization| is true.
     const gfx::ColorSpace& color_space_for_raster() const {
       return color_space_;
     }
 
    private:
     ResourceProvider* resource_provider_;
     ResourceId resource_id_;
+    gfx::ColorSpace color_space_;
     SkBitmap sk_bitmap_;
-    gfx::ColorSpace color_space_;
+
     base::ThreadChecker thread_checker_;
 
     DISALLOW_COPY_AND_ASSIGN(ScopedWriteLockSoftware);
   };
 
   class CC_EXPORT ScopedWriteLockGpuMemoryBuffer {
    public:
     ScopedWriteLockGpuMemoryBuffer(ResourceProvider* resource_provider,
                                    ResourceId resource_id);
     ~ScopedWriteLockGpuMemoryBuffer();
     gfx::GpuMemoryBuffer* GetGpuMemoryBuffer();
     // Will return the invalid color space unless
     // |enable_color_correct_rasterization| is true.
     const gfx::ColorSpace& color_space_for_raster() const {
       return color_space_;
     }
 
    private:
     ResourceProvider* resource_provider_;
     ResourceId resource_id_;
+
+    gfx::Size size_;
     ResourceFormat format_;
     gfx::BufferUsage usage_;
-    gfx::Size size_;
+    gfx::ColorSpace color_space_;
+
     std::unique_ptr<gfx::GpuMemoryBuffer> gpu_memory_buffer_;
-    gfx::ColorSpace color_space_;
+
     base::ThreadChecker thread_checker_;
 
     DISALLOW_COPY_AND_ASSIGN(ScopedWriteLockGpuMemoryBuffer);
   };
 
   // All resources that are returned to children while an instance of this
   // class exists will be stored and returned when the instance is destroyed.
   class CC_EXPORT ScopedBatchReturnResources {
    public:
     explicit ScopedBatchReturnResources(ResourceProvider* resource_provider);
@@ skipping 201 matching lines @@
     gfx::Size size;
     Origin origin;
     GLenum target;
     // TODO(skyostil): Use a separate sampler object for filter state.
     GLenum original_filter;
     GLenum filter;
     unsigned image_id;
     unsigned bound_image_id;
     TextureHint hint;
     ResourceType type;
-
     // GpuMemoryBuffer resource allocation needs to know how the resource will
     // be used.
     gfx::BufferUsage usage;
-    // This is the the actual format of the underlaying GpuMemoryBuffer, if any,
-    // and might not correspond to ResourceFormat. This format is needed to
-    // scanout the buffer as HW overlay.
+    // TODO(sunnyps): Unused. To be removed in a followup cleanup CL.
     gfx::BufferFormat buffer_format;
     // Resource format is the format as seen from the compositor and might not
     // correspond to buffer_format (e.g: A resouce that was created from a YUV
-    // buffer could be seen as RGB from the compositor/GL.)
+    // buffer could be seen as RGB from the compositor/GL.) The format of the
+    // underlying GpuMemoryBuffer, if any, may be different and can be obtained
+    // from |ResourceProvider::GetBufferFormat|.
     ResourceFormat format;
     SharedBitmapId shared_bitmap_id;
     SharedBitmap* shared_bitmap;
     std::unique_ptr<gfx::GpuMemoryBuffer> gpu_memory_buffer;
     gfx::ColorSpace color_space;
 
    private:
     SynchronizationState synchronization_state_ = SYNCHRONIZED;
     bool needs_sync_token_ = false;
     TextureMailbox mailbox_;
@@ skipping 30 matching lines @@
   Resource* InsertResource(ResourceId id, Resource resource);
   Resource* GetResource(ResourceId id);
   const Resource* LockForRead(ResourceId id);
   void UnlockForRead(ResourceId id);
   Resource* LockForWrite(ResourceId id);
   void UnlockForWrite(Resource* resource);
 
   void PopulateSkBitmapWithResource(SkBitmap* sk_bitmap,
                                     const Resource* resource);
 
-  void CreateMailboxAndBindResource(gpu::gles2::GLES2Interface* gl,
-                                    Resource* resource);
-
   void TransferResource(Resource* source,
                         ResourceId id,
                         TransferableResource* resource);
   enum DeleteStyle {
     NORMAL,
     FOR_SHUTDOWN,
   };
   void DeleteResourceInternal(ResourceMap::iterator it, DeleteStyle style);
   void DeleteAndReturnUnusedResourcesToChild(ChildMap::iterator child_it,
                                              DeleteStyle style,
                                              const ResourceIdArray& unused);
   void DestroyChildInternal(ChildMap::iterator it, DeleteStyle style);
+
   void LazyCreate(Resource* resource);
+
+  void LazyCreateMailbox(Resource* resource);
+
   void LazyAllocate(Resource* resource);
+
+  void AllocateGLTexture(gpu::gles2::GLES2Interface* gl,
+                         unsigned gl_id,
+                         GLenum target,
+                         const gfx::Size& size,
+                         ResourceFormat format,
+                         TextureHint hint);
+
+  std::unique_ptr<gfx::GpuMemoryBuffer> AllocateGpuMemoryBuffer(
+      const gfx::Size& size,
+      ResourceFormat format,
+      gfx::BufferUsage usage,
+      gfx::ColorSpace color_space);
+
+  void SetGpuMemoryBuffer(
+      Resource* resource,
+      std::unique_ptr<gfx::GpuMemoryBuffer> gpu_memory_buffer);
+
+  unsigned CreateImage(gpu::gles2::GLES2Interface* gl,
+                       gfx::GpuMemoryBuffer* gpu_memory_buffer,
+                       const gfx::Size& size,
+                       ResourceFormat format);
+
   void LazyCreateImage(Resource* resource);
 
   void BindImageForSampling(Resource* resource);
+
   // Binds the given GL resource to a texture target for sampling using the
   // specified filter for both minification and magnification. Returns the
   // texture target used. The resource must be locked for reading.
   GLenum BindForSampling(ResourceId resource_id, GLenum unit, GLenum filter);
 
   // Returns null if we do not have a ContextProvider.
   gpu::gles2::GLES2Interface* ContextGL() const;
   bool IsGLContextLost() const;
 
   // Will return the invalid color space unless
@@ skipping 53 matching lines @@
   // Set of resource Ids that would like to be notified about promotion hints.
   ResourceIdSet wants_promotion_hints_set_;
 #endif
 
   DISALLOW_COPY_AND_ASSIGN(ResourceProvider);
 };
 
 }  // namespace cc
 
 #endif  // CC_RESOURCES_RESOURCE_PROVIDER_H_