Clean up DrawingBuffer.

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 37 matching lines @@
 
 namespace blink {
 
 namespace {
 
 const float s_resourceAdjustedRatio = 0.5;
 
 class ScopedTextureUnit0BindingRestorer {
     STACK_ALLOCATED();
     WTF_MAKE_NONCOPYABLE(ScopedTextureUnit0BindingRestorer);
+
 public:
     ScopedTextureUnit0BindingRestorer(gpu::gles2::GLES2Interface* gl, GLenum activeTextureUnit, GLuint textureUnitZeroId)
         : m_gl(gl)
         , m_oldActiveTextureUnit(activeTextureUnit)
         , m_oldTextureUnitZeroId(textureUnitZeroId)
     {
         m_gl->ActiveTexture(GL_TEXTURE0);
     }
     ~ScopedTextureUnit0BindingRestorer()
     {
@@ skipping 35 matching lines @@
         extensionsUtil->ensureExtensionEnabled("GL_OES_rgb8_rgba8");
         if (extensionsUtil->supportsExtension("GL_CHROMIUM_framebuffer_multisample"))
             extensionsUtil->ensureExtensionEnabled("GL_CHROMIUM_framebuffer_multisample");
         else
             extensionsUtil->ensureExtensionEnabled("GL_EXT_multisampled_render_to_texture");
     }
     bool discardFramebufferSupported = extensionsUtil->supportsExtension("GL_EXT_discard_framebuffer");
     if (discardFramebufferSupported)
         extensionsUtil->ensureExtensionEnabled("GL_EXT_discard_framebuffer");
 
-    RefPtr<DrawingBuffer> drawingBuffer = adoptRef(new DrawingBuffer(std::move(contextProvider), extensionsUtil.release(), discardFramebufferSupported, wantAlphaChannel, premultipliedAlpha, preserve));
-    if (!drawingBuffer->initialize(size, wantDepthBuffer, wantStencilBuffer, multisampleSupported)) {
+    RefPtr<DrawingBuffer> drawingBuffer = adoptRef(new DrawingBuffer(std::move(contextProvider), extensionsUtil.release(), discardFramebufferSupported, wantAlphaChannel, premultipliedAlpha, preserve, wantDepthBuffer, wantStencilBuffer));
+    if (!drawingBuffer->initialize(size, multisampleSupported)) {
         drawingBuffer->beginDestruction();
         return PassRefPtr<DrawingBuffer>();
     }
     return drawingBuffer.release();
 }
 
 void DrawingBuffer::forceNextDrawingBufferCreationToFail()
 {
     shouldFailDrawingBufferCreationForTesting = true;
 }
 
 DrawingBuffer::DrawingBuffer(
     PassOwnPtr<WebGraphicsContext3DProvider> contextProvider,
     PassOwnPtr<Extensions3DUtil> extensionsUtil,
     bool discardFramebufferSupported,
     bool wantAlphaChannel,
     bool premultipliedAlpha,
-    PreserveDrawingBuffer preserve)
+    PreserveDrawingBuffer preserve,
+    bool wantDepth,
+    bool wantStencil)
     : m_preserveDrawingBuffer(preserve)
-    , m_scissorEnabled(false)
-    , m_texture2DBinding(0)
-    , m_drawFramebufferBinding(0)
-    , m_readFramebufferBinding(0)
-    , m_renderbufferBinding(0)
-    , m_activeTextureUnit(GL_TEXTURE0)
     , m_contextProvider(std::move(contextProvider))
     , m_gl(m_contextProvider->contextGL())
     , m_extensionsUtil(std::move(extensionsUtil))
-    , m_size(-1, -1)
     , m_discardFramebufferSupported(discardFramebufferSupported)
     , m_wantAlphaChannel(wantAlphaChannel)
     , m_premultipliedAlpha(premultipliedAlpha)
-    , m_hasImplicitStencilBuffer(false)
-    , m_fbo(0)
-    , m_depthStencilBuffer(0)
-    , m_multisampleFBO(0)
-    , m_intermediateFBO(0)
-    , m_intermediateRenderbuffer(0)
-    , m_multisampleColorBuffer(0)
-    , m_contentsChanged(true)
-    , m_contentsChangeCommitted(false)
-    , m_bufferClearNeeded(false)
-    , m_antiAliasingMode(None)
-    , m_maxTextureSize(0)
-    , m_sampleCount(0)
-    , m_packAlignment(4)
-    , m_destructionInProgress(false)
-    , m_isHidden(false)
-    , m_filterQuality(kLow_SkFilterQuality)
+    , m_wantDepth(wantDepth)
+    , m_wantStencil(wantStencil)
 {
     memset(m_colorMask, 0, 4 * sizeof(GLboolean));
     memset(m_clearColor, 0, 4 * sizeof(GLfloat));
     // Used by browser tests to detect the use of a DrawingBuffer.
     TRACE_EVENT_INSTANT0("test_gpu", "DrawingBufferCreation", TRACE_EVENT_SCOPE_GLOBAL);
 }
 
 DrawingBuffer::~DrawingBuffer()
 {
     ASSERT(m_destructionInProgress);
@@ skipping 43 matching lines @@
 
 void DrawingBuffer::setFilterQuality(SkFilterQuality filterQuality)
 {
     if (m_filterQuality != filterQuality) {
         m_filterQuality = filterQuality;
         if (m_layer)
             m_layer->setNearestNeighbor(filterQuality == kNone_SkFilterQuality);
     }
 }
 
-bool DrawingBuffer::requiresRGBEmulation()
+bool DrawingBuffer::requiresAlphaMask()
 {
     // When an explicit resolve is required, clients draw into a render buffer
     // which is never backed by an IOSurface.
     if (m_antiAliasingMode == MSAAExplicitResolve)
         return false;
     return !m_drawFramebufferBinding && !m_wantAlphaChannel && m_colorBuffer.imageId && contextProvider()->getCapabilities().chromium_image_rgb_emulation;
 }
 
 void DrawingBuffer::freeRecycledMailboxes()
 {
@@ skipping 13 matching lines @@
         // 4. Here.
         return false;
     }
     ASSERT(!m_isHidden);
     if (!m_contentsChanged)
         return false;
 
     if (m_newMailboxCallback)
         (*m_newMailboxCallback)();
 
-    // Resolve the multisampled buffer into m_colorBuffer texture.
+    // Resolve the multisampled buffer into m_colorBuffertexture.

[Ken Russell (switch to Gerrit), 2016/05/04 21:13:11]

Space was lost in comment.

[erikchen, 2016/05/04 21:17:53]

Done.

     if (m_antiAliasingMode != None)
         commit();
 
     if (bitmap) {
         bitmap->setSize(size());
 
         unsigned char* pixels = bitmap->pixels();
         bool needPremultiply = m_wantAlphaChannel && !m_premultipliedAlpha;
         WebGLImageConversion::AlphaOp op = needPremultiply ? WebGLImageConversion::AlphaDoPremultiply : WebGLImageConversion::AlphaDoNothing;
         if (pixels)
             readBackFramebuffer(pixels, size().width(), size().height(), ReadbackSkia, op);
     }
 
     // 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();
 
     // No buffer available to recycle, create a new one.
     if (!frontColorBufferMailbox)
         frontColorBufferMailbox = createNewMailbox(createTextureAndAllocateMemory(m_size));
 
     if (m_preserveDrawingBuffer == Discard) {
         std::swap(frontColorBufferMailbox->textureInfo, m_colorBuffer);
-        // It appears safe to overwrite the context's framebuffer binding in the Discard case since there will always be a
-        // WebGLRenderingContext::clearIfComposited() call made before the next draw call which restores the framebuffer binding.
-        // If this stops being true at some point, we should track the current framebuffer binding in the DrawingBuffer and restore
-        // it after attaching the new back buffer here.
-        m_gl->BindFramebuffer(GL_FRAMEBUFFER, m_fbo);
-        attachColorBufferToCurrentFBO();
+        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};
+            const GLenum attachments[3] = { GL_COLOR_ATTACHMENT0, GL_DEPTH_ATTACHMENT, GL_STENCIL_ATTACHMENT };
             m_gl->DiscardFramebufferEXT(GL_FRAMEBUFFER, 3, attachments);
         }
     } else {
         m_gl->CopyTextureCHROMIUM(m_colorBuffer.textureId, frontColorBufferMailbox->textureInfo.textureId, frontColorBufferMailbox->textureInfo.parameters.internalColorFormat, GL_UNSIGNED_BYTE, GL_FALSE, GL_FALSE, GL_FALSE);
     }
 
     restoreFramebufferBindings();
     m_contentsChanged = false;
 
     m_gl->ProduceTextureDirectCHROMIUM(frontColorBufferMailbox->textureInfo.textureId, frontColorBufferMailbox->textureInfo.parameters.target, frontColorBufferMailbox->mailbox.name);
@@ skipping 147 matching lines @@
             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 wantDepthBuffer, bool wantStencilBuffer, bool useMultisampling)
