Make DrawingBuffer and Canvas2DLayerBridge be cc::TextureLayerClients.

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

 /*
  * 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 12 matching lines @@
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  * 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.
  */
 
 #include "platform/graphics/gpu/DrawingBuffer.h"
 
+#include "cc/resources/shared_bitmap.h"
 #include "gpu/GLES2/gl2extchromium.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
 #include "gpu/command_buffer/common/capabilities.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/TraceEvent.h"
+#include "platform/graphics/AcceleratedStaticBitmapImage.h"
 #include "platform/graphics/GraphicsLayer.h"
 #include "platform/graphics/ImageBuffer.h"
 #include "platform/graphics/gpu/Extensions3DUtil.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebCompositorSupport.h"
 #include "public/platform/WebExternalBitmap.h"
 #include "public/platform/WebExternalTextureLayer.h"
 #include "public/platform/WebGraphicsContext3DProvider.h"
+#include "skia/ext/texture_handle.h"
+#include "third_party/skia/include/gpu/GrContext.h"
+#include "third_party/skia/include/gpu/gl/GrGLTypes.h"
 #include "wtf/CheckedNumeric.h"
 #include "wtf/PtrUtil.h"
 #include "wtf/typed_arrays/ArrayBufferContents.h"
 #include <algorithm>
 #include <memory>
 
 namespace blink {
 
 namespace {
 
@@ skipping 169 matching lines @@
         return !m_wantAlphaChannel && getMultisampledRenderbufferFormat() == GL_RGBA8_OES;
     }
 
     bool rgbEmulation = contextProvider()->getCapabilities().emulate_rgb_buffer_with_rgba
         || (RuntimeEnabledFeatures::webGLImageChromiumEnabled() && contextProvider()->getCapabilities().chromium_image_rgb_emulation);
     return !m_wantAlphaChannel && rgbEmulation;
 }
 
 void DrawingBuffer::freeRecycledMailboxes()
 {
-    if (m_recycledMailboxQueue.isEmpty())
-        return;
-    while (!m_recycledMailboxQueue.isEmpty())
-        deleteMailbox(m_recycledMailboxQueue.takeLast());
+    while (!m_recycledMailboxQueue.isEmpty()) {
+        RefPtr<RecycledMailbox> recycled = m_recycledMailboxQueue.takeLast();
+        deleteMailbox(recycled->mailbox, recycled->syncToken);
+    }
 }
 
