The Tor Browser: gfx/angle/src/libGLESv2/renderer/Renderer.cpp@129ffea94266 (annotated)

gfx/angle/src/libGLESv2/renderer/Renderer.cpp@129ffea94266 (annotated)

gfx/angle/src/libGLESv2/renderer/Renderer.cpp

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.

 #include "precompiled.h"
 //
 // Copyright (c) 2012-2013 The ANGLE Project Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 //
 // Renderer.cpp: Implements EGL dependencies for creating and destroying Renderer instances.
 #include <EGL/eglext.h>
 #include "libGLESv2/main.h"
 #include "libGLESv2/Program.h"
 #include "libGLESv2/renderer/Renderer.h"
 #include "libGLESv2/renderer/Renderer9.h"
 #include "libGLESv2/renderer/Renderer11.h"
 #include "libGLESv2/utilities.h"
 #if !defined(ANGLE_ENABLE_D3D11)
 // Enables use of the Direct3D 11 API for a default display, when available
 #define ANGLE_ENABLE_D3D11 0
 #endif
 #define ANGLE_PRELOADED_D3DCOMPILER_MODULE_NAMES \
     {                                            \
         TEXT("d3dcompiler_47.dll"),              \
         TEXT("d3dcompiler_46.dll"),              \
         TEXT("d3dcompiler_43.dll")               \
     }
 namespace rx
 {
 Renderer::Renderer(egl::Display *display) : mDisplay(display)
 {
     mD3dCompilerModule = NULL;
     mD3DCompileFunc = NULL;
 }
 Renderer::~Renderer()
 {
     if (mD3dCompilerModule)
     {
         FreeLibrary(mD3dCompilerModule);
         mD3dCompilerModule = NULL;
     }
 }
 bool Renderer::initializeCompiler()
 {
 #if defined(ANGLE_PRELOADED_D3DCOMPILER_MODULE_NAMES)
     // Find a D3DCompiler module that had already been loaded based on a predefined list of versions.
     static TCHAR* d3dCompilerNames[] = ANGLE_PRELOADED_D3DCOMPILER_MODULE_NAMES;
     for (size_t i = 0; i < ArraySize(d3dCompilerNames); ++i)
     {
         if (GetModuleHandleEx(0, d3dCompilerNames[i], &mD3dCompilerModule))
         {
             break;
         }
     }
 #else
     // Load the version of the D3DCompiler DLL associated with the Direct3D version ANGLE was built with.
     mD3dCompilerModule = LoadLibrary(D3DCOMPILER_DLL);
 #endif  // ANGLE_PRELOADED_D3DCOMPILER_MODULE_NAMES
     if (!mD3dCompilerModule)
     {
         ERR("No D3D compiler module found - aborting!\n");
         return false;
     }
     mD3DCompileFunc = reinterpret_cast<pCompileFunc>(GetProcAddress(mD3dCompilerModule, "D3DCompile"));
     ASSERT(mD3DCompileFunc);
     return mD3DCompileFunc != NULL;
 }
 // Compiles HLSL code into executable binaries
 ShaderBlob *Renderer::compileToBinary(gl::InfoLog &infoLog, const char *hlsl, const char *profile, UINT optimizationFlags, bool alternateFlags)
 {
     if (!hlsl)
     {
         return NULL;
     }
     HRESULT result = S_OK;
     UINT flags = 0;
     std::string sourceText;
     if (gl::perfActive())
     {
         flags |= D3DCOMPILE_DEBUG;
 #ifdef NDEBUG
         flags |= optimizationFlags;
 #else
         flags |= D3DCOMPILE_SKIP_OPTIMIZATION;
 #endif
         std::string sourcePath = getTempPath();
         sourceText = std::string("#line 2 \"") + sourcePath + std::string("\"\n\n") + std::string(hlsl);
         writeFile(sourcePath.c_str(), sourceText.c_str(), sourceText.size());
     }
     else
     {
         flags |= optimizationFlags;
         sourceText = hlsl;
     }
     // Sometimes D3DCompile will fail with the default compilation flags for complicated shaders when it would otherwise pass with alternative options.
     // Try the default flags first and if compilation fails, try some alternatives.
     const static UINT extraFlags[] =
     {
 ,
         D3DCOMPILE_AVOID_FLOW_CONTROL,
         D3DCOMPILE_PREFER_FLOW_CONTROL
     };
     const static char * const extraFlagNames[] =
     {
         "default",
         "avoid flow control",
         "prefer flow control"
     };
     int attempts = alternateFlags ? ArraySize(extraFlags) : 1;
     pD3DCompile compileFunc = reinterpret_cast<pD3DCompile>(mD3DCompileFunc);
     for (int i = 0; i < attempts; ++i)
     {
         ID3DBlob *errorMessage = NULL;
         ID3DBlob *binary = NULL;
         result = compileFunc(hlsl, strlen(hlsl), gl::g_fakepath, NULL, NULL,
                              "main", profile, flags | extraFlags[i], 0, &binary, &errorMessage);
         if (errorMessage)
         {
             const char *message = (const char*)errorMessage->GetBufferPointer();
             infoLog.appendSanitized(message);
             TRACE("\n%s", hlsl);
             TRACE("\n%s", message);
             errorMessage->Release();
             errorMessage = NULL;
         }
         if (SUCCEEDED(result))
         {
             return (ShaderBlob*)binary;
         }
         else
         {
             if (result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY)
             {
                 return gl::error(GL_OUT_OF_MEMORY, (ShaderBlob*) NULL);
             }
             infoLog.append("Warning: D3D shader compilation failed with ");
             infoLog.append(extraFlagNames[i]);
             infoLog.append(" flags.");
             if (i + 1 < attempts)
             {
                 infoLog.append(" Retrying with ");
                 infoLog.append(extraFlagNames[i + 1]);
                 infoLog.append(".\n");
             }
         }
     }
     return NULL;
 }
 }
 extern "C"
 {
 rx::Renderer *glCreateRenderer(egl::Display *display, HDC hDc, EGLNativeDisplayType displayId)
 {
     rx::Renderer *renderer = NULL;
     EGLint status = EGL_BAD_ALLOC;
     if (ANGLE_ENABLE_D3D11 ||
         displayId == EGL_D3D11_ELSE_D3D9_DISPLAY_ANGLE ||
         displayId == EGL_D3D11_ONLY_DISPLAY_ANGLE)
     {
         renderer = new rx::Renderer11(display, hDc);
         if (renderer)
         {
             status = renderer->initialize();
         }
         if (status == EGL_SUCCESS)
         {
             return renderer;
         }
         else if (displayId == EGL_D3D11_ONLY_DISPLAY_ANGLE)
         {
             return NULL;
         }
         // Failed to create a D3D11 renderer, try creating a D3D9 renderer
         delete renderer;
     }
     bool softwareDevice = (displayId == EGL_SOFTWARE_DISPLAY_ANGLE);
     renderer = new rx::Renderer9(display, hDc, softwareDevice);
     if (renderer)
     {
         status = renderer->initialize();
     }
     if (status == EGL_SUCCESS)
     {
         return renderer;
     }
     return NULL;
 }
 void glDestroyRenderer(rx::Renderer *renderer)
 {
     delete renderer;
 }
 }

The Tor Browser / annotate

gfx/angle/src/libGLESv2/renderer/Renderer.cpp@129ffea94266 (annotated)

gfx/angle/src/libGLESv2/renderer/Renderer.cpp