Merge lp:~kdub/mir/android-egl-extensions into lp:~mir-team/mir/trunk

[Kevin DuBois]

Android was accessing the egl extension functions directly instead of using eglGetProcAddress() to get them. This caused linking problems. Re-use gbm code that uses eglGetProgAddress so android uses the extensions correctly

fixes: lp:1189938

Android was accessing the egl extension functions directly instead of using eglGetProcAddress() to get them. This caused linking problems. Re-use gbm code that uses eglGetProgAddress so android uses the extensions correctly

fixes: lp:1189938

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:761
http://jenkins.qa.ubuntu.com/job/mir-ci/740/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-raring-i386-build/920
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-raring-amd64-build/802
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-raring-amd64-ci/225
        deb: http://jenkins.qa.ubuntu.com/job/mir-raring-amd64-ci/225/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-vm-ci-build/./distribution=quantal,flavor=amd64/426

Click here to trigger a rebuild:
http://s-jenkins:8080/job/mir-ci/740/rebuild

review: Approve (continuous-integration)

[Robert Carr (robertcarr)]

LGTM

review: Approve

[Kevin DuBois (kdub)]

switching to approve, since its blocking saucy progress, and should be pretty non-controversial :)

=== modified file 'examples/demo_client_accelerated.cpp'
--- examples/demo_client_accelerated.cpp	2013-06-13 06:00:21 +0000
+++ examples/demo_client_accelerated.cpp	2013-06-14 20:23:35 +0000
@@ -127,9 +127,6 @@
         gl_animation.render_gl();
         rc = eglSwapBuffers(disp, egl_surface);
         assert(rc == EGL_TRUE);
-
-        usleep(167);//60fps
-
         gl_animation.step();
     }
 

=== added file 'include/server/mir/graphics/egl_extensions.h'
--- include/server/mir/graphics/egl_extensions.h	1970-01-01 00:00:00 +0000
+++ include/server/mir/graphics/egl_extensions.h	2013-06-14 20:23:35 +0000
@@ -0,0 +1,43 @@
+/*
+ * 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/>.
+ *
+ *   Christopher James Halse Rogers <[e-mail]>
+ */
+
+#ifndef MIR_GRAPHICS_EGL_EXTENSIONS_H_
+#define MIR_GRAPHICS_EGL_EXTENSIONS_H_
+
+#define GL_GLEXT_PROTOTYPES
+#define EGL_EGLEXT_PROTOTYPES
+#include <EGL/egl.h>
+#include <EGL/eglext.h>
+#include <GLES2/gl2.h>
+#include <GLES2/gl2ext.h>
+
+namespace mir
+{
+namespace graphics
+{
+struct EGLExtensions
+{
+    EGLExtensions();
+    PFNEGLCREATEIMAGEKHRPROC const eglCreateImageKHR;
+    PFNEGLDESTROYIMAGEKHRPROC const eglDestroyImageKHR;
+    PFNGLEGLIMAGETARGETTEXTURE2DOESPROC const glEGLImageTargetTexture2DOES;
+};
+}
+}
+
+#endif /* MIR_GRAPHICS_EGL_EXTENSIONS_H_ */

=== modified file 'include/test/mir_test_doubles/mock_egl.h'
--- include/test/mir_test_doubles/mock_egl.h	2013-05-20 15:55:48 +0000
+++ include/test/mir_test_doubles/mock_egl.h	2013-06-14 20:23:35 +0000
@@ -25,6 +25,9 @@
 #define EGL_EGLEXT_PROTOTYPES
 #include <EGL/egl.h>
 #include <EGL/eglext.h>