+bool DrawingBuffer::initialize(const IntSize& size, bool useMultisampling)
 {
     if (m_gl->GetGraphicsResetStatusKHR() != GL_NO_ERROR) {
         // Need to try to restore the context again later.
         return false;
     }
 
     m_gl->GetIntegerv(GL_MAX_TEXTURE_SIZE, &m_maxTextureSize);
 
     int maxSampleCount = 0;
     m_antiAliasingMode = None;
     if (useMultisampling) {
         m_gl->GetIntegerv(GL_MAX_SAMPLES_ANGLE, &maxSampleCount);
         m_antiAliasingMode = MSAAExplicitResolve;
         if (m_extensionsUtil->supportsExtension("GL_EXT_multisampled_render_to_texture")) {
             m_antiAliasingMode = MSAAImplicitResolve;
         } else if (m_extensionsUtil->supportsExtension("GL_CHROMIUM_screen_space_antialiasing")) {
             m_antiAliasingMode = ScreenSpaceAntialiasing;
         }
     }
     m_sampleCount = std::min(4, maxSampleCount);
 
     m_gl->GenFramebuffers(1, &m_fbo);
-
     m_gl->BindFramebuffer(GL_FRAMEBUFFER, m_fbo);
-    createSecondaryBuffers();
-    if (!reset(size, wantDepthBuffer || wantStencilBuffer))
+    if (wantExplicitResolve()) {
+        m_gl->GenFramebuffers(1, &m_multisampleFBO);
+        m_gl->BindFramebuffer(GL_FRAMEBUFFER, m_multisampleFBO);
+        m_gl->GenRenderbuffers(1, &m_multisampleRenderbuffer);
+    }
+    if (!reset(size))
         return false;
 
     if (m_depthStencilBuffer) {
-        DCHECK(wantDepthBuffer || wantStencilBuffer);
-        m_hasImplicitStencilBuffer = !wantStencilBuffer;
+        DCHECK(wantDepthOrStencil());
+        m_hasImplicitStencilBuffer = !m_wantStencil;
     }
 
     if (m_gl->GetGraphicsResetStatusKHR() != GL_NO_ERROR) {
         // It's possible that the drawing buffer allocation provokes a context loss, so check again just in case. http://crbug.com/512302
         return false;
     }
 
     return true;
 }
 
