Add m-esr52 at 52.6.0

1 files changed, 2480 insertions, 0 deletions

diff --git a/dom/canvas/WebGLContext.cpp b/dom/canvas/WebGLContext.cpp
new file mode 100644
index 000000000..176d56f8c
--- /dev/null
+++ b/dom/canvas/WebGLContext.cpp
@@ -0,0 +1,2480 @@
+/* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* 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 "WebGLContext.h"
+
+#include <queue>
+
+#include "AccessCheck.h"
+#include "gfxContext.h"
+#include "gfxCrashReporterUtils.h"
+#include "gfxPattern.h"
+#include "gfxPrefs.h"
+#include "gfxUtils.h"
+#include "GLBlitHelper.h"
+#include "GLContext.h"
+#include "GLContextProvider.h"
+#include "GLReadTexImageHelper.h"
+#include "GLScreenBuffer.h"
+#include "ImageContainer.h"
+#include "ImageEncoder.h"
+#include "Layers.h"
+#include "LayerUserData.h"
+#include "mozilla/dom/BindingUtils.h"
+#include "mozilla/dom/Event.h"
+#include "mozilla/dom/HTMLVideoElement.h"
+#include "mozilla/dom/ImageData.h"
+#include "mozilla/dom/WebGLContextEvent.h"
+#include "mozilla/EnumeratedArrayCycleCollection.h"
+#include "mozilla/Preferences.h"
+#include "mozilla/ProcessPriorityManager.h"
+#include "mozilla/ScopeExit.h"
+#include "mozilla/Services.h"
+#include "mozilla/Telemetry.h"
+#include "nsContentUtils.h"
+#include "nsDisplayList.h"
+#include "nsError.h"
+#include "nsIClassInfoImpl.h"
+#include "nsIConsoleService.h"
+#include "nsIDOMEvent.h"
+#include "nsIGfxInfo.h"
+#include "nsIObserverService.h"
+#include "nsIVariant.h"
+#include "nsIWidget.h"
+#include "nsIXPConnect.h"
+#include "nsServiceManagerUtils.h"
+#include "nsSVGEffects.h"
+#include "prenv.h"
+#include "ScopedGLHelpers.h"
+#include "VRManagerChild.h"
+#include "mozilla/layers/TextureClientSharedSurface.h"
+
+#ifdef MOZ_WIDGET_GONK
+#include "mozilla/layers/ShadowLayers.h"
+#endif
+
+// Local
+#include "CanvasUtils.h"
+#include "WebGL1Context.h"
+#include "WebGLActiveInfo.h"
+#include "WebGLBuffer.h"
+#include "WebGLContextLossHandler.h"
+#include "WebGLContextUtils.h"
+#include "WebGLExtensions.h"
+#include "WebGLFramebuffer.h"
+#include "WebGLMemoryTracker.h"
+#include "WebGLObjectModel.h"
+#include "WebGLProgram.h"
+#include "WebGLQuery.h"
+#include "WebGLSampler.h"
+#include "WebGLShader.h"
+#include "WebGLSync.h"
+#include "WebGLTransformFeedback.h"
+#include "WebGLVertexArray.h"
+#include "WebGLVertexAttribData.h"
+
+#ifdef MOZ_WIDGET_COCOA
+#include "nsCocoaFeatures.h"
+#endif
+
+#ifdef XP_WIN
+#include "WGLLibrary.h"
+#endif
+
+// Generated
+#include "mozilla/dom/WebGLRenderingContextBinding.h"
+
+
+namespace mozilla {
+
+using namespace mozilla::dom;
+using namespace mozilla::gfx;
+using namespace mozilla::gl;
+using namespace mozilla::layers;
+
+WebGLContextOptions::WebGLContextOptions()
+    : alpha(true)
+    , depth(true)
+    , stencil(false)
+    , premultipliedAlpha(true)
+    , antialias(true)
+    , preserveDrawingBuffer(false)
+    , failIfMajorPerformanceCaveat(false)
+{
+    // Set default alpha state based on preference.
+    if (gfxPrefs::WebGLDefaultNoAlpha())
+        alpha = false;
+}
+
+
+/*static*/ const uint32_t WebGLContext::kMinMaxColorAttachments = 4;
+/*static*/ const uint32_t WebGLContext::kMinMaxDrawBuffers = 4;
+
+WebGLContext::WebGLContext()
+    : WebGLContextUnchecked(nullptr)
+    , mBufferFetchingIsVerified(false)
+    , mBufferFetchingHasPerVertex(false)
+    , mMaxFetchedVertices(0)
+    , mMaxFetchedInstances(0)
+    , mLayerIsMirror(false)
+    , mBypassShaderValidation(false)
+    , mEmptyTFO(0)
+    , mContextLossHandler(this)
+    , mNeedsFakeNoAlpha(false)
+    , mNeedsFakeNoDepth(false)
+    , mNeedsFakeNoStencil(false)
+    , mNeedsEmulatedLoneDepthStencil(false)
+    , mAllowFBInvalidation(gfxPrefs::WebGLFBInvalidation())
+{
+    mGeneration = 0;
+    mInvalidated = false;
+    mCapturedFrameInvalidated = false;
+    mShouldPresent = true;
+    mResetLayer = true;
+    mOptionsFrozen = false;
+    mMinCapability = false;
+    mDisableExtensions = false;
+    mIsMesa = false;
+    mEmitContextLostErrorOnce = false;
+    mWebGLError = 0;
+    mUnderlyingGLError = 0;
+
+    mActiveTexture = 0;
+
+    mStencilRefFront = 0;
+    mStencilRefBack = 0;
+    mStencilValueMaskFront = 0;
+    mStencilValueMaskBack = 0;
+    mStencilWriteMaskFront = 0;
+    mStencilWriteMaskBack = 0;
+    mDepthWriteMask = 0;
+    mStencilClearValue = 0;
+    mDepthClearValue = 0;
+    mContextLostErrorSet = false;
+
+    mViewportX = 0;
+    mViewportY = 0;
+    mViewportWidth = 0;
+    mViewportHeight = 0;
+
+    mDitherEnabled = 1;
+    mRasterizerDiscardEnabled = 0; // OpenGL ES 3.0 spec p244
+    mScissorTestEnabled = 0;
+    mDepthTestEnabled = 0;
+    mStencilTestEnabled = 0;
+
+    if (NS_IsMainThread()) {
+        // XXX mtseng: bug 709490, not thread safe
+        WebGLMemoryTracker::AddWebGLContext(this);
+    }
+
+    mAllowContextRestore = true;
+    mLastLossWasSimulated = false;
+    mContextStatus = ContextNotLost;
+    mLoseContextOnMemoryPressure = false;
+    mCanLoseContextInForeground = true;
+    mRestoreWhenVisible = false;
+
+    mAlreadyGeneratedWarnings = 0;
+    mAlreadyWarnedAboutFakeVertexAttrib0 = false;
+    mAlreadyWarnedAboutViewportLargerThanDest = false;
+
+    mMaxWarnings = gfxPrefs::WebGLMaxWarningsPerContext();
+    if (mMaxWarnings < -1) {
+        GenerateWarning("webgl.max-warnings-per-context size is too large (seems like a negative value wrapped)");
+        mMaxWarnings = 0;
+    }
+
+    mLastUseIndex = 0;
+
+    InvalidateBufferFetching();
+
+    mDisableFragHighP = false;
+
+    mDrawCallsSinceLastFlush = 0;
+}
+
+WebGLContext::~WebGLContext()
+{
+    RemovePostRefreshObserver();
+
+    DestroyResourcesAndContext();
+    if (NS_IsMainThread()) {
+        // XXX mtseng: bug 709490, not thread safe
+        WebGLMemoryTracker::RemoveWebGLContext(this);
+    }
+}
+
+template<typename T>
+void
+ClearLinkedList(LinkedList<T>& list)
+{
+    while (!list.isEmpty()) {
+        list.getLast()->DeleteOnce();
+    }
+}
+
+void
+WebGLContext::DestroyResourcesAndContext()
+{
+    if (!gl)
+        return;
+
+    gl->MakeCurrent();
+
+    mBound2DTextures.Clear();
+    mBoundCubeMapTextures.Clear();
+    mBound3DTextures.Clear();
+    mBound2DArrayTextures.Clear();
+    mBoundSamplers.Clear();
+    mBoundArrayBuffer = nullptr;
+    mBoundCopyReadBuffer = nullptr;
+    mBoundCopyWriteBuffer = nullptr;
+    mBoundPixelPackBuffer = nullptr;
+    mBoundPixelUnpackBuffer = nullptr;
+    mBoundUniformBuffer = nullptr;
+    mCurrentProgram = nullptr;
+    mActiveProgramLinkInfo = nullptr;
+    mBoundDrawFramebuffer = nullptr;
+    mBoundReadFramebuffer = nullptr;
+    mBoundRenderbuffer = nullptr;
+    mBoundVertexArray = nullptr;
+    mDefaultVertexArray = nullptr;
+    mBoundTransformFeedback = nullptr;
+    mDefaultTransformFeedback = nullptr;
+
+    mQuerySlot_SamplesPassed = nullptr;
+    mQuerySlot_TFPrimsWritten = nullptr;
+    mQuerySlot_TimeElapsed = nullptr;
+
+    mIndexedUniformBufferBindings.clear();
+
+    //////
+
+    ClearLinkedList(mBuffers);
+    ClearLinkedList(mFramebuffers);
+    ClearLinkedList(mPrograms);
+    ClearLinkedList(mQueries);
+    ClearLinkedList(mRenderbuffers);
+    ClearLinkedList(mSamplers);
+    ClearLinkedList(mShaders);
+    ClearLinkedList(mSyncs);
+    ClearLinkedList(mTextures);
+    ClearLinkedList(mTransformFeedbacks);
+    ClearLinkedList(mVertexArrays);
+
+    //////
+
+    if (mEmptyTFO) {
+        gl->fDeleteTransformFeedbacks(1, &mEmptyTFO);
+        mEmptyTFO = 0;
+    }
+
+    //////
+
+    mFakeBlack_2D_0000       = nullptr;
+    mFakeBlack_2D_0001       = nullptr;
+    mFakeBlack_CubeMap_0000  = nullptr;
+    mFakeBlack_CubeMap_0001  = nullptr;
+    mFakeBlack_3D_0000       = nullptr;
+    mFakeBlack_3D_0001       = nullptr;
+    mFakeBlack_2D_Array_0000 = nullptr;
+    mFakeBlack_2D_Array_0001 = nullptr;
+
+    if (mFakeVertexAttrib0BufferObject) {
+        gl->fDeleteBuffers(1, &mFakeVertexAttrib0BufferObject);
+        mFakeVertexAttrib0BufferObject = 0;
+    }
+
+    // disable all extensions except "WEBGL_lose_context". see bug #927969
+    // spec: http://www.khronos.org/registry/webgl/specs/latest/1.0/#5.15.2
+    for (size_t i = 0; i < size_t(WebGLExtensionID::Max); ++i) {
+        WebGLExtensionID extension = WebGLExtensionID(i);
+
+        if (!IsExtensionEnabled(extension) || (extension == WebGLExtensionID::WEBGL_lose_context))
+            continue;
+
+        mExtensions[extension]->MarkLost();
+        mExtensions[extension] = nullptr;
+    }
+
+    // We just got rid of everything, so the context had better
+    // have been going away.
+    if (GLContext::ShouldSpew()) {
+        printf_stderr("--- WebGL context destroyed: %p\n", gl.get());
+    }
+
+    MOZ_ASSERT(gl);
+    mGL_OnlyClearInDestroyResourcesAndContext = nullptr;
+    MOZ_ASSERT(!gl);
+}
+
+void
+WebGLContext::Invalidate()
+{
+    if (!mCanvasElement)
+        return;
+
+    mCapturedFrameInvalidated = true;
+
+    if (mInvalidated)
+        return;
+
+    nsSVGEffects::InvalidateDirectRenderingObservers(mCanvasElement);
+
+    mInvalidated = true;
+    mCanvasElement->InvalidateCanvasContent(nullptr);
+}
+
+void
+WebGLContext::OnVisibilityChange()
+{
+    if (!IsContextLost()) {
+        return;
+    }
+
+    if (!mRestoreWhenVisible || mLastLossWasSimulated) {
+        return;
+    }
+
+    ForceRestoreContext();
+}
+
+void
+WebGLContext::OnMemoryPressure()
+{
+    bool shouldLoseContext = mLoseContextOnMemoryPressure;
+
+    if (!mCanLoseContextInForeground &&
+        ProcessPriorityManager::CurrentProcessIsForeground())
+    {
+        shouldLoseContext = false;
+    }
+
+    if (shouldLoseContext)
+        ForceLoseContext();
+}
+
+//
+// nsICanvasRenderingContextInternal
+//
+
+NS_IMETHODIMP
+WebGLContext::SetContextOptions(JSContext* cx, JS::Handle<JS::Value> options,
+                                ErrorResult& aRvForDictionaryInit)
+{
+    if (options.isNullOrUndefined() && mOptionsFrozen)
+        return NS_OK;
+
+    WebGLContextAttributes attributes;
+    if (!attributes.Init(cx, options)) {
+      aRvForDictionaryInit.Throw(NS_ERROR_UNEXPECTED);
+      return NS_ERROR_UNEXPECTED;
+    }
+
+    WebGLContextOptions newOpts;
+
+    newOpts.stencil = attributes.mStencil;
+    newOpts.depth = attributes.mDepth;
+    newOpts.premultipliedAlpha = attributes.mPremultipliedAlpha;
+    newOpts.antialias = attributes.mAntialias;
+    newOpts.preserveDrawingBuffer = attributes.mPreserveDrawingBuffer;
+    newOpts.failIfMajorPerformanceCaveat = attributes.mFailIfMajorPerformanceCaveat;
+
+    if (attributes.mAlpha.WasPassed())
+        newOpts.alpha = attributes.mAlpha.Value();
+
+    // Don't do antialiasing if we've disabled MSAA.
+    if (!gfxPrefs::MSAALevel())
+      newOpts.antialias = false;
+
+#if 0
+    GenerateWarning("aaHint: %d stencil: %d depth: %d alpha: %d premult: %d preserve: %d\n",
+               newOpts.antialias ? 1 : 0,
+               newOpts.stencil ? 1 : 0,
+               newOpts.depth ? 1 : 0,
+               newOpts.alpha ? 1 : 0,
+               newOpts.premultipliedAlpha ? 1 : 0,
+               newOpts.preserveDrawingBuffer ? 1 : 0);
+#endif
+
+    if (mOptionsFrozen && newOpts != mOptions) {
+        // Error if the options are already frozen, and the ones that were asked for
+        // aren't the same as what they were originally.
+        return NS_ERROR_FAILURE;
+    }
+
+    mOptions = newOpts;
+    return NS_OK;
+}
+
+int32_t
+WebGLContext::GetWidth() const
+{
+    return mWidth;
+}
+
+int32_t
+WebGLContext::GetHeight() const
+{
+    return mHeight;
+}
+
+/* So there are a number of points of failure here. We might fail based
+ * on EGL vs. WGL, or we might fail to alloc a too-large size, or we
+ * might not be able to create a context with a certain combo of context
+ * creation attribs.
+ *
+ * We don't want to test the complete fallback matrix. (for now, at
+ * least) Instead, attempt creation in this order:
+ * 1. By platform API. (e.g. EGL vs. WGL)
+ * 2. By context creation attribs.
+ * 3. By size.
+ *
+ * That is, try to create headless contexts based on the platform API.
+ * Next, create dummy-sized backbuffers for the contexts with the right
+ * caps. Finally, resize the backbuffer to an acceptable size given the
+ * requested size.
+ */
+
+static bool
+IsFeatureInBlacklist(const nsCOMPtr<nsIGfxInfo>& gfxInfo, int32_t feature,
+                     nsCString* const out_blacklistId)
+{
+    int32_t status;
+    if (!NS_SUCCEEDED(gfxUtils::ThreadSafeGetFeatureStatus(gfxInfo, feature,
+                                                           *out_blacklistId, &status)))
+    {
+        return false;
+    }
+
+    return status != nsIGfxInfo::FEATURE_STATUS_OK;
+}
+
+static bool
+HasAcceleratedLayers(const nsCOMPtr<nsIGfxInfo>& gfxInfo)
+{
+    int32_t status;
+
+    nsCString discardFailureId;
+    gfxUtils::ThreadSafeGetFeatureStatus(gfxInfo,
+                                         nsIGfxInfo::FEATURE_DIRECT3D_9_LAYERS,
+                                         discardFailureId,
+                                         &status);
+    if (status)
+        return true;
+    gfxUtils::ThreadSafeGetFeatureStatus(gfxInfo,
+                                         nsIGfxInfo::FEATURE_DIRECT3D_10_LAYERS,
+                                         discardFailureId,
+                                         &status);
+    if (status)
+        return true;
+    gfxUtils::ThreadSafeGetFeatureStatus(gfxInfo,
+                                         nsIGfxInfo::FEATURE_DIRECT3D_10_1_LAYERS,
+                                         discardFailureId,
+                                         &status);
+    if (status)
+        return true;
+    gfxUtils::ThreadSafeGetFeatureStatus(gfxInfo,
+                                         nsIGfxInfo::FEATURE_DIRECT3D_11_LAYERS,
+                                         discardFailureId,
+                                         &status);
+    if (status)
+        return true;
+    gfxUtils::ThreadSafeGetFeatureStatus(gfxInfo,
+                                         nsIGfxInfo::FEATURE_OPENGL_LAYERS,
+                                         discardFailureId,
+                                         &status);
+    if (status)
+        return true;
+
+    return false;
+}
+
+static void
+PopulateCapFallbackQueue(const gl::SurfaceCaps& baseCaps,
+                         std::queue<gl::SurfaceCaps>* out_fallbackCaps)
+{
+    out_fallbackCaps->push(baseCaps);
+
+    // Dropping antialias drops our quality, but not our correctness.
+    // The user basically doesn't have to handle if this fails, they
+    // just get reduced quality.
+    if (baseCaps.antialias) {
+        gl::SurfaceCaps nextCaps(baseCaps);
+        nextCaps.antialias = false;
+        PopulateCapFallbackQueue(nextCaps, out_fallbackCaps);
+    }
+
+    // If we have to drop one of depth or stencil, we'd prefer to keep
+    // depth. However, the client app will need to handle if this
+    // doesn't work.
+    if (baseCaps.stencil) {
+        gl::SurfaceCaps nextCaps(baseCaps);
+        nextCaps.stencil = false;
+        PopulateCapFallbackQueue(nextCaps, out_fallbackCaps);
+    }
+
+    if (baseCaps.depth) {
+        gl::SurfaceCaps nextCaps(baseCaps);
+        nextCaps.depth = false;
+        PopulateCapFallbackQueue(nextCaps, out_fallbackCaps);
+    }
+}
+
+static gl::SurfaceCaps
+BaseCaps(const WebGLContextOptions& options, WebGLContext* webgl)
+{
+    gl::SurfaceCaps baseCaps;
+
+    baseCaps.color = true;
+    baseCaps.alpha = options.alpha;
+    baseCaps.antialias = options.antialias;
+    baseCaps.depth = options.depth;
+    baseCaps.premultAlpha = options.premultipliedAlpha;
+    baseCaps.preserve = options.preserveDrawingBuffer;
+    baseCaps.stencil = options.stencil;
+
+    if (!baseCaps.alpha)
+        baseCaps.premultAlpha = true;
+
+    // we should really have this behind a
+    // |gfxPlatform::GetPlatform()->GetScreenDepth() == 16| check, but
+    // for now it's just behind a pref for testing/evaluation.
+    baseCaps.bpp16 = gfxPrefs::WebGLPrefer16bpp();
+
+#ifdef MOZ_WIDGET_GONK
+    do {
+        auto canvasElement = webgl->GetCanvas();
+        if (!canvasElement)
+            break;
+
+        auto ownerDoc = canvasElement->OwnerDoc();
+        nsIWidget* docWidget = nsContentUtils::WidgetForDocument(ownerDoc);
+        if (!docWidget)
+            break;
+
+        layers::LayerManager* layerManager = docWidget->GetLayerManager();
+        if (!layerManager)
+            break;
+
+        // XXX we really want "AsSurfaceAllocator" here for generality
+        layers::ShadowLayerForwarder* forwarder = layerManager->AsShadowForwarder();
+        if (!forwarder)
+            break;
+
+        baseCaps.surfaceAllocator = forwarder->GetTextureForwarder();
+    } while (false);
+#endif
+
+    // Done with baseCaps construction.
+
+    if (!gfxPrefs::WebGLForceMSAA()) {
+        const nsCOMPtr<nsIGfxInfo> gfxInfo = services::GetGfxInfo();
+
+        nsCString blocklistId;
+        if (IsFeatureInBlacklist(gfxInfo, nsIGfxInfo::FEATURE_WEBGL_MSAA, &blocklistId)) {
+            webgl->GenerateWarning("Disallowing antialiased backbuffers due"
+                                   " to blacklisting.");
+            baseCaps.antialias = false;
+        }
+    }
+
+    return baseCaps;
+}
+
+////////////////////////////////////////
+
+static already_AddRefed<gl::GLContext>
+CreateGLWithEGL(const gl::SurfaceCaps& caps, gl::CreateContextFlags flags,
+                WebGLContext* webgl,
+                std::vector<WebGLContext::FailureReason>* const out_failReasons)
+{
+    const gfx::IntSize dummySize(16, 16);
+    nsCString failureId;
+    RefPtr<GLContext> gl = gl::GLContextProviderEGL::CreateOffscreen(dummySize, caps,
+                                                                     flags, &failureId);
+    if (gl && gl->IsANGLE()) {
+        gl = nullptr;
+    }
+
+    if (!gl) {
+        out_failReasons->push_back(WebGLContext::FailureReason(
+            failureId,
+            "Error during EGL OpenGL init."
+        ));
+        return nullptr;
+    }
+
+    return gl.forget();
+}
+
+static already_AddRefed<GLContext>
+CreateGLWithANGLE(const gl::SurfaceCaps& caps, gl::CreateContextFlags flags,
+                  WebGLContext* webgl,
+                  std::vector<WebGLContext::FailureReason>* const out_failReasons)
+{
+    const gfx::IntSize dummySize(16, 16);
+    nsCString failureId;
+    RefPtr<GLContext> gl = gl::GLContextProviderEGL::CreateOffscreen(dummySize, caps,
+                                                                     flags, &failureId);
+    if (gl && !gl->IsANGLE()) {
+        gl = nullptr;
+    }
+
+    if (!gl) {
+        out_failReasons->push_back(WebGLContext::FailureReason(
+            failureId,
+            "Error during ANGLE OpenGL init."
+        ));
+        return nullptr;
+    }
+
+    return gl.forget();
+}
+
+static already_AddRefed<gl::GLContext>
+CreateGLWithDefault(const gl::SurfaceCaps& caps, gl::CreateContextFlags flags,
+                    WebGLContext* webgl,
+                    std::vector<WebGLContext::FailureReason>* const out_failReasons)
+{
+    const gfx::IntSize dummySize(16, 16);
+    nsCString failureId;
+    RefPtr<GLContext> gl = gl::GLContextProvider::CreateOffscreen(dummySize, caps,
+                                                                  flags, &failureId);
+    if (gl && gl->IsANGLE()) {
+        gl = nullptr;
+    }
+
+    if (!gl) {
+        out_failReasons->push_back(WebGLContext::FailureReason(
+            failureId,
+            "Error during native OpenGL init."
+        ));
+        return nullptr;
+    }
+
+    return gl.forget();
+}
+
+////////////////////////////////////////
+
+bool
+WebGLContext::CreateAndInitGLWith(FnCreateGL_T fnCreateGL,
+                                  const gl::SurfaceCaps& baseCaps,
+                                  gl::CreateContextFlags flags,
+                                  std::vector<FailureReason>* const out_failReasons)
+{
+    std::queue<gl::SurfaceCaps> fallbackCaps;
+    PopulateCapFallbackQueue(baseCaps, &fallbackCaps);
+
+    MOZ_RELEASE_ASSERT(!gl, "GFX: Already have a context.");
+    RefPtr<gl::GLContext> potentialGL;
+    while (!fallbackCaps.empty()) {
+        const gl::SurfaceCaps& caps = fallbackCaps.front();
+        potentialGL = fnCreateGL(caps, flags, this, out_failReasons);
+        if (potentialGL)
+            break;
+
+        fallbackCaps.pop();
+    }
+    if (!potentialGL) {
+        out_failReasons->push_back(FailureReason("FEATURE_FAILURE_WEBGL_EXHAUSTED_CAPS",
+                                                 "Exhausted GL driver caps."));
+        return false;
+    }
+
+    FailureReason reason;
+
+    mGL_OnlyClearInDestroyResourcesAndContext = potentialGL;
+    MOZ_RELEASE_ASSERT(gl);
+    if (!InitAndValidateGL(&reason)) {
+        DestroyResourcesAndContext();
+        MOZ_RELEASE_ASSERT(!gl);
+
+        // The fail reason here should be specific enough for now.
+        out_failReasons->push_back(reason);
+        return false;
+    }
+
+    return true;
+}
+
+bool
+WebGLContext::CreateAndInitGL(bool forceEnabled,
+                              std::vector<FailureReason>* const out_failReasons)
+{
+    const gl::SurfaceCaps baseCaps = BaseCaps(mOptions, this);
+    gl::CreateContextFlags flags = gl::CreateContextFlags::NO_VALIDATION;
+    bool tryNativeGL = true;
+    bool tryANGLE = false;
+
+    if (forceEnabled) {
+        flags |= gl::CreateContextFlags::FORCE_ENABLE_HARDWARE;
+    }
+
+    if (IsWebGL2()) {
+        flags |= gl::CreateContextFlags::PREFER_ES3;
+    } else {
+        flags |= gl::CreateContextFlags::REQUIRE_COMPAT_PROFILE;
+    }
+
+    //////
+
+    const bool useEGL = PR_GetEnv("MOZ_WEBGL_FORCE_EGL");
+
+#ifdef XP_WIN
+    tryNativeGL = false;
+    tryANGLE = true;
+
+    if (gfxPrefs::WebGLDisableWGL()) {
+        tryNativeGL = false;
+    }
+
+    if (gfxPrefs::WebGLDisableANGLE() || PR_GetEnv("MOZ_WEBGL_FORCE_OPENGL") || useEGL) {
+        tryNativeGL = true;
+        tryANGLE = false;
+    }
+#endif
+
+    if (tryNativeGL && !forceEnabled) {
+        const nsCOMPtr<nsIGfxInfo> gfxInfo = services::GetGfxInfo();
+        const auto feature = nsIGfxInfo::FEATURE_WEBGL_OPENGL;
+
+        FailureReason reason;
+        if (IsFeatureInBlacklist(gfxInfo, feature, &reason.key)) {
+            reason.info = "Refused to create native OpenGL context because of blacklist"
+                          " entry: ";
+            reason.info.Append(reason.key);
+
+            out_failReasons->push_back(reason);
+
+            GenerateWarning(reason.info.BeginReading());
+            tryNativeGL = false;
+        }
+    }
+
+    //////
+
+    if (tryNativeGL) {
+        if (useEGL)
+            return CreateAndInitGLWith(CreateGLWithEGL, baseCaps, flags, out_failReasons);
+
+        if (CreateAndInitGLWith(CreateGLWithDefault, baseCaps, flags, out_failReasons))
+            return true;
+    }
+
+    //////
+
+    if (tryANGLE)
+        return CreateAndInitGLWith(CreateGLWithANGLE, baseCaps, flags, out_failReasons);
+
+    //////
+
+    out_failReasons->push_back(FailureReason("FEATURE_FAILURE_WEBGL_EXHAUSTED_DRIVERS",
+                                             "Exhausted GL driver options."));
+    return false;
+}
+
+// Fallback for resizes:
+bool
+WebGLContext::ResizeBackbuffer(uint32_t requestedWidth,
+                               uint32_t requestedHeight)
+{
+    uint32_t width = requestedWidth;
+    uint32_t height = requestedHeight;
+
+    bool resized = false;
+    while (width || height) {
+      width = width ? width : 1;
+      height = height ? height : 1;
+
+      gfx::IntSize curSize(width, height);
+      if (gl->ResizeOffscreen(curSize)) {
+          resized = true;
+          break;
+      }
+
+      width /= 2;
+      height /= 2;
+    }
+
+    if (!resized)
+        return false;
+
+    mWidth = gl->OffscreenSize().width;
+    mHeight = gl->OffscreenSize().height;
+    MOZ_ASSERT((uint32_t)mWidth == width);
+    MOZ_ASSERT((uint32_t)mHeight == height);
+
+    if (width != requestedWidth ||
+        height != requestedHeight)
+    {
+        GenerateWarning("Requested size %dx%d was too large, but resize"
+                          " to %dx%d succeeded.",
+                        requestedWidth, requestedHeight,
+                        width, height);
+    }
+    return true;
+}
+
+void
+WebGLContext::ThrowEvent_WebGLContextCreationError(const nsACString& text)
+{
+    RefPtr<EventTarget> target = mCanvasElement;
+    if (!target && mOffscreenCanvas) {
+        target = mOffscreenCanvas;
+    } else if (!target) {
+        GenerateWarning("Failed to create WebGL context: %s", text.BeginReading());
+        return;
+    }
+
+    const auto kEventName = NS_LITERAL_STRING("webglcontextcreationerror");
+
+    WebGLContextEventInit eventInit;
+    // eventInit.mCancelable = true; // The spec says this, but it's silly.
+    eventInit.mStatusMessage = NS_ConvertASCIItoUTF16(text);
+
+    const RefPtr<WebGLContextEvent> event = WebGLContextEvent::Constructor(target,
+                                                                           kEventName,
+                                                                           eventInit);
+    event->SetTrusted(true);
+
+    bool didPreventDefault;
+    target->DispatchEvent(event, &didPreventDefault);
+
+    //////
+
+    GenerateWarning("Failed to create WebGL context: %s", text.BeginReading());
+}
+
+NS_IMETHODIMP
+WebGLContext::SetDimensions(int32_t signedWidth, int32_t signedHeight)
+{
+    if (signedWidth < 0 || signedHeight < 0) {
+        if (!gl) {
+            Telemetry::Accumulate(Telemetry::CANVAS_WEBGL_FAILURE_ID,
+                                  NS_LITERAL_CSTRING("FEATURE_FAILURE_WEBGL_SIZE"));
+        }
+        GenerateWarning("Canvas size is too large (seems like a negative value wrapped)");
+        return NS_ERROR_OUT_OF_MEMORY;
+    }
+
+    uint32_t width = signedWidth;
+    uint32_t height = signedHeight;
+
+    // Early success return cases
+
+    // May have a OffscreenCanvas instead of an HTMLCanvasElement
+    if (GetCanvas())
+        GetCanvas()->InvalidateCanvas();
+
+    // Zero-sized surfaces can cause problems.
+    if (width == 0)
+        width = 1;
+
+    if (height == 0)
+        height = 1;
+
+    // If we already have a gl context, then we just need to resize it
+    if (gl) {
+        if ((uint32_t)mWidth == width &&
+            (uint32_t)mHeight == height)
+        {
+            return NS_OK;
+        }
+
+        if (IsContextLost())
+            return NS_OK;
+
+        MakeContextCurrent();
+
+        // If we've already drawn, we should commit the current buffer.
+        PresentScreenBuffer();
+
+        if (IsContextLost()) {
+            GenerateWarning("WebGL context was lost due to swap failure.");
+            return NS_OK;
+        }
+
+        // ResizeOffscreen scraps the current prod buffer before making a new one.
+        if (!ResizeBackbuffer(width, height)) {
+            GenerateWarning("WebGL context failed to resize.");
+            ForceLoseContext();
+            return NS_OK;
+        }
+
+        // everything's good, we're done here
+        mResetLayer = true;
+        mBackbufferNeedsClear = true;
+
+        return NS_OK;
+    }
+
+    nsCString failureId = NS_LITERAL_CSTRING("FEATURE_FAILURE_WEBGL_UNKOWN");
+    auto autoTelemetry = mozilla::MakeScopeExit([&] {
+        Telemetry::Accumulate(Telemetry::CANVAS_WEBGL_FAILURE_ID,
+                              failureId);
+    });
+
+    // End of early return cases.
+    // At this point we know that we're not just resizing an existing context,
+    // we are initializing a new context.
+
+    // if we exceeded either the global or the per-principal limit for WebGL contexts,
+    // lose the oldest-used context now to free resources. Note that we can't do that
+    // in the WebGLContext constructor as we don't have a canvas element yet there.
+    // Here is the right place to do so, as we are about to create the OpenGL context
+    // and that is what can fail if we already have too many.
+    LoseOldestWebGLContextIfLimitExceeded();
+
+    // We're going to create an entirely new context.  If our
+    // generation is not 0 right now (that is, if this isn't the first
+    // context we're creating), we may have to dispatch a context lost
+    // event.
+
+    // If incrementing the generation would cause overflow,
+    // don't allow it.  Allowing this would allow us to use
+    // resource handles created from older context generations.
+    if (!(mGeneration + 1).isValid()) {
+        // exit without changing the value of mGeneration
+        failureId = NS_LITERAL_CSTRING("FEATURE_FAILURE_WEBGL_TOO_MANY");
+        const nsLiteralCString text("Too many WebGL contexts created this run.");
+        ThrowEvent_WebGLContextCreationError(text);
+        return NS_ERROR_FAILURE;
+    }
+
+    // increment the generation number - Do this early because later
+    // in CreateOffscreenGL(), "default" objects are created that will
+    // pick up the old generation.
+    ++mGeneration;
+
+    bool disabled = gfxPrefs::WebGLDisabled();
+
+    // TODO: When we have software webgl support we should use that instead.
+    disabled |= gfxPlatform::InSafeMode();
+
+    if (disabled) {
+        if (gfxPlatform::InSafeMode()) {
+            failureId = NS_LITERAL_CSTRING("FEATURE_FAILURE_WEBGL_SAFEMODE");
+        } else {
+            failureId = NS_LITERAL_CSTRING("FEATURE_FAILURE_WEBGL_DISABLED");
+        }
+        const nsLiteralCString text("WebGL is currently disabled.");
+        ThrowEvent_WebGLContextCreationError(text);
+        return NS_ERROR_FAILURE;
+    }
+
+    if (gfxPrefs::WebGLDisableFailIfMajorPerformanceCaveat()) {
+        mOptions.failIfMajorPerformanceCaveat = false;
+    }
+
+    if (mOptions.failIfMajorPerformanceCaveat) {
+        nsCOMPtr<nsIGfxInfo> gfxInfo = services::GetGfxInfo();
+        if (!HasAcceleratedLayers(gfxInfo)) {
+            failureId = NS_LITERAL_CSTRING("FEATURE_FAILURE_WEBGL_PERF_CAVEAT");
+            const nsLiteralCString text("failIfMajorPerformanceCaveat: Compositor is not"
+                                        " hardware-accelerated.");
+            ThrowEvent_WebGLContextCreationError(text);
+            return NS_ERROR_FAILURE;
+        }
+    }
+
+    // Alright, now let's start trying.
+    bool forceEnabled = gfxPrefs::WebGLForceEnabled();
+    ScopedGfxFeatureReporter reporter("WebGL", forceEnabled);
+
+    MOZ_ASSERT(!gl);
+    std::vector<FailureReason> failReasons;
+    if (!CreateAndInitGL(forceEnabled, &failReasons)) {
+        nsCString text("WebGL creation failed: ");
+        for (const auto& cur : failReasons) {
+            Telemetry::Accumulate(Telemetry::CANVAS_WEBGL_FAILURE_ID, cur.key);
+
+            text.AppendASCII("\n* ");
+            text.Append(cur.info);
+        }
+        failureId = NS_LITERAL_CSTRING("FEATURE_FAILURE_REASON");
+        ThrowEvent_WebGLContextCreationError(text);
+        return NS_ERROR_FAILURE;
+    }
+    MOZ_ASSERT(gl);
+    MOZ_ASSERT_IF(mOptions.alpha, gl->Caps().alpha);
+
+    if (mOptions.failIfMajorPerformanceCaveat) {
+        if (gl->IsWARP()) {
+            DestroyResourcesAndContext();
+            MOZ_ASSERT(!gl);
+
+            failureId = NS_LITERAL_CSTRING("FEATURE_FAILURE_WEBGL_PERF_WARP");
+            const nsLiteralCString text("failIfMajorPerformanceCaveat: Driver is not"
+                                        " hardware-accelerated.");
+            ThrowEvent_WebGLContextCreationError(text);
+            return NS_ERROR_FAILURE;
+        }
+
+#ifdef XP_WIN
+        if (gl->GetContextType() == gl::GLContextType::WGL &&
+            !gl::sWGLLib.HasDXInterop2())
+        {
+            DestroyResourcesAndContext();
+            MOZ_ASSERT(!gl);
+
+            failureId = NS_LITERAL_CSTRING("FEATURE_FAILURE_WEBGL_DXGL_INTEROP2");
+            const nsLiteralCString text("Caveat: WGL without DXGLInterop2.");
+            ThrowEvent_WebGLContextCreationError(text);
+            return NS_ERROR_FAILURE;
+        }
+#endif
+    }
+
+    if (!ResizeBackbuffer(width, height)) {
+        failureId = NS_LITERAL_CSTRING("FEATURE_FAILURE_WEBGL_BACKBUFFER");
+        const nsLiteralCString text("Initializing WebGL backbuffer failed.");
+        ThrowEvent_WebGLContextCreationError(text);
+        return NS_ERROR_FAILURE;
+    }
+
+    if (GLContext::ShouldSpew()) {
+        printf_stderr("--- WebGL context created: %p\n", gl.get());
+    }
+
+    mResetLayer = true;
+    mOptionsFrozen = true;
+
+    // Update our internal stuff:
+    if (gl->WorkAroundDriverBugs()) {
+        if (!mOptions.alpha && gl->Caps().alpha)
+            mNeedsFakeNoAlpha = true;
+
+        if (!mOptions.depth && gl->Caps().depth)
+            mNeedsFakeNoDepth = true;
+
+        if (!mOptions.stencil && gl->Caps().stencil)
+            mNeedsFakeNoStencil = true;
+
+#ifdef MOZ_WIDGET_COCOA
+        if (!nsCocoaFeatures::IsAtLeastVersion(10, 12) &&
+            gl->Vendor() == GLVendor::Intel)
+        {
+            mNeedsEmulatedLoneDepthStencil = true;
+        }
+#endif
+    }
+
+    // Update mOptions.
+    if (!gl->Caps().depth)
+        mOptions.depth = false;
+
+    if (!gl->Caps().stencil)
+        mOptions.stencil = false;
+
+    mOptions.antialias = gl->Caps().antialias;
+
+    //////
+    // Initial setup.
+
+    MakeContextCurrent();
+
+    gl->fViewport(0, 0, mWidth, mHeight);
+    mViewportX = mViewportY = 0;
+    mViewportWidth = mWidth;
+    mViewportHeight = mHeight;
+
+    gl->fScissor(0, 0, mWidth, mHeight);
+    gl->fBindFramebuffer(LOCAL_GL_FRAMEBUFFER, 0);
+
+    //////
+    // Check everything
+
+    AssertCachedBindings();
+    AssertCachedGlobalState();
+
+    MOZ_ASSERT(gl->Caps().color);
+
+    MOZ_ASSERT_IF(!mNeedsFakeNoAlpha, gl->Caps().alpha == mOptions.alpha);
+    MOZ_ASSERT_IF(mNeedsFakeNoAlpha, !mOptions.alpha && gl->Caps().alpha);
+
+    MOZ_ASSERT_IF(!mNeedsFakeNoDepth, gl->Caps().depth == mOptions.depth);
+    MOZ_ASSERT_IF(mNeedsFakeNoDepth, !mOptions.depth && gl->Caps().depth);
+
+    MOZ_ASSERT_IF(!mNeedsFakeNoStencil, gl->Caps().stencil == mOptions.stencil);
+    MOZ_ASSERT_IF(mNeedsFakeNoStencil, !mOptions.stencil && gl->Caps().stencil);
+
+    MOZ_ASSERT(gl->Caps().antialias == mOptions.antialias);
+    MOZ_ASSERT(gl->Caps().preserve == mOptions.preserveDrawingBuffer);
+
+    //////
+    // Clear immediately, because we need to present the cleared initial buffer
+    mBackbufferNeedsClear = true;
+    ClearBackbufferIfNeeded();
+
+    mShouldPresent = true;
+
+    //////
+
+    reporter.SetSuccessful();
+
+    failureId = NS_LITERAL_CSTRING("SUCCESS");
+    return NS_OK;
+}
+
+void
+WebGLContext::ClearBackbufferIfNeeded()
+{
+    if (!mBackbufferNeedsClear)
+        return;
+
+    ClearScreen();
+
+    mBackbufferNeedsClear = false;
+}
+
+void
+WebGLContext::LoseOldestWebGLContextIfLimitExceeded()
+{
+#ifdef MOZ_GFX_OPTIMIZE_MOBILE
+    // some mobile devices can't have more than 8 GL contexts overall
+    const size_t kMaxWebGLContextsPerPrincipal = 2;
+    const size_t kMaxWebGLContexts             = 4;
+#else
+    const size_t kMaxWebGLContextsPerPrincipal = 16;
+    const size_t kMaxWebGLContexts             = 32;
+#endif
+    MOZ_ASSERT(kMaxWebGLContextsPerPrincipal < kMaxWebGLContexts);
+
+    if (!NS_IsMainThread()) {
+        // XXX mtseng: bug 709490, WebGLMemoryTracker is not thread safe.
+        return;
+    }
+
+    // it's important to update the index on a new context before losing old contexts,
+    // otherwise new unused contexts would all have index 0 and we couldn't distinguish older ones
+    // when choosing which one to lose first.
+    UpdateLastUseIndex();
+
+    WebGLMemoryTracker::ContextsArrayType& contexts = WebGLMemoryTracker::Contexts();
+
+    // quick exit path, should cover a majority of cases
+    if (contexts.Length() <= kMaxWebGLContextsPerPrincipal)
+        return;
+
+    // note that here by "context" we mean "non-lost context". See the check for
+    // IsContextLost() below. Indeed, the point of this function is to maybe lose
+    // some currently non-lost context.
+
+    uint64_t oldestIndex = UINT64_MAX;
+    uint64_t oldestIndexThisPrincipal = UINT64_MAX;
+    const WebGLContext* oldestContext = nullptr;
+    const WebGLContext* oldestContextThisPrincipal = nullptr;
+    size_t numContexts = 0;
+    size_t numContextsThisPrincipal = 0;
+
+    for(size_t i = 0; i < contexts.Length(); ++i) {
+        // don't want to lose ourselves.
+        if (contexts[i] == this)
+            continue;
+
+        if (contexts[i]->IsContextLost())
+            continue;
+
+        if (!contexts[i]->GetCanvas()) {
+            // Zombie context: the canvas is already destroyed, but something else
+            // (typically the compositor) is still holding on to the context.
+            // Killing zombies is a no-brainer.
+            const_cast<WebGLContext*>(contexts[i])->LoseContext();
+            continue;
+        }
+
+        numContexts++;
+        if (contexts[i]->mLastUseIndex < oldestIndex) {
+            oldestIndex = contexts[i]->mLastUseIndex;
+            oldestContext = contexts[i];
+        }
+
+        nsIPrincipal* ourPrincipal = GetCanvas()->NodePrincipal();
+        nsIPrincipal* theirPrincipal = contexts[i]->GetCanvas()->NodePrincipal();
+        bool samePrincipal;
+        nsresult rv = ourPrincipal->Equals(theirPrincipal, &samePrincipal);
+        if (NS_SUCCEEDED(rv) && samePrincipal) {
+            numContextsThisPrincipal++;
+            if (contexts[i]->mLastUseIndex < oldestIndexThisPrincipal) {
+                oldestIndexThisPrincipal = contexts[i]->mLastUseIndex;
+                oldestContextThisPrincipal = contexts[i];
+            }
+        }
+    }
+
+    if (numContextsThisPrincipal > kMaxWebGLContextsPerPrincipal) {
+        GenerateWarning("Exceeded %d live WebGL contexts for this principal, losing the "
+                        "least recently used one.", kMaxWebGLContextsPerPrincipal);
+        MOZ_ASSERT(oldestContextThisPrincipal); // if we reach this point, this can't be null
+        const_cast<WebGLContext*>(oldestContextThisPrincipal)->LoseContext();
+    } else if (numContexts > kMaxWebGLContexts) {
+        GenerateWarning("Exceeded %d live WebGL contexts, losing the least recently used one.",
+                        kMaxWebGLContexts);
+        MOZ_ASSERT(oldestContext); // if we reach this point, this can't be null
+        const_cast<WebGLContext*>(oldestContext)->LoseContext();
+    }
+}
+
+UniquePtr<uint8_t[]>
+WebGLContext::GetImageBuffer(int32_t* out_format)
+{
+    *out_format = 0;
+
+    // Use GetSurfaceSnapshot() to make sure that appropriate y-flip gets applied
+    bool premult;
+    RefPtr<SourceSurface> snapshot =
+      GetSurfaceSnapshot(mOptions.premultipliedAlpha ? nullptr : &premult);
+    if (!snapshot) {
+        return nullptr;
+    }
+
+    MOZ_ASSERT(mOptions.premultipliedAlpha || !premult, "We must get unpremult when we ask for it!");
+
+    RefPtr<DataSourceSurface> dataSurface = snapshot->GetDataSurface();
+
+    return gfxUtils::GetImageBuffer(dataSurface, mOptions.premultipliedAlpha,
+                                    out_format);
+}
+
+NS_IMETHODIMP
+WebGLContext::GetInputStream(const char* mimeType,
+                             const char16_t* encoderOptions,
+                             nsIInputStream** out_stream)
+{
+    NS_ASSERTION(gl, "GetInputStream on invalid context?");
+    if (!gl)
+        return NS_ERROR_FAILURE;
+
+    // Use GetSurfaceSnapshot() to make sure that appropriate y-flip gets applied
+    bool premult;
+    RefPtr<SourceSurface> snapshot =
+      GetSurfaceSnapshot(mOptions.premultipliedAlpha ? nullptr : &premult);
+    if (!snapshot)
+        return NS_ERROR_FAILURE;
+
+    MOZ_ASSERT(mOptions.premultipliedAlpha || !premult, "We must get unpremult when we ask for it!");
+
+    RefPtr<DataSourceSurface> dataSurface = snapshot->GetDataSurface();
+    return gfxUtils::GetInputStream(dataSurface, mOptions.premultipliedAlpha, mimeType,
+                                    encoderOptions, out_stream);
+}
+
+void
+WebGLContext::UpdateLastUseIndex()
+{
+    static CheckedInt<uint64_t> sIndex = 0;
+
+    sIndex++;
+
+    // should never happen with 64-bit; trying to handle this would be riskier than
+    // not handling it as the handler code would never get exercised.
+    if (!sIndex.isValid())
+        NS_RUNTIMEABORT("Can't believe it's been 2^64 transactions already!");
+
+    mLastUseIndex = sIndex.value();
+}
+
+static uint8_t gWebGLLayerUserData;
+static uint8_t gWebGLMirrorLayerUserData;
+
+class WebGLContextUserData : public LayerUserData
+{
+public:
+    explicit WebGLContextUserData(HTMLCanvasElement* canvas)
+        : mCanvas(canvas)
+    {}
+
+    /* PreTransactionCallback gets called by the Layers code every time the
+     * WebGL canvas is going to be composited.
+     */
+    static void PreTransactionCallback(void* data) {
+        WebGLContextUserData* userdata = static_cast<WebGLContextUserData*>(data);
+        HTMLCanvasElement* canvas = userdata->mCanvas;
+        WebGLContext* webgl = static_cast<WebGLContext*>(canvas->GetContextAtIndex(0));
+
+        // Prepare the context for composition
+        webgl->BeginComposition();
+    }
+
+    /** DidTransactionCallback gets called by the Layers code everytime the WebGL canvas gets composite,
+      * so it really is the right place to put actions that have to be performed upon compositing
+      */
+    static void DidTransactionCallback(void* data) {
+        WebGLContextUserData* userdata = static_cast<WebGLContextUserData*>(data);
+        HTMLCanvasElement* canvas = userdata->mCanvas;
+        WebGLContext* webgl = static_cast<WebGLContext*>(canvas->GetContextAtIndex(0));
+
+        // Clean up the context after composition
+        webgl->EndComposition();
+    }
+
+private:
+    RefPtr<HTMLCanvasElement> mCanvas;
+};
+
+already_AddRefed<layers::Layer>
+WebGLContext::GetCanvasLayer(nsDisplayListBuilder* builder,
+                             Layer* oldLayer,
+                             LayerManager* manager,
+                             bool aMirror /*= false*/)
+{
+    if (IsContextLost())
+        return nullptr;
+
+    if (!mResetLayer && oldLayer &&
+        oldLayer->HasUserData(aMirror ? &gWebGLMirrorLayerUserData : &gWebGLLayerUserData)) {
+        RefPtr<layers::Layer> ret = oldLayer;
+        return ret.forget();
+    }
+
+    RefPtr<CanvasLayer> canvasLayer = manager->CreateCanvasLayer();
+    if (!canvasLayer) {
+        NS_WARNING("CreateCanvasLayer returned null!");
+        return nullptr;
+    }
+
+    WebGLContextUserData* userData = nullptr;
+    if (builder->IsPaintingToWindow() && mCanvasElement && !aMirror) {
+        // Make the layer tell us whenever a transaction finishes (including
+        // the current transaction), so we can clear our invalidation state and
+        // start invalidating again. We need to do this for the layer that is
+        // being painted to a window (there shouldn't be more than one at a time,
+        // and if there is, flushing the invalidation state more often than
+        // necessary is harmless).
+
+        // The layer will be destroyed when we tear down the presentation
+        // (at the latest), at which time this userData will be destroyed,
+        // releasing the reference to the element.
+        // The userData will receive DidTransactionCallbacks, which flush the
+        // the invalidation state to indicate that the canvas is up to date.
+        userData = new WebGLContextUserData(mCanvasElement);
+        canvasLayer->SetDidTransactionCallback(
+            WebGLContextUserData::DidTransactionCallback, userData);
+        canvasLayer->SetPreTransactionCallback(
+            WebGLContextUserData::PreTransactionCallback, userData);
+    }
+
+    canvasLayer->SetUserData(aMirror ? &gWebGLMirrorLayerUserData : &gWebGLLayerUserData, userData);
+
+    CanvasLayer::Data data;
+    data.mGLContext = gl;
+    data.mSize = nsIntSize(mWidth, mHeight);
+    data.mHasAlpha = gl->Caps().alpha;
+    data.mIsGLAlphaPremult = IsPremultAlpha() || !data.mHasAlpha;
+    data.mIsMirror = aMirror;
+
+    canvasLayer->Initialize(data);
+    uint32_t flags = gl->Caps().alpha ? 0 : Layer::CONTENT_OPAQUE;
+    canvasLayer->SetContentFlags(flags);
+    canvasLayer->Updated();
+
+    mResetLayer = false;
+    // We only wish to update mLayerIsMirror when a new layer is returned.
+    // If a cached layer is returned above, aMirror is not changing since
+    // the last cached layer was created and mLayerIsMirror is still valid.
+    mLayerIsMirror = aMirror;
+
+    return canvasLayer.forget();
+}
+
+layers::LayersBackend
+WebGLContext::GetCompositorBackendType() const
+{
+    if (mCanvasElement) {
+        return mCanvasElement->GetCompositorBackendType();
+    } else if (mOffscreenCanvas) {
+        return mOffscreenCanvas->GetCompositorBackendType();
+    }
+
+    return LayersBackend::LAYERS_NONE;
+}
+
+void
+WebGLContext::Commit()
+{
+    if (mOffscreenCanvas) {
+        mOffscreenCanvas->CommitFrameToCompositor();
+    }
+}
+
+void
+WebGLContext::GetCanvas(Nullable<dom::OwningHTMLCanvasElementOrOffscreenCanvas>& retval)
+{
+    if (mCanvasElement) {
+        MOZ_RELEASE_ASSERT(!mOffscreenCanvas, "GFX: Canvas is offscreen.");
+
+        if (mCanvasElement->IsInNativeAnonymousSubtree()) {
+          retval.SetNull();
+        } else {
+          retval.SetValue().SetAsHTMLCanvasElement() = mCanvasElement;
+        }
+    } else if (mOffscreenCanvas) {
+        retval.SetValue().SetAsOffscreenCanvas() = mOffscreenCanvas;
+    } else {
+        retval.SetNull();
+    }
+}
+
+void
+WebGLContext::GetContextAttributes(dom::Nullable<dom::WebGLContextAttributes>& retval)
+{
+    retval.SetNull();
+    if (IsContextLost())
+        return;
+
+    dom::WebGLContextAttributes& result = retval.SetValue();
+
+    result.mAlpha.Construct(mOptions.alpha);
+    result.mDepth = mOptions.depth;
+    result.mStencil = mOptions.stencil;
+    result.mAntialias = mOptions.antialias;
+    result.mPremultipliedAlpha = mOptions.premultipliedAlpha;
+    result.mPreserveDrawingBuffer = mOptions.preserveDrawingBuffer;
+    result.mFailIfMajorPerformanceCaveat = mOptions.failIfMajorPerformanceCaveat;
+}
+
+NS_IMETHODIMP
+WebGLContext::MozGetUnderlyingParamString(uint32_t pname, nsAString& retval)
+{
+    if (IsContextLost())
+        return NS_OK;
+
+    retval.SetIsVoid(true);
+
+    MakeContextCurrent();
+
+    switch (pname) {
+    case LOCAL_GL_VENDOR:
+    case LOCAL_GL_RENDERER:
+    case LOCAL_GL_VERSION:
+    case LOCAL_GL_SHADING_LANGUAGE_VERSION:
+    case LOCAL_GL_EXTENSIONS:
+        {
+            const char* s = (const char*)gl->fGetString(pname);
+            retval.Assign(NS_ConvertASCIItoUTF16(nsDependentCString(s)));
+            break;
+        }
+
+    default:
+        return NS_ERROR_INVALID_ARG;
+    }
+
+    return NS_OK;
+}
+
+void
+WebGLContext::ClearScreen()
+{
+    MakeContextCurrent();
+    ScopedBindFramebuffer autoFB(gl, 0);
+
+    const bool changeDrawBuffers = (mDefaultFB_DrawBuffer0 != LOCAL_GL_BACK);
+    if (changeDrawBuffers) {
+        gl->Screen()->SetDrawBuffer(LOCAL_GL_BACK);
+    }
+
+    GLbitfield bufferBits = LOCAL_GL_COLOR_BUFFER_BIT;
+    if (mOptions.depth)
+        bufferBits |= LOCAL_GL_DEPTH_BUFFER_BIT;
+    if (mOptions.stencil)
+        bufferBits |= LOCAL_GL_STENCIL_BUFFER_BIT;
+
+    ForceClearFramebufferWithDefaultValues(bufferBits, mNeedsFakeNoAlpha);
+
+    if (changeDrawBuffers) {
+        gl->Screen()->SetDrawBuffer(mDefaultFB_DrawBuffer0);
+    }
+}
+
+void
+WebGLContext::ForceClearFramebufferWithDefaultValues(GLbitfield clearBits,
+                                                     bool fakeNoAlpha)
+{
+    MakeContextCurrent();
+
+    const bool initializeColorBuffer = bool(clearBits & LOCAL_GL_COLOR_BUFFER_BIT);
+    const bool initializeDepthBuffer = bool(clearBits & LOCAL_GL_DEPTH_BUFFER_BIT);
+    const bool initializeStencilBuffer = bool(clearBits & LOCAL_GL_STENCIL_BUFFER_BIT);
+
+    // Fun GL fact: No need to worry about the viewport here, glViewport is just
+    // setting up a coordinates transformation, it doesn't affect glClear at all.
+    AssertCachedGlobalState();
+
+    // Prepare GL state for clearing.
+    gl->fDisable(LOCAL_GL_SCISSOR_TEST);
+
+    if (initializeColorBuffer) {
+        gl->fColorMask(1, 1, 1, 1);
+
+        if (fakeNoAlpha) {
+            gl->fClearColor(0.0f, 0.0f, 0.0f, 1.0f);
+        } else {
+            gl->fClearColor(0.0f, 0.0f, 0.0f, 0.0f);
+        }
+    }
+
+    if (initializeDepthBuffer) {
+        gl->fDepthMask(1);
+        gl->fClearDepth(1.0f);
+    }
+
+    if (initializeStencilBuffer) {
+        // "The clear operation always uses the front stencil write mask
+        //  when clearing the stencil buffer."
+        gl->fStencilMaskSeparate(LOCAL_GL_FRONT, 0xffffffff);
+        gl->fStencilMaskSeparate(LOCAL_GL_BACK,  0xffffffff);
+        gl->fClearStencil(0);
+    }
+
+    if (mRasterizerDiscardEnabled) {
+        gl->fDisable(LOCAL_GL_RASTERIZER_DISCARD);
+    }
+
+    // Do the clear!
+    gl->fClear(clearBits);
+
+    // And reset!
+    if (mScissorTestEnabled)
+        gl->fEnable(LOCAL_GL_SCISSOR_TEST);
+
+    if (mRasterizerDiscardEnabled) {
+        gl->fEnable(LOCAL_GL_RASTERIZER_DISCARD);
+    }
+
+    // Restore GL state after clearing.
+    if (initializeColorBuffer) {
+        gl->fColorMask(mColorWriteMask[0],
+                       mColorWriteMask[1],
+                       mColorWriteMask[2],
+                       mColorWriteMask[3]);
+        gl->fClearColor(mColorClearValue[0],
+                        mColorClearValue[1],
+                        mColorClearValue[2],
+                        mColorClearValue[3]);
+    }
+
+    if (initializeDepthBuffer) {
+        gl->fDepthMask(mDepthWriteMask);
+        gl->fClearDepth(mDepthClearValue);
+    }
+
+    if (initializeStencilBuffer) {
+        gl->fStencilMaskSeparate(LOCAL_GL_FRONT, mStencilWriteMaskFront);
+        gl->fStencilMaskSeparate(LOCAL_GL_BACK,  mStencilWriteMaskBack);
+        gl->fClearStencil(mStencilClearValue);
+    }
+}
+
+// For an overview of how WebGL compositing works, see:
+// https://wiki.mozilla.org/Platform/GFX/WebGL/Compositing
+bool
+WebGLContext::PresentScreenBuffer()
+{
+    if (IsContextLost()) {
+        return false;
+    }
+
+    if (!mShouldPresent) {
+        return false;
+    }
+    MOZ_ASSERT(!mBackbufferNeedsClear);
+
+    gl->MakeCurrent();
+
+    GLScreenBuffer* screen = gl->Screen();
+    MOZ_ASSERT(screen);
+
+    if (!screen->PublishFrame(screen->Size())) {
+        ForceLoseContext();
+        return false;
+    }
+
+    if (!mOptions.preserveDrawingBuffer) {
+        mBackbufferNeedsClear = true;
+    }
+
+    mShouldPresent = false;
+
+    return true;
+}
+
+// Prepare the context for capture before compositing
+void
+WebGLContext::BeginComposition()
+{
+    // Present our screenbuffer, if needed.
+    PresentScreenBuffer();
+    mDrawCallsSinceLastFlush = 0;
+}
+
+// Clean up the context after captured for compositing
+void
+WebGLContext::EndComposition()
+{
+    // Mark ourselves as no longer invalidated.
+    MarkContextClean();
+    UpdateLastUseIndex();
+}
+
+void
+WebGLContext::DummyReadFramebufferOperation(const char* funcName)
+{
+    if (!mBoundReadFramebuffer)
+        return; // Infallible.
+
+    const auto status = mBoundReadFramebuffer->CheckFramebufferStatus(funcName);
+
+    if (status != LOCAL_GL_FRAMEBUFFER_COMPLETE) {
+        ErrorInvalidFramebufferOperation("%s: Framebuffer must be complete.",
+                                         funcName);
+    }
+}
+
+bool
+WebGLContext::Has64BitTimestamps() const
+{
+    // 'sync' provides glGetInteger64v either by supporting ARB_sync, GL3+, or GLES3+.
+    return gl->IsSupported(GLFeature::sync);
+}
+
+static bool
+CheckContextLost(GLContext* gl, bool* const out_isGuilty)
+{
+    MOZ_ASSERT(gl);
+    MOZ_ASSERT(out_isGuilty);
+
+    bool isEGL = gl->GetContextType() == gl::GLContextType::EGL;
+
+    GLenum resetStatus = LOCAL_GL_NO_ERROR;
+    if (gl->IsSupported(GLFeature::robustness)) {
+        gl->MakeCurrent();
+        resetStatus = gl->fGetGraphicsResetStatus();
+    } else if (isEGL) {
+        // Simulate a ARB_robustness guilty context loss for when we
+        // get an EGL_CONTEXT_LOST error. It may not actually be guilty,
+        // but we can't make any distinction.
+        if (!gl->MakeCurrent(true) && gl->IsContextLost()) {
+            resetStatus = LOCAL_GL_UNKNOWN_CONTEXT_RESET_ARB;
+        }
+    }
+
+    if (resetStatus == LOCAL_GL_NO_ERROR) {
+        *out_isGuilty = false;
+        return false;
+    }
+
+    // Assume guilty unless we find otherwise!
+    bool isGuilty = true;
+    switch (resetStatus) {
+    case LOCAL_GL_INNOCENT_CONTEXT_RESET_ARB:
+        // Either nothing wrong, or not our fault.
+        isGuilty = false;
+        break;
+    case LOCAL_GL_GUILTY_CONTEXT_RESET_ARB:
+        NS_WARNING("WebGL content on the page definitely caused the graphics"
+                   " card to reset.");
+        break;
+    case LOCAL_GL_UNKNOWN_CONTEXT_RESET_ARB:
+        NS_WARNING("WebGL content on the page might have caused the graphics"
+                   " card to reset");
+        // If we can't tell, assume guilty.
+        break;
+    default:
+        MOZ_ASSERT(false, "Unreachable.");
+        // If we do get here, let's pretend to be guilty as an escape plan.
+        break;
+    }
+
+    if (isGuilty) {
+        NS_WARNING("WebGL context on this page is considered guilty, and will"
+                   " not be restored.");
+    }
+
+    *out_isGuilty = isGuilty;
+    return true;
+}
+
+bool
+WebGLContext::TryToRestoreContext()
+{
+    if (NS_FAILED(SetDimensions(mWidth, mHeight)))
+        return false;
+
+    return true;
+}
+
+void
+WebGLContext::RunContextLossTimer()
+{
+    mContextLossHandler.RunTimer();
+}
+
+class UpdateContextLossStatusTask : public CancelableRunnable
+{
+    RefPtr<WebGLContext> mWebGL;
+
+public:
+    explicit UpdateContextLossStatusTask(WebGLContext* webgl)
+        : mWebGL(webgl)
+    {
+    }
+
+    NS_IMETHOD Run() override {
+        if (mWebGL)
+            mWebGL->UpdateContextLossStatus();
+
+        return NS_OK;
+    }
+
+    nsresult Cancel() override {
+        mWebGL = nullptr;
+        return NS_OK;
+    }
+};
+
+void
+WebGLContext::EnqueueUpdateContextLossStatus()
+{
+    nsCOMPtr<nsIRunnable> task = new UpdateContextLossStatusTask(this);
+    NS_DispatchToCurrentThread(task);
+}
+
+// We use this timer for many things. Here are the things that it is activated for:
+// 1) If a script is using the MOZ_WEBGL_lose_context extension.
+// 2) If we are using EGL and _NOT ANGLE_, we query periodically to see if the
+//    CONTEXT_LOST_WEBGL error has been triggered.
+// 3) If we are using ANGLE, or anything that supports ARB_robustness, query the
+//    GPU periodically to see if the reset status bit has been set.
+// In all of these situations, we use this timer to send the script context lost
+// and restored events asynchronously. For example, if it triggers a context loss,
+// the webglcontextlost event will be sent to it the next time the robustness timer
+// fires.
+// Note that this timer mechanism is not used unless one of these 3 criteria
+// are met.
+// At a bare minimum, from context lost to context restores, it would take 3
+// full timer iterations: detection, webglcontextlost, webglcontextrestored.
+void
+WebGLContext::UpdateContextLossStatus()
+{
+    if (!mCanvasElement && !mOffscreenCanvas) {
+        // the canvas is gone. That happens when the page was closed before we got
+        // this timer event. In this case, there's nothing to do here, just don't crash.
+        return;
+    }
+    if (mContextStatus == ContextNotLost) {
+        // We don't know that we're lost, but we might be, so we need to
+        // check. If we're guilty, don't allow restores, though.
+
+        bool isGuilty = true;
+        MOZ_ASSERT(gl); // Shouldn't be missing gl if we're NotLost.
+        bool isContextLost = CheckContextLost(gl, &isGuilty);
+
+        if (isContextLost) {
+            if (isGuilty)
+                mAllowContextRestore = false;
+
+            ForceLoseContext();
+        }
+
+        // Fall through.
+    }
+
+    if (mContextStatus == ContextLostAwaitingEvent) {
+        // The context has been lost and we haven't yet triggered the
+        // callback, so do that now.
+        const auto kEventName = NS_LITERAL_STRING("webglcontextlost");
+        const bool kCanBubble = true;
+        const bool kIsCancelable = true;
+        bool useDefaultHandler;
+
+        if (mCanvasElement) {
+            nsContentUtils::DispatchTrustedEvent(
+                mCanvasElement->OwnerDoc(),
+                static_cast<nsIDOMHTMLCanvasElement*>(mCanvasElement),
+                kEventName,
+                kCanBubble,
+                kIsCancelable,
+                &useDefaultHandler);
+        } else {
+            // OffscreenCanvas case
+            RefPtr<Event> event = new Event(mOffscreenCanvas, nullptr, nullptr);
+            event->InitEvent(kEventName, kCanBubble, kIsCancelable);
+            event->SetTrusted(true);
+            mOffscreenCanvas->DispatchEvent(event, &useDefaultHandler);
+        }
+
+        // We sent the callback, so we're just 'regular lost' now.
+        mContextStatus = ContextLost;
+        // If we're told to use the default handler, it means the script
+        // didn't bother to handle the event. In this case, we shouldn't
+        // auto-restore the context.
+        if (useDefaultHandler)
+            mAllowContextRestore = false;
+
+        // Fall through.
+    }
+
+    if (mContextStatus == ContextLost) {
+        // Context is lost, and we've already sent the callback. We
+        // should try to restore the context if we're both allowed to,
+        // and supposed to.
+
+        // Are we allowed to restore the context?
+        if (!mAllowContextRestore)
+            return;
+
+        // If we're only simulated-lost, we shouldn't auto-restore, and
+        // instead we should wait for restoreContext() to be called.
+        if (mLastLossWasSimulated)
+            return;
+
+        // Restore when the app is visible
+        if (mRestoreWhenVisible)
+            return;
+
+        ForceRestoreContext();
+        return;
+    }
+
+    if (mContextStatus == ContextLostAwaitingRestore) {
+        // Context is lost, but we should try to restore it.
+
+        if (!mAllowContextRestore) {
+            // We might decide this after thinking we'd be OK restoring
+            // the context, so downgrade.
+            mContextStatus = ContextLost;
+            return;
+        }
+
+        if (!TryToRestoreContext()) {
+            // Failed to restore. Try again later.
+            mContextLossHandler.RunTimer();
+            return;
+        }
+
+        // Revival!
+        mContextStatus = ContextNotLost;
+
+        if (mCanvasElement) {
+            nsContentUtils::DispatchTrustedEvent(
+                mCanvasElement->OwnerDoc(),
+                static_cast<nsIDOMHTMLCanvasElement*>(mCanvasElement),
+                NS_LITERAL_STRING("webglcontextrestored"),
+                true,
+                true);
+        } else {
+            RefPtr<Event> event = new Event(mOffscreenCanvas, nullptr, nullptr);
+            event->InitEvent(NS_LITERAL_STRING("webglcontextrestored"), true, true);
+            event->SetTrusted(true);
+            bool unused;
+            mOffscreenCanvas->DispatchEvent(event, &unused);
+        }
+
+        mEmitContextLostErrorOnce = true;
+        return;
+    }
+}
+
+void
+WebGLContext::ForceLoseContext(bool simulateLosing)
+{
+    printf_stderr("WebGL(%p)::ForceLoseContext\n", this);
+    MOZ_ASSERT(!IsContextLost());
+    mContextStatus = ContextLostAwaitingEvent;
+    mContextLostErrorSet = false;
+
+    // Burn it all!
+    DestroyResourcesAndContext();
+    mLastLossWasSimulated = simulateLosing;
+
+    // Queue up a task, since we know the status changed.
+    EnqueueUpdateContextLossStatus();
+}
+
+void
+WebGLContext::ForceRestoreContext()
+{
+    printf_stderr("WebGL(%p)::ForceRestoreContext\n", this);
+    mContextStatus = ContextLostAwaitingRestore;
+    mAllowContextRestore = true; // Hey, you did say 'force'.
+
+    // Queue up a task, since we know the status changed.
+    EnqueueUpdateContextLossStatus();
+}
+
+void
+WebGLContext::MakeContextCurrent() const
+{
+    gl->MakeCurrent();
+}
+
+already_AddRefed<mozilla::gfx::SourceSurface>
+WebGLContext::GetSurfaceSnapshot(bool* out_premultAlpha)
+{
+    if (!gl)
+        return nullptr;
+
+    bool hasAlpha = mOptions.alpha;
+    SurfaceFormat surfFormat = hasAlpha ? SurfaceFormat::B8G8R8A8
+                                        : SurfaceFormat::B8G8R8X8;
+    RefPtr<DataSourceSurface> surf;
+    surf = Factory::CreateDataSourceSurfaceWithStride(IntSize(mWidth, mHeight),
+                                                      surfFormat,
+                                                      mWidth * 4);
+    if (NS_WARN_IF(!surf)) {
+        return nullptr;
+    }
+
+    gl->MakeCurrent();
+    {
+        ScopedBindFramebuffer autoFB(gl, 0);
+        ClearBackbufferIfNeeded();
+
+        // Save, override, then restore glReadBuffer.
+        const GLenum readBufferMode = gl->Screen()->GetReadBufferMode();
+
+        if (readBufferMode != LOCAL_GL_BACK) {
+            gl->fReadBuffer(LOCAL_GL_BACK);
+        }
+        ReadPixelsIntoDataSurface(gl, surf);
+
+        if (readBufferMode != LOCAL_GL_BACK) {
+            gl->fReadBuffer(readBufferMode);
+        }
+    }
+
+    if (out_premultAlpha) {
+        *out_premultAlpha = true;
+    }
+    bool srcPremultAlpha = mOptions.premultipliedAlpha;
+    if (!srcPremultAlpha) {
+        if (out_premultAlpha) {
+            *out_premultAlpha = false;
+        } else if(hasAlpha) {
+            gfxUtils::PremultiplyDataSurface(surf, surf);
+        }
+    }
+
+    RefPtr<DrawTarget> dt =
+        Factory::CreateDrawTarget(BackendType::CAIRO,
+                                  IntSize(mWidth, mHeight),
+                                  SurfaceFormat::B8G8R8A8);
+
+    if (!dt) {
+        return nullptr;
+    }
+
+    dt->SetTransform(Matrix::Translation(0.0, mHeight).PreScale(1.0, -1.0));
+
+    dt->DrawSurface(surf,
+                    Rect(0, 0, mWidth, mHeight),
+                    Rect(0, 0, mWidth, mHeight),
+                    DrawSurfaceOptions(),
+                    DrawOptions(1.0f, CompositionOp::OP_SOURCE));
+
+    return dt->Snapshot();
+}
+
+void
+WebGLContext::DidRefresh()
+{
+    if (gl) {
+        gl->FlushIfHeavyGLCallsSinceLastFlush();
+    }
+}
+
+bool
+WebGLContext::ValidateCurFBForRead(const char* funcName,
+                                   const webgl::FormatUsageInfo** const out_format,
+                                   uint32_t* const out_width, uint32_t* const out_height)
+{
+    if (!mBoundReadFramebuffer) {
+        const GLenum readBufferMode = gl->Screen()->GetReadBufferMode();
+        if (readBufferMode == LOCAL_GL_NONE) {
+            ErrorInvalidOperation("%s: Can't read from backbuffer when readBuffer mode is"
+                                  " NONE.",
+                                  funcName);
+            return false;
+        }
+
+        ClearBackbufferIfNeeded();
+
+        // FIXME - here we're assuming that the default framebuffer is backed by
+        // UNSIGNED_BYTE that might not always be true, say if we had a 16bpp default
+        // framebuffer.
+        auto effFormat = mOptions.alpha ? webgl::EffectiveFormat::RGBA8
+                                        : webgl::EffectiveFormat::RGB8;
+
+        *out_format = mFormatUsage->GetUsage(effFormat);
+        MOZ_ASSERT(*out_format);
+
+        *out_width = mWidth;
+        *out_height = mHeight;
+        return true;
+    }
+
+    return mBoundReadFramebuffer->ValidateForRead(funcName, out_format, out_width,
+                                                  out_height);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+WebGLContext::ScopedDrawCallWrapper::ScopedDrawCallWrapper(WebGLContext& webgl)
+    : mWebGL(webgl)
+    , mFakeNoAlpha(ShouldFakeNoAlpha(webgl))
+    , mFakeNoDepth(ShouldFakeNoDepth(webgl))
+    , mFakeNoStencil(ShouldFakeNoStencil(webgl))
+{
+    if (!mWebGL.mBoundDrawFramebuffer) {
+        mWebGL.ClearBackbufferIfNeeded();
+    }
+
+    if (mFakeNoAlpha) {
+        mWebGL.gl->fColorMask(mWebGL.mColorWriteMask[0],
+                              mWebGL.mColorWriteMask[1],
+                              mWebGL.mColorWriteMask[2],
+                              false);
+    }
+    if (mFakeNoDepth) {
+        mWebGL.gl->fDisable(LOCAL_GL_DEPTH_TEST);
+    }
+    if (mFakeNoStencil) {
+        mWebGL.gl->fDisable(LOCAL_GL_STENCIL_TEST);
+    }
+}
+
+WebGLContext::ScopedDrawCallWrapper::~ScopedDrawCallWrapper()
+{
+    if (mFakeNoAlpha) {
+        mWebGL.gl->fColorMask(mWebGL.mColorWriteMask[0],
+                              mWebGL.mColorWriteMask[1],
+                              mWebGL.mColorWriteMask[2],
+                              mWebGL.mColorWriteMask[3]);
+    }
+    if (mFakeNoDepth) {
+        mWebGL.gl->fEnable(LOCAL_GL_DEPTH_TEST);
+    }
+    if (mFakeNoStencil) {
+        MOZ_ASSERT(mWebGL.mStencilTestEnabled);
+        mWebGL.gl->fEnable(LOCAL_GL_STENCIL_TEST);
+    }
+
+    if (!mWebGL.mBoundDrawFramebuffer) {
+        mWebGL.Invalidate();
+        mWebGL.mShouldPresent = true;
+    }
+}
+
+/*static*/ bool
+WebGLContext::ScopedDrawCallWrapper::HasDepthButNoStencil(const WebGLFramebuffer* fb)
+{
+    const auto& depth = fb->DepthAttachment();
+    const auto& stencil = fb->StencilAttachment();
+    return depth.IsDefined() && !stencil.IsDefined();
+}
+
+////
+
+void
+WebGLContext::OnBeforeReadCall()
+{
+    if (!mBoundReadFramebuffer) {
+        ClearBackbufferIfNeeded();
+    }
+}
+
+////////////////////////////////////////
+
+IndexedBufferBinding::IndexedBufferBinding()
+    : mRangeStart(0)
+    , mRangeSize(0)
+{ }
+
+uint64_t
+IndexedBufferBinding::ByteCount() const
+{
+    if (!mBufferBinding)
+        return 0;
+
+    uint64_t bufferSize = mBufferBinding->ByteLength();
+    if (!mRangeSize) // BindBufferBase
+        return bufferSize;
+
+    if (mRangeStart >= bufferSize)
+        return 0;
+    bufferSize -= mRangeStart;
+
+    return std::min(bufferSize, mRangeSize);
+}
+
+////////////////////////////////////////
+
+ScopedUnpackReset::ScopedUnpackReset(WebGLContext* webgl)
+    : ScopedGLWrapper<ScopedUnpackReset>(webgl->gl)
+    , mWebGL(webgl)
+{
+    if (mWebGL->mPixelStore_UnpackAlignment != 4) mGL->fPixelStorei(LOCAL_GL_UNPACK_ALIGNMENT, 4);
+
+    if (mWebGL->IsWebGL2()) {
+        if (mWebGL->mPixelStore_UnpackRowLength   != 0) mGL->fPixelStorei(LOCAL_GL_UNPACK_ROW_LENGTH  , 0);
+        if (mWebGL->mPixelStore_UnpackImageHeight != 0) mGL->fPixelStorei(LOCAL_GL_UNPACK_IMAGE_HEIGHT, 0);
+        if (mWebGL->mPixelStore_UnpackSkipPixels  != 0) mGL->fPixelStorei(LOCAL_GL_UNPACK_SKIP_PIXELS , 0);
+        if (mWebGL->mPixelStore_UnpackSkipRows    != 0) mGL->fPixelStorei(LOCAL_GL_UNPACK_SKIP_ROWS   , 0);
+        if (mWebGL->mPixelStore_UnpackSkipImages  != 0) mGL->fPixelStorei(LOCAL_GL_UNPACK_SKIP_IMAGES , 0);
+
+        if (mWebGL->mBoundPixelUnpackBuffer) mGL->fBindBuffer(LOCAL_GL_PIXEL_UNPACK_BUFFER, 0);
+    }
+}
+
+void
+ScopedUnpackReset::UnwrapImpl()
+{
+    mGL->fPixelStorei(LOCAL_GL_UNPACK_ALIGNMENT, mWebGL->mPixelStore_UnpackAlignment);
+
+    if (mWebGL->IsWebGL2()) {
+        mGL->fPixelStorei(LOCAL_GL_UNPACK_ROW_LENGTH  , mWebGL->mPixelStore_UnpackRowLength  );
+        mGL->fPixelStorei(LOCAL_GL_UNPACK_IMAGE_HEIGHT, mWebGL->mPixelStore_UnpackImageHeight);
+        mGL->fPixelStorei(LOCAL_GL_UNPACK_SKIP_PIXELS , mWebGL->mPixelStore_UnpackSkipPixels );
+        mGL->fPixelStorei(LOCAL_GL_UNPACK_SKIP_ROWS   , mWebGL->mPixelStore_UnpackSkipRows   );
+        mGL->fPixelStorei(LOCAL_GL_UNPACK_SKIP_IMAGES , mWebGL->mPixelStore_UnpackSkipImages );
+
+        GLuint pbo = 0;
+        if (mWebGL->mBoundPixelUnpackBuffer) {
+            pbo = mWebGL->mBoundPixelUnpackBuffer->mGLName;
+        }
+
+        mGL->fBindBuffer(LOCAL_GL_PIXEL_UNPACK_BUFFER, pbo);
+    }
+}
+
+////////////////////
+
+void
+ScopedFBRebinder::UnwrapImpl()
+{
+    const auto fnName = [&](WebGLFramebuffer* fb) {
+        return fb ? fb->mGLName : 0;
+    };
+
+    if (mWebGL->IsWebGL2()) {
+        mGL->fBindFramebuffer(LOCAL_GL_DRAW_FRAMEBUFFER, fnName(mWebGL->mBoundDrawFramebuffer));
+        mGL->fBindFramebuffer(LOCAL_GL_READ_FRAMEBUFFER, fnName(mWebGL->mBoundReadFramebuffer));
+    } else {
+        MOZ_ASSERT(mWebGL->mBoundDrawFramebuffer == mWebGL->mBoundReadFramebuffer);
+        mGL->fBindFramebuffer(LOCAL_GL_FRAMEBUFFER, fnName(mWebGL->mBoundDrawFramebuffer));
+    }
+}
+
+////////////////////
+
+static GLenum
+TargetIfLazy(GLenum target)
+{
+    switch (target) {
+    case LOCAL_GL_PIXEL_PACK_BUFFER:
+    case LOCAL_GL_PIXEL_UNPACK_BUFFER:
+        return target;
+
+    default:
+        return 0;
+    }
+}
+
+ScopedLazyBind::ScopedLazyBind(gl::GLContext* gl, GLenum target, const WebGLBuffer* buf)
+    : ScopedGLWrapper<ScopedLazyBind>(gl)
+    , mTarget(buf ? TargetIfLazy(target) : 0)
+    , mBuf(buf)
+{
+    if (mTarget) {
+        mGL->fBindBuffer(mTarget, mBuf->mGLName);
+    }
+}
+
+void
+ScopedLazyBind::UnwrapImpl()
+{
+    if (mTarget) {
+        mGL->fBindBuffer(mTarget, 0);
+    }
+}
+
+////////////////////////////////////////
+
+bool
+Intersect(const int32_t srcSize, const int32_t read0, const int32_t readSize,
+          int32_t* const out_intRead0, int32_t* const out_intWrite0,
+          int32_t* const out_intSize)
+{
+    MOZ_ASSERT(srcSize >= 0);
+    MOZ_ASSERT(readSize >= 0);
+    const auto read1 = int64_t(read0) + readSize;
+
+    int32_t intRead0 = read0; // Clearly doesn't need validation.
+    int64_t intWrite0 = 0;
+    int64_t intSize = readSize;
+
+    if (read1 <= 0 || read0 >= srcSize) {
+        // Disjoint ranges.
+        intSize = 0;
+    } else {
+        if (read0 < 0) {
+            const auto diff = int64_t(0) - read0;
+            MOZ_ASSERT(diff >= 0);
+            intRead0 = 0;
+            intWrite0 = diff;
+            intSize -= diff;
+        }
+        if (read1 > srcSize) {
+            const auto diff = int64_t(read1) - srcSize;
+            MOZ_ASSERT(diff >= 0);
+            intSize -= diff;
+        }
+
+        if (!CheckedInt<int32_t>(intWrite0).isValid() ||
+            !CheckedInt<int32_t>(intSize).isValid())
+        {
+            return false;
+        }
+    }
+
+    *out_intRead0 = intRead0;
+    *out_intWrite0 = intWrite0;
+    *out_intSize = intSize;
+    return true;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+CheckedUint32
+WebGLContext::GetUnpackSize(bool isFunc3D, uint32_t width, uint32_t height,
+                            uint32_t depth, uint8_t bytesPerPixel)
+{
+    if (!width || !height || !depth)
+        return 0;
+
+    ////////////////
+
+    const auto& maybeRowLength = mPixelStore_UnpackRowLength;
+    const auto& maybeImageHeight = mPixelStore_UnpackImageHeight;
+
+    const auto usedPixelsPerRow = CheckedUint32(mPixelStore_UnpackSkipPixels) + width;
+    const auto stridePixelsPerRow = (maybeRowLength ? CheckedUint32(maybeRowLength)
+                                                    : usedPixelsPerRow);
+
+    const auto usedRowsPerImage = CheckedUint32(mPixelStore_UnpackSkipRows) + height;
+    const auto strideRowsPerImage = (maybeImageHeight ? CheckedUint32(maybeImageHeight)
+                                                      : usedRowsPerImage);
+
+    const uint32_t skipImages = (isFunc3D ? mPixelStore_UnpackSkipImages
+                                          : 0);
+    const CheckedUint32 usedImages = CheckedUint32(skipImages) + depth;
+
+    ////////////////
+
+    CheckedUint32 strideBytesPerRow = bytesPerPixel * stridePixelsPerRow;
+    strideBytesPerRow = RoundUpToMultipleOf(strideBytesPerRow,
+                                            mPixelStore_UnpackAlignment);
+
+    const CheckedUint32 strideBytesPerImage = strideBytesPerRow * strideRowsPerImage;
+
+    ////////////////
+
+    CheckedUint32 usedBytesPerRow = bytesPerPixel * usedPixelsPerRow;
+    // Don't round this to the alignment, since alignment here is really just used for
+    // establishing stride, particularly in WebGL 1, where you can't set ROW_LENGTH.
+
+    CheckedUint32 totalBytes = strideBytesPerImage * (usedImages - 1);
+    totalBytes += strideBytesPerRow * (usedRowsPerImage - 1);
+    totalBytes += usedBytesPerRow;
+
+    return totalBytes;
+}
+
+already_AddRefed<layers::SharedSurfaceTextureClient>
+WebGLContext::GetVRFrame()
+{
+    if (!mLayerIsMirror) {
+        /**
+         * Do not allow VR frame submission until a mirroring canvas layer has
+         * been returned by GetCanvasLayer
+         */
+        return nullptr;
+    }
+
+    VRManagerChild* vrmc = VRManagerChild::Get();
+    if (!vrmc) {
+        return nullptr;
+    }
+
+    /**
+     * Swap buffers as though composition has occurred.
+     * We will then share the resulting front buffer to be submitted to the VR
+     * compositor.
+     */
+    BeginComposition();
+    EndComposition();
+
+    gl::GLScreenBuffer* screen = gl->Screen();
+    if (!screen) {
+        return nullptr;
+    }
+
+    RefPtr<SharedSurfaceTextureClient> sharedSurface = screen->Front();
+    if (!sharedSurface) {
+        return nullptr;
+    }
+
+    if (sharedSurface && sharedSurface->GetAllocator() != vrmc) {
+        RefPtr<SharedSurfaceTextureClient> dest =
+        screen->Factory()->NewTexClient(sharedSurface->GetSize());
+        if (!dest) {
+            return nullptr;
+        }
+        gl::SharedSurface* destSurf = dest->Surf();
+        destSurf->ProducerAcquire();
+        SharedSurface::ProdCopy(sharedSurface->Surf(), dest->Surf(),
+                                screen->Factory());
+        destSurf->ProducerRelease();
+
+        return dest.forget();
+    }
+
+  return sharedSurface.forget();
+}
+
+bool
+WebGLContext::StartVRPresentation()
+{
+    VRManagerChild* vrmc = VRManagerChild::Get();
+    if (!vrmc) {
+        return false;
+    }
+    gl::GLScreenBuffer* screen = gl->Screen();
+    if (!screen) {
+        return false;
+    }
+    gl::SurfaceCaps caps = screen->mCaps;
+
+    UniquePtr<gl::SurfaceFactory> factory =
+        gl::GLScreenBuffer::CreateFactory(gl,
+            caps,
+            vrmc,
+            vrmc->GetBackendType(),
+            TextureFlags::ORIGIN_BOTTOM_LEFT);
+
+    if (factory) {
+        screen->Morph(Move(factory));
+    }
+    return true;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+static inline size_t
+SizeOfViewElem(const dom::ArrayBufferView& view)
+{
+    const auto& elemType = view.Type();
+    if (elemType == js::Scalar::MaxTypedArrayViewType) // DataViews.
+        return 1;
+
+    return js::Scalar::byteSize(elemType);
+}
+
+bool
+WebGLContext::ValidateArrayBufferView(const char* funcName,
+                                      const dom::ArrayBufferView& view, GLuint elemOffset,
+                                      GLuint elemCountOverride, uint8_t** const out_bytes,
+                                      size_t* const out_byteLen)
+{
+    view.ComputeLengthAndData();
+    uint8_t* const bytes = view.DataAllowShared();
+    const size_t byteLen = view.LengthAllowShared();
+
+    const auto& elemSize = SizeOfViewElem(view);
+
+    size_t elemCount = byteLen / elemSize;
+    if (elemOffset > elemCount) {
+        ErrorInvalidValue("%s: Invalid offset into ArrayBufferView.", funcName);
+        return false;
+    }
+    elemCount -= elemOffset;
+
+    if (elemCountOverride) {
+        if (elemCountOverride > elemCount) {
+            ErrorInvalidValue("%s: Invalid sub-length for ArrayBufferView.", funcName);
+            return false;
+        }
+        elemCount = elemCountOverride;
+    }
+
+    *out_bytes = bytes + (elemOffset * elemSize);
+    *out_byteLen = elemCount * elemSize;
+    return true;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// XPCOM goop
+
+void
+ImplCycleCollectionTraverse(nsCycleCollectionTraversalCallback& callback,
+                            const std::vector<IndexedBufferBinding>& field,
+                            const char* name, uint32_t flags)
+{
+    for (const auto& cur : field) {
+        ImplCycleCollectionTraverse(callback, cur.mBufferBinding, name, flags);
+    }
+}
+
+void
+ImplCycleCollectionUnlink(std::vector<IndexedBufferBinding>& field)
+{
+    field.clear();
+}
+
+////
+
+NS_IMPL_CYCLE_COLLECTING_ADDREF(WebGLContext)
+NS_IMPL_CYCLE_COLLECTING_RELEASE(WebGLContext)
+
+NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(WebGLContext,
+  mCanvasElement,
+  mOffscreenCanvas,
+  mExtensions,
+  mBound2DTextures,
+  mBoundCubeMapTextures,
+  mBound3DTextures,
+  mBound2DArrayTextures,
+  mBoundSamplers,
+  mBoundArrayBuffer,
+  mBoundCopyReadBuffer,
+  mBoundCopyWriteBuffer,
+  mBoundPixelPackBuffer,
+  mBoundPixelUnpackBuffer,
+  mBoundTransformFeedback,
+  mBoundUniformBuffer,
+  mCurrentProgram,
+  mBoundDrawFramebuffer,
+  mBoundReadFramebuffer,
+  mBoundRenderbuffer,
+  mBoundVertexArray,
+  mDefaultVertexArray,
+  mQuerySlot_SamplesPassed,
+  mQuerySlot_TFPrimsWritten,
+  mQuerySlot_TimeElapsed)
+
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(WebGLContext)
+    NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
+    NS_INTERFACE_MAP_ENTRY(nsIDOMWebGLRenderingContext)
+    NS_INTERFACE_MAP_ENTRY(nsICanvasRenderingContextInternal)
+    NS_INTERFACE_MAP_ENTRY(nsISupportsWeakReference)
+    // If the exact way we cast to nsISupports here ever changes, fix our
+    // ToSupports() method.
+    NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIDOMWebGLRenderingContext)
+NS_INTERFACE_MAP_END
+
+} // namespace mozilla