+//for GL extensions
+#include <GLES2/gl2.h>
+#include <GLES2/gl2ext.h>
 
 namespace mir
 {
@@ -84,9 +87,9 @@
 
     MOCK_METHOD0(eglGetError, EGLint (void));
 
-    /* extensions */
     MOCK_METHOD5(eglCreateImageKHR, EGLImageKHR(EGLDisplay, EGLContext, EGLenum, EGLClientBuffer, const EGLint*));
     MOCK_METHOD2(eglDestroyImageKHR,EGLBoolean(EGLDisplay, EGLImageKHR));
+    MOCK_METHOD2(glEGLImageTargetTexture2DOES, void(GLenum, GLeglImageOES));
 
     EGLDisplay fake_egl_display;
     EGLConfig* fake_configs;

=== modified file 'include/test/mir_test_doubles/mock_gl.h'
--- include/test/mir_test_doubles/mock_gl.h	2013-05-20 15:55:48 +0000
+++ include/test/mir_test_doubles/mock_gl.h	2013-06-14 20:23:35 +0000
@@ -20,11 +20,7 @@
 #define MIR_TEST_DOUBLES_MOCK_GL_H_
 
 #include <gmock/gmock.h>
-
-#define GL_GLEXT_PROTOTYPES
-#define EGL_EGLEXT_PROTOTYPES
 #include <GLES2/gl2.h>
-#include <GLES2/gl2ext.h>
 
 namespace mir
 {
@@ -40,7 +36,6 @@
     ~MockGL();
     void silence_uninteresting();
 
-    MOCK_METHOD2(glEGLImageTargetTexture2DOES, void(GLenum, GLeglImageOES));
     MOCK_METHOD1(glGetString, const GLubyte*(GLenum));
     MOCK_METHOD1(glUseProgram, void (GLuint));
     MOCK_METHOD1(glEnable, void (GLenum));

=== modified file 'src/server/graphics/CMakeLists.txt'
--- src/server/graphics/CMakeLists.txt	2013-05-08 17:22:54 +0000
+++ src/server/graphics/CMakeLists.txt	2013-06-14 20:23:35 +0000
@@ -15,6 +15,7 @@
   GRAPHICS_SOURCES
 
   gl_renderer.cpp
+  egl_extensions.cpp
   display_configuration.cpp
   null_display_report.cpp
 )

=== modified file 'src/server/graphics/android/android_buffer_allocator.cpp'
--- src/server/graphics/android/android_buffer_allocator.cpp	2013-05-01 22:05:55 +0000
+++ src/server/graphics/android/android_buffer_allocator.cpp	2013-06-14 20:23:35 +0000
@@ -19,6 +19,7 @@
 
 #include "mir/graphics/platform.h"
 #include "mir/graphics/buffer_initializer.h"
+#include "mir/graphics/egl_extensions.h"
 #include "mir/compositor/buffer_properties.h"
 #include "android_graphic_buffer_allocator.h"
 #include "android_alloc_adaptor.h"
@@ -47,7 +48,8 @@
 
 mga::AndroidGraphicBufferAllocator::AndroidGraphicBufferAllocator(
         std::shared_ptr<BufferInitializer> const& buffer_initializer)
-    : buffer_initializer{buffer_initializer}
+    : buffer_initializer(buffer_initializer),
+      egl_extensions(std::make_shared<mg::EGLExtensions>())
 {
     int err;
 
@@ -78,7 +80,8 @@
 std::shared_ptr<mga::Buffer> mga::AndroidGraphicBufferAllocator::alloc_buffer_platform(
     geom::Size sz, geom::PixelFormat pf, mga::BufferUsage use)
 {
-    auto buffer = std::make_shared<Buffer>(alloc_device, sz, pf, use);
+    auto native_handle = alloc_device->alloc_buffer(sz, pf, use);
+    auto buffer = std::make_shared<Buffer>(native_handle, egl_extensions);
     (*buffer_initializer)(*buffer);
     return buffer;
 }

=== modified file 'src/server/graphics/android/android_graphic_buffer_allocator.h'
--- src/server/graphics/android/android_graphic_buffer_allocator.h	2013-05-24 15:51:37 +0000
+++ src/server/graphics/android/android_graphic_buffer_allocator.h	2013-06-14 20:23:35 +0000
@@ -32,6 +32,7 @@
 {
 
 class BufferInitializer;
+class EGLExtensions;
 
 namespace android
 {
@@ -58,6 +59,7 @@
     const hw_module_t    *hw_module;
     std::shared_ptr<GraphicAllocAdaptor> alloc_device;
     std::shared_ptr<BufferInitializer> const buffer_initializer;
+    std::shared_ptr<EGLExtensions> const egl_extensions;
 };
 
 }

=== modified file 'src/server/graphics/android/buffer.cpp'
--- src/server/graphics/android/buffer.cpp	2013-06-12 09:36:20 +0000
+++ src/server/graphics/android/buffer.cpp	2013-06-14 20:23:35 +0000
@@ -17,9 +17,9 @@
  *   Kevin DuBois <[e-mail]>
  */
 
+#include "mir/graphics/egl_extensions.h"
+#include "android_format_conversion-inl.h"
 #include "buffer.h"
-#include "graphic_alloc_adaptor.h"
-#include "android_format_conversion-inl.h"
 
 #include <system/window.h>
 #include <GLES2/gl2.h>
@@ -32,19 +32,11 @@
 namespace mga=mir::graphics::android;
 namespace geom=mir::geometry;
 
-mga::Buffer::Buffer(const std::shared_ptr<GraphicAllocAdaptor>& alloc_device,
-                    geom::Size size, geom::PixelFormat pf, mga::BufferUsage use)
+mga::Buffer::Buffer(std::shared_ptr<ANativeWindowBuffer> const& buffer_handle,
+                    std::shared_ptr<mg::EGLExtensions> const& extensions)
+    : native_buffer(buffer_handle),
+      egl_extensions(extensions)
 {
-    if (!alloc_device)
-        BOOST_THROW_EXCEPTION(std::runtime_error("No allocation device for graphics buffer"));
-
-    native_buffer = alloc_device->alloc_buffer(size, pf, use);
-
-    //TODO: we could make the native buffer itself a constructor dependency and move creation
-    //      failures to the factory
-    if (!native_buffer.get())
-        BOOST_THROW_EXCEPTION(std::runtime_error("Graphics buffer allocation failed"));
-
 }
 
 mga::Buffer::~Buffer()
@@ -52,7 +44,7 @@
     std::map<EGLDisplay,EGLImageKHR>::iterator it;
     for(it = egl_image_map.begin(); it != egl_image_map.end(); it++)
     {
-        eglDestroyImageKHR(it->first, it->second);
+        egl_extensions->eglDestroyImageKHR(it->first, it->second);
     }
 }
 
@@ -82,14 +74,14 @@
     }
     static const EGLint image_attrs[] =
     {
-        EGL_IMAGE_PRESERVED_KHR,    EGL_TRUE,
+        EGL_IMAGE_PRESERVED_KHR, EGL_TRUE,
         EGL_NONE
     };
     EGLImageKHR image;
     auto it = egl_image_map.find(disp);
     if (it == egl_image_map.end())
     {
-        image = eglCreateImageKHR(disp, EGL_NO_CONTEXT, EGL_NATIVE_BUFFER_ANDROID,
+        image = egl_extensions->eglCreateImageKHR(disp, EGL_NO_CONTEXT, EGL_NATIVE_BUFFER_ANDROID,
                                   native_buffer.get(), image_attrs);
         if (image == EGL_NO_IMAGE_KHR)
         {
@@ -102,9 +94,7 @@
         image = it->second;
     }
 
-    glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, image);
-
-    return;
+    egl_extensions->glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, image);
 }
  
 std::shared_ptr<ANativeWindowBuffer> mga::Buffer::native_buffer_handle() const

