Merge lp:~kdub/mir/gl-program-creation-factory into lp:mir

[Kevin DuBois]

Add a factory that is capable of compiling a vertex shader and a fragment shader into a gl program.

I am doing this so that the android platform can create a gl program that it can use when the overlays fail. I don't intend to expose this program in the platform-independent code, that will continue to use GLRenderer.

A few things were weighed (do we /really/ need another factory?)...

1) calls relating to gl program/shader creation should be serialized which points to a common factory.
2) the GLRendererFactory is a class that is overridable by the user. (see the demo-shell). I didn't want to extend the GLRendererFactory to have a method for creating a separate android-only specific renderer. It seemed better to have a generic factory for making any gl program, and have GLRendererFactory and GLRenderer use that generic factory to accomplish its goals

Add a factory that is capable of compiling a vertex shader and a fragment shader into a gl program.

I am doing this so that the android platform can create a gl program that it can use when the overlays fail. I don't intend to expose this program in the platform-independent code, that will continue to use GLRenderer.

A few things were weighed (do we /really/ need another factory?)...

1) calls relating to gl program/shader creation should be serialized which points to a common factory.
2) the GLRendererFactory is a class that is overridable by the user. (see the demo-shell). I didn't want to extend the GLRendererFactory to have a method for creating a separate android-only specific renderer. It seemed better to have a generic factory for making any gl program, and have GLRendererFactory and GLRenderer use that generic factory to accomplish its goals

note 1:
I also made an attempt to split out testing the gl program setup from the GLRenderer use cases. This one of the oldest tests (and... a mess by 'modern' mir test standards), so it has some cruft that could still use some attention. We'll probably have to continue to improve this test in smaller steps in subsequent MPs.

note 2:
If HWC rejects a surface, we are expected to draw that surface with OpenGLES. We should be doing this in the android platform, so the platform-independent code doesn't have to deal with this.

note 3: (future planning)
I plan on giving the GLProgramFactory down to the android platform so it can make its own HWC gl program.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:1571
http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-ci/1359/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-android-trusty-i386-build/1651/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-clang-trusty-amd64-build/1649/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-trusty-touch/1224/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-trusty-amd64-ci/1091/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-trusty-armhf-ci/1096/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-trusty-armhf/1225/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/mir-team-mir-development-branch-ci/1359/rebuild

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:1572
http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-ci/1361/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-trusty-i386-build/1653
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-trusty-amd64-build/1651
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-trusty-touch/1226
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-trusty-amd64-ci/1093
        deb: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-trusty-amd64-ci/1093/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-trusty-armhf-ci/1098
        deb: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-trusty-armhf-ci/1098/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-trusty-armhf/1227
        deb: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-trusty-armhf/1227/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-runner-mako/1134
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/touch-flash-device/6187

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/mir-team-mir-development-branch-ci/1361/rebuild

review: Approve (continuous-integration)

[Robert Carr (robertcarr)]

>> 557 + /*
>> 558 + * We need to serialize renderer creation because some GL calls used
>> 559 + * during renderer construction that create unique resource ids
>> 560 + * (e.g. glCreateProgram) are not thread-safe when the threads are
>> 561 + * have the same or shared EGL contexts.
>> 562 + */

Can you explain the synchronization requirements a little here? I got a little confused...it seems like this isn't sufficient.

If this can be called from multiple threads then something has to ensure the eglMakeCurrent is called from the right threads (and held for the duration of GL usage), right? So if something is doing this then the lock guard is not necessary, if nothing else is handling it then its not quite enough....

review: Needs Information

[Kevin DuBois (kdub)]

> >> 557 + /*
> >> 558 + * We need to serialize renderer creation because some GL calls used
> >> 559 + * during renderer construction that create unique resource ids
> >> 560 + * (e.g. glCreateProgram) are not thread-safe when the threads are
> >> 561 + * have the same or shared EGL contexts.
> >> 562 + */
>
> Can you explain the synchronization requirements a little here? I got a little
> confused...it seems like this isn't sufficient.
>
> If this can be called from multiple threads then something has to ensure the
> eglMakeCurrent is called from the right threads (and held for the duration of
> GL usage), right? So if something is doing this then the lock guard is not
> necessary, if nothing else is handling it then its not quite enough....

I would agree that our handling of the context doesn't really model the requirements of using gl contexts and could be improved. (but I'm not looking to improve that in this MP) I'm trying to preserve the guards that are in place so android can make a shader program in addition to the default compositor.

I suppose this guard is fulfilling:
http://www.khronos.org/opengles/sdk/docs/man/xhtml/glCreateShader.xml
"Applications are responsible for providing the synchronization across API calls when objects are accessed from different execution threads."

[Alexandros Frantzis (afrantzis)]

> If this can be called from multiple threads then something has to ensure the eglMakeCurrent
> is called from the right threads (and held for the duration of GL usage), right? So if
> something is doing this then the lock guard is not necessary, if nothing else is handling
> it then its not quite enough....

Not sure I follow, but let me try to explain the reason we need this. If two GL contexts are shared then objects in them live in the same "namespace". Creation of objects in this shared namespace is not thread-safe. So, imagine:

C1: EGL context 1
C2: EGL context 2 shared with context 1

T1: MakeCurrent(C1)
T2: MakeCurrent(C2)

Now if T1 and T2 run concurrently and call glCreateProgram() we have a potential race. What happened in our case was that both T1:glCreateProgram() and T2:glCreateProgram() occasionally returned the same program id, messing things up.

[Alexandros Frantzis (afrantzis)]

100 + GLProgramFactory() {};

= default;

review: Needs Fixing

[Alexandros Frantzis (afrantzis)]

> 100 + GLProgramFactory() {};
> = default;

Looks good otherwise, so pre-approving to unblock.

review: Approve

[Kevin DuBois (kdub)]

> > 100 + GLProgramFactory() {};
> > = default;
>
> Looks good otherwise, so pre-approving to unblock.

thanks! working on change now

[Alberto Aguirre (albaguirre)]

489 + * Copyright © 2013 Canonical Ltd.
525 + * Copyright © 2012 Canonical Ltd.

Wrong year?