@@ skipping 93 matching lines @@
 
     while (!m_recycledMailboxQueue.isEmpty())
         deleteMailbox(m_recycledMailboxQueue.takeLast());
 
     if (m_multisampleFBO)
         m_gl->DeleteFramebuffers(1, &m_multisampleFBO);
 
     if (m_fbo)
         m_gl->DeleteFramebuffers(1, &m_fbo);
 
-    if (m_multisampleColorBuffer)
-        m_gl->DeleteRenderbuffers(1, &m_multisampleColorBuffer);
+    if (m_multisampleRenderbuffer)
+        m_gl->DeleteRenderbuffers(1, &m_multisampleRenderbuffer);
 
     if (m_intermediateFBO)
         m_gl->DeleteFramebuffers(1, &m_intermediateFBO);
 
     if (m_intermediateRenderbuffer)
         m_gl->DeleteRenderbuffers(1, &m_intermediateRenderbuffer);
 
     if (m_depthStencilBuffer)
         m_gl->DeleteRenderbuffers(1, &m_depthStencilBuffer);
 
     if (m_colorBuffer.textureId) {
         deleteChromiumImageForTexture(&m_colorBuffer);
         m_gl->DeleteTextures(1, &m_colorBuffer.textureId);
     }
 
     setSize(IntSize());
 
     m_colorBuffer = TextureInfo();
     m_frontColorBuffer = FrontBufferInfo();