=== modified file 'src/server/graphics/android/buffer.h'
--- src/server/graphics/android/buffer.h	2013-06-04 14:23:56 +0000
+++ src/server/graphics/android/buffer.h	2013-06-14 20:23:35 +0000
@@ -34,15 +34,15 @@
 {
 namespace graphics
 {
+struct EGLExtensions;
 namespace android
 {
 
-class GraphicAllocAdaptor;
 class Buffer: public compositor::BufferBasic 
 {
 public:
-    Buffer(const std::shared_ptr<GraphicAllocAdaptor>& device,
-                  geometry::Size size, geometry::PixelFormat pf, BufferUsage use);
+    Buffer(std::shared_ptr<ANativeWindowBuffer> const& buffer_handle,
+           std::shared_ptr<EGLExtensions> const& extensions);
     ~Buffer();
 
     geometry::Size size() const;
@@ -55,6 +55,7 @@
     std::map<EGLDisplay,EGLImageKHR> egl_image_map;
 
     std::shared_ptr<ANativeWindowBuffer> native_buffer;
+    std::shared_ptr<EGLExtensions> egl_extensions;
 };
 
 }

=== added file 'src/server/graphics/egl_extensions.cpp'
--- src/server/graphics/egl_extensions.cpp	1970-01-01 00:00:00 +0000
+++ src/server/graphics/egl_extensions.cpp	2013-06-14 20:23:35 +0000
@@ -0,0 +1,42 @@
+/*
+ * 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:
+ *   Kevin DuBois <[e-mail]>
+ */
+
+#include "mir/graphics/egl_extensions.h"
+#include <boost/throw_exception.hpp>
+#include <stdexcept>
+
+namespace mg=mir::graphics;
+
+mg::EGLExtensions::EGLExtensions()
+    : eglCreateImageKHR{
+          reinterpret_cast<PFNEGLCREATEIMAGEKHRPROC>(
+              eglGetProcAddress("eglCreateImageKHR"))},
+      eglDestroyImageKHR{
+          reinterpret_cast<PFNEGLDESTROYIMAGEKHRPROC>(
+              eglGetProcAddress("eglDestroyImageKHR"))},
+      glEGLImageTargetTexture2DOES{
+          reinterpret_cast<PFNGLEGLIMAGETARGETTEXTURE2DOESPROC>(
+              eglGetProcAddress("glEGLImageTargetTexture2DOES"))}
+{
+    if (!eglCreateImageKHR || !eglDestroyImageKHR)
+        BOOST_THROW_EXCEPTION(std::runtime_error("EGL implementation doesn't support EGLImage"));
+
+    if (!glEGLImageTargetTexture2DOES)
+        BOOST_THROW_EXCEPTION(std::runtime_error("GLES2 implementation doesn't support updating a texture from an EGLImage"));
+}

=== modified file 'src/server/graphics/gbm/gbm_buffer_allocator.cpp'
--- src/server/graphics/gbm/gbm_buffer_allocator.cpp	2013-04-29 23:59:18 +0000
+++ src/server/graphics/gbm/gbm_buffer_allocator.cpp	2013-06-14 20:23:35 +0000
@@ -22,6 +22,7 @@
 #include "gbm_platform.h"
 #include "buffer_texture_binder.h"
 #include "mir/graphics/buffer_initializer.h"
+#include "mir/graphics/egl_extensions.h"
 #include "mir/compositor/buffer_properties.h"
 #include <boost/throw_exception.hpp>
 
@@ -39,42 +40,6 @@
 namespace mc  = mir::compositor;
 namespace geom = mir::geometry;
 
-namespace mir
-{
-namespace graphics
-{
-namespace gbm
-{
-
-struct EGLExtensions
-{
-    EGLExtensions()
-        : eglCreateImageKHR{
-              reinterpret_cast<PFNEGLCREATEIMAGEKHRPROC>(
-                  eglGetProcAddress("eglCreateImageKHR"))},
-          eglDestroyImageKHR{
-              reinterpret_cast<PFNEGLDESTROYIMAGEKHRPROC>(
-                  eglGetProcAddress("eglDestroyImageKHR"))},
-          glEGLImageTargetTexture2DOES{
-              reinterpret_cast<PFNGLEGLIMAGETARGETTEXTURE2DOESPROC>(
-                  eglGetProcAddress("glEGLImageTargetTexture2DOES"))}
-    {
-        if (!eglCreateImageKHR || !eglDestroyImageKHR)
-            BOOST_THROW_EXCEPTION(std::runtime_error("EGL implementation doesn't support EGLImage"));
-
-        if (!glEGLImageTargetTexture2DOES)
-            BOOST_THROW_EXCEPTION(std::runtime_error("GLES2 implementation doesn't support updating a texture from an EGLImage"));
-    }
-
-    PFNEGLCREATEIMAGEKHRPROC const eglCreateImageKHR;
-    PFNEGLDESTROYIMAGEKHRPROC const eglDestroyImageKHR;
-    PFNGLEGLIMAGETARGETTEXTURE2DOESPROC const glEGLImageTargetTexture2DOES;
-};
-
-}
-}
-}
-
 namespace
 {
 
@@ -82,7 +47,7 @@
 {
 public:
     EGLImageBufferTextureBinder(std::shared_ptr<gbm_bo> const& gbm_bo,
-                                std::shared_ptr<mgg::EGLExtensions> const& egl_extensions)
+                                std::shared_ptr<mg::EGLExtensions> const& egl_extensions)
         : bo{gbm_bo}, egl_extensions{egl_extensions}, egl_image{EGL_NO_IMAGE_KHR}
     {
     }
@@ -125,7 +90,7 @@
     }
 
     std::shared_ptr<gbm_bo> const bo;
-    std::shared_ptr<mgg::EGLExtensions> const egl_extensions;
+    std::shared_ptr<mg::EGLExtensions> const egl_extensions;
     EGLDisplay egl_display;
     EGLImageKHR egl_image;
 };
@@ -146,7 +111,7 @@
         const std::shared_ptr<BufferInitializer>& buffer_initializer)
         : platform(platform),
           buffer_initializer(buffer_initializer),
-          egl_extensions(std::make_shared<EGLExtensions>())
+          egl_extensions(std::make_shared<mg::EGLExtensions>())
 {
     assert(buffer_initializer.get() != 0);
 }

=== modified file 'src/server/graphics/gbm/gbm_buffer_allocator.h'
--- src/server/graphics/gbm/gbm_buffer_allocator.h	2013-04-24 05:22:20 +0000
+++ src/server/graphics/gbm/gbm_buffer_allocator.h	2013-06-14 20:23:35 +0000
@@ -29,12 +29,11 @@
 namespace graphics
 {
 class BufferInitializer;
+struct EGLExtensions;
 
 namespace gbm
 {
-
 class GBMPlatform;
-struct EGLExtensions;
 
 class GBMBufferAllocator: public compositor::GraphicBufferAllocator
 {

=== modified file 'tests/mir_test_doubles/mock_egl.cpp'
--- tests/mir_test_doubles/mock_egl.cpp	2013-05-20 15:55:48 +0000
+++ tests/mir_test_doubles/mock_egl.cpp	2013-06-14 20:23:35 +0000
@@ -38,6 +38,13 @@
 };
 EGLint config_size = 4;
 
+/* We prefix GL/EGL extensions with "extension_" so code under test has to get their function
+   ptrs with eglGetProcAddress */
+EGLImageKHR extension_eglCreateImageKHR(EGLDisplay dpy, EGLContext ctx, EGLenum target,
+                                        EGLClientBuffer buffer, const EGLint *attrib_list);
+EGLBoolean extension_eglDestroyImageKHR (EGLDisplay dpy, EGLImageKHR image);
+void extension_glEGLImageTargetTexture2DOES(GLenum target, GLeglImageOES image);
+
 /* EGL{Surface,Display,Config,Context} are all opaque types, so we can put whatever
    we want in them for testing */
 mtd::MockEGL::MockEGL()
@@ -100,6 +107,14 @@
 
     ON_CALL(*this, eglCreateImageKHR(_,_,_,_,_))
     .WillByDefault(Return(fake_egl_image));
+
+    typedef mtd::MockEGL::generic_function_pointer_t func_ptr_t;
+    ON_CALL(*this, eglGetProcAddress(StrEq("eglCreateImageKHR")))
+        .WillByDefault(Return(reinterpret_cast<func_ptr_t>(extension_eglCreateImageKHR)));
+    ON_CALL(*this, eglGetProcAddress(StrEq("eglDestroyImageKHR")))
+        .WillByDefault(Return(reinterpret_cast<func_ptr_t>(extension_eglDestroyImageKHR)));
+    ON_CALL(*this, eglGetProcAddress(StrEq("glEGLImageTargetTexture2DOES")))
+        .WillByDefault(Return(reinterpret_cast<func_ptr_t>(extension_glEGLImageTargetTexture2DOES)));
 }
 
 mtd::MockEGL::~MockEGL()
@@ -146,13 +161,21 @@
         .Times(AtLeast(0));
 }
 