review: Approve

[Kevin DuBois (kdub)]

> 489 + * Copyright © 2013 Canonical Ltd.
> 525 + * Copyright © 2012 Canonical Ltd.
>
> Wrong year?

Indeed, fixed!

=== modified file 'examples/demo-shell/demo_renderer.cpp'
--- examples/demo-shell/demo_renderer.cpp	2014-04-15 05:31:19 +0000
+++ examples/demo-shell/demo_renderer.cpp	2014-04-22 16:51:34 +0000
@@ -134,8 +134,10 @@
 
 } // namespace
 
-DemoRenderer::DemoRenderer(geometry::Rectangle const& display_area)
-    : GLRenderer(display_area)
+DemoRenderer::DemoRenderer(
+    graphics::GLProgramFactory const& program_factory,
+    geometry::Rectangle const& display_area)
+    : GLRenderer(program_factory, display_area)
     , corner_radius(0.5f)
 {
     shadow_corner_tex = generate_shadow_corner_texture(0.4f);

=== modified file 'examples/demo-shell/demo_renderer.h'
--- examples/demo-shell/demo_renderer.h	2014-04-15 05:31:19 +0000
+++ examples/demo-shell/demo_renderer.h	2014-04-22 16:51:34 +0000
@@ -29,7 +29,7 @@
 class DemoRenderer : public compositor::GLRenderer
 {
 public:
-    DemoRenderer(geometry::Rectangle const& display_area);
+    DemoRenderer(graphics::GLProgramFactory const& factory, geometry::Rectangle const& display_area);
     ~DemoRenderer();
 
     void begin() const override;

=== modified file 'examples/demo-shell/demo_shell.cpp'
--- examples/demo-shell/demo_shell.cpp	2014-04-15 05:31:19 +0000
+++ examples/demo-shell/demo_shell.cpp	2014-04-22 16:51:34 +0000
@@ -47,11 +47,18 @@
 class DemoRendererFactory : public compositor::RendererFactory
 {
 public:
+    DemoRendererFactory(std::shared_ptr<graphics::GLProgramFactory> const& gl_program_factory) :
+        gl_program_factory(gl_program_factory)
+    {
+    }
+
     std::unique_ptr<compositor::Renderer> create_renderer_for(
         geometry::Rectangle const& rect) override
     {
-        return std::unique_ptr<compositor::Renderer>(new DemoRenderer(rect));
+        return std::unique_ptr<compositor::Renderer>(new DemoRenderer(*gl_program_factory, rect));
     }
+private:
+    std::shared_ptr<graphics::GLProgramFactory> const gl_program_factory;
 };
 
 class DemoServerConfiguration : public mir::examples::ServerConfiguration
@@ -97,7 +104,7 @@
 
     std::shared_ptr<compositor::RendererFactory> the_renderer_factory() override
     {
-        return std::make_shared<DemoRendererFactory>();
+        return std::make_shared<DemoRendererFactory>(the_gl_program_factory());
     }
 
 private:

=== added file 'include/platform/mir/graphics/gl_program_factory.h'
--- include/platform/mir/graphics/gl_program_factory.h	1970-01-01 00:00:00 +0000
+++ include/platform/mir/graphics/gl_program_factory.h	2014-04-22 16:51:34 +0000
@@ -0,0 +1,50 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Kevin DuBois <[e-mail]>
+ */
+
+#ifndef MIR_COMPOSITOR_GL_PROGRAM_FACTORY_H_
+#define MIR_COMPOSITOR_GL_PROGRAM_FACTORY_H_
+
+#include "mir/graphics/gl_program.h"
+#include <memory>
+
+namespace mir
+{
+namespace graphics
+{
+
+class GLProgramFactory
+{
+public:
+    virtual ~GLProgramFactory() = default;
+
+    virtual std::unique_ptr<GLProgram>
+        create_gl_program(std::string const&, std::string const&) const = 0;
+
+protected:
+    GLProgramFactory() = default;
+
+private:
+    GLProgramFactory(GLProgramFactory const&) = delete;
+    GLProgramFactory& operator=(GLProgramFactory const&) = delete;
+
+};
+
+}
+}
+
+#endif /* MIR_COMPOSITOR_GL_PROGRAM_FACTORY_H_ */

=== modified file 'include/server/mir/compositor/gl_renderer.h'
--- include/server/mir/compositor/gl_renderer.h	2014-04-17 03:56:51 +0000
+++ include/server/mir/compositor/gl_renderer.h	2014-04-22 16:51:34 +0000
@@ -20,10 +20,11 @@
 #define MIR_COMPOSITOR_GL_RENDERER_H_
 
 #include <mir/compositor/renderer.h>
-#include <mir/compositor/gl_program.h>
+#include <mir/graphics/gl_program.h>
 #include <mir/geometry/rectangle.h>
 #include <mir/graphics/buffer_id.h>
 #include <mir/graphics/renderable.h>
+#include <mir/graphics/gl_program_factory.h>
 #include <GLES2/gl2.h>
 #include <unordered_map>
 #include <unordered_set>
@@ -37,7 +38,9 @@
 class GLRenderer : public Renderer
 {
 public:
-    GLRenderer(geometry::Rectangle const& display_area);
+    GLRenderer(
+        graphics::GLProgramFactory const& program_factory,
+        geometry::Rectangle const& display_area);
     virtual ~GLRenderer() noexcept;
 
     // These are called with a valid GL context:
@@ -98,7 +101,7 @@
                                 graphics::Buffer& buffer) const;
 
 private:
-    GLProgram program;
+    std::unique_ptr<graphics::GLProgram> program;
     GLuint position_attr_loc;
     GLuint texcoord_attr_loc;
     GLuint centre_uniform_loc;

=== modified file 'include/server/mir/default_server_configuration.h'
--- include/server/mir/default_server_configuration.h	2014-04-15 05:31:19 +0000
+++ include/server/mir/default_server_configuration.h	2014-04-22 16:51:34 +0000
@@ -92,6 +92,7 @@
 class DisplayReport;
 class GraphicBufferAllocator;
 class GLConfig;
+class GLProgramFactory;
 namespace nested { class HostConnection; }
 }
 namespace input
@@ -247,6 +248,7 @@
 protected:
     std::shared_ptr<options::Option> the_options() const;
 
+    virtual std::shared_ptr<graphics::GLProgramFactory> the_gl_program_factory();
     virtual std::shared_ptr<input::InputChannelFactory> the_input_channel_factory();
     virtual std::shared_ptr<scene::MediatingDisplayChanger> the_mediating_display_changer();
     virtual std::shared_ptr<frontend::ProtobufIpcFactory> the_ipc_factory(
@@ -303,6 +305,7 @@
     CachedPtr<graphics::DisplayConfigurationPolicy> display_configuration_policy;
     CachedPtr<graphics::nested::HostConnection> host_connection;
     CachedPtr<scene::MediatingDisplayChanger> mediating_display_changer;
+    CachedPtr<graphics::GLProgramFactory> gl_program_factory;
     CachedPtr<graphics::GLConfig> gl_config;
 
 private:

=== renamed file 'include/server/mir/compositor/gl_program.h' => 'include/server/mir/graphics/gl_program.h'
--- include/server/mir/compositor/gl_program.h	2014-04-07 23:05:24 +0000
+++ include/server/mir/graphics/gl_program.h	2014-04-22 16:51:34 +0000
@@ -16,14 +16,14 @@
  * Authored by: Kevin DuBois <[e-mail]>
  */
 
-#ifndef MIR_COMPOSITOR_GL_PROGRAM_H_
-#define MIR_COMPOSITOR_GL_PROGRAM_H_
+#ifndef MIR_GRAPHICS_GL_PROGRAM_H_
+#define MIR_GRAPHICS_GL_PROGRAM_H_
 
 #include <GLES2/gl2.h>
 
 namespace mir
 {
-namespace compositor
+namespace graphics
 {
 
 class GLShader
@@ -62,4 +62,4 @@
 }
 }
 
-#endif /* MIR_COMPOSITOR_GL_PROGRAM_H_ */
+#endif /* MIR_GRAPHICS_GL_PROGRAM_H_ */

=== modified file 'src/server/compositor/CMakeLists.txt'
--- src/server/compositor/CMakeLists.txt	2014-04-16 21:26:27 +0000
+++ src/server/compositor/CMakeLists.txt	2014-04-22 16:51:34 +0000
@@ -6,7 +6,6 @@
   temporary_buffers.cpp
   buffer_stream_factory.cpp
   buffer_stream_surfaces.cpp
-  gl_program.cpp
   gl_renderer.cpp
   gl_renderer_factory.cpp
   multi_threaded_compositor.cpp

=== modified file 'src/server/compositor/default_configuration.cpp'
--- src/server/compositor/default_configuration.cpp	2014-03-07 03:15:55 +0000
+++ src/server/compositor/default_configuration.cpp	2014-04-22 16:51:34 +0000
@@ -72,9 +72,9 @@
 std::shared_ptr<mc::RendererFactory> mir::DefaultServerConfiguration::the_renderer_factory()
 {
     return renderer_factory(
-        []()
+        [this]()
         {
-            return std::make_shared<mc::GLRendererFactory>();
+            return std::make_shared<mc::GLRendererFactory>(the_gl_program_factory());
         });
 }
 

=== modified file 'src/server/compositor/gl_renderer.cpp'
--- src/server/compositor/gl_renderer.cpp	2014-04-17 03:56:51 +0000
+++ src/server/compositor/gl_renderer.cpp	2014-04-22 16:51:34 +0000
@@ -65,8 +65,10 @@
 };
 }
 