-bool DrawingBuffer::prepareMailbox(WebExternalTextureMailbox* outMailbox, WebExternalBitmap* bitmap)
+std::unique_ptr<cc::SharedBitmap> DrawingBuffer::createOrRecycleBitmap()
+{
+    for (auto it = m_recycledBitmapQueue.begin(); it != m_recycledBitmapQueue.end(); ++it) {
+        if (it->size != m_size) {
+            m_recycledBitmapQueue.remove(it);
+            --it; // Removed this position so iterate on it again.
+        }
+    }
+    if (!m_recycledBitmapQueue.isEmpty()) {
+        RecycledBitmap recycled = m_recycledBitmapQueue.takeLast();
+        DCHECK(recycled.size == m_size);
+        return std::move(recycled.bitmap);
+    }
+
+    return Platform::current()->allocateSharedBitmap(m_size);
+}
+
+bool DrawingBuffer::PrepareTextureMailbox(cc::TextureMailbox* outMailbox,
+    std::unique_ptr<cc::SingleReleaseCallback>* outReleaseCallback,
+    bool useSharedMemory)
 {
     if (m_destructionInProgress) {
         // It can be hit in the following sequence.
         // 1. WebGL draws something.
         // 2. The compositor begins the frame.
         // 3. Javascript makes a context lost using WEBGL_lose_context extension.
         // 4. Here.
         return false;
     }
     ASSERT(!m_isHidden);
     if (!m_contentsChanged)
         return false;
 
     TRACE_EVENT0("blink,rail", "DrawingBuffer::prepareMailbox");
 
     if (m_newMailboxCallback)
         (*m_newMailboxCallback)();
 
     // Resolve the multisampled buffer into m_colorBuffer texture.
     if (m_antiAliasingMode != None)
         commit();
 
-    if (bitmap) {
-        bitmap->setSize(size());
-
+    if (useSharedMemory) {
+        std::unique_ptr<cc::SharedBitmap> bitmap = createOrRecycleBitmap();
+        if (!bitmap)
+            return false;
         unsigned char* pixels = bitmap->pixels();
-        if (!pixels)
-            return false;
+        DCHECK(pixels);
 
         bool needPremultiply = m_wantAlphaChannel && !m_premultipliedAlpha;
         WebGLImageConversion::AlphaOp op = needPremultiply ? WebGLImageConversion::AlphaDoPremultiply : WebGLImageConversion::AlphaDoNothing;
         readBackFramebuffer(pixels, size().width(), size().height(), ReadbackSkia, op);
+
+        *outMailbox = cc::TextureMailbox(bitmap.get(), m_size);
+
+        // This holds a ref on the DrawingBuffer that will keep it alive until the
+        // mailbox is released (and while the release callback is running). It also
+        // owns the SharedBitmap.
+        auto func = WTF::bind(&DrawingBuffer::softwareMailboxReleased,
+            RefPtr<DrawingBuffer>(this),
+            WTF::passed(std::move(bitmap)),
+            m_size);
+        *outReleaseCallback = cc::SingleReleaseCallback::Create(
+            convertToBaseCallback(std::move(func)));
+        return true;
     }
 
     // We must restore the texture binding since creating new textures,
     // consuming and producing mailboxes changes it.
     ScopedTextureUnit0BindingRestorer restorer(m_gl, m_activeTextureUnit, m_texture2DBinding);
 
     // First try to recycle an old buffer.
-    RefPtr<MailboxInfo> frontColorBufferMailbox = recycledMailbox();
+    RefPtr<MailboxInfo> mailboxInfo = takeRecycledMailbox();
 
     // No buffer available to recycle, create a new one.
-    if (!frontColorBufferMailbox)
-        frontColorBufferMailbox = createNewMailbox(createTextureAndAllocateMemory(m_size));
+    if (!mailboxInfo)
+        mailboxInfo = createNewMailbox(createTextureAndAllocateMemory(m_size));
 
     if (m_preserveDrawingBuffer == Discard) {
-        std::swap(frontColorBufferMailbox->textureInfo, m_colorBuffer);
+        std::swap(mailboxInfo->textureInfo, m_colorBuffer);
         attachColorBufferToReadFramebuffer();
 
         if (m_discardFramebufferSupported) {
             // Explicitly discard framebuffer to save GPU memory bandwidth for tile-based GPU arch.
             const GLenum attachments[3] = { GL_COLOR_ATTACHMENT0, GL_DEPTH_ATTACHMENT, GL_STENCIL_ATTACHMENT };
             m_gl->BindFramebuffer(GL_FRAMEBUFFER, m_fbo);
             m_gl->DiscardFramebufferEXT(GL_FRAMEBUFFER, 3, attachments);
         }
     } else {
-        m_gl->CopySubTextureCHROMIUM(m_colorBuffer.textureId, frontColorBufferMailbox->textureInfo.textureId,
+        m_gl->CopySubTextureCHROMIUM(m_colorBuffer.textureId, mailboxInfo->textureInfo.textureId,
             0, 0, 0, 0, m_size.width(), m_size.height(), GL_FALSE, GL_FALSE, GL_FALSE);
     }
 
     restoreFramebufferBindings();
     m_contentsChanged = false;
 
-    m_gl->ProduceTextureDirectCHROMIUM(frontColorBufferMailbox->textureInfo.textureId, frontColorBufferMailbox->textureInfo.parameters.target, frontColorBufferMailbox->mailbox.name);
+    m_gl->ProduceTextureDirectCHROMIUM(mailboxInfo->textureInfo.textureId, mailboxInfo->textureInfo.parameters.target, mailboxInfo->mailbox.name);
     const GLuint64 fenceSync = m_gl->InsertFenceSyncCHROMIUM();
 #if OS(MACOSX)
     m_gl->DescheduleUntilFinishedCHROMIUM();
 #endif
     m_gl->Flush();
-    m_gl->GenSyncTokenCHROMIUM(fenceSync, frontColorBufferMailbox->mailbox.syncToken);
-    frontColorBufferMailbox->mailbox.validSyncToken = true;
-    frontColorBufferMailbox->mailbox.allowOverlay = frontColorBufferMailbox->textureInfo.imageId != 0;
-    frontColorBufferMailbox->mailbox.textureTarget = frontColorBufferMailbox->textureInfo.parameters.target;
-    frontColorBufferMailbox->mailbox.textureSize = WebSize(m_size.width(), m_size.height());
+    gpu::SyncToken syncToken;
+    m_gl->GenSyncTokenCHROMIUM(fenceSync, syncToken.GetData());
+
+    bool isOverlayCandidate = mailboxInfo->textureInfo.imageId != 0;
+    bool secureOutputOnly = false;
+    *outMailbox = cc::TextureMailbox(
+        mailboxInfo->mailbox, syncToken,
+        mailboxInfo->textureInfo.parameters.target,
+        gfx::Size(m_size.width(), m_size.height()),
+        isOverlayCandidate,
+        secureOutputOnly);
+
+    // This holds a ref on the DrawingBuffer that will keep it alive until the
+    // mailbox is released (and while the release callback is running).
+    auto func = WTF::bind(&DrawingBuffer::gpuMailboxReleased,
+        RefPtr<DrawingBuffer>(this),
+        mailboxInfo->mailbox);
+    *outReleaseCallback = cc::SingleReleaseCallback::Create(
+        convertToBaseCallback(std::move(func)));
+
+    m_frontColorBuffer = { mailboxInfo->mailbox, syncToken, mailboxInfo->textureInfo };
     setBufferClearNeeded(true);
-
-    // set m_parentDrawingBuffer to make sure 'this' stays alive as long as it has live mailboxes
-    ASSERT(!frontColorBufferMailbox->m_parentDrawingBuffer);
-    frontColorBufferMailbox->m_parentDrawingBuffer = this;
-    *outMailbox = frontColorBufferMailbox->mailbox;
-    m_frontColorBuffer = { frontColorBufferMailbox->textureInfo, frontColorBufferMailbox->mailbox };
     return true;
 }
 
-void DrawingBuffer::mailboxReleased(const WebExternalTextureMailbox& mailbox, bool lostResource)
+void DrawingBuffer::gpuMailboxReleased(const gpu::Mailbox& mailbox, const gpu::SyncToken& syncToken,
+    bool lostResource)
 {
     if (m_destructionInProgress || m_gl->GetGraphicsResetStatusKHR() != GL_NO_ERROR || lostResource || m_isHidden) {
-        mailboxReleasedWithoutRecycling(mailbox);
+        deleteMailbox(mailbox, syncToken);
         return;
     }
 
     for (size_t i = 0; i < m_textureMailboxes.size(); i++) {
         RefPtr<MailboxInfo> mailboxInfo = m_textureMailboxes[i];
-        if (nameEquals(mailboxInfo->mailbox, mailbox)) {
-            memcpy(mailboxInfo->mailbox.syncToken, mailbox.syncToken,
-                sizeof(mailboxInfo->mailbox.syncToken));
-            mailboxInfo->mailbox.validSyncToken = mailbox.validSyncToken;
-            ASSERT(mailboxInfo->m_parentDrawingBuffer.get() == this);
-            mailboxInfo->m_parentDrawingBuffer.clear();
-            m_recycledMailboxQueue.prepend(mailboxInfo->mailbox);
+        if (mailboxInfo->mailbox == mailbox) {
+            m_recycledMailboxQueue.prepend(adoptRef(new RecycledMailbox(mailbox, syncToken)));
             return;
         }
     }
     ASSERT_NOT_REACHED();
 }
 
+void DrawingBuffer::softwareMailboxReleased(std::unique_ptr<cc::SharedBitmap> bitmap, const IntSize& size, const gpu::SyncToken& syncToken, bool lostResource)
+{
+    DCHECK(!syncToken.HasData()); // No sync tokens for software resources.
+    if (m_destructionInProgress || lostResource || m_isHidden || size != m_size)
+        return; // Just delete the bitmap.
+
+    RecycledBitmap recycled = { std::move(bitmap), m_size };
+    m_recycledBitmapQueue.append(std::move(recycled));
+}
+
+PassRefPtr<StaticBitmapImage> DrawingBuffer::transferToStaticBitmapImage()
+{
+    // This can be null if the context is lost before the first call to grContext().
+    GrContext* grContext = m_contextProvider->grContext();
+
+    cc::TextureMailbox textureMailbox;
+    std::unique_ptr<cc::SingleReleaseCallback> releaseCallback;
+    bool useSharedMemory = false;
+    bool success = false;
+    if (grContext)
+        success = PrepareTextureMailbox(&textureMailbox, &releaseCallback, useSharedMemory);
+    if (!success) {
+        // If we can't get a mailbox, return an transparent black ImageBitmap.
+        // The only situation this could happen is when two or more calls to transferToImageBitmap are made back-to-back, or when the context gets lost.
+        sk_sp<SkSurface> surface = SkSurface::MakeRasterN32Premul(m_size.width(), m_size.height());
+        return StaticBitmapImage::create(fromSkSp(surface->makeImageSnapshot()));
+    }
+
+    DCHECK_EQ(m_size.width(), textureMailbox.size_in_pixels().width());
+    DCHECK_EQ(m_size.height(), textureMailbox.size_in_pixels().height());
+
+    // Make our own textureId that is a reference on the same texture backing being used as the front
+    // buffer (which was returned from PrepareTextureMailbox()).

[piman, 2016/08/19 22:30:21]

Why do we do this dance? The texture was created on this context, right? We
already did insert a sync token and flushed this context, why do it again?

[danakj, 2016/08/19 22:37:17]

Since this function is acting on a mailbox only it needs to get a texture id.
The function used to be outside of DrawingBuffer, now it could just use a
texture id instead of making a mailbox at all, but I left it for now creating a
new texture id from the mailbox. So I'm doing a wait (for the mailbox produce),
a consume, and then a gensynctoken (for the mailbox consume) here. I think I'd
need to do some more surgery to PrepareTextureMailbox to avoid this, or am I
missing your point? I will leave a TODO about this though.

[danakj, 2016/08/19 22:43:03]

Oh or are you saying I could do the consume but not wait on the token from
produce or gen a new one. That makes sense, since same context.

[piman, 2016/08/19 23:11:35]

It's super subtle, but this works I guess - provided the releaseCallback is run
after the CreateAndConsumeTextureCHROMIUM, then the mailbox refers to something,
and I guess you're not doing any modification to the texture itself, so it
doesn't matter if the other context runs before or after the
CreateAndConsumeTextureCHROMIUM? 
If before, there is the reference from the original texture, if after there is
(at least) the reference from the new texture

What I was thinking originally was to steal the original texture id from
DrawingBuffer, and avoid both sync token and mailbox operations.

+    m_gl->WaitSyncTokenCHROMIUM(textureMailbox.GetSyncTokenData());
+    GLuint textureId = m_gl->CreateAndConsumeTextureCHROMIUM(GL_TEXTURE_2D, textureMailbox.name());
+    const GLuint64 fenceSync = m_gl->InsertFenceSyncCHROMIUM();
+    m_gl->Flush();
+    gpu::SyncToken syncToken;
+    m_gl->GenSyncTokenCHROMIUM(fenceSync, syncToken.GetData());
+    // Return the mailbox but report that the resource is lost to prevent trying to use
+    // the backing for future frames. We keep it alive with our own reference to the
+    // backing via our |textureId|.
+    releaseCallback->Run(syncToken, true /* lostResource */);
+
+    // Store that texture id as the backing for an SkImage.
+    GrGLTextureInfo textureInfo;
+    textureInfo.fTarget = GL_TEXTURE_2D;
+    textureInfo.fID = textureId;
+    GrBackendTextureDesc backendTexture;
+    backendTexture.fOrigin = kBottomLeft_GrSurfaceOrigin;
+    backendTexture.fWidth = m_size.width();
+    backendTexture.fHeight = m_size.height();
+    backendTexture.fConfig = kSkia8888_GrPixelConfig;
+    backendTexture.fTextureHandle = skia::GrGLTextureInfoToGrBackendObject(textureInfo);
+    sk_sp<SkImage> skImage = SkImage::MakeFromAdoptedTexture(grContext, backendTexture);
+
+    // Hold a ref on the GrContext for the texture backing the |skImage|.
+    sk_sp<GrContext> grContextRef = sk_ref_sp(grContext);
+    // We reuse the same mailbox name from above since our texture id was consumed from it.
+    const auto& skImageMailbox = textureMailbox.mailbox();
+    // Use the sync token generated after producing the mailbox. Waiting for this before trying to use
+    // the mailbox with some other context will ensure it is valid. We wouldn't need to wait for the
+    // consume because the texture id it generated would only be valid for the DrawingBuffer's context
+    // anyways.
+    const auto& skImageSyncToken = textureMailbox.sync_token();
+
+    // TODO(xidachen): Create a small pool of recycled textures from ImageBitmapRenderingContext's
+    // transferFromImageBitmap, and try to use them in DrawingBuffer.
+    return AcceleratedStaticBitmapImage::create(fromSkSp(skImage), fromSkSp(grContextRef), skImageMailbox, skImageSyncToken);
+}
+
 DrawingBuffer::TextureParameters DrawingBuffer::chromiumImageTextureParameters()
 {
 #if OS(MACOSX)
     // A CHROMIUM_image backed texture requires a specialized set of parameters
     // on OSX.
     TextureParameters parameters;
     parameters.target = GC3D_TEXTURE_RECTANGLE_ARB;
 
     if (m_wantAlphaChannel) {
         parameters.creationInternalColorFormat = GL_RGBA;
@@ skipping 29 matching lines @@
         parameters.colorFormat = GL_RGBA;
     } else {
         GLenum format = defaultBufferRequiresAlphaChannelToBePreserved() ? GL_RGBA : GL_RGB;
         parameters.creationInternalColorFormat = format;
         parameters.internalColorFormat = format;
         parameters.colorFormat = format;
     }
     return parameters;
 }
 
-void DrawingBuffer::mailboxReleasedWithoutRecycling(const WebExternalTextureMailbox& mailbox)
-{
-    ASSERT(m_textureMailboxes.size());
-    // Ensure not to call the destructor until deleteMailbox() is completed.
-    RefPtr<DrawingBuffer> self = this;
-    deleteMailbox(mailbox);
-}
-
-PassRefPtr<DrawingBuffer::MailboxInfo> DrawingBuffer::recycledMailbox()
+PassRefPtr<DrawingBuffer::MailboxInfo> DrawingBuffer::takeRecycledMailbox()
 {
     if (m_recycledMailboxQueue.isEmpty())
-        return PassRefPtr<MailboxInfo>();
+        return nullptr;
 
     // Creation of image backed mailboxes is very expensive, so be less
     // aggressive about pruning them.
     size_t cacheLimit = 1;
     if (RuntimeEnabledFeatures::webGLImageChromiumEnabled())
         cacheLimit = 4;
 
-    WebExternalTextureMailbox mailbox;
+    RefPtr<RecycledMailbox> recycled;
     while (m_recycledMailboxQueue.size() > cacheLimit) {
-        mailbox = m_recycledMailboxQueue.takeLast();
-        deleteMailbox(mailbox);
+        recycled = m_recycledMailboxQueue.takeLast();
+        deleteMailbox(recycled->mailbox, recycled->syncToken);
     }
-    mailbox = m_recycledMailboxQueue.takeLast();
+    recycled = m_recycledMailboxQueue.takeLast();
+
+    if (recycled->syncToken.HasData())
+        m_gl->WaitSyncTokenCHROMIUM(recycled->syncToken.GetData());
 
     RefPtr<MailboxInfo> mailboxInfo;
     for (size_t i = 0; i < m_textureMailboxes.size(); i++) {
-        if (nameEquals(m_textureMailboxes[i]->mailbox, mailbox)) {
+        if (m_textureMailboxes[i]->mailbox == recycled->mailbox) {
             mailboxInfo = m_textureMailboxes[i];
             break;
         }
     }
     ASSERT(mailboxInfo);
 
-    if (mailboxInfo->mailbox.validSyncToken) {
-        m_gl->WaitSyncTokenCHROMIUM(mailboxInfo->mailbox.syncToken);
-        mailboxInfo->mailbox.validSyncToken = false;
-    }
-
     if (mailboxInfo->size != m_size) {
         resizeTextureMemory(&mailboxInfo->textureInfo, m_size);
         mailboxInfo->size = m_size;
     }
 
     return mailboxInfo.release();
 }
 
 PassRefPtr<DrawingBuffer::MailboxInfo> DrawingBuffer::createNewMailbox(const TextureInfo& info)
 {
-    RefPtr<MailboxInfo> returnMailbox = adoptRef(new MailboxInfo());
+    RefPtr<MailboxInfo> returnMailbox = adoptRef(new MailboxInfo);
     m_gl->GenMailboxCHROMIUM(returnMailbox->mailbox.name);
     returnMailbox->textureInfo = info;
     returnMailbox->size = m_size;
     m_textureMailboxes.append(returnMailbox);
     return returnMailbox.release();
 }
 
-void DrawingBuffer::deleteMailbox(const WebExternalTextureMailbox& mailbox)
+void DrawingBuffer::deleteMailbox(const gpu::Mailbox& mailbox, const gpu::SyncToken& syncToken)
 {
+    if (syncToken.HasData())
+        m_gl->WaitSyncTokenCHROMIUM(syncToken.GetConstData());
     for (size_t i = 0; i < m_textureMailboxes.size(); i++) {
-        if (nameEquals(m_textureMailboxes[i]->mailbox, mailbox)) {
-            if (mailbox.validSyncToken)
-                m_gl->WaitSyncTokenCHROMIUM(mailbox.syncToken);
-
+        if (m_textureMailboxes[i]->mailbox == mailbox) {
             deleteChromiumImageForTexture(&m_textureMailboxes[i]->textureInfo);
-
             m_gl->DeleteTextures(1, &m_textureMailboxes[i]->textureInfo.textureId);
             m_textureMailboxes.remove(i);
             return;
         }
     }
     ASSERT_NOT_REACHED();
 }
 
 bool DrawingBuffer::initialize(const IntSize& size, bool useMultisampling)
 {
@@ skipping 56 matching lines @@
             restoreFramebufferBindings();
         }
         m_gl->Flush();
     }
 
     // Assume that the destination target is GL_TEXTURE_2D.
     if (!Extensions3DUtil::canUseCopyTextureCHROMIUM(GL_TEXTURE_2D, internalFormat, destType, level))
         return false;
 
     // Contexts may be in a different share group. We must transfer the texture through a mailbox first
-    WebExternalTextureMailbox mailbox;
     GLint textureId = 0;
     GLenum target = 0;
+    gpu::Mailbox mailbox;
+    gpu::SyncToken produceSyncToken;
     if (sourceBuffer == FrontBuffer && m_frontColorBuffer.texInfo.textureId) {
         textureId = m_frontColorBuffer.texInfo.textureId;
+        target = m_frontColorBuffer.texInfo.parameters.target;
         mailbox = m_frontColorBuffer.mailbox;
-        target = m_frontColorBuffer.texInfo.parameters.target;
+        produceSyncToken = m_frontColorBuffer.produceSyncToken;
     } else {
         textureId = m_colorBuffer.textureId;
         target = m_colorBuffer.parameters.target;
         m_gl->GenMailboxCHROMIUM(mailbox.name);
         m_gl->ProduceTextureDirectCHROMIUM(textureId, target, mailbox.name);
         const GLuint64 fenceSync = m_gl->InsertFenceSyncCHROMIUM();
         m_gl->Flush();
-        m_gl->GenSyncTokenCHROMIUM(fenceSync, mailbox.syncToken);
-        mailbox.validSyncToken = true;
+        m_gl->GenSyncTokenCHROMIUM(fenceSync, produceSyncToken.GetData());
     }
 
-    if (mailbox.validSyncToken)
-        gl->WaitSyncTokenCHROMIUM(mailbox.syncToken);
+    DCHECK(produceSyncToken.HasData());
+    gl->WaitSyncTokenCHROMIUM(produceSyncToken.GetConstData());
     GLuint sourceTexture = gl->CreateAndConsumeTextureCHROMIUM(target, mailbox.name);
 
     GLboolean unpackPremultiplyAlphaNeeded = GL_FALSE;
     GLboolean unpackUnpremultiplyAlphaNeeded = GL_FALSE;
     if (m_wantAlphaChannel && m_premultipliedAlpha && !premultiplyAlpha)
         unpackUnpremultiplyAlphaNeeded = GL_TRUE;
     else if (m_wantAlphaChannel && !m_premultipliedAlpha && premultiplyAlpha)
         unpackPremultiplyAlphaNeeded = GL_TRUE;
 
     gl->CopyTextureCHROMIUM(sourceTexture, texture, internalFormat, destType, flipY, unpackPremultiplyAlphaNeeded, unpackUnpremultiplyAlphaNeeded);
 
     gl->DeleteTextures(1, &sourceTexture);
 
     const GLuint64 fenceSync = gl->InsertFenceSyncCHROMIUM();
 
     gl->Flush();
-    GLbyte syncToken[GL_SYNC_TOKEN_SIZE_CHROMIUM] = { 0 };
-    gl->GenSyncTokenCHROMIUM(fenceSync, syncToken);
-    m_gl->WaitSyncTokenCHROMIUM(syncToken);
+    gpu::SyncToken syncToken;
+    gl->GenSyncTokenCHROMIUM(fenceSync, syncToken.GetData());
+    m_gl->WaitSyncTokenCHROMIUM(syncToken.GetData());
 
     return true;
 }
 
 GLuint DrawingBuffer::framebuffer() const
 {
     return m_fbo;
 }
 
 WebLayer* DrawingBuffer::platformLayer()
@@ skipping 18 matching lines @@
 
     m_gl->Flush();
 }
 
 void DrawingBuffer::beginDestruction()
 {
     ASSERT(!m_destructionInProgress);
     m_destructionInProgress = true;
 
     clearPlatformLayer();
-
-    while (!m_recycledMailboxQueue.isEmpty())
-        deleteMailbox(m_recycledMailboxQueue.takeLast());
+    freeRecycledMailboxes();
 
     if (m_multisampleFBO)
         m_gl->DeleteFramebuffers(1, &m_multisampleFBO);
 
     if (m_fbo)
         m_gl->DeleteFramebuffers(1, &m_fbo);
 
     if (m_multisampleRenderbuffer)
         m_gl->DeleteRenderbuffers(1, &m_multisampleRenderbuffer);
 
@@ skipping 482 matching lines @@
 
 void DrawingBuffer::restoreTextureBindings()
 {
     // This class potentially modifies the bindings for GL_TEXTURE_2D and
     // GL_TEXTURE_RECTANGLE. Only GL_TEXTURE_2D needs to be restored since
     // the public interface for WebGL does not support GL_TEXTURE_RECTANGLE.
     m_gl->BindTexture(GL_TEXTURE_2D, m_texture2DBinding);
 }
 
 } // namespace blink