-#define CHECK_GLOBAL_MOCK(rettype)  \
-    if (!global_mock_egl)               \
-    {                               \
-        using namespace ::testing;  \
+#define CHECK_GLOBAL_MOCK(rettype)         \
+    if (!global_mock_egl)                  \
+    {                                      \
+        using namespace ::testing;         \
         ADD_FAILURE_AT(__FILE__,__LINE__); \
-        rettype type = (rettype) 0;       \
-        return type;        \
+        rettype type = (rettype) 0;        \
+        return type;                       \
+    }
+
+#define CHECK_GLOBAL_VOID_MOCK()            \
+    if (!global_mock_egl)                   \
+    {                                       \
+        using namespace ::testing;          \
+        ADD_FAILURE_AT(__FILE__,__LINE__);  \
+        return;                             \
     }
 
 EGLint eglGetError (void)
@@ -338,15 +361,20 @@
 }
 
 /* extensions */
-EGLImageKHR eglCreateImageKHR(EGLDisplay dpy, EGLContext ctx, EGLenum target, EGLClientBuffer buffer, const EGLint *attrib_list)
+EGLImageKHR extension_eglCreateImageKHR(EGLDisplay dpy, EGLContext ctx, EGLenum target, EGLClientBuffer buffer, const EGLint *attrib_list)
 {
     CHECK_GLOBAL_MOCK(EGLImageKHR)
-    return global_mock_egl->eglCreateImageKHR ( dpy, ctx, target, buffer, attrib_list);
+    return global_mock_egl->eglCreateImageKHR(dpy, ctx, target, buffer, attrib_list);
 }
 
-EGLBoolean eglDestroyImageKHR (EGLDisplay dpy, EGLImageKHR image)
+EGLBoolean extension_eglDestroyImageKHR (EGLDisplay dpy, EGLImageKHR image)
 {
     CHECK_GLOBAL_MOCK(EGLBoolean)
-    return global_mock_egl->eglDestroyImageKHR ( dpy, image);
+    return global_mock_egl->eglDestroyImageKHR(dpy, image);
 }
 
+void extension_glEGLImageTargetTexture2DOES(GLenum target, GLeglImageOES image)
+{
+    CHECK_GLOBAL_VOID_MOCK();
+    global_mock_egl->glEGLImageTargetTexture2DOES(target, image);
+}

=== modified file 'tests/mir_test_doubles/mock_gl.cpp'
--- tests/mir_test_doubles/mock_gl.cpp	2013-05-20 15:55:48 +0000
+++ tests/mir_test_doubles/mock_gl.cpp	2013-06-14 20:23:35 +0000
@@ -58,12 +58,6 @@
         return type;                        \
     }
 
-void glEGLImageTargetTexture2DOES(GLenum target, GLeglImageOES image)
-{
-    CHECK_GLOBAL_VOID_MOCK();
-    global_mock_gl->glEGLImageTargetTexture2DOES(target, image);
-}
-
 const GLubyte* glGetString(GLenum name)
 {
     CHECK_GLOBAL_MOCK(const GLubyte*);
@@ -270,7 +264,4 @@
 
 void mtd::MockGL::silence_uninteresting()
 {
-    using namespace testing;
-    EXPECT_CALL(*this, glEGLImageTargetTexture2DOES(_,_))
-        .Times(AtLeast(0));
 }

=== modified file 'tests/unit-tests/graphics/CMakeLists.txt'
--- tests/unit-tests/graphics/CMakeLists.txt	2013-06-12 10:27:50 +0000
+++ tests/unit-tests/graphics/CMakeLists.txt	2013-06-14 20:23:35 +0000
@@ -2,6 +2,7 @@
     ${CMAKE_CURRENT_SOURCE_DIR}/test_graphics_platform.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/test_gl_renderer.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/test_display_configuration.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/test_egl_extensions.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/test_display.cpp
 )
 

=== modified file 'tests/unit-tests/graphics/android/test_android_buffer_allocator.cpp'
--- tests/unit-tests/graphics/android/test_android_buffer_allocator.cpp	2013-05-24 15:51:37 +0000
+++ tests/unit-tests/graphics/android/test_android_buffer_allocator.cpp	2013-06-14 20:23:35 +0000
@@ -22,6 +22,7 @@
 #include "mir/compositor/buffer_properties.h"
 
 #include "mir_test_doubles/mock_buffer_initializer.h"
+#include "mir_test_doubles/mock_egl.h"
 
 #include <hardware/gralloc.h>
 #include <gtest/gtest.h>
@@ -42,6 +43,7 @@
 
     std::shared_ptr<mg::BufferInitializer> const null_buffer_initializer;
     testing::NiceMock<mtd::HardwareAccessMock> hw_access_mock;
+    mtd::MockEGL mock_egl;
 };
 
 TEST_F(AndroidGraphicBufferAllocatorTest, allocator_accesses_gralloc_module)

=== modified file 'tests/unit-tests/graphics/android/test_buffer.cpp'
--- tests/unit-tests/graphics/android/test_buffer.cpp	2013-06-12 09:36:20 +0000
+++ tests/unit-tests/graphics/android/test_buffer.cpp	2013-06-14 20:23:35 +0000
@@ -16,8 +16,9 @@
  * Authored by: Kevin DuBois <[e-mail]>
  */
 
+#include "mir/graphics/egl_extensions.h"
 #include "src/server/graphics/android/buffer.h"
-#include "mir_test_doubles/mock_alloc_adaptor.h"
+#include "mir_test_doubles/mock_egl.h"
 
 #include <hardware/gralloc.h>
 #include <gtest/gtest.h>
@@ -42,37 +43,25 @@
         mock_buffer_handle->stride = 46;
         mock_buffer_handle->format = HAL_PIXEL_FORMAT_RGBA_8888;
 
-        mock_alloc_device = std::make_shared<NiceMock<mtd::MockAllocAdaptor>>();
-        ON_CALL(*mock_alloc_device, alloc_buffer(_,_,_))
-            .WillByDefault(Return(mock_buffer_handle));
- 
         default_use = mga::BufferUsage::use_hardware;
         pf = geom::PixelFormat::abgr_8888;
         size = geom::Size{geom::Width{300}, geom::Height{200}};
+        extensions = std::make_shared<mg::EGLExtensions>();
     }
 
-    std::shared_ptr<mtd::MockAllocAdaptor> mock_alloc_device;
+    mtd::MockEGL mock_egl;
     std::shared_ptr<ANativeWindowBuffer> mock_buffer_handle;
     geom::PixelFormat pf;
     geom::Size size;
     mga::BufferUsage default_use;