-mc::GLRenderer::GLRenderer(geom::Rectangle const& display_area)
-    : program(vertex_shader_src, fragment_shader_src),
+mc::GLRenderer::GLRenderer(
+    mg::GLProgramFactory const& program_factory,
+    geom::Rectangle const& display_area)
+    : program(program_factory.create_gl_program(vertex_shader_src, fragment_shader_src)),
       position_attr_loc(0),
       texcoord_attr_loc(0),
       centre_uniform_loc(0),
@@ -74,16 +76,16 @@
       alpha_uniform_loc(0),
       rotation(NAN) // ensure the first set_rotation succeeds
 {
-    glUseProgram(program);
+    glUseProgram(*program);
 
     /* Set up program variables */
-    GLint tex_loc = glGetUniformLocation(program, "tex");
-    display_transform_uniform_loc = glGetUniformLocation(program, "display_transform");
-    transform_uniform_loc = glGetUniformLocation(program, "transform");
-    alpha_uniform_loc = glGetUniformLocation(program, "alpha");
-    position_attr_loc = glGetAttribLocation(program, "position");
-    texcoord_attr_loc = glGetAttribLocation(program, "texcoord");
-    centre_uniform_loc = glGetUniformLocation(program, "centre");
+    GLint tex_loc = glGetUniformLocation(*program, "tex");
+    display_transform_uniform_loc = glGetUniformLocation(*program, "display_transform");
+    transform_uniform_loc = glGetUniformLocation(*program, "transform");
+    alpha_uniform_loc = glGetUniformLocation(*program, "alpha");
+    position_attr_loc = glGetAttribLocation(*program, "position");
+    texcoord_attr_loc = glGetAttribLocation(*program, "texcoord");
+    centre_uniform_loc = glGetUniformLocation(*program, "centre");
 
     glUniform1i(tex_loc, 0);
 
@@ -133,7 +135,7 @@
     auto buffer = renderable.buffer(this);
     saved_resources.insert(buffer);
 
-    glUseProgram(program);
+    glUseProgram(*program);
 
     if (renderable.shaped() || renderable.alpha() < 1.0f)
     {
@@ -252,8 +254,8 @@
                       -rect.top_left.y.as_float(),
                       0.0f});
 
-    glUseProgram(program);
-    GLint mat_loc = glGetUniformLocation(program, "screen_to_gl_coords");
+    glUseProgram(*program);
+    GLint mat_loc = glGetUniformLocation(*program, "screen_to_gl_coords");
     glUniformMatrix4fv(mat_loc, 1, GL_FALSE, glm::value_ptr(screen_to_gl_coords));
     glUseProgram(0);
 
