Make DrawingBuffer and Canvas2DLayerBridge be cc::TextureLayerClients.

third_party/WebKit/Source/platform/graphics/gpu/DrawingBuffer.h

 /*
  * Copyright (c) 2010, Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 13 matching lines @@
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifndef DrawingBuffer_h
 #define DrawingBuffer_h
 
+#include "cc/layers/texture_layer_client.h"
+#include "gpu/command_buffer/common/mailbox.h"
+#include "gpu/command_buffer/common/sync_token.h"
 #include "platform/PlatformExport.h"
 #include "platform/geometry/IntSize.h"
 #include "platform/graphics/GraphicsTypes3D.h"
 #include "platform/graphics/gpu/WebGLImageConversion.h"
-#include "public/platform/WebExternalTextureLayerClient.h"
-#include "public/platform/WebExternalTextureMailbox.h"
 #include "third_party/khronos/GLES2/gl2.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "wtf/Deque.h"
 #include "wtf/Noncopyable.h"
 #include "wtf/RefCounted.h"
 #include <memory>
 
+namespace cc {
+class SharedBitmap;
+}
+
 namespace gpu {
 namespace gles2 {
 class GLES2Interface;
 }
 }
 
 namespace WTF {
 class ArrayBufferContents;
 }
 
 namespace blink {
-
 class Extensions3DUtil;
 class ImageBuffer;
+class StaticBitmapImage;
 class WebExternalBitmap;
 class WebExternalTextureLayer;
 class WebGraphicsContext3DProvider;
 class WebLayer;
 
 // Manages a rendering target (framebuffer + attachment) for a canvas.  Can publish its rendering
 // results to a WebLayer for compositing.
-class PLATFORM_EXPORT DrawingBuffer : public RefCounted<DrawingBuffer>, public WebExternalTextureLayerClient  {
+class PLATFORM_EXPORT DrawingBuffer : public NON_EXPORTED_BASE(cc::TextureLayerClient), public RefCounted<DrawingBuffer> {
     WTF_MAKE_NONCOPYABLE(DrawingBuffer);
 public:
     enum PreserveDrawingBuffer {
         Preserve,
         Discard
     };
     enum WebGLVersion {
         WebGL1,
         WebGL2,
     };
@@ skipping 115 matching lines @@
 
     // Similar to requiresAlphaChannelToBePreserved(), but always targets the
     // default framebuffer.
     bool defaultBufferRequiresAlphaChannelToBePreserved();
 
     WebLayer* platformLayer();
 
     gpu::gles2::GLES2Interface* contextGL();
     WebGraphicsContext3DProvider* contextProvider();
 
-    // WebExternalTextureLayerClient implementation.
-    bool prepareMailbox(WebExternalTextureMailbox*, WebExternalBitmap*) override;
-    void mailboxReleased(const WebExternalTextureMailbox&, bool lostResource = false) override;
+    // cc::TextureLayerClient implementation.
+    bool PrepareTextureMailbox(
+        cc::TextureMailbox* outMailbox,
+        std::unique_ptr<cc::SingleReleaseCallback>* outReleaseCallback,
+        bool useSharedMemory) override;
+
+    // Callbacks for mailboxes given to the compositor from PrepareTextureMailbox.
+    void gpuMailboxReleased(const gpu::Mailbox&, const gpu::SyncToken&, bool lostResource);
+    void softwareMailboxReleased(std::unique_ptr<cc::SharedBitmap>, const IntSize&, const gpu::SyncToken&, bool lostResource);
+
+    // Returns a StaticBitmapImage backed by a texture containing the/ current contents of
+    // the front buffer. This is done without any pixel copies. The texture in the ImageBitmap
+    // is from the active ContextProvider on the DrawingBuffer.
+    PassRefPtr<StaticBitmapImage> transferToStaticBitmapImage();
 
     // Destroys the TEXTURE_2D binding for the owned context
     bool copyToPlatformTexture(gpu::gles2::GLES2Interface*, GLuint texture, GLenum internalFormat,
         GLenum destType, GLint level, bool premultiplyAlpha, bool flipY, SourceDrawingBuffer);
 
     void setPackAlignment(GLint param);
 
     bool paintRenderingResultsToImageData(int&, int&, SourceDrawingBuffer, WTF::ArrayBufferContents&);
 
     int sampleCount() const { return m_sampleCount; }
@@ skipping 40 matching lines @@
     // we need to know the mapping from texture id to image.
     struct TextureInfo {
         DISALLOW_NEW();
         GLuint textureId = 0;
         GLuint imageId = 0;
         bool immutable = false;
         TextureParameters parameters;
     };
 
     struct MailboxInfo : public RefCounted<MailboxInfo> {
-        WTF_MAKE_NONCOPYABLE(MailboxInfo);
-
-    public:
-        MailboxInfo() {}
-
-        WebExternalTextureMailbox mailbox;
+        MailboxInfo() = default;
+        gpu::Mailbox mailbox;
         TextureInfo textureInfo;
         IntSize size;
-        // This keeps the parent drawing buffer alive as long as the compositor is
-        // referring to one of the mailboxes DrawingBuffer produced. The parent drawing buffer is
-        // cleared when the compositor returns the mailbox. See mailboxReleased().
-        RefPtr<DrawingBuffer> m_parentDrawingBuffer;
+
+    private:
+        WTF_MAKE_NONCOPYABLE(MailboxInfo);
     };
 
     // The texture parameters to use for a texture that will be backed by a
     // CHROMIUM_image.
     TextureParameters chromiumImageTextureParameters();
 
     // The texture parameters to use for a default texture.
     TextureParameters defaultTextureParameters();
 
-    void mailboxReleasedWithoutRecycling(const WebExternalTextureMailbox&);
-
     // Creates and binds a texture with the given parameters. Returns 0 on
     // failure, or the newly created texture id on success. The caller takes
     // ownership of the newly created texture.
     GLuint createColorTexture(const TextureParameters&);
 
     // Create the depth/stencil and multisample buffers, if needed.
     bool resizeMultisampleFramebuffer(const IntSize&);
     void resizeDepthStencil(const IntSize&);
 
     // Attempts to allocator storage for, or resize all buffers. Returns whether
     // the operation was successful.
     bool resizeDefaultFramebuffer(const IntSize&);
 
     void clearPlatformLayer();
 
-    PassRefPtr<MailboxInfo> recycledMailbox();
+    PassRefPtr<MailboxInfo> takeRecycledMailbox();
     PassRefPtr<MailboxInfo> createNewMailbox(const TextureInfo&);
-    void deleteMailbox(const WebExternalTextureMailbox&);
+    void deleteMailbox(const gpu::Mailbox&, const gpu::SyncToken&);
     void freeRecycledMailboxes();
 
+    std::unique_ptr<cc::SharedBitmap> createOrRecycleBitmap();
+
     // Updates the current size of the buffer, ensuring that s_currentResourceUsePixels is updated.
     void setSize(const IntSize& size);
 
     // This is the order of bytes to use when doing a readback.
     enum ReadbackOrder {
         ReadbackRGBA,
         ReadbackSkia
     };
 
     // Helper function which does a readback from the currently-bound
@@ skipping 53 matching lines @@
     // Lifetime is tied to the m_contextProvider.
     gpu::gles2::GLES2Interface* m_gl;
     std::unique_ptr<Extensions3DUtil> m_extensionsUtil;
     IntSize m_size = { -1, -1 };
     const bool m_discardFramebufferSupported;
     const bool m_wantAlphaChannel;
     const bool m_premultipliedAlpha;
     bool m_hasImplicitStencilBuffer = false;
     bool m_storageTextureSupported = false;
     struct FrontBufferInfo {
+        gpu::Mailbox mailbox;
+        gpu::SyncToken produceSyncToken;
         TextureInfo texInfo;
-        WebExternalTextureMailbox mailbox;
     };
     FrontBufferInfo m_frontColorBuffer;
 
     std::unique_ptr<WTF::Closure> m_newMailboxCallback;
 
     // This is used when the user requests either a depth or stencil buffer.
     GLuint m_depthStencilBuffer = 0;
 
     // When wantExplicitResolve() returns true, the target of all draw
     // operations.
@@ skipping 35 matching lines @@
     int m_sampleCount = 0;
     int m_packAlignment = 4;
     bool m_destructionInProgress = false;
     bool m_isHidden = false;
     SkFilterQuality m_filterQuality = kLow_SkFilterQuality;
 
     std::unique_ptr<WebExternalTextureLayer> m_layer;
 
     // All of the mailboxes that this DrawingBuffer has ever created.
     Vector<RefPtr<MailboxInfo>> m_textureMailboxes;
+    struct RecycledMailbox : RefCounted<RecycledMailbox> {
+        RecycledMailbox(const gpu::Mailbox& mailbox, const gpu::SyncToken& syncToken)
+            : mailbox(mailbox)
+            , syncToken(syncToken)
+        {
+        }
+
+        gpu::Mailbox mailbox;
+        gpu::SyncToken syncToken;
+
+    private:
+        WTF_MAKE_NONCOPYABLE(RecycledMailbox);
+    };
     // Mailboxes that were released by the compositor can be used again by this DrawingBuffer.
-    Deque<WebExternalTextureMailbox> m_recycledMailboxQueue;
+    Deque<RefPtr<RecycledMailbox>> m_recycledMailboxQueue;
+    struct RecycledBitmap {
+        std::unique_ptr<cc::SharedBitmap> bitmap;
+        IntSize size;
+    };
+    // Shared memory bitmaps that were released by the compositor and can be used again by this DrawingBuffer.
+    Deque<RecycledBitmap> m_recycledBitmapQueue;
 
     // If the width and height of the Canvas's backing store don't
     // match those that we were given in the most recent call to
     // reshape(), then we need an intermediate bitmap to read back the
     // frame buffer into. This seems to happen when CSS styles are
     // used to resize the Canvas.
     SkBitmap m_resizingBitmap;
 
     // Used to flip a bitmap vertically.
     Vector<uint8_t> m_scanline;
 };
 
 } // namespace blink
 
 #endif // DrawingBuffer_h