+    std::shared_ptr<mg::EGLExtensions> extensions;
 };
 
-
-TEST_F(AndroidGraphicBufferBasic, basic_allocation_uses_alloc_device)
-{
-    using namespace testing;
-
-    EXPECT_CALL(*mock_alloc_device, alloc_buffer(size, pf, default_use));
-    mga::Buffer buffer(mock_alloc_device, size, pf, default_use);
-}
-
 TEST_F(AndroidGraphicBufferBasic, size_query_test)
 {
     using namespace testing;
 
-    EXPECT_CALL(*mock_alloc_device, alloc_buffer(_,_,_));
-    mga::Buffer buffer(mock_alloc_device, size, pf, default_use);
+    mga::Buffer buffer(mock_buffer_handle, extensions);
 
     geom::Size expected_size{geom::Width{mock_buffer_handle->width},
                              geom::Height{mock_buffer_handle->height}};
@@ -83,15 +72,15 @@
 {
     using namespace testing;
 
-    mga::Buffer buffer(mock_alloc_device, size, pf, default_use);
+    mga::Buffer buffer(mock_buffer_handle, extensions);
     EXPECT_EQ(geom::PixelFormat::abgr_8888, buffer.pixel_format());
 }
 
-TEST_F(AndroidGraphicBufferBasic, queries_native_window_for_native_handle)
+TEST_F(AndroidGraphicBufferBasic, returns_native_buffer_when_asked)
 {
     using namespace testing;
 
-    mga::Buffer buffer(mock_alloc_device, size, pf, default_use);
+    mga::Buffer buffer(mock_buffer_handle, extensions);
     EXPECT_EQ(mock_buffer_handle, buffer.native_buffer_handle());
 }
 
@@ -101,6 +90,6 @@
 
     geom::Stride expected_stride{mock_buffer_handle->stride *
                                  geom::bytes_per_pixel(pf)};
-    mga::Buffer buffer(mock_alloc_device, size, pf, default_use);
+    mga::Buffer buffer(mock_buffer_handle, extensions);
     EXPECT_EQ(expected_stride, buffer.stride());
 }

=== modified file 'tests/unit-tests/graphics/android/test_buffer_tex_bind.cpp'
--- tests/unit-tests/graphics/android/test_buffer_tex_bind.cpp	2013-05-22 16:23:40 +0000
+++ tests/unit-tests/graphics/android/test_buffer_tex_bind.cpp	2013-06-14 20:23:35 +0000
@@ -17,11 +17,10 @@
  */
 
 #include "src/server/graphics/android/buffer.h"
-
-#include "mir_test_doubles/mock_alloc_adaptor.h"
-#include "mir_test_doubles/mock_gl.h"
 #include "mir_test_doubles/mock_egl.h"
+#include "mir/graphics/egl_extensions.h"
 
+#include <system/window.h>
 #include <stdexcept>
 #include <gtest/gtest.h>
 
@@ -39,16 +38,11 @@
         using namespace testing;
 
         stub_buffer = std::make_shared<ANativeWindowBuffer>();
-        mock_alloc_dev = std::make_shared<NiceMock<mtd::MockAllocAdaptor>>();
-        ON_CALL(*mock_alloc_dev, alloc_buffer(_,_,_))
-            .WillByDefault(Return(stub_buffer)); 
-
         size = geom::Size{geom::Width{300}, geom::Height{220}};
         pf = geom::PixelFormat::abgr_8888;
-        buffer = std::make_shared<mga::Buffer>(mock_alloc_dev, size, pf, mga::BufferUsage::use_hardware);
+        extensions = std::make_shared<mg::EGLExtensions>();
 
         mock_egl.silence_uninteresting();
-        mock_gl.silence_uninteresting();
     };
     virtual void TearDown()
     {
@@ -58,10 +52,9 @@
     geom::Size size;
     geom::PixelFormat pf;
 
+    mtd::MockEGL mock_egl;
+    std::shared_ptr<mg::EGLExtensions> extensions;
     std::shared_ptr<mga::Buffer> buffer;
-    mtd::MockGL mock_gl;
-    mtd::MockEGL mock_egl;
-    std::shared_ptr<mtd::MockAllocAdaptor> mock_alloc_dev;
     std::shared_ptr<ANativeWindowBuffer> stub_buffer;
 };
 
@@ -69,29 +62,32 @@
 {
     using namespace testing;
     EXPECT_CALL(mock_egl, eglGetCurrentDisplay())
-    .Times(Exactly(1));
+        .Times(Exactly(1));
 
-    buffer->bind_to_texture();
+    mga::Buffer buffer(stub_buffer, extensions);
+    buffer.bind_to_texture();
 }
 
 TEST_F(AndroidBufferBinding, buffer_creates_image_on_first_bind)
 {
     using namespace testing;
     EXPECT_CALL(mock_egl, eglCreateImageKHR(_,_,_,_,_))
-    .Times(Exactly(1));
+        .Times(Exactly(1));
 
-    buffer->bind_to_texture();
+    mga::Buffer buffer(stub_buffer, extensions);
+    buffer.bind_to_texture();
 }
 
 TEST_F(AndroidBufferBinding, buffer_only_makes_one_image_per_display)
 {
     using namespace testing;
     EXPECT_CALL(mock_egl, eglCreateImageKHR(_,_,_,_,_))
-    .Times(Exactly(1));
+        .Times(Exactly(1));
 
-    buffer->bind_to_texture();
-    buffer->bind_to_texture();
-    buffer->bind_to_texture();
+    mga::Buffer buffer(stub_buffer, extensions);
+    buffer.bind_to_texture();
+    buffer.bind_to_texture();
+    buffer.bind_to_texture();
 }
 
 TEST_F(AndroidBufferBinding, buffer_makes_new_image_with_new_display)
@@ -101,16 +97,17 @@
 
     /* return 1st fake display */
     EXPECT_CALL(mock_egl, eglCreateImageKHR(_,_,_,_,_))
-    .Times(Exactly(2));
+        .Times(Exactly(2));
 
-    buffer->bind_to_texture();
+    mga::Buffer buffer(stub_buffer, extensions);
+    buffer.bind_to_texture();
 
     /* return 2nd fake display */
     EXPECT_CALL(mock_egl, eglGetCurrentDisplay())
-    .Times(Exactly(1))
-    .WillOnce(Return(second_fake_display));
+        .Times(Exactly(1))
+        .WillOnce(Return(second_fake_display));
 
-    buffer->bind_to_texture();
+    buffer.bind_to_texture();
 }
 
 TEST_F(AndroidBufferBinding, buffer_frees_images_it_makes)
@@ -119,15 +116,16 @@
     EGLDisplay second_fake_display = (EGLDisplay) ((int)mock_egl.fake_egl_display +1);
 
     EXPECT_CALL(mock_egl, eglDestroyImageKHR(_,_))