@@ -272,7 +274,7 @@
                        -sin, cos,  0.0f, 0.0f,
                        0.0f, 0.0f, 1.0f, 0.0f,
                        0.0f, 0.0f, 0.0f, 1.0f};
-    glUseProgram(program);
+    glUseProgram(*program);
     glUniformMatrix4fv(display_transform_uniform_loc, 1, GL_FALSE, rot);
     glUseProgram(0);
 

=== modified file 'src/server/compositor/gl_renderer_factory.cpp'
--- src/server/compositor/gl_renderer_factory.cpp	2014-04-07 20:23:24 +0000
+++ src/server/compositor/gl_renderer_factory.cpp	2014-04-22 16:51:34 +0000
@@ -17,17 +17,22 @@
  */
 
 #include "gl_renderer_factory.h"
+#include "mir/compositor/gl_renderer.h"
+#include "mir/graphics/gl_program.h"
 #include "mir/geometry/rectangle.h"
-#include "mir/compositor/gl_renderer.h"
 
+namespace mg = mir::graphics;
 namespace mc = mir::compositor;
 namespace geom = mir::geometry;
 
+mc::GLRendererFactory::GLRendererFactory(std::shared_ptr<mg::GLProgramFactory> const& factory) :
+    program_factory(factory)
+{
+}
+
 std::unique_ptr<mc::Renderer>
 mc::GLRendererFactory::create_renderer_for(geom::Rectangle const& rect)
 {
-    std::lock_guard<std::mutex> lock(mutex);
-
-    auto raw = new GLRenderer(rect);
+    auto raw = new GLRenderer(*program_factory, rect);
     return std::unique_ptr<mc::Renderer>(raw);
 }

=== modified file 'src/server/compositor/gl_renderer_factory.h'
--- src/server/compositor/gl_renderer_factory.h	2014-04-07 20:23:24 +0000
+++ src/server/compositor/gl_renderer_factory.h	2014-04-22 16:51:34 +0000
@@ -20,28 +20,24 @@
 #define MIR_COMPOSITOR_GL_RENDERER_FACTORY_H_
 
 #include "mir/compositor/renderer_factory.h"
-#include <mutex>
 
 namespace mir
 {
+namespace graphics
+{
+class GLProgramFactory;
+}
 namespace compositor
 {
 
 class GLRendererFactory : public RendererFactory
 {
 public:
+    GLRendererFactory(std::shared_ptr<graphics::GLProgramFactory> const& factory);
     std::unique_ptr<Renderer> create_renderer_for(geometry::Rectangle const& rect);
-
 private:
-    /*
-     * We need to serialize renderer creation because some GL calls used
-     * during renderer construction that create unique resource ids
-     * (e.g. glCreateProgram) are not thread-safe when the threads are
-     * have the same or shared EGL contexts.
-     */
-    std::mutex mutex;
+    std::shared_ptr<graphics::GLProgramFactory> const program_factory;
 };
-
 }
 }
 

=== modified file 'src/server/graphics/CMakeLists.txt'
--- src/server/graphics/CMakeLists.txt	2014-03-12 02:46:58 +0000
+++ src/server/graphics/CMakeLists.txt	2014-04-22 16:51:34 +0000
@@ -6,6 +6,8 @@
   default_configuration.cpp
   default_display_configuration_policy.cpp
   gl_extensions_base.cpp
+  gl_program.cpp
+  program_factory.cpp
   surfaceless_egl_context.cpp
 )
 

=== modified file 'src/server/graphics/default_configuration.cpp'
--- src/server/graphics/default_configuration.cpp	2014-03-27 09:52:04 +0000
+++ src/server/graphics/default_configuration.cpp	2014-04-22 16:51:34 +0000
@@ -27,6 +27,7 @@
 
 #include "mir/graphics/buffer_initializer.h"
 #include "mir/graphics/gl_config.h"
+#include "program_factory.h"
 
 #include "mir/shared_library.h"
 #include "mir/shared_library_loader.h"
@@ -165,3 +166,13 @@
             return std::make_shared<NoGLConfig>();
         });
 }
+
+std::shared_ptr<mg::GLProgramFactory>
+mir::DefaultServerConfiguration::the_gl_program_factory()
+{
+    return gl_program_factory(
+        [this]
+        {
+            return std::make_shared<mg::ProgramFactory>();
+        });
+}

=== renamed file 'src/server/compositor/gl_program.cpp' => 'src/server/graphics/gl_program.cpp'
--- src/server/compositor/gl_program.cpp	2014-04-07 21:21:09 +0000
+++ src/server/graphics/gl_program.cpp	2014-04-22 16:51:34 +0000
@@ -16,11 +16,11 @@
  * Authored by: Kevin DuBois <[e-mail]>
  */
 
-#include "mir/compositor/gl_program.h"
+#include "mir/graphics/gl_program.h"
 #include <boost/throw_exception.hpp>
 #include <stdexcept>
 
-namespace mc = mir::compositor;
+namespace mg = mir::graphics;
 
 namespace
 {
@@ -49,7 +49,7 @@
 }
 }
 
-mc::GLShader::GLShader(GLchar const* shader_src, GLuint type)
+mg::GLShader::GLShader(GLchar const* shader_src, GLuint type)
     : shader(glCreateShader(type))
 {
     GLint param{0};
@@ -66,17 +66,17 @@
     }
 }
 
-mc::GLShader::~GLShader()
+mg::GLShader::~GLShader()
 {
     glDeleteShader(shader);
 }
 
-mc::GLShader::operator GLuint() const
+mg::GLShader::operator GLuint() const
 {
     return shader;
 }
 
-mc::GLProgram::GLProgram(
+mg::GLProgram::GLProgram(
     GLchar const* vertex_shader_src,
     GLchar const* fragment_shader_src)
   : vertex_shader(vertex_shader_src, GL_VERTEX_SHADER),
@@ -98,12 +98,12 @@
     }
 }
 
-mc::GLProgram::~GLProgram()
+mg::GLProgram::~GLProgram()
 {
     glDeleteProgram(program);
 }
 
