diff -r 000000000000 -r 6474c204b198 gfx/gl/GLContextProviderCGL.mm
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/gfx/gl/GLContextProviderCGL.mm	Wed Dec 31 06:09:35 2014 +0100
@@ -0,0 +1,296 @@
+/* -*- 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 "GLContextProvider.h"
+#include "GLContextCGL.h"
+#include "TextureImageCGL.h"
+#include "nsDebug.h"
+#include "nsIWidget.h"
+#include <OpenGL/gl.h>
+#include "gfxPrefs.h"
+#include "gfxFailure.h"
+#include "prenv.h"
+#include "mozilla/Preferences.h"
+#include "GeckoProfiler.h"
+#include "mozilla/gfx/MacIOSurface.h"
+
+using namespace mozilla::gfx;
+
+namespace mozilla {
+namespace gl {
+
+static bool gUseDoubleBufferedWindows = true;
+
+class CGLLibrary
+{
+public:
+    CGLLibrary()
+      : mInitialized(false),
+        mOGLLibrary(nullptr),
+        mPixelFormat(nullptr)
+    { }
+
+    bool EnsureInitialized()
+    {
+        if (mInitialized) {
+            return true;
+        }
+        if (!mOGLLibrary) {
+            mOGLLibrary = PR_LoadLibrary("/System/Library/Frameworks/OpenGL.framework/OpenGL");
+            if (!mOGLLibrary) {
+                NS_WARNING("Couldn't load OpenGL Framework.");
+                return false;
+            }
+        }
+
+        const char* db = PR_GetEnv("MOZ_CGL_DB");
+        gUseDoubleBufferedWindows = (!db || *db != '0');
+
+        mInitialized = true;
+        return true;
+    }
+
+    NSOpenGLPixelFormat *PixelFormat()
+    {
+        if (mPixelFormat == nullptr) {
+            NSOpenGLPixelFormatAttribute attribs[] = {
+                NSOpenGLPFAAccelerated,
+                NSOpenGLPFAAllowOfflineRenderers,
+                NSOpenGLPFADoubleBuffer,
+                0
+            };
+
+            if (!gUseDoubleBufferedWindows) {
+              attribs[2] = 0;
+            }
+
+            mPixelFormat = [[NSOpenGLPixelFormat alloc] initWithAttributes:attribs];
+        }
+
+        return mPixelFormat;
+    }
+private:
+    bool mInitialized;
+    PRLibrary *mOGLLibrary;
+    NSOpenGLPixelFormat *mPixelFormat;
+};
+
+CGLLibrary sCGLLibrary;
+
+GLContextCGL::GLContextCGL(
+                  const SurfaceCaps& caps,
+                  GLContext *shareContext,
+                  NSOpenGLContext *context,
+                  bool isOffscreen)
+    : GLContext(caps, shareContext, isOffscreen),
+      mContext(context)
+{
+    SetProfileVersion(ContextProfile::OpenGLCompatibility, 210);
+}
+
+GLContextCGL::~GLContextCGL()
+{
+    MarkDestroyed();
+
+    if (mContext) {
+        if ([NSOpenGLContext currentContext] == mContext) {
+            // Clear the current context before releasing. If we don't do
+            // this, the next time we call [NSOpenGLContext currentContext],
+            // "invalid context" will be printed to the console.
+            [NSOpenGLContext clearCurrentContext];
+        }
+        [mContext release];
+    }
+
+}
+
+bool
+GLContextCGL::Init()
+{
+    if (!InitWithPrefix("gl", true))
+        return false;
+
+    return true;
+}
+
+CGLContextObj
+GLContextCGL::GetCGLContext() const
+{
+    return static_cast<CGLContextObj>([mContext CGLContextObj]);
+}
+
+bool
+GLContextCGL::MakeCurrentImpl(bool aForce)
+{
+    if (!aForce && [NSOpenGLContext currentContext] == mContext) {
+        return true;
+    }
+
+    if (mContext) {
+        [mContext makeCurrentContext];
+        // Use non-blocking swap in "ASAP mode".
+        // ASAP mode means that rendering is iterated as fast as possible.
+        // ASAP mode is entered when layout.frame_rate=0 (requires restart).
+        // If swapInt is 1, then glSwapBuffers will block and wait for a vblank signal.
+        // When we're iterating as fast as possible, however, we want a non-blocking
+        // glSwapBuffers, which will happen when swapInt==0.
+        GLint swapInt = gfxPrefs::LayoutFrameRate() == 0 ? 0 : 1;
+        [mContext setValues:&swapInt forParameter:NSOpenGLCPSwapInterval];
+    }
+    return true;
+}
+
+bool
+GLContextCGL::IsCurrent() {
+    return [NSOpenGLContext currentContext] == mContext;
+}
+
+GLenum
+GLContextCGL::GetPreferredARGB32Format() const
+{
+    return LOCAL_GL_BGRA;
+}
+
+bool
+GLContextCGL::SetupLookupFunction()
+{
+    return false;
+}
+
+bool
+GLContextCGL::IsDoubleBuffered() const
+{
+  return gUseDoubleBufferedWindows;
+}
+
+bool
+GLContextCGL::SupportsRobustness() const
+{
+    return false;
+}
+
+bool
+GLContextCGL::SwapBuffers()
+{
+  PROFILER_LABEL("GLContext", "SwapBuffers");
+  [mContext flushBuffer];
+  return true;
+}
+
+
+static GLContextCGL *
+GetGlobalContextCGL()
+{
+    return static_cast<GLContextCGL*>(GLContextProviderCGL::GetGlobalContext());
+}
+
+already_AddRefed<GLContext>
+GLContextProviderCGL::CreateWrappingExisting(void*, void*)
+{
+    return nullptr;
+}
+
+already_AddRefed<GLContext>
+GLContextProviderCGL::CreateForWindow(nsIWidget *aWidget)
+{
+    GLContextCGL *shareContext = GetGlobalContextCGL();
+
+    NSOpenGLContext *context = [[NSOpenGLContext alloc]
+                                initWithFormat:sCGLLibrary.PixelFormat()
+                                shareContext:(shareContext ? shareContext->mContext : NULL)];
+    if (!context) {
+        return nullptr;
+    }
+
+    // make the context transparent
+    GLint opaque = 0;
+    [context setValues:&opaque forParameter:NSOpenGLCPSurfaceOpacity];
+
+    SurfaceCaps caps = SurfaceCaps::ForRGBA();
+    nsRefPtr<GLContextCGL> glContext = new GLContextCGL(caps,
+                                                        shareContext,
+                                                        context);
+    if (!glContext->Init()) {
+        return nullptr;
+    }
+
+    return glContext.forget();
+}
+
+static already_AddRefed<GLContextCGL>
+CreateOffscreenFBOContext(bool aShare = true)
+{
+    if (!sCGLLibrary.EnsureInitialized()) {
+        return nullptr;
+    }
+
+    GLContextCGL *shareContext = aShare ? GetGlobalContextCGL() : nullptr;
+    if (aShare && !shareContext) {
+        // if there is no share context, then we can't use FBOs.
+        return nullptr;
+    }
+
+    NSOpenGLContext *context = [[NSOpenGLContext alloc]
+                                initWithFormat:sCGLLibrary.PixelFormat()
+                                shareContext:shareContext ? shareContext->GetNSOpenGLContext() : NULL];
+    if (!context) {
+        return nullptr;
+    }
+
+    SurfaceCaps dummyCaps = SurfaceCaps::Any();
+    nsRefPtr<GLContextCGL> glContext = new GLContextCGL(dummyCaps, shareContext, context, true);
+
+    return glContext.forget();
+}
+
+already_AddRefed<GLContext>
+GLContextProviderCGL::CreateOffscreen(const gfxIntSize& size,
+                                      const SurfaceCaps& caps)
+{
+    nsRefPtr<GLContextCGL> glContext = CreateOffscreenFBOContext();
+    if (glContext &&
+        glContext->Init() &&
+        glContext->InitOffscreen(ToIntSize(size), caps))
+    {
+        return glContext.forget();
+    }
+
+    // everything failed
+    return nullptr;
+}
+
+static nsRefPtr<GLContext> gGlobalContext;
+
+GLContext *
+GLContextProviderCGL::GetGlobalContext()
+{
+    if (!sCGLLibrary.EnsureInitialized()) {
+        return nullptr;
+    }
+
+    if (!gGlobalContext) {
+        // There are bugs in some older drivers with pbuffers less
+        // than 16x16 in size; also 16x16 is POT so that we can do
+        // a FBO with it on older video cards.  A FBO context for
+        // sharing is preferred since it has no associated target.
+        gGlobalContext = CreateOffscreenFBOContext(false);
+        if (!gGlobalContext || !static_cast<GLContextCGL*>(gGlobalContext.get())->Init()) {
+            NS_WARNING("Couldn't init gGlobalContext.");
+            gGlobalContext = nullptr;
+            return nullptr;
+        }
+    }
+
+    return gGlobalContext;
+}
+
+void
+GLContextProviderCGL::Shutdown()
+{
+  gGlobalContext = nullptr;
+}
+
+} /* namespace gl */
+} /* namespace mozilla */