-    .Times(Exactly(2));
+        .Times(Exactly(2));
 
-    buffer->bind_to_texture();
+    mga::Buffer buffer(stub_buffer, extensions);
+    buffer.bind_to_texture();
 
     EXPECT_CALL(mock_egl, eglGetCurrentDisplay())
-    .Times(Exactly(1))
-    .WillOnce(Return(second_fake_display));
+        .Times(Exactly(1))
+        .WillOnce(Return(second_fake_display));
 
-    buffer->bind_to_texture();
+    buffer.bind_to_texture();
 }
 
 TEST_F(AndroidBufferBinding, buffer_frees_images_it_makes_with_proper_args)
@@ -141,29 +139,30 @@
 
     /* actual expectations */
     EXPECT_CALL(mock_egl, eglDestroyImageKHR(first_fake_display, first_fake_egl_image))
-    .Times(Exactly(1));
+        .Times(Exactly(1));
     EXPECT_CALL(mock_egl, eglDestroyImageKHR(second_fake_display, second_fake_egl_image))
-    .Times(Exactly(1));
+        .Times(Exactly(1));
 
     /* manipulate mock to return 1st set */
     EXPECT_CALL(mock_egl, eglGetCurrentDisplay())
-    .Times(Exactly(1))
-    .WillOnce(Return(first_fake_display));
+        .Times(Exactly(1))
+        .WillOnce(Return(first_fake_display));
     EXPECT_CALL(mock_egl, eglCreateImageKHR(_,_,_,_,_))
-    .Times(Exactly(1))
-    .WillOnce(Return((first_fake_egl_image)));
+        .Times(Exactly(1))
+        .WillOnce(Return((first_fake_egl_image)));
 
-    buffer->bind_to_texture();
+    mga::Buffer buffer(stub_buffer, extensions);
+    buffer.bind_to_texture();
 
     /* manipulate mock to return 2nd set */
     EXPECT_CALL(mock_egl, eglGetCurrentDisplay())
-    .Times(Exactly(1))
-    .WillOnce(Return(second_fake_display));
+        .Times(Exactly(1))
+        .WillOnce(Return(second_fake_display));
     EXPECT_CALL(mock_egl, eglCreateImageKHR(_,_,_,_,_))
-    .Times(Exactly(1))
-    .WillOnce(Return((second_fake_egl_image)));
+        .Times(Exactly(1))
+        .WillOnce(Return((second_fake_egl_image)));
 
-    buffer->bind_to_texture();
+    buffer.bind_to_texture();
 }
 
 TEST_F(AndroidBufferBinding, buffer_uses_current_display)
@@ -172,12 +171,13 @@
     EGLDisplay fake_display = (EGLDisplay) 0x32298;
 
     EXPECT_CALL(mock_egl, eglGetCurrentDisplay())
-    .Times(Exactly(1))
-    .WillOnce(Return(fake_display));
+        .Times(Exactly(1))
+        .WillOnce(Return(fake_display));
 
     EXPECT_CALL(mock_egl, eglCreateImageKHR(fake_display,_,_,_,_))
-    .Times(Exactly(1));
-    buffer->bind_to_texture();
+        .Times(Exactly(1));
+    mga::Buffer buffer(stub_buffer, extensions);
+    buffer.bind_to_texture();
 }
 
 TEST_F(AndroidBufferBinding, buffer_specifies_no_context)
@@ -185,8 +185,9 @@
     using namespace testing;
 
     EXPECT_CALL(mock_egl, eglCreateImageKHR(_, EGL_NO_CONTEXT,_,_,_))
-    .Times(Exactly(1));
-    buffer->bind_to_texture();
+        .Times(Exactly(1));
+    mga::Buffer buffer(stub_buffer, extensions);
+    buffer.bind_to_texture();
 }
 
 TEST_F(AndroidBufferBinding, buffer_sets_egl_native_buffer_android)
@@ -194,8 +195,9 @@
     using namespace testing;
 
     EXPECT_CALL(mock_egl, eglCreateImageKHR(_,_,EGL_NATIVE_BUFFER_ANDROID,_,_))
-    .Times(Exactly(1));
-    buffer->bind_to_texture();
+        .Times(Exactly(1));
+    mga::Buffer buffer(stub_buffer, extensions);
+    buffer.bind_to_texture();
 }
 
 TEST_F(AndroidBufferBinding, buffer_sets_anw_buffer_to_provided_anw)
@@ -203,8 +205,9 @@
     using namespace testing;
 
     EXPECT_CALL(mock_egl, eglCreateImageKHR(_,_,_,stub_buffer.get(),_))
-    .Times(Exactly(1));
-    buffer->bind_to_texture();
+        .Times(Exactly(1));
+    mga::Buffer buffer(stub_buffer, extensions);
+    buffer.bind_to_texture();
 }
 
 TEST_F(AndroidBufferBinding, buffer_sets_proper_attributes)
@@ -214,11 +217,11 @@
     const EGLint* attrs;
 
     EXPECT_CALL(mock_egl, eglCreateImageKHR(_,_,_,_,_))
-    .Times(Exactly(1))
-    .WillOnce(DoAll(
-                  SaveArg<4>(&attrs),
-                  Return(mock_egl.fake_egl_image)));
-    buffer->bind_to_texture();
+        .Times(Exactly(1))
+        .WillOnce(DoAll(SaveArg<4>(&attrs),
+                        Return(mock_egl.fake_egl_image)));
+    mga::Buffer buffer(stub_buffer, extensions);
+    buffer.bind_to_texture();
 
     /* note: this should not segfault. if it does, the attributes were set wrong */
     EXPECT_EQ(attrs[0],    EGL_IMAGE_PRESERVED_KHR);
@@ -232,31 +235,33 @@
     using namespace testing;
     EGLImageKHR fake_egl_image = (EGLImageKHR) 0x84210;
     EXPECT_CALL(mock_egl, eglCreateImageKHR(mock_egl.fake_egl_display,_,_,_,_))
-    .Times(Exactly(1))
-    .WillOnce(Return((fake_egl_image)));
+        .Times(Exactly(1))
+        .WillOnce(Return((fake_egl_image)));
     EXPECT_CALL(mock_egl, eglDestroyImageKHR(mock_egl.fake_egl_display, fake_egl_image))
-    .Times(Exactly(1));
+        .Times(Exactly(1));
 