-mc::GLProgram::operator GLuint() const
+mg::GLProgram::operator GLuint() const
 {
     return program;
 }

=== added file 'src/server/graphics/program_factory.cpp'
--- src/server/graphics/program_factory.cpp	1970-01-01 00:00:00 +0000
+++ src/server/graphics/program_factory.cpp	2014-04-22 16:51:34 +0000
@@ -0,0 +1,32 @@
+
+/*
+ * Copyright © 2013 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Alexandros Frantzis <[e-mail]>
+ */
+
+#include "program_factory.h"
+#include "mir/graphics/gl_program.h"
+
+namespace mg = mir::graphics;
+
+std::unique_ptr<mg::GLProgram>
+mg::ProgramFactory::create_gl_program(
+    std::string const& vertex_shader,
+    std::string const& fragment_shader) const
+{
+    std::lock_guard<decltype(mutex)> lock(mutex);
+    return std::unique_ptr<mg::GLProgram>(new GLProgram(vertex_shader.c_str(), fragment_shader.c_str()));
+}

=== added file 'src/server/graphics/program_factory.h'
--- src/server/graphics/program_factory.h	1970-01-01 00:00:00 +0000
+++ src/server/graphics/program_factory.h	2014-04-22 16:51:34 +0000
@@ -0,0 +1,47 @@
+/*
+ * Copyright © 2012 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Alexandros Frantzis <[e-mail]>
+ */
+
+#ifndef MIR_GRAPHICS_GL_RENDERER_FACTORY_H_
+#define MIR_GRAPHICS_GL_RENDERER_FACTORY_H_
+
+#include "mir/graphics/gl_program_factory.h"
+#include "mir/graphics/gl_program.h"
+#include <mutex>
+
+namespace mir
+{
+namespace graphics
+{
+class ProgramFactory : public GLProgramFactory
+{
+public:
+    std::unique_ptr<GLProgram> create_gl_program(std::string const&, std::string const&) const override;
+
+private:
+    /*
+     * We need to serialize renderer creation because some GL calls used
+     * during renderer construction that create unique resource ids
+     * (e.g. glCreateProgram) are not thread-safe when the threads are
+     * have the same or shared EGL contexts.
+     */
+    std::mutex mutable mutex;
+};
+}
+}
+
+#endif /* MIR_GRAPHICS_GL_RENDERER_FACTORY_H_ */

=== modified file 'tests/unit-tests/compositor/test_gl_renderer.cpp'
--- tests/unit-tests/compositor/test_gl_renderer.cpp	2014-04-22 03:40:44 +0000
+++ tests/unit-tests/compositor/test_gl_renderer.cpp	2014-04-22 16:51:34 +0000
@@ -25,6 +25,7 @@
 #include <mir/geometry/rectangle.h>
 #include "mir/compositor/renderer.h"
 #include "src/server/compositor/gl_renderer_factory.h"
+#include "src/server/graphics/program_factory.h"
 #include <mir_test/fake_shared.h>
 #include <mir_test_doubles/mock_buffer.h>
 #include <mir_test_doubles/mock_renderable.h>
@@ -64,60 +65,6 @@
 const std::string stub_info_log = "something failed!";
 const size_t stub_info_log_length = stub_info_log.size();
 
-void ExpectShaderCompileFailure(const GLint shader, mtd::MockGL &mock_gl)
-{
-    EXPECT_CALL(mock_gl, glGetShaderiv(shader, GL_COMPILE_STATUS, _))
-        .WillOnce(SetArgPointee<2>(GL_FALSE));
-}
-
-void ExpectShaderCompileSuccess(const GLint shader, mtd::MockGL &mock_gl)
-{
-    EXPECT_CALL(mock_gl, glGetShaderiv(shader, GL_COMPILE_STATUS, _))
-        .WillOnce(SetArgPointee<2>(GL_TRUE));
-}
-
-void SetUpMockVertexShader(mtd::MockGL &mock_gl, const std::function<void(const GLint, mtd::MockGL &)> &shader_compile_expectation)
-{
-    /* Vertex Shader */
-    EXPECT_CALL(mock_gl, glCreateShader(GL_VERTEX_SHADER))
-        .WillOnce(Return(stub_v_shader));
-    EXPECT_CALL(mock_gl, glShaderSource(stub_v_shader, 1, _, 0));
-    EXPECT_CALL(mock_gl, glCompileShader(stub_v_shader));
-    shader_compile_expectation(stub_v_shader, mock_gl);
-}
-
-void SetUpMockFragmentShader(mtd::MockGL &mock_gl, const std::function<void(const GLint, mtd::MockGL &)> &shader_compile_expectation)
-{
-    /* Fragment Shader */
-    EXPECT_CALL(mock_gl, glCreateShader(GL_FRAGMENT_SHADER))
-        .WillOnce(Return(stub_f_shader));
-    EXPECT_CALL(mock_gl, glShaderSource(stub_f_shader, 1, _, 0));
-    EXPECT_CALL(mock_gl, glCompileShader(stub_f_shader));
-    shader_compile_expectation(stub_f_shader, mock_gl);
-}
-
-void ExpectProgramLinkFailure(const GLint program, mtd::MockGL &mock_gl)
-{
-    EXPECT_CALL(mock_gl, glGetProgramiv(program, GL_LINK_STATUS, _))
-        .WillOnce(SetArgPointee<2>(GL_FALSE));
-}
-
-void ExpectProgramLinkSuccess(const GLint program, mtd::MockGL &mock_gl)
-{
-    EXPECT_CALL(mock_gl, glGetProgramiv(program, GL_LINK_STATUS, _))
-        .WillOnce(SetArgPointee<2>(GL_TRUE));
-}
-
-void SetUpMockGraphicsProgram(mtd::MockGL &mock_gl, const std::function<void(const GLint, mtd::MockGL &)> &program_link_expectation)
-{
-    /* Graphics Program */
-    EXPECT_CALL(mock_gl, glCreateProgram())
-            .WillOnce(Return(stub_program));
-    EXPECT_CALL(mock_gl, glAttachShader(stub_program, stub_v_shader));
-    EXPECT_CALL(mock_gl, glAttachShader(stub_program, stub_f_shader));
-    EXPECT_CALL(mock_gl, glLinkProgram(stub_program));
-    program_link_expectation(stub_program, mock_gl);
-}
 
 void SetUpMockProgramData(mtd::MockGL &mock_gl)
 {
@@ -140,95 +87,6 @@
         .WillOnce(Return(centre_uniform_location));
 }
 
