1 files changed, 35 insertions, 168 deletions

diff --git a/chromium/third_party/angle/src/libGLESv2/renderer/Renderer.cpp b/chromium/third_party/angle/src/libGLESv2/renderer/Renderer.cpp
index e0b3abcf879..92594a4d566 100644
--- a/chromium/third_party/angle/src/libGLESv2/renderer/Renderer.cpp
+++ b/chromium/third_party/angle/src/libGLESv2/renderer/Renderer.cpp
@@ -11,14 +11,21 @@
 #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"
+#include "common/utilities.h"
 #include "third_party/trace_event/trace_event.h"
+#include "libGLESv2/Shader.h"
 
-#if !defined(ANGLE_ENABLE_D3D11)
+#if defined (ANGLE_ENABLE_D3D9)
+#include "libGLESv2/renderer/d3d9/Renderer9.h"
+#endif // ANGLE_ENABLE_D3D9
+
+#if defined (ANGLE_ENABLE_D3D11)
+#include "libGLESv2/renderer/d3d11/Renderer11.h"
+#endif // ANGLE_ENABLE_D3D11
+
+#if !defined(ANGLE_DEFAULT_D3D11)
 // Enables use of the Direct3D 11 API for a default display, when available
-#define ANGLE_ENABLE_D3D11 0
+#define ANGLE_DEFAULT_D3D11 0
 #endif
 
 namespace rx
@@ -26,145 +33,12 @@ namespace rx
 
 Renderer::Renderer(egl::Display *display) : mDisplay(display)
 {
-    mD3dCompilerModule = NULL;
-    mD3DCompileFunc = NULL;
+    mCurrentClientVersion = 2;
 }
 
 Renderer::~Renderer()
 {
-    if (mD3dCompilerModule)
-    {
-        FreeLibrary(mD3dCompilerModule);
-        mD3dCompilerModule = NULL;
-    }
-}
-
-bool Renderer::initializeCompiler()
-{
-    TRACE_EVENT0("gpu", "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;
-        }
-    }
-#endif  // ANGLE_PRELOADED_D3DCOMPILER_MODULE_NAMES
-
-    if (!mD3dCompilerModule)
-    {
-        // Load the version of the D3DCompiler DLL associated with the Direct3D version ANGLE was built with.
-        mD3dCompilerModule = LoadLibrary(D3DCOMPILER_DLL);
-    }
-
-    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[] =
-    {
-        0,
-        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;
+    gl::Shader::releaseCompiler();
 }
 
 }
@@ -174,45 +48,38 @@ 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 ||
+#if defined(ANGLE_ENABLE_D3D11)
+    if (ANGLE_DEFAULT_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)
+        rx::Renderer11 *renderer = new rx::Renderer11(display, hDc);
+        if (renderer->initialize() == EGL_SUCCESS)
         {
             return renderer;
         }
-        else if (displayId == EGL_D3D11_ONLY_DISPLAY_ANGLE)
+        else
         {
-            return NULL;
+            // Failed to create a D3D11 renderer, try D3D9
+            SafeDelete(renderer);
         }
-
-        // 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();
     }
+#endif
 
-    if (status == EGL_SUCCESS)
+#if defined(ANGLE_ENABLE_D3D9)
+    if (displayId != EGL_D3D11_ONLY_DISPLAY_ANGLE)
     {
-        return renderer;
+        rx::Renderer9 *renderer = new rx::Renderer9(display, hDc);
+        if (renderer->initialize() == EGL_SUCCESS)
+        {
+            return renderer;
+        }
+        else
+        {
+            SafeDelete(renderer);
+        }
     }
+#endif
 
     return NULL;
 }
@@ -222,4 +89,4 @@ void glDestroyRenderer(rx::Renderer *renderer)
     delete renderer;
 }
 
-}
\ No newline at end of file
+}