-    buffer->bind_to_texture();
+    mga::Buffer buffer(stub_buffer, extensions);
+    buffer.bind_to_texture();
 }
 
 TEST_F(AndroidBufferBinding, buffer_image_creation_failure_does_not_save)
 {
     using namespace testing;
     EXPECT_CALL(mock_egl, eglCreateImageKHR(_,_,_,_,_))
-    .Times(Exactly(2))
-    .WillRepeatedly(Return((EGL_NO_IMAGE_KHR)));
+        .Times(Exactly(2))
+        .WillRepeatedly(Return((EGL_NO_IMAGE_KHR)));
     EXPECT_CALL(mock_egl, eglDestroyImageKHR(_,_))
-    .Times(Exactly(0));
+        .Times(Exactly(0));
 
+    mga::Buffer buffer(stub_buffer, extensions);
     EXPECT_THROW(
     {
-        buffer->bind_to_texture();
+        buffer.bind_to_texture();
     }, std::runtime_error);
 
     EXPECT_THROW(
     {
-        buffer->bind_to_texture();
+        buffer.bind_to_texture();
     }, std::runtime_error);
 }
 
@@ -264,12 +269,13 @@
 {
     using namespace testing;
     EXPECT_CALL(mock_egl, eglCreateImageKHR(_,_,_,_,_))
-    .Times(Exactly(1))
-    .WillRepeatedly(Return((EGL_NO_IMAGE_KHR)));
+        .Times(Exactly(1))
+        .WillRepeatedly(Return((EGL_NO_IMAGE_KHR)));
 
+    mga::Buffer buffer(stub_buffer, extensions);
     EXPECT_THROW(
     {
-        buffer->bind_to_texture();
+        buffer.bind_to_texture();
     }, std::runtime_error);
 }
 
@@ -278,37 +284,40 @@
 TEST_F(AndroidBufferBinding, buffer_calls_binding_extension)
 {
     using namespace testing;
-    EXPECT_CALL(mock_gl, glEGLImageTargetTexture2DOES(_, _))
-    .Times(Exactly(1));
-    buffer->bind_to_texture();
+    EXPECT_CALL(mock_egl, glEGLImageTargetTexture2DOES(_, _))
+        .Times(Exactly(1));
+    mga::Buffer buffer(stub_buffer, extensions);
+    buffer.bind_to_texture();
 }
 
 TEST_F(AndroidBufferBinding, buffer_calls_binding_extension_every_time)
 {
     using namespace testing;
-    EXPECT_CALL(mock_gl, glEGLImageTargetTexture2DOES(_, _))
-    .Times(Exactly(3));
-
-    buffer->bind_to_texture();
-    buffer->bind_to_texture();
-    buffer->bind_to_texture();
-
+    EXPECT_CALL(mock_egl, glEGLImageTargetTexture2DOES(_, _))
+        .Times(Exactly(3));
+
+    mga::Buffer buffer(stub_buffer, extensions);
+    buffer.bind_to_texture();
+    buffer.bind_to_texture();
+    buffer.bind_to_texture();
 }
 
 TEST_F(AndroidBufferBinding, buffer_binding_specifies_gl_texture_2d)
 {
     using namespace testing;
-    EXPECT_CALL(mock_gl, glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, _))
-    .Times(Exactly(1));
-    buffer->bind_to_texture();
+    EXPECT_CALL(mock_egl, glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, _))
+        .Times(Exactly(1));
+    mga::Buffer buffer(stub_buffer, extensions);
+    buffer.bind_to_texture();
 }
 
 TEST_F(AndroidBufferBinding, buffer_binding_uses_right_image)
 {
     using namespace testing;
-    EXPECT_CALL(mock_gl, glEGLImageTargetTexture2DOES(_, mock_egl.fake_egl_image))
-    .Times(Exactly(1));
-    buffer->bind_to_texture();
+    EXPECT_CALL(mock_egl, glEGLImageTargetTexture2DOES(_, mock_egl.fake_egl_image))
+        .Times(Exactly(1));
+    mga::Buffer buffer(stub_buffer, extensions);
+    buffer.bind_to_texture();
 }
 
 TEST_F(AndroidBufferBinding, buffer_binding_uses_right_image_after_display_swap)
@@ -317,17 +326,18 @@
     EGLDisplay second_fake_display = (EGLDisplay) ((int)mock_egl.fake_egl_display +1);
     EGLImageKHR second_fake_egl_image = (EGLImageKHR) 0x84211;
 
-    EXPECT_CALL(mock_gl, glEGLImageTargetTexture2DOES(_, _))
-    .Times(Exactly(1));
-    buffer->bind_to_texture();
+    EXPECT_CALL(mock_egl, glEGLImageTargetTexture2DOES(_, _))
+        .Times(Exactly(1));
+    mga::Buffer buffer(stub_buffer, extensions);
+    buffer.bind_to_texture();
 
-    EXPECT_CALL(mock_gl, glEGLImageTargetTexture2DOES(_, second_fake_egl_image))
-    .Times(Exactly(1));
+    EXPECT_CALL(mock_egl, glEGLImageTargetTexture2DOES(_, second_fake_egl_image))
+        .Times(Exactly(1));
     EXPECT_CALL(mock_egl, eglGetCurrentDisplay())
-    .Times(Exactly(1))
-    .WillOnce(Return(second_fake_display));
+        .Times(Exactly(1))
+        .WillOnce(Return(second_fake_display));
     EXPECT_CALL(mock_egl, eglCreateImageKHR(_,_,_,_,_))
-    .Times(Exactly(1))
-    .WillOnce(Return((second_fake_egl_image)));
-    buffer->bind_to_texture();
+        .Times(Exactly(1))
+        .WillOnce(Return((second_fake_egl_image)));
+    buffer.bind_to_texture();
 }

=== modified file 'tests/unit-tests/graphics/gbm/test_gbm_buffer.cpp'
--- tests/unit-tests/graphics/gbm/test_gbm_buffer.cpp	2013-05-22 06:30:39 +0000
+++ tests/unit-tests/graphics/gbm/test_gbm_buffer.cpp	2013-06-14 20:23:35 +0000
@@ -69,15 +69,6 @@
         ON_CALL(mock_gbm, gbm_bo_get_stride(_))
         .WillByDefault(Return(stride.as_uint32_t()));
 
-        typedef mtd::MockEGL::generic_function_pointer_t func_ptr_t;
-
-        ON_CALL(mock_egl, eglGetProcAddress(StrEq("eglCreateImageKHR")))
-            .WillByDefault(Return(reinterpret_cast<func_ptr_t>(eglCreateImageKHR)));
-        ON_CALL(mock_egl, eglGetProcAddress(StrEq("eglDestroyImageKHR")))
-            .WillByDefault(Return(reinterpret_cast<func_ptr_t>(eglDestroyImageKHR)));
-        ON_CALL(mock_egl, eglGetProcAddress(StrEq("glEGLImageTargetTexture2DOES")))
-            .WillByDefault(Return(reinterpret_cast<func_ptr_t>(glEGLImageTargetTexture2DOES)));
-
         platform = std::make_shared<mgg::GBMPlatform>(std::make_shared<mg::NullDisplayReport>(),
                                                       std::make_shared<mtd::NullVirtualTerminal>());
         null_init = std::make_shared<mg::NullBufferInitializer>();