-class GLRendererSetupProcess :
-    public testing::Test
-{
-public:
-
-    mtd::MockGL mock_gl;
-    mc::GLRendererFactory gl_renderer_factory;
-    mir::geometry::Rectangle display_area;
-};
-
-ACTION_P2(CopyString, str, len)
-{
-    memcpy(arg3, str, len);
-    arg3[len] = '\0';
-}
-
-ACTION_P(ReturnByConstReference, cref)
-{
-    return cref;
-}
-
-MATCHER_P(NthCharacterIsNul, n, "specified character is the nul-byte")
-{
-    return arg[n] == '\0';
-}
-
-TEST_F(GLRendererSetupProcess, vertex_shader_compiler_failure_recovers_and_throws)
-{
-    using namespace std::placeholders;
-
-    SetUpMockVertexShader(mock_gl, std::bind(ExpectShaderCompileFailure, _1, _2));
-
-    EXPECT_CALL(mock_gl, glGetShaderiv(stub_v_shader, GL_INFO_LOG_LENGTH, _))
-        .WillOnce(SetArgPointee<2>(stub_info_log_length));
-    EXPECT_CALL(mock_gl, glGetShaderInfoLog(stub_v_shader,
-        stub_info_log_length,
-        _,
-        NthCharacterIsNul(stub_info_log_length)))
-            .WillOnce(CopyString(stub_info_log.c_str(),
-                stub_info_log.size()));
-
-    EXPECT_THROW({
-        auto r = gl_renderer_factory.create_renderer_for(display_area);
-    }, std::runtime_error);
-}
-
-TEST_F(GLRendererSetupProcess, fragment_shader_compiler_failure_recovers_and_throw)
-{
-    using namespace std::placeholders;
-
-    SetUpMockVertexShader(mock_gl, std::bind(ExpectShaderCompileSuccess, _1, _2));
-    SetUpMockFragmentShader(mock_gl, std::bind(ExpectShaderCompileFailure, _1, _2));
-
-    EXPECT_CALL(mock_gl, glGetShaderiv(stub_f_shader, GL_INFO_LOG_LENGTH, _))
-        .WillOnce(SetArgPointee<2>(stub_info_log_length));
-    EXPECT_CALL(mock_gl, glGetShaderInfoLog(stub_f_shader,
-        stub_info_log_length,
-        _,
-        NthCharacterIsNul(stub_info_log_length)))
-            .WillOnce(CopyString(stub_info_log.c_str(),
-                stub_info_log.size()));
-
-    EXPECT_THROW({
-        auto r = gl_renderer_factory.create_renderer_for(display_area);
-    }, std::runtime_error);
-}
-
-TEST_F(GLRendererSetupProcess, graphics_program_linker_failure_recovers_and_throw)
-{
-    using namespace std::placeholders;
-
-    SetUpMockVertexShader(mock_gl, std::bind(ExpectShaderCompileSuccess, _1, _2));
-    SetUpMockFragmentShader(mock_gl, std::bind(ExpectShaderCompileSuccess, _1, _2));
-    SetUpMockGraphicsProgram(mock_gl, std::bind(ExpectProgramLinkFailure, _1, _2));
-
-    EXPECT_CALL(mock_gl, glGetProgramiv(stub_program, GL_INFO_LOG_LENGTH, _))
-            .WillOnce(SetArgPointee<2>(stub_info_log_length));
-    EXPECT_CALL(mock_gl, glGetProgramInfoLog(stub_program,
-        stub_info_log_length,
-        _,
-        NthCharacterIsNul(stub_info_log_length)))
-            .WillOnce(CopyString(stub_info_log.c_str(),
-                stub_info_log.size()));
-
-    EXPECT_THROW({
-        auto r = gl_renderer_factory.create_renderer_for(display_area);
-    }, std::runtime_error);
-}
-
 class GLRenderer :
     public testing::Test
 {
@@ -236,11 +94,19 @@
 
     GLRenderer()
     {
-        using namespace std::placeholders;
+        //Mock defaults
+        ON_CALL(mock_gl, glCreateShader(GL_VERTEX_SHADER))
+            .WillByDefault(Return(stub_v_shader));
+        ON_CALL(mock_gl, glCreateShader(GL_FRAGMENT_SHADER))
+            .WillByDefault(Return(stub_f_shader));
+        ON_CALL(mock_gl, glCreateProgram())
+            .WillByDefault(Return(stub_program));
+        ON_CALL(mock_gl, glGetProgramiv(_,_,_))
+            .WillByDefault(SetArgPointee<2>(GL_TRUE));
+        ON_CALL(mock_gl, glGetShaderiv(_,_,_))
+            .WillByDefault(SetArgPointee<2>(GL_TRUE));
 
-        // Silence warnings about "uninteresting" calls that we truly aren't
-        // interested in (for most test cases)...
-        EXPECT_CALL(mock_gl, glClear(_)).Times(AnyNumber());
+        //A mix of defaults and silencing from here on out
         EXPECT_CALL(mock_gl, glUseProgram(_)).Times(AnyNumber());
         EXPECT_CALL(mock_gl, glActiveTexture(_)).Times(AnyNumber());
         EXPECT_CALL(mock_gl, glUniformMatrix4fv(_, _, GL_FALSE, _))
@@ -269,29 +135,23 @@
         EXPECT_CALL(mock_gl, glDisable(_)).Times(AnyNumber());
 
         InSequence s;
-
-        SetUpMockVertexShader(mock_gl, std::bind(ExpectShaderCompileSuccess, _1, _2));
-        SetUpMockFragmentShader(mock_gl, std::bind(ExpectShaderCompileSuccess, _1, _2));
-        SetUpMockGraphicsProgram(mock_gl, std::bind(ExpectProgramLinkSuccess, _1,_2));
         SetUpMockProgramData(mock_gl);
         EXPECT_CALL(mock_gl, glUniform1i(tex_uniform_location, 0));
 
         EXPECT_CALL(mock_gl, glGetUniformLocation(stub_program, _))
             .WillOnce(Return(screen_to_gl_coords_uniform_location));
 
+        mc::GLRendererFactory gl_renderer_factory{std::make_shared<mg::ProgramFactory>()};
         display_area = {{1, 2}, {3, 4}};
-
-        EXPECT_CALL(mock_gl, glDeleteProgram(stub_program));
-        EXPECT_CALL(mock_gl, glDeleteShader(stub_f_shader));
-        EXPECT_CALL(mock_gl, glDeleteShader(stub_v_shader));
+        renderer = gl_renderer_factory.create_renderer_for(display_area);
     }
 
     testing::NiceMock<mtd::MockGL> mock_gl;
     std::shared_ptr<mtd::MockBuffer> mock_buffer;
     mir::geometry::Rectangle display_area;
-    glm::mat4           trans;
+    std::unique_ptr<mc::Renderer> renderer;
     testing::NiceMock<mtd::MockRenderable> renderable;
-    mc::GLRendererFactory gl_renderer_factory;
+    glm::mat4 trans;
 };
 
 }