-    m_multisampleColorBuffer = 0;
+    m_multisampleRenderbuffer = 0;
     m_depthStencilBuffer = 0;
     m_multisampleFBO = 0;
     m_fbo = 0;
 
     if (m_layer)
         GraphicsLayer::unregisterContentsLayer(m_layer->layer());
 }
 
 GLuint DrawingBuffer::createColorTexture(const TextureParameters& parameters)
 {
     GLuint offscreenColorTexture;
     m_gl->GenTextures(1, &offscreenColorTexture);
     m_gl->BindTexture(parameters.target, offscreenColorTexture);
     m_gl->TexParameteri(parameters.target, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
     m_gl->TexParameteri(parameters.target, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
     m_gl->TexParameteri(parameters.target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
     m_gl->TexParameteri(parameters.target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
     return offscreenColorTexture;
 }
 
-void DrawingBuffer::createSecondaryBuffers()
+bool DrawingBuffer::resizeMultisampleFramebuffer(const IntSize& size)
 {
-    // create a multisample FBO
-    if (m_antiAliasingMode == MSAAExplicitResolve) {
-        m_gl->GenFramebuffers(1, &m_multisampleFBO);
-        m_gl->BindFramebuffer(GL_FRAMEBUFFER, m_multisampleFBO);
-        m_gl->GenRenderbuffers(1, &m_multisampleColorBuffer);
-    }
-}
+    DCHECK(wantExplicitResolve());
+    m_gl->BindFramebuffer(GL_FRAMEBUFFER, m_multisampleFBO);
+    m_gl->BindRenderbuffer(GL_RENDERBUFFER, m_multisampleRenderbuffer);
+    m_gl->RenderbufferStorageMultisampleCHROMIUM(GL_RENDERBUFFER, m_sampleCount, m_colorBuffer.parameters.internalRenderbufferFormat, size.width(), size.height());
 
-bool DrawingBuffer::resizeFramebuffer(const IntSize& size, bool wantDepthOrStencilBuffer)
-{
-    m_gl->BindFramebuffer(GL_FRAMEBUFFER, m_fbo);
-    if (m_antiAliasingMode != MSAAExplicitResolve && wantDepthOrStencilBuffer)
-        resizeDepthStencil(size);
-    if (m_gl->CheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
+    if (m_gl->GetError() == GL_OUT_OF_MEMORY)
         return false;
 
-    return true;
-}
+    m_gl->FramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, m_multisampleRenderbuffer);
 
-bool DrawingBuffer::resizeMultisampleFramebuffer(const IntSize& size, bool wantDepthOrStencilBuffer)
-{
-    if (m_antiAliasingMode == MSAAExplicitResolve) {
-        m_gl->BindFramebuffer(GL_FRAMEBUFFER, m_multisampleFBO);
-
-        m_gl->BindRenderbuffer(GL_RENDERBUFFER, m_multisampleColorBuffer);
-        m_gl->RenderbufferStorageMultisampleCHROMIUM(GL_RENDERBUFFER, m_sampleCount, m_colorBuffer.parameters.internalRenderbufferFormat, size.width(), size.height());
+    if (m_intermediateFBO) {
+        m_gl->BindFramebuffer(GL_FRAMEBUFFER, m_intermediateFBO);
+        m_gl->BindRenderbuffer(GL_RENDERBUFFER, m_intermediateRenderbuffer);
+        m_gl->RenderbufferStorage(GL_RENDERBUFFER, m_colorBuffer.parameters.internalRenderbufferFormat, size.width(), size.height());
 
         if (m_gl->GetError() == GL_OUT_OF_MEMORY)
             return false;
 
-        m_gl->FramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, m_multisampleColorBuffer);
-        if (wantDepthOrStencilBuffer)
-            resizeDepthStencil(size);
+        m_gl->FramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, m_intermediateRenderbuffer);
         if (m_gl->CheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
             return false;
 
-        if (m_intermediateFBO) {
-            m_gl->BindFramebuffer(GL_FRAMEBUFFER, m_intermediateFBO);
-            m_gl->BindRenderbuffer(GL_RENDERBUFFER, m_intermediateRenderbuffer);
-            m_gl->RenderbufferStorage(GL_RENDERBUFFER, m_colorBuffer.parameters.internalRenderbufferFormat, size.width(), size.height());
-
-            if (m_gl->GetError() == GL_OUT_OF_MEMORY)
-                return false;
-
-            m_gl->FramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, m_intermediateRenderbuffer);
-            if (m_gl->CheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
-                return false;
-
-            m_gl->BindFramebuffer(GL_FRAMEBUFFER, m_multisampleFBO);
-        }
+        m_gl->BindFramebuffer(GL_FRAMEBUFFER, m_multisampleFBO);
     }
-
     return true;
 }
 
 void DrawingBuffer::resizeDepthStencil(const IntSize& size)
 {
+    m_gl->BindFramebuffer(GL_FRAMEBUFFER, m_multisampleFBO ? m_multisampleFBO : m_fbo);
     if (!m_depthStencilBuffer)
         m_gl->GenRenderbuffers(1, &m_depthStencilBuffer);
     m_gl->BindRenderbuffer(GL_RENDERBUFFER, m_depthStencilBuffer);
     if (m_antiAliasingMode == MSAAImplicitResolve)
         m_gl->RenderbufferStorageMultisampleEXT(GL_RENDERBUFFER, m_sampleCount, GL_DEPTH24_STENCIL8_OES, size.width(), size.height());
     else if (m_antiAliasingMode == MSAAExplicitResolve)
         m_gl->RenderbufferStorageMultisampleCHROMIUM(GL_RENDERBUFFER, m_sampleCount, GL_DEPTH24_STENCIL8_OES, size.width(), size.height());
     else
         m_gl->RenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8_OES, size.width(), size.height());
     // For ES 2.0 contexts DEPTH_STENCIL is not available natively, so we emulate it
     // at the command buffer level for WebGL contexts.
     m_gl->FramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER, m_depthStencilBuffer);
     m_gl->BindRenderbuffer(GL_RENDERBUFFER, 0);
 }
 
+bool DrawingBuffer::resizeDefaultFramebuffer(const IntSize& size)
+{
+    // Resize or create m_colorBuffer.
+    if (m_colorBuffer.textureId) {
+        resizeTextureMemory(&m_colorBuffer, size);
+    } else {
+        m_colorBuffer = createTextureAndAllocateMemory(size);
+    }
 
+    attachColorBufferToReadFramebuffer();
+
+    if (wantExplicitResolve()) {
+        if (!resizeMultisampleFramebuffer(size))
+            return false;
+    }
+
+    if (wantDepthOrStencil())
+        resizeDepthStencil(size);
+    return m_gl->CheckFramebufferStatus(GL_FRAMEBUFFER) == GL_FRAMEBUFFER_COMPLETE;
+}
 
 void DrawingBuffer::clearFramebuffers(GLbitfield clearMask)
 {
     // We will clear the multisample FBO, but we also need to clear the non-multisampled buffer.
     if (m_multisampleFBO) {
         m_gl->BindFramebuffer(GL_FRAMEBUFFER, m_fbo);
         m_gl->Clear(GL_COLOR_BUFFER_BIT);
     }
 
     m_gl->BindFramebuffer(GL_FRAMEBUFFER, m_multisampleFBO ? m_multisampleFBO : m_fbo);
@@ skipping 15 matching lines @@
     // Clamp if the desired size is greater than the maximum texture size for the device.
     if (adjustedSize.height() > maxTextureSize)
         adjustedSize.setHeight(maxTextureSize);
 
     if (adjustedSize.width() > maxTextureSize)
         adjustedSize.setWidth(maxTextureSize);
 
     return adjustedSize;
 }
 
-bool DrawingBuffer::reset(const IntSize& newSize, bool wantDepthOrStencilBuffer)
+bool DrawingBuffer::reset(const IntSize& newSize)
 {
     ASSERT(!newSize.isEmpty());
     IntSize adjustedSize = adjustSize(newSize, m_size, m_maxTextureSize);
     if (adjustedSize.isEmpty())
         return false;
 
     if (adjustedSize != m_size) {
         do {
-            if (m_colorBuffer.textureId) {
-                resizeTextureMemory(&m_colorBuffer, adjustedSize);
-            } else {
-                m_colorBuffer = createTextureAndAllocateMemory(adjustedSize);
-            }
-
-            m_gl->BindFramebuffer(GL_FRAMEBUFFER, m_fbo);
-            attachColorBufferToCurrentFBO();
-
-            // resize multisample FBO
-            if (!resizeMultisampleFramebuffer(adjustedSize, wantDepthOrStencilBuffer)
-                || !resizeFramebuffer(adjustedSize, wantDepthOrStencilBuffer)) {
+            if (!resizeDefaultFramebuffer(m_size)) {
                 adjustedSize.scale(s_resourceAdjustedRatio);
                 continue;
             }
             break;
         } while (!adjustedSize.isEmpty());
 
         setSize(adjustedSize);
 
         if (adjustedSize.isEmpty())
             return false;
     }
 
     m_gl->Disable(GL_SCISSOR_TEST);
     m_gl->ClearColor(0, 0, 0, 0);
-    m_gl->ColorMask(true, true, true, !requiresRGBEmulation());
+    m_gl->ColorMask(true, true, true, !requiresAlphaMask());
 
     GLbitfield clearMask = GL_COLOR_BUFFER_BIT;
     if (!!m_depthStencilBuffer) {
         m_gl->ClearDepthf(1.0f);
         clearMask |= GL_DEPTH_BUFFER_BIT;
         m_gl->DepthMask(true);
     }
     if (!!m_depthStencilBuffer) {
         m_gl->ClearStencil(0);
         clearMask |= GL_STENCIL_BUFFER_BIT;
         m_gl->StencilMaskSeparate(GL_FRONT, 0xFFFFFFFF);
     }
 
     clearFramebuffers(clearMask);
     return true;
 }
 
 void DrawingBuffer::commit()
 {
-    if (m_multisampleFBO && !m_contentsChangeCommitted) {
+    if (wantExplicitResolve() && !m_contentsChangeCommitted) {
         m_gl->BindFramebuffer(GL_READ_FRAMEBUFFER_ANGLE, m_multisampleFBO);
         m_gl->BindFramebuffer(GL_DRAW_FRAMEBUFFER_ANGLE, m_fbo);
 
         if (m_scissorEnabled)
             m_gl->Disable(GL_SCISSOR_TEST);
 
         int width = m_size.width();
         int height = m_size.height();
         // Use NEAREST, because there is no scale performed during the blit.
         GLuint filter = GL_NEAREST;
@@ skipping 62 matching lines @@
     }
 }
 
 bool DrawingBuffer::multisample() const
 {
     return m_antiAliasingMode != None;
 }
 
 void DrawingBuffer::bind(GLenum target)
 {
-    if (target != GL_READ_FRAMEBUFFER)
-        m_gl->BindFramebuffer(target, m_multisampleFBO ? m_multisampleFBO : m_fbo);
-    else
-        m_gl->BindFramebuffer(target, m_fbo);
+    m_gl->BindFramebuffer(target, wantExplicitResolve() ? m_multisampleFBO : m_fbo);
 }
 
 void DrawingBuffer::setPackAlignment(GLint param)
 {
     m_packAlignment = param;
 }
 
 bool DrawingBuffer::paintRenderingResultsToImageData(int& width, int& height, SourceDrawingBuffer sourceBuffer, WTF::ArrayBufferContents& contents)
 {
     ASSERT(!m_premultipliedAlpha);
@@ skipping 165 matching lines @@
         // If the desired texture target is different, there's no way to fall back
         // to a non CHROMIUM_image texture.
         if (chromiumImageTextureParameters().target != defaultTextureParameters().target)
             return;
     }
 
     m_gl->BindTexture(info->parameters.target, info->textureId);
     texImage2DResourceSafe(info->parameters.target, 0, info->parameters.creationInternalColorFormat, size.width(), size.height(), 0, info->parameters.colorFormat, GL_UNSIGNED_BYTE);
 }
 
-void DrawingBuffer::attachColorBufferToCurrentFBO()
+void DrawingBuffer::attachColorBufferToReadFramebuffer()
 {
+    m_gl->BindFramebuffer(GL_FRAMEBUFFER, m_fbo);
+
     GLenum target = m_colorBuffer.parameters.target;
+    GLenum id = m_colorBuffer.textureId;
 
-    m_gl->BindTexture(target, m_colorBuffer.textureId);
+    m_gl->BindTexture(target, id);
 
     if (m_antiAliasingMode == MSAAImplicitResolve)
-        m_gl->FramebufferTexture2DMultisampleEXT(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, target, m_colorBuffer.textureId, 0, m_sampleCount);
+        m_gl->FramebufferTexture2DMultisampleEXT(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, target, id, 0, m_sampleCount);
     else
-        m_gl->FramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, target, m_colorBuffer.textureId, 0);
+        m_gl->FramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, target, id, 0);
 
+    restoreTextureBindings();
+    restoreFramebufferBindings();
+}
+
+bool DrawingBuffer::wantExplicitResolve()
+{
+    return m_antiAliasingMode == MSAAExplicitResolve;
+}
+
+bool DrawingBuffer::wantDepthOrStencil()
+{
+    return m_wantDepth || m_wantStencil;
+}
+
+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