@@ -218,7 +209,7 @@
         EXPECT_CALL(mock_egl, eglCreateImageKHR(_,_,_,_,_))
             .Times(Exactly(1));
 
-        EXPECT_CALL(mock_gl, glEGLImageTargetTexture2DOES(_,mock_egl.fake_egl_image))
+        EXPECT_CALL(mock_egl, glEGLImageTargetTexture2DOES(_,mock_egl.fake_egl_image))
             .Times(Exactly(1));
 
         EXPECT_CALL(mock_egl, eglDestroyImageKHR(_,mock_egl.fake_egl_image))

=== modified file 'tests/unit-tests/graphics/gbm/test_gbm_buffer_allocator.cpp'
--- tests/unit-tests/graphics/gbm/test_gbm_buffer_allocator.cpp	2013-05-20 15:55:48 +0000
+++ tests/unit-tests/graphics/gbm/test_gbm_buffer_allocator.cpp	2013-06-14 20:23:35 +0000
@@ -1,4 +1,3 @@
-
 /*
  * Copyright © 2012 Canonical Ltd.
  *
@@ -59,15 +58,6 @@
         ON_CALL(mock_gbm, gbm_bo_get_handle(_))
         .WillByDefault(Return(mock_gbm.fake_gbm.bo_handle));
 
-        typedef mtd::MockEGL::generic_function_pointer_t func_ptr_t;
-
-        ON_CALL(mock_egl, eglGetProcAddress(StrEq("eglCreateImageKHR")))
-            .WillByDefault(Return(reinterpret_cast<func_ptr_t>(eglCreateImageKHR)));
-        ON_CALL(mock_egl, eglGetProcAddress(StrEq("eglDestroyImageKHR")))
-            .WillByDefault(Return(reinterpret_cast<func_ptr_t>(eglDestroyImageKHR)));
-        ON_CALL(mock_egl, eglGetProcAddress(StrEq("glEGLImageTargetTexture2DOES")))
-            .WillByDefault(Return(reinterpret_cast<func_ptr_t>(glEGLImageTargetTexture2DOES)));
-
         platform = std::make_shared<mgg::GBMPlatform>(std::make_shared<mg::NullDisplayReport>(),
                                                       std::make_shared<mtd::NullVirtualTerminal>());
         mock_buffer_initializer = std::make_shared<testing::NiceMock<mtd::MockBufferInitializer>>();
@@ -227,34 +217,6 @@
     }, std::runtime_error);
 }
 
-TEST_F(GBMBufferAllocatorTest, constructor_throws_if_egl_image_not_supported)
-{
-    using namespace testing;
-    typedef mtd::MockEGL::generic_function_pointer_t func_ptr_t;
-
-    ON_CALL(mock_egl, eglGetProcAddress(StrEq("eglCreateImageKHR")))
-        .WillByDefault(Return(reinterpret_cast<func_ptr_t>(0)));
-    ON_CALL(mock_egl, eglGetProcAddress(StrEq("eglDestroyImageKHR")))
-        .WillByDefault(Return(reinterpret_cast<func_ptr_t>(0)));
-
-    EXPECT_THROW({
-        mgg::GBMBufferAllocator allocator(platform, mock_buffer_initializer);
-    }, std::runtime_error);
-}
-
-TEST_F(GBMBufferAllocatorTest, constructor_throws_if_gl_oes_egl_image_not_supported)
-{
-    using namespace testing;
-    typedef mtd::MockEGL::generic_function_pointer_t func_ptr_t;
-
-    ON_CALL(mock_egl, eglGetProcAddress(StrEq("glEGLImageTargetTexture2DOES")))
-        .WillByDefault(Return(reinterpret_cast<func_ptr_t>(0)));
-
-    EXPECT_THROW({
-        mgg::GBMBufferAllocator allocator(platform, mock_buffer_initializer);
-    }, std::runtime_error);
-}
-
 TEST_F(GBMBufferAllocatorTest, supported_pixel_formats_contain_common_formats)
 {
     auto supported_pixel_formats = allocator->supported_pixel_formats();

=== added file 'tests/unit-tests/graphics/test_egl_extensions.cpp'
--- tests/unit-tests/graphics/test_egl_extensions.cpp	1970-01-01 00:00:00 +0000
+++ tests/unit-tests/graphics/test_egl_extensions.cpp	2013-06-14 20:23:35 +0000
@@ -0,0 +1,75 @@
+/*
+ * 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:
+ *   Kevin DuBois <[e-mail]>
+ */
+
+#include "mir/graphics/egl_extensions.h"
+#include "mir_test_doubles/mock_egl.h"
+#include <stdexcept>
+
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+
+namespace mg = mir::graphics;
+namespace mtd = mir::test::doubles;
+
+class EGLExtensionsTest  : public ::testing::Test
+{
+protected:
+    virtual void SetUp()
+    {
+    }
+
+    testing::NiceMock<mtd::MockEGL> mock_egl;
+};
+
+TEST_F(EGLExtensionsTest, constructor_throws_if_egl_image_not_supported)
+{
+    using namespace testing;
+    typedef mtd::MockEGL::generic_function_pointer_t func_ptr_t;
+
+    ON_CALL(mock_egl, eglGetProcAddress(StrEq("eglCreateImageKHR")))
+        .WillByDefault(Return(reinterpret_cast<func_ptr_t>(0)));
+    ON_CALL(mock_egl, eglGetProcAddress(StrEq("eglDestroyImageKHR")))
+        .WillByDefault(Return(reinterpret_cast<func_ptr_t>(0)));
+
+    EXPECT_THROW({
+        mg::EGLExtensions extensions;
+    }, std::runtime_error);
+}
+
+TEST_F(EGLExtensionsTest, constructor_throws_if_gl_oes_egl_image_not_supported)
+{
+    using namespace testing;
+    typedef mtd::MockEGL::generic_function_pointer_t func_ptr_t;
+
+    ON_CALL(mock_egl, eglGetProcAddress(StrEq("glEGLImageTargetTexture2DOES")))
+        .WillByDefault(Return(reinterpret_cast<func_ptr_t>(0)));
+
+    EXPECT_THROW({
+        mg::EGLExtensions extensions;
+    }, std::runtime_error);
+}
+
+TEST_F(EGLExtensionsTest, success_has_sane_function_hooks)
+{
+    mg::EGLExtensions extensions;
+    EXPECT_NE(nullptr, extensions.eglCreateImageKHR);
+    EXPECT_NE(nullptr, extensions.eglDestroyImageKHR);
+    EXPECT_NE(nullptr, extensions.glEGLImageTargetTexture2DOES);
+}
+