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.

[Ken Russell (switch to Gerrit), 2016/08/20 03:54:01]

This won't assert if it was the first element that was removed, will it?

[danakj, 2016/08/22 18:45:25]

The DequeTest I added deletes element 0 and passes. It's because the iterator
uses an unsigned index:
https://cs.chromium.org/chromium/src/third_party/WebKit/Source/wtf/Deque.h?rc...

+        }
+    }
+    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.

[Ken Russell (switch to Gerrit), 2016/08/20 03:54:01]

The intent of transferToStaticBitmapImage is that it takes the DrawingBuffer's
most recent rendering result and transfers it into a StaticBitmapImage -- after
it's called, the DrawingBuffer's contents are lost. This is what implements
OffscreenCanvas' transferToImageBitmap method:
https://wiki.whatwg.org/wiki/OffscreenCanvas .

I don't see where in PrepareTextureMailbox it can return false for the second
call if they're made back-to-back, before any further rendering is done to the
DrawingBuffer so it has a chance to reallocate its back buffer. Is that still
working as expected?

[danakj, 2016/08/22 18:45:24]

So I think how this works is if |m_preserveDrawingBuffer| is |Discard|, then
PrepareTextureMailbox will throw the last recycled mailbox into the
m_colorBuffer spot.

Since transferToStaticBitmapImage always "loses" the mailboxes its given (since
it wants to retain ownership forever), they do not get recycled. So as long as
the compositor isn't also calling PrepareTextureMailbox and returning them
unlost, each call to the method makes a new texture via
createTextureAndAllocateMemory(m_size), gets a mailbox for it via
createNewMailbox(), and makes that the new m_colorBuffer. So a 2nd call would
give you a black texture.

[Ken Russell (switch to Gerrit), 2016/08/22 19:03:11]

Thanks for this explanation - sounds good.

+        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()).
+    // TODO(danakj): Instead of using PrepareTextureMailbox(), we could just use the actual texture id and
+    // avoid this whole dance of wait for sync token, consume, generate new sync token.

[Ken Russell (switch to Gerrit), 2016/08/20 03:54:01]

It's possible this wasn't implemented as desired before -- but the intent really
is to give the sole reference to the DrawingBuffer's current texture away. Even
the compositor shouldn't be able to get a handle to it. Again, this is a
primitive only accessible to OffscreenCanvas, which can't be displayed in the
DOM in the first place, and can't be rendered directly by the compositor. One
intended way to display OffscreenCanvas' results is in an
ImageBitmapRenderingContext, importing them via transferFromImageBitmap.

Does this change or simplify any of the code below? Can the DrawingBuffer
immediately drop its reference to the texture once it's been put in the mailbox
and given to the caller in the form of an AcceleratedStaticBitmapImage?

[danakj, 2016/08/22 19:01:04]

I think this is what is happening. We PrepareTextureMailbox, and discard the
m_colorBuffer (replace it with a new texture). Then we call
releaseCallback->Run() with lostResource=true which means the DrawingBuffer can
not reuse it, and it deletes its client id.

I think this can be simpler if we just dont deal with PrepareTextureMailbox tho,
which is what TODO on 424 is trying to get at.

[Ken Russell (switch to Gerrit), 2016/08/22 19:03:11]

I see. Thanks for this explanation. Per our offline discussion it sounds fine to
rework and/or simplify this further in subsequent CLs. Agree that making
incremental non-breaking changes is the best way forward.

+    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), 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