Add m-esr52 at 52.6.0

1 files changed, 1044 insertions, 0 deletions

diff --git a/gfx/gl/GLScreenBuffer.cpp b/gfx/gl/GLScreenBuffer.cpp
new file mode 100755
index 000000000..463f7ebab
--- /dev/null
+++ b/gfx/gl/GLScreenBuffer.cpp
@@ -0,0 +1,1044 @@
+/* -*- Mode: c++; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 40; -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "GLScreenBuffer.h"
+
+#include <cstring>
+#include "CompositorTypes.h"
+#include "GLContext.h"
+#include "GLBlitHelper.h"
+#include "GLReadTexImageHelper.h"
+#include "SharedSurfaceEGL.h"
+#include "SharedSurfaceGL.h"
+#include "ScopedGLHelpers.h"
+#include "gfx2DGlue.h"
+#include "../layers/ipc/ShadowLayers.h"
+#include "mozilla/layers/TextureForwarder.h"
+#include "mozilla/layers/TextureClientSharedSurface.h"
+
+#ifdef XP_WIN
+#include "SharedSurfaceANGLE.h"         // for SurfaceFactory_ANGLEShareHandle
+#include "SharedSurfaceD3D11Interop.h"  // for SurfaceFactory_D3D11Interop
+#include "mozilla/gfx/DeviceManagerDx.h"
+#endif
+
+#ifdef XP_MACOSX
+#include "SharedSurfaceIO.h"
+#endif
+
+#ifdef GL_PROVIDER_GLX
+#include "GLXLibrary.h"
+#include "SharedSurfaceGLX.h"
+#endif
+
+namespace mozilla {
+namespace gl {
+
+using gfx::SurfaceFormat;
+
+UniquePtr<GLScreenBuffer>
+GLScreenBuffer::Create(GLContext* gl,
+                       const gfx::IntSize& size,
+                       const SurfaceCaps& caps)
+{
+    UniquePtr<GLScreenBuffer> ret;
+    if (caps.antialias &&
+        !gl->IsSupported(GLFeature::framebuffer_multisample))
+    {
+        return Move(ret);
+    }
+
+    layers::TextureFlags flags = layers::TextureFlags::ORIGIN_BOTTOM_LEFT;
+    if (!caps.premultAlpha) {
+        flags |= layers::TextureFlags::NON_PREMULTIPLIED;
+    }
+
+    UniquePtr<SurfaceFactory> factory = MakeUnique<SurfaceFactory_Basic>(gl, caps, flags);
+
+    ret.reset( new GLScreenBuffer(gl, caps, Move(factory)) );
+    return Move(ret);
+}
+
+/* static */ UniquePtr<SurfaceFactory>
+GLScreenBuffer::CreateFactory(GLContext* gl,
+                              const SurfaceCaps& caps,
+                              KnowsCompositor* compositorConnection,
+                              const layers::TextureFlags& flags)
+{
+  return CreateFactory(gl, caps, compositorConnection->GetTextureForwarder(),
+                       compositorConnection->GetCompositorBackendType(), flags);
+}
+
+/* static */ UniquePtr<SurfaceFactory>
+GLScreenBuffer::CreateFactory(GLContext* gl,
+                              const SurfaceCaps& caps,
+                              LayersIPCChannel* ipcChannel,
+                              const mozilla::layers::LayersBackend backend,
+                              const layers::TextureFlags& flags)
+{
+    UniquePtr<SurfaceFactory> factory = nullptr;
+    if (!gfxPrefs::WebGLForceLayersReadback()) {
+        switch (backend) {
+            case mozilla::layers::LayersBackend::LAYERS_OPENGL: {
+#if defined(XP_MACOSX)
+                factory = SurfaceFactory_IOSurface::Create(gl, caps, ipcChannel, flags);
+#elif defined(GL_PROVIDER_GLX)
+                if (sGLXLibrary.UseTextureFromPixmap())
+                  factory = SurfaceFactory_GLXDrawable::Create(gl, caps, ipcChannel, flags);
+#elif defined(MOZ_WIDGET_UIKIT)
+                factory = MakeUnique<SurfaceFactory_GLTexture>(mGLContext, caps, ipcChannel, mFlags);
+#else
+                if (gl->GetContextType() == GLContextType::EGL) {
+                    if (XRE_IsParentProcess()) {
+                        factory = SurfaceFactory_EGLImage::Create(gl, caps, ipcChannel, flags);
+                    }
+                }
+#endif
+                break;
+            }
+            case mozilla::layers::LayersBackend::LAYERS_D3D11: {
+#ifdef XP_WIN
+                // Enable surface sharing only if ANGLE and compositing devices
+                // are both WARP or both not WARP
+                gfx::DeviceManagerDx* dm = gfx::DeviceManagerDx::Get();
+                if (gl->IsANGLE() &&
+                    (gl->IsWARP() == dm->IsWARP()) &&
+                    dm->TextureSharingWorks())
+                {
+                    factory = SurfaceFactory_ANGLEShareHandle::Create(gl, caps, ipcChannel, flags);
+                }
+
+                if (!factory && gfxPrefs::WebGLDXGLEnabled()) {
+                  factory = SurfaceFactory_D3D11Interop::Create(gl, caps, ipcChannel, flags);
+                }
+#endif
+              break;
+            }
+            default:
+              break;
+        }
+
+#ifdef GL_PROVIDER_GLX
+        if (!factory && sGLXLibrary.UseTextureFromPixmap()) {
+            factory = SurfaceFactory_GLXDrawable::Create(gl, caps, ipcChannel, flags);
+        }
+#endif
+    }
+
+    return factory;
+}
+
+GLScreenBuffer::GLScreenBuffer(GLContext* gl,
+                               const SurfaceCaps& caps,
+                               UniquePtr<SurfaceFactory> factory)
+    : mGL(gl)
+    , mCaps(caps)
+    , mFactory(Move(factory))
+    , mNeedsBlit(true)
+    , mUserReadBufferMode(LOCAL_GL_BACK)
+    , mUserDrawBufferMode(LOCAL_GL_BACK)
+    , mUserDrawFB(0)
+    , mUserReadFB(0)
+    , mInternalDrawFB(0)
+    , mInternalReadFB(0)
+#ifdef DEBUG
+    , mInInternalMode_DrawFB(true)
+    , mInInternalMode_ReadFB(true)
+#endif
+{ }
+
+GLScreenBuffer::~GLScreenBuffer()
+{
+    mFactory = nullptr;
+    mDraw = nullptr;
+    mRead = nullptr;
+
+    if (!mBack)
+        return;
+
+    // Detach mBack cleanly.
+    mBack->Surf()->ProducerRelease();
+}
+
+void
+GLScreenBuffer::BindAsFramebuffer(GLContext* const gl, GLenum target) const
+{
+    GLuint drawFB = DrawFB();
+    GLuint readFB = ReadFB();
+
+    if (!gl->IsSupported(GLFeature::split_framebuffer)) {
+        MOZ_ASSERT(drawFB == readFB);
+        gl->raw_fBindFramebuffer(target, readFB);
+        return;
+    }
+
+    switch (target) {
+    case LOCAL_GL_FRAMEBUFFER:
+        gl->raw_fBindFramebuffer(LOCAL_GL_DRAW_FRAMEBUFFER_EXT, drawFB);
+        gl->raw_fBindFramebuffer(LOCAL_GL_READ_FRAMEBUFFER_EXT, readFB);
+        break;
+
+    case LOCAL_GL_DRAW_FRAMEBUFFER_EXT:
+        gl->raw_fBindFramebuffer(LOCAL_GL_DRAW_FRAMEBUFFER_EXT, drawFB);
+        break;
+
+    case LOCAL_GL_READ_FRAMEBUFFER_EXT:
+        gl->raw_fBindFramebuffer(LOCAL_GL_READ_FRAMEBUFFER_EXT, readFB);
+        break;
+
+    default:
+        MOZ_CRASH("GFX: Bad `target` for BindFramebuffer.");
+    }
+}
+
+void
+GLScreenBuffer::BindFB(GLuint fb)
+{
+    GLuint drawFB = DrawFB();
+    GLuint readFB = ReadFB();
+
+    mUserDrawFB = fb;
+    mUserReadFB = fb;
+    mInternalDrawFB = (fb == 0) ? drawFB : fb;
+    mInternalReadFB = (fb == 0) ? readFB : fb;
+
+    if (mInternalDrawFB == mInternalReadFB) {
+        mGL->raw_fBindFramebuffer(LOCAL_GL_FRAMEBUFFER, mInternalDrawFB);
+    } else {
+        MOZ_ASSERT(mGL->IsSupported(GLFeature::split_framebuffer));
+        mGL->raw_fBindFramebuffer(LOCAL_GL_DRAW_FRAMEBUFFER_EXT, mInternalDrawFB);
+        mGL->raw_fBindFramebuffer(LOCAL_GL_READ_FRAMEBUFFER_EXT, mInternalReadFB);
+    }
+
+#ifdef DEBUG
+    mInInternalMode_DrawFB = false;
+    mInInternalMode_ReadFB = false;
+#endif
+}
+
+void
+GLScreenBuffer::BindDrawFB(GLuint fb)
+{
+    MOZ_ASSERT(mGL->IsSupported(GLFeature::split_framebuffer));
+
+    GLuint drawFB = DrawFB();
+    mUserDrawFB = fb;
+    mInternalDrawFB = (fb == 0) ? drawFB : fb;
+
+    mGL->raw_fBindFramebuffer(LOCAL_GL_DRAW_FRAMEBUFFER_EXT, mInternalDrawFB);
+
+#ifdef DEBUG
+    mInInternalMode_DrawFB = false;
+#endif
+}
+
+void
+GLScreenBuffer::BindReadFB(GLuint fb)
+{
+    MOZ_ASSERT(mGL->IsSupported(GLFeature::split_framebuffer));
+
+    GLuint readFB = ReadFB();
+    mUserReadFB = fb;
+    mInternalReadFB = (fb == 0) ? readFB : fb;
+
+    mGL->raw_fBindFramebuffer(LOCAL_GL_READ_FRAMEBUFFER_EXT, mInternalReadFB);
+
+#ifdef DEBUG
+    mInInternalMode_ReadFB = false;
+#endif
+}
+
+void
+GLScreenBuffer::BindFB_Internal(GLuint fb)
+{
+    mInternalDrawFB = mUserDrawFB = fb;
+    mInternalReadFB = mUserReadFB = fb;
+    mGL->raw_fBindFramebuffer(LOCAL_GL_FRAMEBUFFER, mInternalDrawFB);
+
+#ifdef DEBUG
+    mInInternalMode_DrawFB = true;
+    mInInternalMode_ReadFB = true;
+#endif
+}
+
+void
+GLScreenBuffer::BindDrawFB_Internal(GLuint fb)
+{
+    MOZ_ASSERT(mGL->IsSupported(GLFeature::split_framebuffer));
+
+    mInternalDrawFB = mUserDrawFB = fb;
+    mGL->raw_fBindFramebuffer(LOCAL_GL_DRAW_FRAMEBUFFER_EXT, mInternalDrawFB);
+
+#ifdef DEBUG
+    mInInternalMode_DrawFB = true;
+#endif
+}
+
+void
+GLScreenBuffer::BindReadFB_Internal(GLuint fb)
+{
+    MOZ_ASSERT(mGL->IsSupported(GLFeature::split_framebuffer));
+
+    mInternalReadFB = mUserReadFB = fb;
+    mGL->raw_fBindFramebuffer(LOCAL_GL_READ_FRAMEBUFFER_EXT, mInternalReadFB);
+
+#ifdef DEBUG
+    mInInternalMode_ReadFB = true;
+#endif
+}
+
+
+GLuint
+GLScreenBuffer::GetDrawFB() const
+{
+#ifdef DEBUG
+    MOZ_ASSERT(mGL->IsCurrent());
+    MOZ_ASSERT(!mInInternalMode_DrawFB);
+
+    // Don't need a branch here, because:
+    // LOCAL_GL_DRAW_FRAMEBUFFER_BINDING_EXT == LOCAL_GL_FRAMEBUFFER_BINDING == 0x8CA6
+    // We use raw_ here because this is debug code and we need to see what
+    // the driver thinks.
+    GLuint actual = 0;
+    mGL->raw_fGetIntegerv(LOCAL_GL_DRAW_FRAMEBUFFER_BINDING_EXT, (GLint*)&actual);
+
+    GLuint predicted = mInternalDrawFB;
+    if (predicted != actual) {
+        printf_stderr("Misprediction: Bound draw FB predicted: %d. Was: %d.\n",
+                      predicted, actual);
+        MOZ_ASSERT(false, "Draw FB binding misprediction!");
+    }
+#endif
+
+    return mUserDrawFB;
+}
+
+GLuint
+GLScreenBuffer::GetReadFB() const
+{
+#ifdef DEBUG
+    MOZ_ASSERT(mGL->IsCurrent());
+    MOZ_ASSERT(!mInInternalMode_ReadFB);
+
+    // We use raw_ here because this is debug code and we need to see what
+    // the driver thinks.
+    GLuint actual = 0;
+    if (mGL->IsSupported(GLFeature::split_framebuffer))
+        mGL->raw_fGetIntegerv(LOCAL_GL_READ_FRAMEBUFFER_BINDING_EXT, (GLint*)&actual);
+    else
+        mGL->raw_fGetIntegerv(LOCAL_GL_FRAMEBUFFER_BINDING, (GLint*)&actual);
+
+    GLuint predicted = mInternalReadFB;
+    if (predicted != actual) {
+        printf_stderr("Misprediction: Bound read FB predicted: %d. Was: %d.\n",
+                      predicted, actual);
+        MOZ_ASSERT(false, "Read FB binding misprediction!");
+    }
+#endif
+
+    return mUserReadFB;
+}
+
+GLuint
+GLScreenBuffer::GetFB() const
+{
+    MOZ_ASSERT(GetDrawFB() == GetReadFB());
+    return GetDrawFB();
+}
+
+
+void
+GLScreenBuffer::DeletingFB(GLuint fb)
+{
+    if (fb == mInternalDrawFB) {
+        mInternalDrawFB = 0;
+        mUserDrawFB = 0;
+    }
+    if (fb == mInternalReadFB) {
+        mInternalReadFB = 0;
+        mUserReadFB = 0;
+    }
+}
+
+
+void
+GLScreenBuffer::AfterDrawCall()
+{
+    if (mUserDrawFB != 0)
+        return;
+
+    RequireBlit();
+}
+
+void
+GLScreenBuffer::BeforeReadCall()
+{
+    if (mUserReadFB != 0)
+        return;
+
+    AssureBlitted();
+}
+
+bool
+GLScreenBuffer::CopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x,
+                               GLint y, GLsizei width, GLsizei height, GLint border)
+{
+    SharedSurface* surf;
+    if (GetReadFB() == 0) {
+        surf = SharedSurf();
+    } else {
+        surf = mGL->mFBOMapping[GetReadFB()];
+    }
+    if (surf) {
+        return surf->CopyTexImage2D(target, level, internalformat,  x, y, width, height, border);
+    }
+
+    return false;
+}
+
+bool
+GLScreenBuffer::ReadPixels(GLint x, GLint y,
+                           GLsizei width, GLsizei height,
+                           GLenum format, GLenum type,
+                           GLvoid* pixels)
+{
+    // If the currently bound framebuffer is backed by a SharedSurface
+    // then it might want to override how we read pixel data from it.
+    // This is normally only the default framebuffer, but we can also
+    // have SharedSurfaces bound to other framebuffers when doing
+    // readback for BasicLayers.
+    SharedSurface* surf;
+    if (GetReadFB() == 0) {
+        surf = SharedSurf();
+    } else {
+        surf = mGL->mFBOMapping[GetReadFB()];
+    }
+    if (surf) {
+        return surf->ReadPixels(x, y, width, height, format, type, pixels);
+    }
+
+    return false;
+}
+
+void
+GLScreenBuffer::RequireBlit()
+{
+    mNeedsBlit = true;
+}
+
+void
+GLScreenBuffer::AssureBlitted()
+{
+    if (!mNeedsBlit)
+        return;
+
+    if (mDraw) {
+        GLuint drawFB = DrawFB();
+        GLuint readFB = ReadFB();
+
+        MOZ_ASSERT(drawFB != 0);
+        MOZ_ASSERT(drawFB != readFB);
+        MOZ_ASSERT(mGL->IsSupported(GLFeature::split_framebuffer));
+        MOZ_ASSERT(mDraw->mSize == mRead->Size());
+
+        ScopedBindFramebuffer boundFB(mGL);
+        ScopedGLState scissor(mGL, LOCAL_GL_SCISSOR_TEST, false);
+
+        BindReadFB_Internal(drawFB);
+        BindDrawFB_Internal(readFB);
+
+        if (mGL->IsSupported(GLFeature::framebuffer_blit)) {
+            const gfx::IntSize&  srcSize = mDraw->mSize;
+            const gfx::IntSize& destSize = mRead->Size();
+
+            mGL->raw_fBlitFramebuffer(0, 0,  srcSize.width,  srcSize.height,
+                                      0, 0, destSize.width, destSize.height,
+                                      LOCAL_GL_COLOR_BUFFER_BIT,
+                                      LOCAL_GL_NEAREST);
+        } else if (mGL->IsExtensionSupported(GLContext::APPLE_framebuffer_multisample)) {
+            mGL->fResolveMultisampleFramebufferAPPLE();
+        } else {
+            MOZ_CRASH("GFX: No available blit methods.");
+        }
+        // Done!
+    }
+
+    mNeedsBlit = false;
+}
+
+void
+GLScreenBuffer::Morph(UniquePtr<SurfaceFactory> newFactory)
+{
+    MOZ_RELEASE_ASSERT(newFactory, "newFactory must not be null");
+    mFactory = Move(newFactory);
+}
+
+bool
+GLScreenBuffer::Attach(SharedSurface* surf, const gfx::IntSize& size)
+{
+    ScopedBindFramebuffer autoFB(mGL);
+
+    const bool readNeedsUnlock = (mRead && SharedSurf());
+    if (readNeedsUnlock) {
+        SharedSurf()->UnlockProd();
+    }
+
+    surf->LockProd();
+
+    if (mRead &&
+        surf->mAttachType == SharedSurf()->mAttachType &&
+        size == Size())
+    {
+        // Same size, same type, ready for reuse!
+        mRead->Attach(surf);
+    } else {
+        // Else something changed, so resize:
+        UniquePtr<DrawBuffer> draw;
+        bool drawOk = true;
+
+        /* Don't change out the draw buffer unless we resize. In the
+         * preserveDrawingBuffer:true case, prior contents of the buffer must
+         * be retained. If we're using a draw buffer, it's an MSAA buffer, so
+         * even if we copy the previous frame into the (single-sampled) read
+         * buffer, if we need to re-resolve from draw to read (as triggered by
+         * drawing), we'll need the old MSAA content to still be in the draw
+         * buffer.
+         */
+        if (!mDraw || size != Size())
+            drawOk = CreateDraw(size, &draw);  // Can be null.
+
+        UniquePtr<ReadBuffer> read = CreateRead(surf);
+        bool readOk = !!read;
+
+        if (!drawOk || !readOk) {
+            surf->UnlockProd();
+            if (readNeedsUnlock) {
+                SharedSurf()->LockProd();
+            }
+            return false;
+        }
+
+        if (draw)
+            mDraw = Move(draw);
+
+        mRead = Move(read);
+    }
+
+    // Check that we're all set up.
+    MOZ_ASSERT(SharedSurf() == surf);
+
+    // Update the ReadBuffer mode.
+    if (mGL->IsSupported(gl::GLFeature::read_buffer)) {
+        BindFB(0);
+        mRead->SetReadBuffer(mUserReadBufferMode);
+    }
+
+    // Update the DrawBuffer mode.
+    if (mGL->IsSupported(gl::GLFeature::draw_buffers)) {
+        BindFB(0);
+        SetDrawBuffer(mUserDrawBufferMode);
+    }
+
+    RequireBlit();
+
+    return true;
+}
+
+bool
+GLScreenBuffer::Swap(const gfx::IntSize& size)
+{
+    RefPtr<SharedSurfaceTextureClient> newBack = mFactory->NewTexClient(size);
+    if (!newBack)
+        return false;
+
+    // In the case of DXGL interop, the new surface needs to be acquired before
+    // it is attached so that the interop surface is locked, which populates
+    // the GL renderbuffer. This results in the renderbuffer being ready and
+    // attachment to framebuffer succeeds in Attach() call.
+    newBack->Surf()->ProducerAcquire();
+
+    if (!Attach(newBack->Surf(), size)) {
+        newBack->Surf()->ProducerRelease();
+        return false;
+    }
+    // Attach was successful.
+
+    mFront = mBack;
+    mBack = newBack;
+
+    if (ShouldPreserveBuffer() &&
+        mFront &&
+        mBack &&
+        !mDraw)
+    {
+        auto src  = mFront->Surf();
+        auto dest = mBack->Surf();
+
+        //uint32_t srcPixel = ReadPixel(src);
+        //uint32_t destPixel = ReadPixel(dest);
+        //printf_stderr("Before: src: 0x%08x, dest: 0x%08x\n", srcPixel, destPixel);
+#ifdef DEBUG
+        GLContext::LocalErrorScope errorScope(*mGL);
+#endif
+
+        SharedSurface::ProdCopy(src, dest, mFactory.get());
+
+#ifdef DEBUG
+        MOZ_ASSERT(!errorScope.GetError());
+#endif
+
+        //srcPixel = ReadPixel(src);
+        //destPixel = ReadPixel(dest);
+        //printf_stderr("After: src: 0x%08x, dest: 0x%08x\n", srcPixel, destPixel);
+    }
+
+    // XXX: We would prefer to fence earlier on platforms that don't need
+    // the full ProducerAcquire/ProducerRelease semantics, so that the fence
+    // doesn't include the copy operation. Unfortunately, the current API
+    // doesn't expose a good way to do that.
+    if (mFront) {
+        mFront->Surf()->ProducerRelease();
+    }
+
+    return true;
+}
+
+bool
+GLScreenBuffer::PublishFrame(const gfx::IntSize& size)
+{
+    AssureBlitted();
+
+    bool good = Swap(size);
+    return good;
+}
+
+bool
+GLScreenBuffer::Resize(const gfx::IntSize& size)
+{
+    RefPtr<SharedSurfaceTextureClient> newBack = mFactory->NewTexClient(size);
+    if (!newBack)
+        return false;
+
+    if (!Attach(newBack->Surf(), size))
+        return false;
+
+    if (mBack)
+        mBack->Surf()->ProducerRelease();
+
+    mBack = newBack;
+
+    mBack->Surf()->ProducerAcquire();
+
+    return true;
+}
+
+bool
+GLScreenBuffer::CreateDraw(const gfx::IntSize& size,
+                           UniquePtr<DrawBuffer>* out_buffer)
+{
+    GLContext* gl = mFactory->mGL;
+    const GLFormats& formats = mFactory->mFormats;
+    const SurfaceCaps& caps = mFactory->DrawCaps();
+
+    return DrawBuffer::Create(gl, caps, formats, size, out_buffer);
+}
+
+UniquePtr<ReadBuffer>
+GLScreenBuffer::CreateRead(SharedSurface* surf)
+{
+    GLContext* gl = mFactory->mGL;
+    const GLFormats& formats = mFactory->mFormats;
+    const SurfaceCaps& caps = mFactory->ReadCaps();
+
+    return ReadBuffer::Create(gl, caps, formats, surf);
+}
+
+void
+GLScreenBuffer::SetDrawBuffer(GLenum mode)
+{
+    MOZ_ASSERT(mGL->IsSupported(gl::GLFeature::draw_buffers));
+    MOZ_ASSERT(GetDrawFB() == 0);
+
+    if (!mGL->IsSupported(GLFeature::draw_buffers))
+        return;
+
+    mUserDrawBufferMode = mode;
+
+    GLuint fb = mDraw ? mDraw->mFB : mRead->mFB;
+    GLenum internalMode;
+
+    switch (mode) {
+    case LOCAL_GL_BACK:
+        internalMode = (fb == 0) ? LOCAL_GL_BACK
+                                 : LOCAL_GL_COLOR_ATTACHMENT0;
+        break;
+
+    case LOCAL_GL_NONE:
+        internalMode = LOCAL_GL_NONE;
+        break;
+
+    default:
+        MOZ_CRASH("GFX: Bad value.");
+    }
+
+    mGL->MakeCurrent();
+    mGL->fDrawBuffers(1, &internalMode);
+}
+
+void
+GLScreenBuffer::SetReadBuffer(GLenum mode)
+{
+    MOZ_ASSERT(mGL->IsSupported(gl::GLFeature::read_buffer));
+    MOZ_ASSERT(GetReadFB() == 0);
+
+    mUserReadBufferMode = mode;
+    mRead->SetReadBuffer(mUserReadBufferMode);
+}
+
+bool
+GLScreenBuffer::IsDrawFramebufferDefault() const
+{
+    if (!mDraw)
+        return IsReadFramebufferDefault();
+    return mDraw->mFB == 0;
+}
+
+bool
+GLScreenBuffer::IsReadFramebufferDefault() const
+{
+    return SharedSurf()->mAttachType == AttachmentType::Screen;
+}
+
+uint32_t
+GLScreenBuffer::DepthBits() const
+{
+    const GLFormats& formats = mFactory->mFormats;
+
+    if (formats.depth == LOCAL_GL_DEPTH_COMPONENT16)
+        return 16;
+
+    return 24;
+}
+
+////////////////////////////////////////////////////////////////////////
+// Utils
+
+static void
+RenderbufferStorageBySamples(GLContext* aGL, GLsizei aSamples,
+                             GLenum aInternalFormat, const gfx::IntSize& aSize)
+{
+    if (aSamples) {
+        aGL->fRenderbufferStorageMultisample(LOCAL_GL_RENDERBUFFER,
+                                             aSamples,
+                                             aInternalFormat,
+                                             aSize.width, aSize.height);
+    } else {
+        aGL->fRenderbufferStorage(LOCAL_GL_RENDERBUFFER,
+                                  aInternalFormat,
+                                  aSize.width, aSize.height);
+    }
+}
+
+static GLuint
+CreateRenderbuffer(GLContext* aGL, GLenum aFormat, GLsizei aSamples,
+                   const gfx::IntSize& aSize)
+{
+    GLuint rb = 0;
+    aGL->fGenRenderbuffers(1, &rb);
+    ScopedBindRenderbuffer autoRB(aGL, rb);
+
+    RenderbufferStorageBySamples(aGL, aSamples, aFormat, aSize);
+
+    return rb;
+}
+
+static void
+CreateRenderbuffersForOffscreen(GLContext* aGL, const GLFormats& aFormats,
+                                const gfx::IntSize& aSize, bool aMultisample,
+                                GLuint* aColorMSRB, GLuint* aDepthRB,
+                                GLuint* aStencilRB)
+{
+    GLsizei samples = aMultisample ? aFormats.samples : 0;
+    if (aColorMSRB) {
+        MOZ_ASSERT(aFormats.samples > 0);
+        MOZ_ASSERT(aFormats.color_rbFormat);
+
+        GLenum colorFormat = aFormats.color_rbFormat;
+        if (aGL->IsANGLE()) {
+            MOZ_ASSERT(colorFormat == LOCAL_GL_RGBA8);
+            colorFormat = LOCAL_GL_BGRA8_EXT;
+        }
+
+        *aColorMSRB = CreateRenderbuffer(aGL, colorFormat, samples, aSize);
+    }
+
+    if (aDepthRB &&
+        aStencilRB &&
+        aFormats.depthStencil)
+    {
+        *aDepthRB = CreateRenderbuffer(aGL, aFormats.depthStencil, samples, aSize);
+        *aStencilRB = *aDepthRB;
+    } else {
+        if (aDepthRB) {
+            MOZ_ASSERT(aFormats.depth);
+
+            *aDepthRB = CreateRenderbuffer(aGL, aFormats.depth, samples, aSize);
+        }
+
+        if (aStencilRB) {
+            MOZ_ASSERT(aFormats.stencil);
+
+            *aStencilRB = CreateRenderbuffer(aGL, aFormats.stencil, samples, aSize);
+        }
+    }
+}
+
+////////////////////////////////////////////////////////////////////////
+// DrawBuffer
+
+bool
+DrawBuffer::Create(GLContext* const gl,
+                   const SurfaceCaps& caps,
+                   const GLFormats& formats,
+                   const gfx::IntSize& size,
+                   UniquePtr<DrawBuffer>* out_buffer)
+{
+    MOZ_ASSERT(out_buffer);
+    *out_buffer = nullptr;
+
+    if (!caps.color) {
+        MOZ_ASSERT(!caps.alpha && !caps.depth && !caps.stencil);
+
+        // Nothing is needed.
+        return true;
+    }
+
+    if (caps.antialias) {
+        if (formats.samples == 0)
+            return false; // Can't create it.
+
+        MOZ_ASSERT(formats.samples <= gl->MaxSamples());
+    }
+
+    GLuint colorMSRB = 0;
+    GLuint depthRB   = 0;
+    GLuint stencilRB = 0;
+
+    GLuint* pColorMSRB = caps.antialias ? &colorMSRB : nullptr;
+    GLuint* pDepthRB   = caps.depth     ? &depthRB   : nullptr;
+    GLuint* pStencilRB = caps.stencil   ? &stencilRB : nullptr;
+
+    if (!formats.color_rbFormat)
+        pColorMSRB = nullptr;
+
+    if (pDepthRB && pStencilRB) {
+        if (!formats.depth && !formats.depthStencil)
+            pDepthRB = nullptr;
+
+        if (!formats.stencil && !formats.depthStencil)
+            pStencilRB = nullptr;
+    } else {
+        if (!formats.depth)
+            pDepthRB = nullptr;
+
+        if (!formats.stencil)
+            pStencilRB = nullptr;
+    }
+
+    GLContext::LocalErrorScope localError(*gl);
+
+    CreateRenderbuffersForOffscreen(gl, formats, size, caps.antialias,
+                                    pColorMSRB, pDepthRB, pStencilRB);
+
+    GLuint fb = 0;
+    gl->fGenFramebuffers(1, &fb);
+    gl->AttachBuffersToFB(0, colorMSRB, depthRB, stencilRB, fb);
+
+    const GLsizei samples = formats.samples;
+    UniquePtr<DrawBuffer> ret( new DrawBuffer(gl, size, samples, fb, colorMSRB,
+                                              depthRB, stencilRB) );
+
+    GLenum err = localError.GetError();
+    MOZ_ASSERT_IF(err != LOCAL_GL_NO_ERROR, err == LOCAL_GL_OUT_OF_MEMORY);
+    if (err || !gl->IsFramebufferComplete(fb))
+        return false;
+
+    *out_buffer = Move(ret);
+    return true;
+}
+
+DrawBuffer::~DrawBuffer()
+{
+    if (!mGL->MakeCurrent())
+        return;
+
+    GLuint fb = mFB;
+    GLuint rbs[] = {
+        mColorMSRB,
+        mDepthRB,
+        mStencilRB
+    };
+
+    mGL->fDeleteFramebuffers(1, &fb);
+    mGL->fDeleteRenderbuffers(3, rbs);
+}
+
+////////////////////////////////////////////////////////////////////////
+// ReadBuffer
+
+UniquePtr<ReadBuffer>
+ReadBuffer::Create(GLContext* gl,
+                   const SurfaceCaps& caps,
+                   const GLFormats& formats,
+                   SharedSurface* surf)
+{
+    MOZ_ASSERT(surf);
+
+    if (surf->mAttachType == AttachmentType::Screen) {
+        // Don't need anything. Our read buffer will be the 'screen'.
+        return UniquePtr<ReadBuffer>( new ReadBuffer(gl, 0, 0, 0,
+                                                     surf) );
+    }
+
+    GLuint depthRB = 0;
+    GLuint stencilRB = 0;
+
+    GLuint* pDepthRB   = caps.depth   ? &depthRB   : nullptr;
+    GLuint* pStencilRB = caps.stencil ? &stencilRB : nullptr;
+
+    GLContext::LocalErrorScope localError(*gl);
+
+    CreateRenderbuffersForOffscreen(gl, formats, surf->mSize, caps.antialias,
+                                    nullptr, pDepthRB, pStencilRB);
+
+    GLuint colorTex = 0;
+    GLuint colorRB = 0;
+    GLenum target = 0;
+
+    switch (surf->mAttachType) {
+    case AttachmentType::GLTexture:
+        colorTex = surf->ProdTexture();
+        target = surf->ProdTextureTarget();
+        break;
+    case AttachmentType::GLRenderbuffer:
+        colorRB = surf->ProdRenderbuffer();
+        break;
+    default:
+        MOZ_CRASH("GFX: Unknown attachment type, create?");
+    }
+    MOZ_ASSERT(colorTex || colorRB);
+
+    GLuint fb = 0;
+    gl->fGenFramebuffers(1, &fb);
+    gl->AttachBuffersToFB(colorTex, colorRB, depthRB, stencilRB, fb, target);
+    gl->mFBOMapping[fb] = surf;
+
+    UniquePtr<ReadBuffer> ret( new ReadBuffer(gl, fb, depthRB,
+                                              stencilRB, surf) );
+
+    GLenum err = localError.GetError();
+    MOZ_ASSERT_IF(err != LOCAL_GL_NO_ERROR, err == LOCAL_GL_OUT_OF_MEMORY);
+    if (err)
+        return nullptr;
+
+    const bool needsAcquire = !surf->IsProducerAcquired();
+    if (needsAcquire) {
+        surf->ProducerReadAcquire();
+    }
+    const bool isComplete = gl->IsFramebufferComplete(fb);
+    if (needsAcquire) {
+        surf->ProducerReadRelease();
+    }
+
+    if (!isComplete)
+        return nullptr;
+
+    return Move(ret);
+}
+
+ReadBuffer::~ReadBuffer()
+{
+    if (!mGL->MakeCurrent())
+        return;
+
+    GLuint fb = mFB;
+    GLuint rbs[] = {
+        mDepthRB,
+        mStencilRB
+    };
+
+    mGL->fDeleteFramebuffers(1, &fb);
+    mGL->fDeleteRenderbuffers(2, rbs);
+    mGL->mFBOMapping.erase(mFB);
+}
+
+void
+ReadBuffer::Attach(SharedSurface* surf)
+{
+    MOZ_ASSERT(surf && mSurf);
+    MOZ_ASSERT(surf->mAttachType == mSurf->mAttachType);
+    MOZ_ASSERT(surf->mSize == mSurf->mSize);
+
+    // Nothing else is needed for AttachType Screen.
+    if (surf->mAttachType != AttachmentType::Screen) {
+        GLuint colorTex = 0;
+        GLuint colorRB = 0;
+        GLenum target = 0;
+
+        switch (surf->mAttachType) {
+        case AttachmentType::GLTexture:
+            colorTex = surf->ProdTexture();
+            target = surf->ProdTextureTarget();
+            break;
+        case AttachmentType::GLRenderbuffer:
+            colorRB = surf->ProdRenderbuffer();
+            break;
+        default:
+            MOZ_CRASH("GFX: Unknown attachment type, attach?");
+        }
+
+        mGL->AttachBuffersToFB(colorTex, colorRB, 0, 0, mFB, target);
+        mGL->mFBOMapping[mFB] = surf;
+        MOZ_ASSERT(mGL->IsFramebufferComplete(mFB));
+    }
+
+    mSurf = surf;
+}
+
+const gfx::IntSize&
+ReadBuffer::Size() const
+{
+    return mSurf->mSize;
+}
+
+void
+ReadBuffer::SetReadBuffer(GLenum userMode) const
+{
+    if (!mGL->IsSupported(GLFeature::read_buffer))
+        return;
+
+    GLenum internalMode;
+
+    switch (userMode) {
+    case LOCAL_GL_BACK:
+    case LOCAL_GL_FRONT:
+        internalMode = (mFB == 0) ? userMode
+                                  : LOCAL_GL_COLOR_ATTACHMENT0;
+        break;
+
+    case LOCAL_GL_NONE:
+        internalMode = LOCAL_GL_NONE;
+        break;
+
+    default:
+        MOZ_CRASH("GFX: Bad value.");
+    }
+
+    mGL->MakeCurrent();
+    mGL->fReadBuffer(internalMode);
+}
+
+} /* namespace gl */
+} /* namespace mozilla */