Revert of cc: Add mailbox support to ResourceProvider write locks.

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 198 matching lines @@
       const ReturnedResourceArray& transferable_resources);
 
   // The following lock classes are part of the ResourceProvider API and are
   // needed to read and write the resource contents. The user must ensure
   // that they only use GL locks on GL resources, etc, and this is enforced
   // by assertions.
   class CC_EXPORT ScopedReadLockGL {
    public:
     ScopedReadLockGL(ResourceProvider* resource_provider,
                      ResourceId resource_id);
-    ~ScopedReadLockGL();
+    virtual ~ScopedReadLockGL();
 
-    unsigned texture_id() const { return texture_id_; }
-    GLenum target() const { return target_; }
-    const gfx::Size& size() const { return size_; }
+    unsigned texture_id() const { return resource_->gl_id; }
+    GLenum target() const { return resource_->target; }
+    const gfx::Size& texture_size() const { return resource_->size; }
 
    private:
     ResourceProvider* resource_provider_;
     ResourceId resource_id_;
-    unsigned texture_id_;
-    GLenum target_;
-    gfx::Size size_;
+    const ResourceProvider::Resource* resource_;
 
     DISALLOW_COPY_AND_ASSIGN(ScopedReadLockGL);
   };
 
-  class CC_EXPORT ScopedSamplerGL {
+  class CC_EXPORT ScopedSamplerGL : public ScopedReadLockGL {
    public:
     ScopedSamplerGL(ResourceProvider* resource_provider,
                     ResourceId resource_id,
                     GLenum filter);
     ScopedSamplerGL(ResourceProvider* resource_provider,
                     ResourceId resource_id,
                     GLenum unit,
                     GLenum filter);
-    ~ScopedSamplerGL();
+    ~ScopedSamplerGL() override;
 
-    unsigned texture_id() const { return resource_lock_.texture_id(); }
     GLenum target() const { return target_; }
 
    private:
-    ScopedReadLockGL resource_lock_;
     GLenum unit_;
     GLenum target_;
 
     DISALLOW_COPY_AND_ASSIGN(ScopedSamplerGL);
   };
 
   class CC_EXPORT ScopedWriteLockGL {
    public:
     ScopedWriteLockGL(ResourceProvider* resource_provider,
-                      ResourceId resource_id,
-                      bool create_mailbox);
+                      ResourceId resource_id);
     ~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_; }
 
-    const TextureMailbox& mailbox() const { return mailbox_; }
-
-    void set_sync_token(const gpu::SyncToken& sync_token) {
+    void UpdateResourceSyncToken(const gpu::SyncToken& sync_token) {
+      set_sync_token_ = true;
       sync_token_ = sync_token;
     }
 
-    void set_synchronized(bool synchronized) { synchronized_ = synchronized; }
-
    private:
     ResourceProvider* resource_provider_;
-    ResourceId resource_id_;
+    ResourceProvider::Resource* resource_;
     unsigned texture_id_;
-    GLenum target_;
-    ResourceFormat format_;
-    gfx::Size size_;
-    TextureMailbox mailbox_;
+    bool set_sync_token_;
     gpu::SyncToken sync_token_;
-    bool synchronized_;
-    base::ThreadChecker thread_checker_;
 
     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 12 matching lines @@
    public:
     ScopedWriteLockSoftware(ResourceProvider* resource_provider,
                             ResourceId resource_id);
     ~ScopedWriteLockSoftware();
 
     SkBitmap& sk_bitmap() { return sk_bitmap_; }
     bool valid() const { return !!sk_bitmap_.getPixels(); }
 
    private:
     ResourceProvider* resource_provider_;
-    ResourceId resource_id_;
+    ResourceProvider::Resource* resource_;
     SkBitmap sk_bitmap_;
     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();
 
    private:
     ResourceProvider* resource_provider_;
-    ResourceId resource_id_;
-    ResourceFormat format_;
-    gfx::Size size_;
+    ResourceProvider::Resource* resource_;
     std::unique_ptr<gfx::GpuMemoryBuffer> gpu_memory_buffer_;
     base::ThreadChecker thread_checker_;
 
     DISALLOW_COPY_AND_ASSIGN(ScopedWriteLockGpuMemoryBuffer);
   };
 
+  class CC_EXPORT ScopedWriteLockGr {
+   public:
+    ScopedWriteLockGr(ResourceProvider* resource_provider,
+                      ResourceId resource_id);
+    ~ScopedWriteLockGr();
+
+    void InitSkSurface(GrContext* gr_context,
+                       bool use_distance_field_text,
+                       bool can_use_lcd_text,
+                       int msaa_sample_count);
+    void ReleaseSkSurface();
+
+    SkSurface* sk_surface() { return sk_surface_.get(); }
+
+    gfx::Size GetResourceSize() const { return resource_->size; }
+
+    void UpdateResourceSyncToken(const gpu::SyncToken& sync_token) {
+      set_sync_token_ = true;
+      sync_token_ = sync_token;
+    }
+
+   private:
+    ResourceProvider* resource_provider_;
+    ResourceProvider::Resource* resource_;
+    base::ThreadChecker thread_checker_;
+    sk_sp<SkSurface> sk_surface_;
+    bool set_sync_token_;
+    gpu::SyncToken sync_token_;
+
+    DISALLOW_COPY_AND_ASSIGN(ScopedWriteLockGr);
+  };
+
   class Fence : public base::RefCounted<Fence> {
    public:
     Fence() {}
 
     virtual void Set() = 0;
     virtual bool HasPassed() = 0;
     virtual void Wait() = 0;
 
    protected:
     friend class base::RefCounted<Fence>;
@@ skipping 285 matching lines @@
   // A process-unique ID used for disambiguating memory dumps from different
   // resource providers.
   int tracing_id_;
 
   DISALLOW_COPY_AND_ASSIGN(ResourceProvider);
 };
 
 }  // namespace cc
 
 #endif  // CC_RESOURCES_RESOURCE_PROVIDER_H_