The Tor Browser: gfx/gl/GLContextProviderCGL.mm@129ffea94266 (annotated)

gfx/gl/GLContextProviderCGL.mm@129ffea94266 (annotated)

gfx/gl/GLContextProviderCGL.mm

Sat, 03 Jan 2015 20:18:00 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Sat, 03 Jan 2015 20:18:00 +0100
branch: TOR_BUG_3246
changeset 7: 129ffea94266
permissions: -rw-r--r--

Conditionally enable double key logic according to:
private browsing mode or privacy.thirdparty.isolate preference and
implement in GetCookieStringCommon and FindCookie where it counts...
With some reservations of how to convince FindCookie users to test
condition and pass a nullptr when disabling double key logic.

 /* -*- 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,
 
             };
             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 */

The Tor Browser / annotate

gfx/gl/GLContextProviderCGL.mm@129ffea94266 (annotated)

gfx/gl/GLContextProviderCGL.mm