@@ -300,8 +160,6 @@
 {
     using namespace std::placeholders;
 
-    auto renderer = gl_renderer_factory.create_renderer_for(display_area);
-
     InSequence seq;
 
     EXPECT_CALL(mock_gl, glClear(_));
@@ -353,8 +211,6 @@
 
 TEST_F(GLRenderer, disables_blending_for_rgbx_surfaces)
 {
-    auto renderer = gl_renderer_factory.create_renderer_for(display_area);
-
     InSequence seq;
     EXPECT_CALL(renderable, shaped())
         .WillOnce(Return(false));
@@ -380,8 +236,6 @@
 
 TEST_F(GLRenderer, caches_and_uploads_texture_only_on_buffer_changes)
 {
-    auto renderer = gl_renderer_factory.create_renderer_for(display_area);
-
     InSequence seq;
 
     // First render() - texture generated and uploaded
@@ -459,8 +313,6 @@
 
 TEST_F(GLRenderer, holds_buffers_till_the_end)
 {
-    auto renderer = gl_renderer_factory.create_renderer_for(display_area);
-
     InSequence seq;
 
     EXPECT_CALL(*mock_buffer, id())

=== modified file 'tests/unit-tests/graphics/CMakeLists.txt'
--- tests/unit-tests/graphics/CMakeLists.txt	2014-04-15 05:31:19 +0000
+++ tests/unit-tests/graphics/CMakeLists.txt	2014-04-22 16:51:34 +0000
@@ -9,6 +9,7 @@
     ${CMAKE_CURRENT_SOURCE_DIR}/test_pixel_format_utils.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/test_surfaceless_egl_context.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/test_overlapping_output_grouping.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/test_program_factory.cpp
 )
 
 add_subdirectory(nested/)

=== added file 'tests/unit-tests/graphics/test_program_factory.cpp'
--- tests/unit-tests/graphics/test_program_factory.cpp	1970-01-01 00:00:00 +0000
+++ tests/unit-tests/graphics/test_program_factory.cpp	2014-04-22 16:51:34 +0000
@@ -0,0 +1,211 @@
+/*
+ * Copyright © 2012-2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Sam Spilsbury <[e-mail]>
+ *              Kevin DuBois <[e-mail]>
+ */
+
+#include <functional>
+#include <string>
+#include <cstring>
+#include <stdexcept>
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include <mir/geometry/rectangle.h>
+#include "mir/compositor/renderer.h"
+#include "src/server/compositor/gl_renderer_factory.h"
+#include "src/server/graphics/program_factory.h"
+#include <mir_test/fake_shared.h>
+#include <mir_test_doubles/mock_buffer.h>
+#include <mir_test_doubles/mock_renderable.h>
+#include <mir_test_doubles/mock_buffer_stream.h>
+#include <mir/compositor/buffer_stream.h>
+#include <mir_test_doubles/mock_gl.h>
+
+using testing::SetArgPointee;
+using testing::InSequence;
+using testing::Return;
+using testing::ReturnRef;
+using testing::Pointee;
+using testing::AnyNumber;
+using testing::AtLeast;
+using testing::_;
+
+namespace mt=mir::test;
+namespace mtd=mir::test::doubles;
+namespace mc=mir::compositor;
+namespace mg=mir::graphics;
+
+namespace
+{
+
+const GLint stub_v_shader = 1;
+const GLint stub_f_shader = 2;
+const GLint stub_program = 1;
+const std::string stub_info_log = "something failed!";
+const size_t stub_info_log_length = stub_info_log.size();
+
+void ExpectShaderCompileFailure(const GLint shader, mtd::MockGL &mock_gl)
+{
+    EXPECT_CALL(mock_gl, glGetShaderiv(shader, GL_COMPILE_STATUS, _))
+        .WillOnce(SetArgPointee<2>(GL_FALSE));
+}
+
+void ExpectShaderCompileSuccess(const GLint shader, mtd::MockGL &mock_gl)
+{
+    EXPECT_CALL(mock_gl, glGetShaderiv(shader, GL_COMPILE_STATUS, _))
+        .WillOnce(SetArgPointee<2>(GL_TRUE));
+}
+
+void SetUpMockVertexShader(mtd::MockGL &mock_gl, const std::function<void(const GLint, mtd::MockGL &)> &shader_compile_expectation)
+{
+    /* Vertex Shader */
+    EXPECT_CALL(mock_gl, glCreateShader(GL_VERTEX_SHADER))
+        .WillOnce(Return(stub_v_shader));
+    EXPECT_CALL(mock_gl, glShaderSource(stub_v_shader, 1, _, 0));
+    EXPECT_CALL(mock_gl, glCompileShader(stub_v_shader));
+    shader_compile_expectation(stub_v_shader, mock_gl);
+}
+
+void SetUpMockFragmentShader(mtd::MockGL &mock_gl, const std::function<void(const GLint, mtd::MockGL &)> &shader_compile_expectation)
+{
+    /* Fragment Shader */
+    EXPECT_CALL(mock_gl, glCreateShader(GL_FRAGMENT_SHADER))
+        .WillOnce(Return(stub_f_shader));
+    EXPECT_CALL(mock_gl, glShaderSource(stub_f_shader, 1, _, 0));
+    EXPECT_CALL(mock_gl, glCompileShader(stub_f_shader));
+    shader_compile_expectation(stub_f_shader, mock_gl);
+}
+
+void ExpectProgramLinkFailure(const GLint program, mtd::MockGL &mock_gl)
+{
+    EXPECT_CALL(mock_gl, glGetProgramiv(program, GL_LINK_STATUS, _))
+        .WillOnce(SetArgPointee<2>(GL_FALSE));
+}
+
+void ExpectProgramLinkSuccess(const GLint program, mtd::MockGL &mock_gl)
+{
+    EXPECT_CALL(mock_gl, glGetProgramiv(program, GL_LINK_STATUS, _))
+        .WillOnce(SetArgPointee<2>(GL_TRUE));
+}
+
+void SetUpMockGraphicsProgram(mtd::MockGL &mock_gl, const std::function<void(const GLint, mtd::MockGL &)> &program_link_expectation)
+{
+    /* Graphics Program */
+    EXPECT_CALL(mock_gl, glCreateProgram())
+            .WillOnce(Return(stub_program));
+    EXPECT_CALL(mock_gl, glAttachShader(stub_program, stub_v_shader));
+    EXPECT_CALL(mock_gl, glAttachShader(stub_program, stub_f_shader));
+    EXPECT_CALL(mock_gl, glLinkProgram(stub_program));
+    program_link_expectation(stub_program, mock_gl);
+}
+
+class ProgramFactory : public testing::Test
+{
+public:
+    ProgramFactory() :
+        gl_renderer_factory{std::make_shared<mg::ProgramFactory>()}
+    {
+    }
+    testing::NiceMock<mtd::MockGL> mock_gl;
+    mc::GLRendererFactory gl_renderer_factory;
+    mir::geometry::Rectangle display_area;
+};
+
+ACTION_P2(CopyString, str, len)
+{
+    memcpy(arg3, str, len);
+    arg3[len] = '\0';
+}
+
+MATCHER_P(NthCharacterIsNul, n, "specified character is the nul-byte")
+{
+    return arg[n] == '\0';
+}
+
+TEST_F(ProgramFactory, vertex_shader_compiler_failure_recovers_and_throws)
+{
+    using namespace std::placeholders;
+
+    SetUpMockVertexShader(mock_gl, std::bind(ExpectShaderCompileFailure, _1, _2));
+
+    EXPECT_CALL(mock_gl, glGetShaderiv(stub_v_shader, GL_INFO_LOG_LENGTH, _))
+        .WillOnce(SetArgPointee<2>(stub_info_log_length));
+    EXPECT_CALL(mock_gl, glGetShaderInfoLog(stub_v_shader,
+        stub_info_log_length,
+        _,
+        NthCharacterIsNul(stub_info_log_length)))
+            .WillOnce(CopyString(stub_info_log.c_str(),
+                stub_info_log.size()));
+
+    EXPECT_THROW({
+        auto r = gl_renderer_factory.create_renderer_for(display_area);
+    }, std::runtime_error);
+}
+
+TEST_F(ProgramFactory, fragment_shader_compiler_failure_recovers_and_throw)
+{
+    using namespace std::placeholders;
+
+    SetUpMockVertexShader(mock_gl, std::bind(ExpectShaderCompileSuccess, _1, _2));
+    SetUpMockFragmentShader(mock_gl, std::bind(ExpectShaderCompileFailure, _1, _2));
+
+    EXPECT_CALL(mock_gl, glGetShaderiv(stub_f_shader, GL_INFO_LOG_LENGTH, _))
+        .WillOnce(SetArgPointee<2>(stub_info_log_length));
+    EXPECT_CALL(mock_gl, glGetShaderInfoLog(stub_f_shader,
+        stub_info_log_length,
+        _,
+        NthCharacterIsNul(stub_info_log_length)))
+            .WillOnce(CopyString(stub_info_log.c_str(),
+                stub_info_log.size()));
+
+    EXPECT_THROW({
+        auto r = gl_renderer_factory.create_renderer_for(display_area);
+    }, std::runtime_error);
+}
+
+TEST_F(ProgramFactory, graphics_program_linker_failure_recovers_and_throw)
+{
+    using namespace std::placeholders;
+
+    SetUpMockVertexShader(mock_gl, std::bind(ExpectShaderCompileSuccess, _1, _2));
+    SetUpMockFragmentShader(mock_gl, std::bind(ExpectShaderCompileSuccess, _1, _2));
+    SetUpMockGraphicsProgram(mock_gl, std::bind(ExpectProgramLinkFailure, _1, _2));
+
+    EXPECT_CALL(mock_gl, glGetProgramiv(stub_program, GL_INFO_LOG_LENGTH, _))
+            .WillOnce(SetArgPointee<2>(stub_info_log_length));
+    EXPECT_CALL(mock_gl, glGetProgramInfoLog(stub_program,
+        stub_info_log_length,
+        _,
+        NthCharacterIsNul(stub_info_log_length)))
+            .WillOnce(CopyString(stub_info_log.c_str(),
+                stub_info_log.size()));
+
+    EXPECT_THROW({
+        auto r = gl_renderer_factory.create_renderer_for(display_area);
+    }, std::runtime_error);
+}
+
+TEST_F(ProgramFactory, graphics_program_creation_success)
+{
+    using namespace std::placeholders;
+
+    SetUpMockVertexShader(mock_gl, std::bind(ExpectShaderCompileSuccess, _1, _2));
+    SetUpMockFragmentShader(mock_gl, std::bind(ExpectShaderCompileSuccess, _1, _2));
+    SetUpMockGraphicsProgram(mock_gl, std::bind(ExpectProgramLinkSuccess, _1, _2));
+
+    gl_renderer_factory.create_renderer_for(display_area);
+}
+}