Merge lp:~alan-griffiths/mir/move-graphicsplatform-dependencies-to-graphics into lp:~mir-team/mir/trunk

[Alan Griffiths]

graphics, conpositor: Move dependencies of graphics platform into graphics.

graphics, conpositor: Move dependencies of graphics platform into graphics.

This is preparatory to splitting graphics off into an LGPL library that breaks the current dependency of graphicsplatform implementations on GPL code.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:858
http://jenkins.qa.ubuntu.com/job/mir-ci/1026/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-saucy-i386-build/1332
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-saucy-amd64-build/1217
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-saucy-amd64-ci/264
        deb: http://jenkins.qa.ubuntu.com/job/mir-saucy-amd64-ci/264/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-vm-ci-build/./distribution=quantal,flavor=amd64/655

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

review: Approve (continuous-integration)

[Daniel van Vugt (vanvugt)]

1. So the graphics namespace would no longer be used inside libmirserver right? Because everything remaining in libmirserver would ideally be moved into mir::server:: or grouped more logically in future.

2. Can we think of a better namespace than "mir::graphics::"? It seems silly to imply that other components of Mir are not graphics-related. It's all graphics-related. So calling the namespace "graphics" does not communicate the intention at all. Maybe use "driver" or "platform"...

review: Needs Information

[Alexandros Frantzis (afrantzis)]

One concern I have is that we move some interfaces away from their consumers (e.g. msh::PixelBuffer). Although the consumer can still conceptually stay in control of the interface, the dissociation makes it less intuitive to do so. An alternative would be to change the license in files without moving them, but that's arguably more complicated and confusing for interested parties. So I guess this dissociation is something we will need to live with :/

[Daniel van Vugt (vanvugt)]

There's a very simple (albeit initially labour intensive) solution I mentioned a while back: Just define a bare interface that is "a graphics driver" header, which has zero dependencies on anything else. Then both the server and the driver can use that interface without any license mixture.

[Alan Griffiths (alan-griffiths)]

> 1. So the graphics namespace would no longer be used inside libmirserver
> right? Because everything remaining in libmirserver would ideally be moved
> into mir::server:: or grouped more logically in future.

No. Like the protobuf namespace the graphics namespace will be consumed in libmirserver, but implemented in another library.

> 2. Can we think of a better namespace than "mir::graphics::"? It seems silly
> to imply that other components of Mir are not graphics-related. It's all
> graphics-related. So calling the namespace "graphics" does not communicate the
> intention at all. Maybe use "driver" or "platform"...

Possibly, the name originates from the the project startup meeting (and I'm used to it).

I don't think this MP is the right place to change it though - an MP dedicated to changing the name would be far easier to review.

[Daniel van Vugt (vanvugt)]

OK, it sounds quite plausible, and I hope reasonable, that the "graphics" namespace should go away. So I think it might be a bad idea to move everything into "graphics" if it should/might go away soon.

I think this MP is the correct place to fix it.

review: Needs Fixing

[Daniel van Vugt (vanvugt)]

Now I look in more detail, there is a bigger issue - We are moving platform independent classes out of mir::compositor:: and into mir::graphics::. So the mir::graphics:: you see here is actually a superset of what will be the "platform" or driver". Much of it however is platform independent.

I'm now wondering if the whole exercise makes sense. Dividing the server library into 3 eventual parts seems a bit messy:

1. Existing GPL server code
2. Server code which has to become LGPL
3. The platform/driver code

I don't think designating 2 and 3 as mir::graphics:: is helpful. Particularly when 2 is more closely related to 1.

review: Needs Fixing

[Daniel van Vugt (vanvugt)]

I suggest two possible solutions:

(a) Define a clear and completely independent driver interface which has no dependencies; or
(b) Move the whole libmirserver to LGPL, as a temporary step in the absence of (a).

[Alan Griffiths (alan-griffiths)]

> I suggest two possible solutions:
>
> (a) Define a clear and completely independent driver interface which has no
> dependencies; or
> (b) Move the whole libmirserver to LGPL, as a temporary step in the absence of
> (a).

(c) Define a clear driver interface which only has dependencies on LGPL code, not on libmirserver. (This MP moves "graphics" a step in that direction - "graphics" will become that interface and new LGPL library.)

[Alan Griffiths (alan-griffiths)]

> Now I look in more detail, there is a bigger issue - We are moving platform
> independent classes out of mir::compositor:: and into mir::graphics::. So the
> mir::graphics:: you see here is actually a superset of what will be the
> "platform" or driver". Much of it however is platform independent.
>
> I'm now wondering if the whole exercise makes sense. Dividing the server
> library into 3 eventual parts seems a bit messy:
>
> 1. Existing GPL server code
> 2. Server code which has to become LGPL
> 3. The platform/driver code
>
> I don't think designating 2 and 3 as mir::graphics:: is helpful. Particularly
> when 2 is more closely related to 1.

No-one is proposing to move 3 into graphics

[Daniel van Vugt (vanvugt)]

I think dividing libmirserver into more libraries is just going to make maintenance more difficult. Plus we won't get it right first time and more classes will drift from GPL into LGPL over time. There's no reason to maintain any GPL server code if so much of it needs to be LGPL.

But again, if your "driver interface" is carefully designed to have zero dependencies, then the server library can stay full GPL.

[lp:~alan-griffiths/mir/move-graphicsplatform-dependencies-to-graphics]

859. By Alan Griffiths on 2013-07-17

merge lp:mir

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:859
http://jenkins.qa.ubuntu.com/job/mir-ci/1038/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-saucy-i386-build/1348
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-saucy-amd64-build/1233
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-saucy-amd64-ci/276
        deb: http://jenkins.qa.ubuntu.com/job/mir-saucy-amd64-ci/276/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-vm-ci-build/./distribution=quantal,flavor=amd64/665

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

review: Approve (continuous-integration)

[lp:~alan-griffiths/mir/move-graphicsplatform-dependencies-to-graphics]

860. By Alan Griffiths on 2013-07-17

merge lp:mir

861. By Alan Griffiths on 2013-07-17

merge lp:mir

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:861
http://jenkins.qa.ubuntu.com/job/mir-ci/1039/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-saucy-i386-build/1352
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-saucy-amd64-build/1237
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-saucy-amd64-ci/277
        deb: http://jenkins.qa.ubuntu.com/job/mir-saucy-amd64-ci/277/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-vm-ci-build/./distribution=quantal,flavor=amd64/666

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

review: Approve (continuous-integration)

[lp:~alan-griffiths/mir/move-graphicsplatform-dependencies-to-graphics]

862. By Alan Griffiths on 2013-07-17

Move IntWrapper to LGPL

[Alan Griffiths (alan-griffiths)]

Note that everything moved in this MP is a header. All parts of the "graphics platform" interface that we are using.

[Alan Griffiths (alan-griffiths)]

> One concern I have is that we move some interfaces away from their consumers
> (e.g. msh::PixelBuffer). Although the consumer can still conceptually stay in
> control of the interface, the dissociation makes it less intuitive to do so.
> An alternative would be to change the license in files without moving them,
> but that's arguably more complicated and confusing for interested parties. So
> I guess this dissociation is something we will need to live with :/

In the specific case of PixelBuffer it would also be possible to move the gl_pixel_buffer.cpp/.h code out of graphics as it is platform independent gl code.

Perhaps the same is true of the other implementations in graphics? I need to think about this (and where, if anywhere, to put them).

Buffer however is implemented differently across gbm and android.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:862
http://jenkins.qa.ubuntu.com/job/mir-ci/1040/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-saucy-i386-build/1353
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-saucy-amd64-build/1238
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-saucy-amd64-ci/278
        deb: http://jenkins.qa.ubuntu.com/job/mir-saucy-amd64-ci/278/artifact/work/output/*zip*/output.zip
    UNSTABLE: http://jenkins.qa.ubuntu.com/job/mir-vm-ci-build/./distribution=quantal,flavor=amd64/667

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

review: Approve (continuous-integration)

Unmerged revisions

862. By Alan Griffiths on 2013-07-17

Move IntWrapper to LGPL

861. By Alan Griffiths on 2013-07-17

merge lp:mir

860. By Alan Griffiths on 2013-07-17

merge lp:mir

859. By Alan Griffiths on 2013-07-17

merge lp:mir

858. By Alan Griffiths on 2013-07-16

Move buffer.h and buffer_id.h to graphics

857. By Alan Griffiths on 2013-07-16

Move Buffer interface and BufferID to graphics

856. By Alan Griffiths on 2013-07-16

Simpler and more flexible IntWrapper

855. By Alan Griffiths on 2013-07-16

merge lp:mir

854. By Alan Griffiths on 2013-07-15

Move shell/pixel_buffer.h to graphics

853. By Alan Griffiths on 2013-07-15

Move PixelBuffer to graphics

=== modified file 'examples/buffer_render_target.cpp'
--- examples/buffer_render_target.cpp	2013-03-21 03:32:59 +0000
+++ examples/buffer_render_target.cpp	2013-07-17 14:20:33 +0000
@@ -17,16 +17,16 @@
  */
 
 #include "buffer_render_target.h"
-#include "mir/compositor/buffer.h"
+#include "mir/graphics/buffer.h"
 
 #include <GLES2/gl2ext.h>
 #include <stdexcept>
 
 namespace geom = mir::geometry;
-namespace mc = mir::compositor;
+namespace mg = mir::graphics;
 namespace mt = mir::tools;
 
-mt::BufferRenderTarget::BufferRenderTarget(mc::Buffer& buffer)
+mt::BufferRenderTarget::BufferRenderTarget(mg::Buffer& buffer)
     : buffer(buffer)
 {
     resources.setup(buffer);
@@ -55,7 +55,7 @@
         glDeleteFramebuffers(1, &fbo);
 }
 
-void mt::BufferRenderTarget::Resources::setup(mc::Buffer& buffer)
+void mt::BufferRenderTarget::Resources::setup(mg::Buffer& buffer)
 {
     geom::Size buf_size = buffer.size();
 
 
=== modified file 'examples/buffer_render_target.h'
--- examples/buffer_render_target.h	2013-03-21 03:32:59 +0000
+++ examples/buffer_render_target.h	2013-07-17 14:20:33 +0000
@@ -25,7 +25,7 @@
 
 namespace mir
 {
-namespace compositor
+namespace graphics
 {
 class Buffer;
 }
@@ -35,7 +35,7 @@
 class BufferRenderTarget
 {
 public:
-    BufferRenderTarget(mir::compositor::Buffer& buffer);
+    BufferRenderTarget(mir::graphics::Buffer& buffer);
     ~BufferRenderTarget();
 
     void make_current();
@@ -49,7 +49,7 @@
         {
         }
         ~Resources();
-        void setup(mir::compositor::Buffer& buffer);
+        void setup(mir::graphics::Buffer& buffer);
 
         GLuint fbo;
         GLuint color_tex;
@@ -57,7 +57,7 @@
     };
 
     Resources resources;
-    mir::compositor::Buffer& buffer;
+    mir::graphics::Buffer& buffer;
 };
 
 }
 
=== modified file 'examples/render_surfaces.cpp'
--- examples/render_surfaces.cpp	2013-07-11 16:54:41 +0000
+++ examples/render_surfaces.cpp	2013-07-17 14:20:33 +0000
@@ -289,7 +289,7 @@
             {
             }
 
-            void operator()(mc::Buffer& buffer)
+            void operator()(mg::Buffer& buffer)
             {
                 mt::BufferRenderTarget brt{buffer};
                 brt.make_current();
 
=== modified file 'include/server/mir/compositor/back_buffer_strategy.h'
--- include/server/mir/compositor/back_buffer_strategy.h	2013-06-17 15:55:04 +0000
+++ include/server/mir/compositor/back_buffer_strategy.h	2013-07-17 14:20:33 +0000
@@ -23,18 +23,17 @@
 
 namespace mir
 {
+namespace graphics { class Buffer; }
+
 namespace compositor
 {
-
-class Buffer;
-
 class BackBufferStrategy
 {
 public:
     virtual ~BackBufferStrategy() = default;
 
-    virtual std::shared_ptr<Buffer> acquire() = 0;
-    virtual void release(std::shared_ptr<Buffer> const& buffer) = 0;
+    virtual std::shared_ptr<graphics::Buffer> acquire() = 0;
+    virtual void release(std::shared_ptr<graphics::Buffer> const& buffer) = 0;
 
 protected:
     BackBufferStrategy() = default;
 
=== modified file 'include/server/mir/compositor/buffer_allocation_strategy.h'
--- include/server/mir/compositor/buffer_allocation_strategy.h	2013-06-21 23:40:49 +0000
+++ include/server/mir/compositor/buffer_allocation_strategy.h	2013-07-17 14:20:33 +0000
@@ -21,7 +21,7 @@
 #ifndef MIR_COMPOSITOR_BUFFER_ALLOCATION_STRATEGY_H_
 #define MIR_COMPOSITOR_BUFFER_ALLOCATION_STRATEGY_H_
 
-#include "mir/compositor/buffer.h"
+#include "mir/graphics/buffer.h"
 
 #include <vector>
 #include <memory>
@@ -46,7 +46,7 @@
 {
 public:
     virtual std::shared_ptr<BufferSwapper> create_swapper_reuse_buffers(BufferProperties const&,
-        std::vector<std::shared_ptr<Buffer>>&, size_t, SwapperType) const = 0;
+        std::vector<std::shared_ptr<graphics::Buffer>>&, size_t, SwapperType) const = 0;
     virtual std::shared_ptr<BufferSwapper> create_swapper_new_buffers(
         BufferProperties& actual_properties, BufferProperties const& requested_properties, SwapperType) const = 0;
 
 
=== modified file 'include/server/mir/compositor/buffer_basic.h'
--- include/server/mir/compositor/buffer_basic.h	2013-04-24 05:22:20 +0000
+++ include/server/mir/compositor/buffer_basic.h	2013-07-17 14:20:33 +0000
@@ -18,26 +18,26 @@
 #ifndef MIR_COMPOSITOR_BUFFER_BASIC_H_
 #define MIR_COMPOSITOR_BUFFER_BASIC_H_
 
-#include "mir/compositor/buffer.h"
-#include "mir/compositor/buffer_id.h"
+#include "mir/graphics/buffer.h"
+#include "mir/graphics/buffer_id.h"
 
 namespace mir
 {
 namespace compositor
 {
 
-class BufferBasic : public Buffer
+class BufferBasic : public graphics::Buffer
 {
 public:
     BufferBasic();
 
-    BufferID id() const
+    graphics::BufferID id() const
     {
         return buffer_id;
     }
 
 private:
-    BufferID const buffer_id;
+    graphics::BufferID const buffer_id;
 };
 
 }
 
=== modified file 'include/server/mir/compositor/buffer_stream_factory.h'
--- include/server/mir/compositor/buffer_stream_factory.h	2013-06-12 15:36:31 +0000
+++ include/server/mir/compositor/buffer_stream_factory.h	2013-07-17 14:20:33 +0000
@@ -21,7 +21,7 @@
 #ifndef MIR_COMPOSITOR_BUFFER_STREAM_FACTORY_H_
 #define MIR_COMPOSITOR_BUFFER_STREAM_FACTORY_H_
 
-#include "mir/compositor/buffer.h"
+#include "mir/graphics/buffer.h"
 #include "mir/surfaces/buffer_stream_factory.h"
 
 #include <memory>
 
=== modified file 'include/server/mir/compositor/buffer_stream_surfaces.h'
--- include/server/mir/compositor/buffer_stream_surfaces.h	2013-06-21 23:40:49 +0000
+++ include/server/mir/compositor/buffer_stream_surfaces.h	2013-07-17 14:20:33 +0000
@@ -40,9 +40,9 @@
     BufferStreamSurfaces(std::shared_ptr<BufferBundle> const& swapper);
     ~BufferStreamSurfaces();
 
-    std::shared_ptr<Buffer> secure_client_buffer();
+    std::shared_ptr<graphics::Buffer> secure_client_buffer();
 
-    std::shared_ptr<Buffer> lock_back_buffer();
+    std::shared_ptr<graphics::Buffer> lock_back_buffer();
 
     geometry::PixelFormat get_stream_pixel_format();
     geometry::Size stream_size();
 
=== modified file 'include/server/mir/compositor/buffer_swapper.h'
--- include/server/mir/compositor/buffer_swapper.h	2013-06-19 09:57:32 +0000
+++ include/server/mir/compositor/buffer_swapper.h	2013-07-17 14:20:33 +0000
@@ -25,10 +25,10 @@
 
 namespace mir
 {
+namespace graphics { class Buffer; }
+
 namespace compositor
 {
-class Buffer;
-
 class BufferSwapper
 {
 public:
@@ -41,12 +41,12 @@
      *
      * May throw a mc::BufferSwapperRequestAbortedException.
      */
-    virtual std::shared_ptr<Buffer> client_acquire() = 0;
+    virtual std::shared_ptr<graphics::Buffer> client_acquire() = 0;
 
     /**
      * Releases a client buffer, making it available to the compositor.
      */
-    virtual void client_release(std::shared_ptr<Buffer> const& queued_buffer) = 0;
+    virtual void client_release(std::shared_ptr<graphics::Buffer> const& queued_buffer) = 0;
 
     /**
      * Acquires the last posted buffer.
@@ -61,12 +61,12 @@
      *
      * May throw a mc::BufferSwapperOutOfBuffersException.
      */
-    virtual std::shared_ptr<Buffer> compositor_acquire() = 0;
+    virtual std::shared_ptr<graphics::Buffer> compositor_acquire() = 0;
 
     /**
      * Releases a compositor buffer, making it available to the client.
      */
-    virtual void compositor_release(std::shared_ptr<Buffer> const& released_buffer) = 0;
+    virtual void compositor_release(std::shared_ptr<graphics::Buffer> const& released_buffer) = 0;
 
     /**
      * Forces client requests on the buffer swapper to abort.
@@ -110,7 +110,7 @@
      * After the completion of this call, neither the client, nor the compositor can
      * continue to request or return buffers to this swapper.
      */
-    virtual void end_responsibility(std::vector<std::shared_ptr<Buffer>>& buffers, size_t& original_size) = 0;
+    virtual void end_responsibility(std::vector<std::shared_ptr<graphics::Buffer>>& buffers, size_t& original_size) = 0;
 
     /**
      * If the swapper has been used, and you want to preserve the buffers that have been used, 
 
=== modified file 'include/server/mir/compositor/buffer_swapper_multi.h'
--- include/server/mir/compositor/buffer_swapper_multi.h	2013-06-15 11:09:16 +0000
+++ include/server/mir/compositor/buffer_swapper_multi.h	2013-07-17 14:20:33 +0000
@@ -34,28 +34,26 @@
 namespace compositor
 {
 
-class Buffer;
-
 class BufferSwapperMulti : public BufferSwapper
 {
 public:
-    explicit BufferSwapperMulti(std::vector<std::shared_ptr<compositor::Buffer>>& buffer_list, size_t swapper_size);
+    explicit BufferSwapperMulti(std::vector<std::shared_ptr<graphics::Buffer>>& buffer_list, size_t swapper_size);
 
-    std::shared_ptr<Buffer> client_acquire();
-    void client_release(std::shared_ptr<Buffer> const& queued_buffer);
-    std::shared_ptr<Buffer> compositor_acquire();
-    void compositor_release(std::shared_ptr<Buffer> const& released_buffer);
+    std::shared_ptr<graphics::Buffer> client_acquire();
+    void client_release(std::shared_ptr<graphics::Buffer> const& queued_buffer);
+    std::shared_ptr<graphics::Buffer> compositor_acquire();
+    void compositor_release(std::shared_ptr<graphics::Buffer> const& released_buffer);
 
     void force_client_abort();
     void force_requests_to_complete();
-    void end_responsibility(std::vector<std::shared_ptr<Buffer>>&, size_t&);
+    void end_responsibility(std::vector<std::shared_ptr<graphics::Buffer>>&, size_t&);
 
 private:
     std::mutex swapper_mutex;
     std::condition_variable client_available_cv;
 
-    std::deque<std::shared_ptr<Buffer>> client_queue;
-    std::deque<std::shared_ptr<Buffer>> compositor_queue;
+    std::deque<std::shared_ptr<graphics::Buffer>> client_queue;
+    std::deque<std::shared_ptr<graphics::Buffer>> compositor_queue;
     unsigned int in_use_by_client;
     unsigned int const swapper_size;
     int clients_trying_to_acquire;
 
=== modified file 'include/server/mir/compositor/buffer_swapper_spin.h'
--- include/server/mir/compositor/buffer_swapper_spin.h	2013-07-16 09:31:36 +0000
+++ include/server/mir/compositor/buffer_swapper_spin.h	2013-07-17 14:20:33 +0000
@@ -47,21 +47,21 @@
 class BufferSwapperSpin : public BufferSwapper
 {
 public:
-    BufferSwapperSpin(std::vector<std::shared_ptr<compositor::Buffer>>& buffer_list, size_t swapper_size);
+    BufferSwapperSpin(std::vector<std::shared_ptr<graphics::Buffer>>& buffer_list, size_t swapper_size);
 
-    std::shared_ptr<Buffer> client_acquire();
-    void client_release(std::shared_ptr<Buffer> const& queued_buffer);
-    std::shared_ptr<Buffer> compositor_acquire();
-    void compositor_release(std::shared_ptr<Buffer> const& released_buffer);
+    std::shared_ptr<graphics::Buffer> client_acquire();
+    void client_release(std::shared_ptr<graphics::Buffer> const& queued_buffer);
+    std::shared_ptr<graphics::Buffer> compositor_acquire();
+    void compositor_release(std::shared_ptr<graphics::Buffer> const& released_buffer);
 
     void force_client_abort();
     void force_requests_to_complete();
-    void end_responsibility(std::vector<std::shared_ptr<Buffer>>&, size_t&);
+    void end_responsibility(std::vector<std::shared_ptr<graphics::Buffer>>&, size_t&);
 
 private:
     std::mutex swapper_mutex;
 
-    std::deque<std::shared_ptr<Buffer>> buffer_queue;
+    std::deque<std::shared_ptr<graphics::Buffer>> buffer_queue;
     unsigned int in_use_by_client;
     bool client_submitted_new_buffer;
     size_t const swapper_size;
 
=== modified file 'include/server/mir/compositor/graphic_buffer_allocator.h'
--- include/server/mir/compositor/graphic_buffer_allocator.h	2013-06-17 09:51:42 +0000
+++ include/server/mir/compositor/graphic_buffer_allocator.h	2013-07-17 14:20:33 +0000
@@ -19,7 +19,7 @@
 #ifndef MIR_COMPOSITOR_GRAPHIC_BUFFER_ALLOCATOR_H_
 #define MIR_COMPOSITOR_GRAPHIC_BUFFER_ALLOCATOR_H_
 
-#include "mir/compositor/buffer.h"
+#include "mir/graphics/buffer.h"
 
 #include <vector>
 #include <memory>
@@ -44,7 +44,7 @@
      *
      * \param [in] buffer_properties the properties the allocated buffer should have
      */
-    virtual std::shared_ptr<Buffer> alloc_buffer(
+    virtual std::shared_ptr<graphics::Buffer> alloc_buffer(
         BufferProperties const& buffer_properties) = 0;
 
     /**
 
=== modified file 'include/server/mir/compositor/multi_acquisition_back_buffer_strategy.h'
--- include/server/mir/compositor/multi_acquisition_back_buffer_strategy.h	2013-06-17 15:55:04 +0000
+++ include/server/mir/compositor/multi_acquisition_back_buffer_strategy.h	2013-07-17 14:20:33 +0000
@@ -29,8 +29,6 @@
 {
 namespace compositor
 {
-
-class Buffer;
 class BufferBundle;
 
 namespace detail
@@ -38,7 +36,7 @@
 
 struct AcquiredBufferInfo
 {
-    std::weak_ptr<Buffer> buffer;
+    std::weak_ptr<graphics::Buffer> buffer;
     bool partly_released;
     int use_count;
 };
@@ -50,12 +48,12 @@
 public:
     MultiAcquisitionBackBufferStrategy(std::shared_ptr<BufferBundle> const& buffer_bundle);
 
-    std::shared_ptr<Buffer> acquire();
-    void release(std::shared_ptr<Buffer> const& buffer);
+    std::shared_ptr<graphics::Buffer> acquire();
+    void release(std::shared_ptr<graphics::Buffer> const& buffer);
 
 private:
     std::vector<detail::AcquiredBufferInfo>::iterator find_info(
-        std::shared_ptr<Buffer> const& buffer);
+        std::shared_ptr<graphics::Buffer> const& buffer);
 
     std::shared_ptr<BufferBundle> const buffer_bundle;
     std::vector<detail::AcquiredBufferInfo> acquired_buffers;
 
=== modified file 'include/server/mir/compositor/swapper_factory.h'
--- include/server/mir/compositor/swapper_factory.h	2013-06-17 19:40:58 +0000
+++ include/server/mir/compositor/swapper_factory.h	2013-07-17 14:20:33 +0000
@@ -39,13 +39,13 @@
         int number_of_buffers);
 
     std::shared_ptr<BufferSwapper> create_swapper_reuse_buffers(BufferProperties const&,
-        std::vector<std::shared_ptr<Buffer>>&, size_t, SwapperType) const;
+        std::vector<std::shared_ptr<graphics::Buffer>>&, size_t, SwapperType) const;
     std::shared_ptr<BufferSwapper> create_swapper_new_buffers(
         BufferProperties& actual_properties, BufferProperties const& requested_properties, SwapperType) const;
 
 private:
     void change_swapper_size(
-        std::vector<std::shared_ptr<Buffer>>&, size_t const, size_t, BufferProperties const&) const;
+        std::vector<std::shared_ptr<graphics::Buffer>>&, size_t const, size_t, BufferProperties const&) const;
 
     std::shared_ptr<GraphicBufferAllocator> const gr_allocator;
     unsigned int const synchronous_number_of_buffers;
 
=== modified file 'include/server/mir/default_server_configuration.h'
--- include/server/mir/default_server_configuration.h	2013-07-15 09:29:14 +0000
+++ include/server/mir/default_server_configuration.h	2013-07-17 14:20:33 +0000
@@ -60,7 +60,6 @@
 class SessionListener;
 class FocusController;
 class SessionManager;
-class PixelBuffer;
 class SnapshotStrategy;
 }
 namespace time
@@ -82,6 +81,7 @@
 class Display;
 class ViewableArea;
 class BufferInitializer;
+class PixelBuffer;
 class DisplayReport;
 }
 namespace input
@@ -164,7 +164,7 @@
     virtual std::shared_ptr<shell::FocusSequence>     the_shell_focus_sequence();
     virtual std::shared_ptr<shell::PlacementStrategy> the_shell_placement_strategy();
     virtual std::shared_ptr<shell::SessionListener>   the_shell_session_listener();
-    virtual std::shared_ptr<shell::PixelBuffer>       the_shell_pixel_buffer();
+    virtual std::shared_ptr<graphics::PixelBuffer>       the_shell_pixel_buffer();
     virtual std::shared_ptr<shell::SnapshotStrategy>  the_shell_snapshot_strategy();
     /** @} */
 
@@ -248,7 +248,7 @@
     CachedPtr<shell::FocusSequence>     shell_focus_sequence;
     CachedPtr<shell::PlacementStrategy> shell_placement_strategy;
     CachedPtr<shell::SessionListener> shell_session_listener;
-    CachedPtr<shell::PixelBuffer>       shell_pixel_buffer;
+    CachedPtr<graphics::PixelBuffer>       shell_pixel_buffer;
     CachedPtr<shell::SnapshotStrategy>  shell_snapshot_strategy;
     CachedPtr<compositor::CompositingStrategy> compositing_strategy;
     CachedPtr<compositor::OverlayRenderer> overlay_renderer;
 
=== modified file 'include/server/mir/frontend/session_mediator.h'
--- include/server/mir/frontend/session_mediator.h	2013-07-09 18:53:16 +0000
+++ include/server/mir/frontend/session_mediator.h	2013-07-17 14:20:33 +0000
@@ -34,13 +34,13 @@
 }
 namespace graphics
 {
+class Buffer;
 class Platform;
 class ViewableArea;
 }
 
 namespace compositor
 {
-class Buffer;
 class GraphicBufferAllocator;
 }
 
@@ -123,7 +123,7 @@
     std::shared_ptr<ResourceCache> const resource_cache;
     std::shared_ptr<ClientBufferTracker> const client_tracker;
 
-    std::shared_ptr<compositor::Buffer> client_buffer_resource;
+    std::shared_ptr<graphics::Buffer> client_buffer_resource;
 
     std::mutex session_mutex;
     std::shared_ptr<Session> session;
 
=== modified file 'include/server/mir/frontend/surface.h'
--- include/server/mir/frontend/surface.h	2013-06-25 05:42:49 +0000
+++ include/server/mir/frontend/surface.h	2013-07-17 14:20:33 +0000
@@ -29,7 +29,7 @@
 
 namespace mir
 {
-namespace compositor
+namespace graphics
 {
 class Buffer;
 }
@@ -53,7 +53,7 @@
     virtual geometry::Size size() const = 0;
     virtual geometry::PixelFormat pixel_format() const = 0;
 
-    virtual std::shared_ptr<compositor::Buffer> advance_client_buffer() = 0;
+    virtual std::shared_ptr<graphics::Buffer> advance_client_buffer() = 0;
 
     virtual bool supports_input() const = 0;
     virtual int client_input_fd() const = 0;
 
=== renamed file 'include/server/mir/compositor/buffer.h' => 'include/server/mir/graphics/buffer.h'
--- include/server/mir/compositor/buffer.h	2013-05-14 17:39:25 +0000
+++ include/server/mir/graphics/buffer.h	2013-07-17 14:20:33 +0000
@@ -26,9 +26,8 @@
 
 namespace mir
 {
-namespace compositor
+namespace graphics
 {
-struct BufferIPCPackage;
 class BufferID;
 
 class Buffer : public surfaces::GraphicRegion
 
=== renamed file 'include/server/mir/compositor/buffer_id.h' => 'include/server/mir/graphics/buffer_id.h'
--- include/server/mir/compositor/buffer_id.h	2013-04-24 05:22:20 +0000
+++ include/server/mir/graphics/buffer_id.h	2013-07-17 14:20:33 +0000
@@ -15,14 +15,14 @@
  *
  * Authored by: Kevin DuBois <[e-mail]>
  */
-#ifndef MIR_COMPOSITOR_BUFFER_ID_H_
-#define MIR_COMPOSITOR_BUFFER_ID_H_
+#ifndef MIR_GRAPHICS_BUFFER_ID_H_
+#define MIR_GRAPHICS_BUFFER_ID_H_
 
 #include <cstdint>
 
 namespace mir
 {
-namespace compositor
+namespace graphics
 {
 class BufferID
 {
@@ -53,4 +53,4 @@
 
 }
 }
-#endif /* MIR_COMPOSITOR_BUFFER_ID_H_ */
+#endif /* MIR_GRAPHICS_BUFFER_ID_H_ */
 
=== modified file 'include/server/mir/graphics/buffer_initializer.h'
--- include/server/mir/graphics/buffer_initializer.h	2013-06-18 08:49:16 +0000
+++ include/server/mir/graphics/buffer_initializer.h	2013-07-17 14:20:33 +0000
@@ -21,12 +21,9 @@
 
 namespace mir
 {
-namespace compositor
+namespace graphics
 {
 class Buffer;
-}
-namespace graphics
-{
 
 /**
  * Interface to buffer initialization.
@@ -37,7 +34,7 @@
     virtual ~BufferInitializer() {}
 
     /** Operator to call to initialize a buffer. */
-    virtual void operator()(compositor::Buffer& buffer) = 0;
+    virtual void operator()(Buffer& buffer) = 0;
 
 protected:
     BufferInitializer() = default;
@@ -48,7 +45,7 @@
 class NullBufferInitializer : public BufferInitializer
 {
 public:
-    void operator()(compositor::Buffer& /*buffer*/) {}
+    void operator()(Buffer& /*buffer*/) {}
 };
 
 }
 
=== modified file 'include/server/mir/graphics/gl_pixel_buffer.h'
--- include/server/mir/graphics/gl_pixel_buffer.h	2013-06-25 10:44:13 +0000
+++ include/server/mir/graphics/gl_pixel_buffer.h	2013-07-17 14:20:33 +0000
@@ -19,7 +19,7 @@
 #ifndef MIR_GRAPHICS_GL_PIXEL_BUFFER_H_
 #define MIR_GRAPHICS_GL_PIXEL_BUFFER_H_
 
-#include "mir/shell/pixel_buffer.h"
+#include "mir/graphics/pixel_buffer.h"
 
 #include <memory>
 #include <vector>
@@ -30,17 +30,17 @@
 {
 namespace graphics
 {
-
+class Buffer;
 class GLContext;
 
 /** Extracts the pixels from a compositor::Buffer using GL facilities. */
-class GLPixelBuffer : public shell::PixelBuffer
+class GLPixelBuffer : public PixelBuffer
 {
 public:
     GLPixelBuffer(std::unique_ptr<GLContext> gl_context);
     ~GLPixelBuffer() noexcept;
 
-    void fill_from(compositor::Buffer& buffer);
+    void fill_from(Buffer& buffer);
     void const* as_argb_8888();
     geometry::Size size() const;
     geometry::Stride stride() const;
 
=== renamed file 'include/server/mir/shell/pixel_buffer.h' => 'include/server/mir/graphics/pixel_buffer.h'
--- include/server/mir/shell/pixel_buffer.h	2013-06-25 10:44:13 +0000
+++ include/server/mir/graphics/pixel_buffer.h	2013-07-17 14:20:33 +0000
@@ -16,20 +16,17 @@
  * Authored By: Alexandros Frantzis <[e-mail]>
  */
 
-#ifndef MIR_SHELL_PIXEL_BUFFER_H_
-#define MIR_SHELL_PIXEL_BUFFER_H_
+#ifndef MIR_GRAPHICS_PIXEL_BUFFER_H_
+#define MIR_GRAPHICS_PIXEL_BUFFER_H_
 
 #include "mir/geometry/size.h"
 #include "mir/geometry/dimensions.h"
 
 namespace mir
 {
-namespace compositor
+namespace graphics
 {
 class Buffer;
-}
-namespace shell
-{
 
 /**
  * Interface for extracting the pixels from a compositor::Buffer.
@@ -44,7 +41,7 @@
      *
      * \param [in] buffer the buffer to get the pixels of
      */
-    virtual void fill_from(compositor::Buffer& buffer) = 0;
+    virtual void fill_from(Buffer& buffer) = 0;
 
     /**
      * The pixels in 0xAARRGGBB format.
@@ -75,4 +72,4 @@
 }
 }
 
-#endif /* MIR_SHELL_PIXEL_BUFFER_H_ */
+#endif /* MIR_GRAPHICS_PIXEL_BUFFER_H_ */
 
=== modified file 'include/server/mir/graphics/platform.h'
--- include/server/mir/graphics/platform.h	2013-07-10 08:50:53 +0000
+++ include/server/mir/graphics/platform.h	2013-07-17 14:20:33 +0000
@@ -31,7 +31,6 @@
 namespace compositor
 {
 class GraphicBufferAllocator;
-class Buffer;
 class BufferIPCPacker;
 }
 namespace options
@@ -44,6 +43,7 @@
 namespace graphics
 {
 
+class Buffer;
 class Display;
 struct PlatformIPCPackage;
 class BufferInitializer;
@@ -102,7 +102,7 @@
      * \param [in] buffer the buffer to fill the IPC package for
      */
     virtual void fill_ipc_package(std::shared_ptr<compositor::BufferIPCPacker> const& packer,
-                                  std::shared_ptr<compositor::Buffer> const& buffer) const = 0;
+                                  std::shared_ptr<graphics::Buffer> const& buffer) const = 0;
 
     /**
      * Creates the in-process client support object.
 
=== modified file 'include/server/mir/shell/surface.h'
--- include/server/mir/shell/surface.h	2013-07-09 18:55:47 +0000
+++ include/server/mir/shell/surface.h	2013-07-17 14:20:33 +0000
@@ -78,8 +78,8 @@
     virtual geometry::PixelFormat pixel_format() const;
 
     virtual void with_most_recent_buffer_do(
-        std::function<void(compositor::Buffer&)> const& exec);
-    virtual std::shared_ptr<compositor::Buffer> advance_client_buffer();
+        std::function<void(graphics::Buffer&)> const& exec);
+    virtual std::shared_ptr<graphics::Buffer> advance_client_buffer();
 
     virtual bool supports_input() const;
     virtual int client_input_fd() const;
 
=== modified file 'include/server/mir/shell/surface_buffer_access.h'
--- include/server/mir/shell/surface_buffer_access.h	2013-06-25 13:19:14 +0000
+++ include/server/mir/shell/surface_buffer_access.h	2013-07-17 14:20:33 +0000
@@ -23,7 +23,7 @@
 
 namespace mir
 {
-namespace compositor
+namespace graphics
 {
 class Buffer;
 }
@@ -36,7 +36,7 @@
     virtual ~SurfaceBufferAccess() = default;
 
     virtual void with_most_recent_buffer_do(
-        std::function<void(compositor::Buffer&)> const& exec) = 0;
+        std::function<void(graphics::Buffer&)> const& exec) = 0;
 
 protected:
     SurfaceBufferAccess() = default;
 
=== modified file 'include/server/mir/shell/threaded_snapshot_strategy.h'
--- include/server/mir/shell/threaded_snapshot_strategy.h	2013-06-25 13:19:14 +0000
+++ include/server/mir/shell/threaded_snapshot_strategy.h	2013-07-17 14:20:33 +0000
@@ -27,16 +27,19 @@
 
 namespace mir
 {
+namespace graphics
+{
+class PixelBuffer;
+}
+
 namespace shell
 {
-
-class PixelBuffer;
 class SnapshottingFunctor;
 
 class ThreadedSnapshotStrategy : public SnapshotStrategy
 {
 public:
-    ThreadedSnapshotStrategy(std::shared_ptr<PixelBuffer> const& pixels);
+    ThreadedSnapshotStrategy(std::shared_ptr<graphics::PixelBuffer> const& pixels);
     ~ThreadedSnapshotStrategy() noexcept;
 
     void take_snapshot_of(
@@ -44,7 +47,7 @@
         SnapshotCallback const& snapshot_taken);
 
 private:
-    std::shared_ptr<PixelBuffer> const pixels;
+    std::shared_ptr<graphics::PixelBuffer> const pixels;
     std::unique_ptr<SnapshottingFunctor> functor;
     std::thread thread;
 };
 
=== modified file 'include/server/mir/surfaces/buffer_stream.h'
--- include/server/mir/surfaces/buffer_stream.h	2013-06-21 23:40:49 +0000
+++ include/server/mir/surfaces/buffer_stream.h	2013-07-17 14:20:33 +0000
@@ -22,13 +22,13 @@
 
 #include "mir/geometry/size.h"
 #include "mir/geometry/pixel_format.h"
-#include "mir/compositor/buffer_id.h"
+#include "mir/graphics/buffer_id.h"
 
 #include <memory>
 
 namespace mir
 {
-namespace compositor
+namespace graphics
 {
 class Buffer;
 }
@@ -41,8 +41,8 @@
 public:
     virtual ~BufferStream() {/* TODO: make nothrow */}
 
-    virtual std::shared_ptr<compositor::Buffer> secure_client_buffer() = 0;
-    virtual std::shared_ptr<compositor::Buffer> lock_back_buffer() = 0;
+    virtual std::shared_ptr<graphics::Buffer> secure_client_buffer() = 0;
+    virtual std::shared_ptr<graphics::Buffer> lock_back_buffer() = 0;
     virtual geometry::PixelFormat get_stream_pixel_format() = 0;
     virtual geometry::Size stream_size() = 0;
     virtual void allow_framedropping(bool) = 0;
 
=== modified file 'include/server/mir/surfaces/surface.h'
--- include/server/mir/surfaces/surface.h	2013-07-15 15:15:40 +0000
+++ include/server/mir/surfaces/surface.h	2013-07-17 14:20:33 +0000
@@ -32,10 +32,12 @@
 {
 namespace compositor
 {
-class Buffer;
 class GraphicRegion;
 struct BufferIPCPackage;
-class BufferID;
+}
+namespace graphics
+{
+class Buffer;
 }
 namespace input
 {
@@ -75,8 +77,8 @@
 
     geometry::PixelFormat pixel_format() const;
 
-    std::shared_ptr<compositor::Buffer> compositor_buffer() const;
-    std::shared_ptr<compositor::Buffer> advance_client_buffer();
+    std::shared_ptr<graphics::Buffer> compositor_buffer() const;
+    std::shared_ptr<graphics::Buffer> advance_client_buffer();
     void force_requests_to_complete();
     void flag_for_render();
 
 
=== renamed file 'include/server/mir/int_wrapper.h' => 'include/shared/mir/int_wrapper.h'
--- include/server/mir/int_wrapper.h	2013-07-16 12:00:39 +0000
+++ include/shared/mir/int_wrapper.h	2013-07-17 14:20:33 +0000
@@ -1,17 +1,17 @@
 /*
- * Copyright © 2012 Canonical Ltd.
+ * Copyright © 2012, 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,
+ * 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 General Public License for more details.
+ * 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 General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ * 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: Alan Griffiths <[e-mail]>
  */
 
=== modified file 'include/test/mir_test_doubles/mock_buffer.h'
--- include/test/mir_test_doubles/mock_buffer.h	2013-05-14 21:39:52 +0000
+++ include/test/mir_test_doubles/mock_buffer.h	2013-07-17 14:20:33 +0000
@@ -21,7 +21,7 @@
 
 #include "mir/compositor/buffer_basic.h"
 #include "mir/geometry/size.h"
-#include "mir/compositor/buffer_id.h"
+#include "mir/graphics/buffer_id.h"
 
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
@@ -33,7 +33,7 @@
 namespace doubles
 {
 
-struct MockBuffer : public compositor::Buffer
+struct MockBuffer : public graphics::Buffer
 {
  public:
     MockBuffer()
@@ -53,7 +53,7 @@
                 .WillByDefault(Return(pf));
 
         ON_CALL(*this, id())
-                .WillByDefault(Return(compositor::BufferID{4}));
+                .WillByDefault(Return(graphics::BufferID{4}));
         ON_CALL(*this, native_buffer_handle())
                 .WillByDefault(Return(std::shared_ptr<MirNativeBuffer>()));
     }
@@ -64,7 +64,7 @@
     MOCK_CONST_METHOD0(native_buffer_handle, std::shared_ptr<MirNativeBuffer>());
 
     MOCK_METHOD0(bind_to_texture, void());
-    MOCK_CONST_METHOD0(id, compositor::BufferID());
+    MOCK_CONST_METHOD0(id, graphics::BufferID());
 };
 
 }
 
=== modified file 'include/test/mir_test_doubles/mock_buffer_bundle.h'
--- include/test/mir_test_doubles/mock_buffer_bundle.h	2013-06-13 08:59:25 +0000
+++ include/test/mir_test_doubles/mock_buffer_bundle.h	2013-07-17 14:20:33 +0000
@@ -37,10 +37,10 @@
     ~MockBufferBundle() noexcept
     {}
 
-    MOCK_METHOD0(client_acquire,     std::shared_ptr<compositor::Buffer>());
-    MOCK_METHOD1(client_release,     void(std::shared_ptr<compositor::Buffer> const&));
-    MOCK_METHOD0(compositor_acquire, std::shared_ptr<compositor::Buffer>());
-    MOCK_METHOD1(compositor_release, void(std::shared_ptr<compositor::Buffer> const&));
+    MOCK_METHOD0(client_acquire,     std::shared_ptr<graphics::Buffer>());
+    MOCK_METHOD1(client_release,     void(std::shared_ptr<graphics::Buffer> const&));
+    MOCK_METHOD0(compositor_acquire, std::shared_ptr<graphics::Buffer>());
+    MOCK_METHOD1(compositor_release, void(std::shared_ptr<graphics::Buffer> const&));
     MOCK_METHOD1(allow_framedropping, void(bool));
     MOCK_CONST_METHOD0(properties, compositor::BufferProperties());
     MOCK_METHOD0(force_client_abort, void());
 
=== modified file 'include/test/mir_test_doubles/mock_buffer_initializer.h'
--- include/test/mir_test_doubles/mock_buffer_initializer.h	2013-04-24 05:22:20 +0000
+++ include/test/mir_test_doubles/mock_buffer_initializer.h	2013-07-17 14:20:33 +0000
@@ -33,9 +33,9 @@
 class MockBufferInitializer : public graphics::BufferInitializer
 {
 public:
-    MOCK_METHOD1(operator_call, void(compositor::Buffer& buffer));
+    MOCK_METHOD1(operator_call, void(graphics::Buffer& buffer));
 
-    void operator()(compositor::Buffer& buffer)
+    void operator()(graphics::Buffer& buffer)
     {
         operator_call(buffer);
     }
 
=== modified file 'include/test/mir_test_doubles/mock_buffer_stream.h'
--- include/test/mir_test_doubles/mock_buffer_stream.h	2013-06-21 23:40:49 +0000
+++ include/test/mir_test_doubles/mock_buffer_stream.h	2013-07-17 14:20:33 +0000
@@ -31,8 +31,8 @@
 {
 struct MockBufferStream : public surfaces::BufferStream
 {
-    MOCK_METHOD0(secure_client_buffer, std::shared_ptr<compositor::Buffer>());
-    MOCK_METHOD0(lock_back_buffer, std::shared_ptr<compositor::Buffer>());
+    MOCK_METHOD0(secure_client_buffer, std::shared_ptr<graphics::Buffer>());
+    MOCK_METHOD0(lock_back_buffer, std::shared_ptr<graphics::Buffer>());
 
     MOCK_METHOD0(get_stream_pixel_format, geometry::PixelFormat());
     MOCK_METHOD0(stream_size, geometry::Size());
 
=== modified file 'include/test/mir_test_doubles/mock_display_support_provider.h'
--- include/test/mir_test_doubles/mock_display_support_provider.h	2013-05-16 20:04:58 +0000
+++ include/test/mir_test_doubles/mock_display_support_provider.h	2013-07-17 14:20:33 +0000
@@ -35,7 +35,7 @@
     MOCK_CONST_METHOD0(display_size, geometry::Size());
     MOCK_CONST_METHOD0(display_format, geometry::PixelFormat());
     MOCK_CONST_METHOD0(number_of_framebuffers_available, unsigned int());
-    MOCK_METHOD1(set_next_frontbuffer, void(std::shared_ptr<mir::compositor::Buffer> const&));
+    MOCK_METHOD1(set_next_frontbuffer, void(std::shared_ptr<mir::graphics::Buffer> const&));
     MOCK_METHOD1(sync_to_display, void(bool));
 };
 }
 
=== modified file 'include/test/mir_test_doubles/mock_hwc_interface.h'
--- include/test/mir_test_doubles/mock_hwc_interface.h	2013-05-16 20:04:58 +0000
+++ include/test/mir_test_doubles/mock_hwc_interface.h	2013-07-17 14:20:33 +0000
@@ -39,7 +39,7 @@
     MOCK_CONST_METHOD0(display_size, geometry::Size());
     MOCK_CONST_METHOD0(display_format, geometry::PixelFormat());
     MOCK_CONST_METHOD0(number_of_framebuffers_available, unsigned int());
-    MOCK_METHOD1(set_next_frontbuffer, void(std::shared_ptr<mir::compositor::Buffer> const&));
+    MOCK_METHOD1(set_next_frontbuffer, void(std::shared_ptr<mir::graphics::Buffer> const&));
     MOCK_METHOD1(sync_to_display, void(bool));
 };
 
 
=== modified file 'include/test/mir_test_doubles/mock_hwc_organizer.h'
--- include/test/mir_test_doubles/mock_hwc_organizer.h	2013-05-02 00:34:03 +0000
+++ include/test/mir_test_doubles/mock_hwc_organizer.h	2013-07-17 14:20:33 +0000
@@ -34,7 +34,7 @@
 {
     ~MockHWCOrganizer() noexcept {}
     MOCK_CONST_METHOD0(native_list, graphics::android::LayerList const&());
-    MOCK_METHOD1(set_fb_target, void(std::shared_ptr<compositor::Buffer> const&));
+    MOCK_METHOD1(set_fb_target, void(std::shared_ptr<graphics::Buffer> const&));
 };
 
 }
 
=== modified file 'include/test/mir_test_doubles/mock_interpreter_resource_cache.h'
--- include/test/mir_test_doubles/mock_interpreter_resource_cache.h	2013-05-06 21:25:47 +0000
+++ include/test/mir_test_doubles/mock_interpreter_resource_cache.h	2013-07-17 14:20:33 +0000
@@ -28,8 +28,8 @@
 {
 struct MockInterpreterResourceCache : public graphics::android::InterpreterResourceCache
 {
-    MOCK_METHOD2(store_buffer, void(std::shared_ptr<compositor::Buffer>const&, ANativeWindowBuffer*));
-    MOCK_METHOD1(retrieve_buffer, std::shared_ptr<compositor::Buffer>(ANativeWindowBuffer*));
+    MOCK_METHOD2(store_buffer, void(std::shared_ptr<graphics::Buffer>const&, ANativeWindowBuffer*));
+    MOCK_METHOD1(retrieve_buffer, std::shared_ptr<graphics::Buffer>(ANativeWindowBuffer*));
 };
 }
 }
 
=== modified file 'include/test/mir_test_doubles/mock_surface.h'
--- include/test/mir_test_doubles/mock_surface.h	2013-07-03 22:10:48 +0000
+++ include/test/mir_test_doubles/mock_surface.h	2013-07-17 14:20:33 +0000
@@ -49,7 +49,7 @@
 
     MOCK_METHOD0(destroy, void());
     MOCK_METHOD0(force_requests_to_complete, void());
-    MOCK_METHOD0(advance_client_buffer, std::shared_ptr<compositor::Buffer>());
+    MOCK_METHOD0(advance_client_buffer, std::shared_ptr<graphics::Buffer>());
 
     MOCK_CONST_METHOD0(name, std::string());
     MOCK_CONST_METHOD0(size, geometry::Size());
 
=== modified file 'include/test/mir_test_doubles/mock_swapper.h'
--- include/test/mir_test_doubles/mock_swapper.h	2013-06-12 16:56:32 +0000
+++ include/test/mir_test_doubles/mock_swapper.h	2013-07-17 14:20:33 +0000
@@ -35,7 +35,7 @@
     MockSwapper() {}
     ~MockSwapper() noexcept {}
 
-    MockSwapper(std::shared_ptr<compositor::Buffer> buffer)
+    MockSwapper(std::shared_ptr<graphics::Buffer> buffer)
         : default_buffer(buffer)
     {
         using namespace testing;
@@ -46,17 +46,17 @@
             .WillByDefault(Return(default_buffer));
     }
 
-    MOCK_METHOD0(client_acquire,     std::shared_ptr<compositor::Buffer>());
-    MOCK_METHOD1(client_release,     void(std::shared_ptr<compositor::Buffer> const&));
-    MOCK_METHOD0(compositor_acquire, std::shared_ptr<compositor::Buffer>());
-    MOCK_METHOD1(compositor_release, void(std::shared_ptr<compositor::Buffer> const&));
+    MOCK_METHOD0(client_acquire,     std::shared_ptr<graphics::Buffer>());
+    MOCK_METHOD1(client_release,     void(std::shared_ptr<graphics::Buffer> const&));
+    MOCK_METHOD0(compositor_acquire, std::shared_ptr<graphics::Buffer>());
+    MOCK_METHOD1(compositor_release, void(std::shared_ptr<graphics::Buffer> const&));
     MOCK_METHOD0(force_client_abort, void());
     MOCK_METHOD0(force_requests_to_complete, void());
 
-    MOCK_METHOD2(end_responsibility, void(std::vector<std::shared_ptr<compositor::Buffer>>&, size_t&));
+    MOCK_METHOD2(end_responsibility, void(std::vector<std::shared_ptr<graphics::Buffer>>&, size_t&));
 
 private:
-    std::shared_ptr<compositor::Buffer> default_buffer;
+    std::shared_ptr<graphics::Buffer> default_buffer;
 };
 
 }
 
=== modified file 'include/test/mir_test_doubles/mock_swapper_factory.h'
--- include/test/mir_test_doubles/mock_swapper_factory.h	2013-06-13 23:31:56 +0000
+++ include/test/mir_test_doubles/mock_swapper_factory.h	2013-07-17 14:20:33 +0000
@@ -35,7 +35,7 @@
 
     MOCK_CONST_METHOD4(create_swapper_reuse_buffers,
         std::shared_ptr<compositor::BufferSwapper>(compositor::BufferProperties const&,
-            std::vector<std::shared_ptr<compositor::Buffer>>&, size_t, compositor::SwapperType));
+            std::vector<std::shared_ptr<graphics::Buffer>>&, size_t, compositor::SwapperType));
     MOCK_CONST_METHOD3(create_swapper_new_buffers,
         std::shared_ptr<compositor::BufferSwapper>(
             compositor::BufferProperties&, compositor::BufferProperties const&, compositor::SwapperType));
 
=== modified file 'include/test/mir_test_doubles/null_platform.h'
--- include/test/mir_test_doubles/null_platform.h	2013-07-10 08:50:53 +0000
+++ include/test/mir_test_doubles/null_platform.h	2013-07-17 14:20:33 +0000
@@ -55,7 +55,7 @@
     }
 
     void fill_ipc_package(std::shared_ptr<compositor::BufferIPCPacker> const&,
-                          std::shared_ptr<compositor::Buffer> const&) const
+                          std::shared_ptr<graphics::Buffer> const&) const
     {
     }
 };
 
=== modified file 'include/test/mir_test_doubles/stub_buffer.h'
--- include/test/mir_test_doubles/stub_buffer.h	2013-07-11 16:54:41 +0000
+++ include/test/mir_test_doubles/stub_buffer.h	2013-07-17 14:20:33 +0000
@@ -22,7 +22,7 @@
 #include "mir/compositor/buffer_basic.h"
 #include "mir/compositor/buffer_properties.h"
 #include "mir/geometry/size.h"
-#include "mir/compositor/buffer_id.h"
+#include "mir/graphics/buffer_id.h"
 
 namespace mir
 {
 
=== modified file 'include/test/mir_test_doubles/stub_buffer_stream.h'
--- include/test/mir_test_doubles/stub_buffer_stream.h	2013-06-21 23:40:49 +0000
+++ include/test/mir_test_doubles/stub_buffer_stream.h	2013-07-17 14:20:33 +0000
@@ -37,12 +37,12 @@
         stub_client_buffer = std::make_shared<StubBuffer>();
         stub_compositor_buffer = std::make_shared<StubBuffer>();
     }
-    std::shared_ptr<compositor::Buffer> secure_client_buffer()
+    std::shared_ptr<graphics::Buffer> secure_client_buffer()
     {
         return stub_client_buffer;
     }
 
-    std::shared_ptr<compositor::Buffer> lock_back_buffer()
+    std::shared_ptr<graphics::Buffer> lock_back_buffer()
     {
         return stub_compositor_buffer;
     }
@@ -65,8 +65,8 @@
     {
     }
 
-    std::shared_ptr<compositor::Buffer> stub_client_buffer;
-    std::shared_ptr<compositor::Buffer> stub_compositor_buffer;
+    std::shared_ptr<graphics::Buffer> stub_client_buffer;
+    std::shared_ptr<graphics::Buffer> stub_compositor_buffer;
 };
 
 }
 
=== modified file 'include/test/mir_test_doubles/stub_surface.h'
--- include/test/mir_test_doubles/stub_surface.h	2013-06-25 05:42:49 +0000
+++ include/test/mir_test_doubles/stub_surface.h	2013-07-17 14:20:33 +0000
@@ -47,9 +47,9 @@
         return geometry::PixelFormat();
     }
 
-    std::shared_ptr<compositor::Buffer> advance_client_buffer()
+    std::shared_ptr<graphics::Buffer> advance_client_buffer()
     {
-        return std::shared_ptr<compositor::Buffer>();
+        return std::shared_ptr<graphics::Buffer>();
     }
 
     virtual int configure(MirSurfaceAttrib, int)
 
=== modified file 'src/server/compositor/buffer_basic.cpp'
--- src/server/compositor/buffer_basic.cpp	2013-04-24 05:22:20 +0000
+++ src/server/compositor/buffer_basic.cpp	2013-07-17 14:20:33 +0000
@@ -19,20 +19,22 @@
 #include "mir/compositor/buffer_basic.h"
 #include <atomic>
 
+namespace mg = mir::graphics;
+
 namespace mir
 {
 namespace compositor
 {
 namespace
 {
-BufferID generate_next_buffer_id()
+mg::BufferID generate_next_buffer_id()
 {
     static std::atomic<uint32_t> next_id{0};
 
-    auto id = BufferID(next_id.fetch_add(1));
+    auto id = mg::BufferID(next_id.fetch_add(1));
 
     // Avoid returning an "invalid" id. (Not sure we need invalid ids)
-    while (!id.is_valid()) id = BufferID(next_id.fetch_add(1));
+    while (!id.is_valid()) id = mg::BufferID(next_id.fetch_add(1));
 
     return id;
 }
 
=== modified file 'src/server/compositor/buffer_bundle.h'
--- src/server/compositor/buffer_bundle.h	2013-06-19 09:57:32 +0000
+++ src/server/compositor/buffer_bundle.h	2013-07-17 14:20:33 +0000
@@ -25,18 +25,19 @@
 
 namespace mir
 {
+namespace graphics { class Buffer; }
+
 namespace compositor
 {
-class Buffer;
 
 class BufferBundle
 {
 public:
     virtual ~BufferBundle() noexcept {}
-    virtual std::shared_ptr<Buffer> client_acquire() = 0;
-    virtual void client_release(std::shared_ptr<Buffer> const&) = 0;
-    virtual std::shared_ptr<Buffer> compositor_acquire() = 0;
-    virtual void compositor_release(std::shared_ptr<Buffer> const&) = 0;
+    virtual std::shared_ptr<graphics::Buffer> client_acquire() = 0;
+    virtual void client_release(std::shared_ptr<graphics::Buffer> const&) = 0;
+    virtual std::shared_ptr<graphics::Buffer> compositor_acquire() = 0;
+    virtual void compositor_release(std::shared_ptr<graphics::Buffer> const&) = 0;
 
     virtual BufferProperties properties() const = 0;
     virtual void allow_framedropping(bool dropping_allowed) = 0;
 
=== modified file 'src/server/compositor/buffer_stream_factory.cpp'
--- src/server/compositor/buffer_stream_factory.cpp	2013-06-12 15:36:31 +0000
+++ src/server/compositor/buffer_stream_factory.cpp	2013-07-17 14:20:33 +0000
@@ -23,8 +23,8 @@
 #include "mir/compositor/buffer_stream_surfaces.h"
 #include "mir/compositor/buffer_properties.h"
 #include "switching_bundle.h"
-#include "mir/compositor/buffer.h"
-#include "mir/compositor/buffer_id.h"
+#include "mir/graphics/buffer.h"
+#include "mir/graphics/buffer_id.h"
 #include "mir/compositor/graphic_buffer_allocator.h"
 #include "mir/graphics/display.h"
 
 
=== modified file 'src/server/compositor/buffer_stream_surfaces.cpp'
--- src/server/compositor/buffer_stream_surfaces.cpp	2013-06-21 23:40:49 +0000
+++ src/server/compositor/buffer_stream_surfaces.cpp	2013-07-17 14:20:33 +0000
@@ -25,6 +25,7 @@
 #include "temporary_buffers.h"
 
 namespace mc = mir::compositor;
+namespace mg = mir::graphics;
 namespace geom = mir::geometry;
 
 mc::BufferStreamSurfaces::BufferStreamSurfaces(std::shared_ptr<BufferBundle> const& buffer_bundle)
@@ -38,12 +39,12 @@
 {
 }
 
-std::shared_ptr<mc::Buffer> mc::BufferStreamSurfaces::lock_back_buffer()
+std::shared_ptr<mg::Buffer> mc::BufferStreamSurfaces::lock_back_buffer()
 {
     return std::make_shared<mc::TemporaryCompositorBuffer>(back_buffer_strategy);
 }
 
-std::shared_ptr<mc::Buffer> mc::BufferStreamSurfaces::secure_client_buffer()
+std::shared_ptr<mg::Buffer> mc::BufferStreamSurfaces::secure_client_buffer()
 {
     return std::make_shared<mc::TemporaryClientBuffer>(buffer_bundle);
 }
 
=== modified file 'src/server/compositor/buffer_swapper_multi.cpp'
--- src/server/compositor/buffer_swapper_multi.cpp	2013-06-15 11:09:16 +0000
+++ src/server/compositor/buffer_swapper_multi.cpp	2013-07-17 14:20:33 +0000
@@ -21,8 +21,9 @@
 #include <boost/throw_exception.hpp>
 
 namespace mc = mir::compositor;
+namespace mg = mir::graphics;
 
-mc::BufferSwapperMulti::BufferSwapperMulti(std::vector<std::shared_ptr<compositor::Buffer>>& buffer_list, size_t swapper_size)
+mc::BufferSwapperMulti::BufferSwapperMulti(std::vector<std::shared_ptr<mg::Buffer>>& buffer_list, size_t swapper_size)
  : in_use_by_client(0),
    swapper_size(swapper_size),
    clients_trying_to_acquire(0),
@@ -39,7 +40,7 @@
     }
 }
 
-std::shared_ptr<mc::Buffer> mc::BufferSwapperMulti::client_acquire()
+std::shared_ptr<mg::Buffer> mc::BufferSwapperMulti::client_acquire()
 {
     std::unique_lock<std::mutex> lk(swapper_mutex);
 
@@ -71,7 +72,7 @@
     return dequeued_buffer;
 }
 
-void mc::BufferSwapperMulti::client_release(std::shared_ptr<Buffer> const& queued_buffer)
+void mc::BufferSwapperMulti::client_release(std::shared_ptr<mg::Buffer> const& queued_buffer)
 {
     std::unique_lock<std::mutex> lk(swapper_mutex);
 
@@ -87,11 +88,11 @@
      */
 }
 
-std::shared_ptr<mc::Buffer> mc::BufferSwapperMulti::compositor_acquire()
+std::shared_ptr<mg::Buffer> mc::BufferSwapperMulti::compositor_acquire()
 {
     std::unique_lock<std::mutex> lk(swapper_mutex);
 
-    std::shared_ptr<mc::Buffer> dequeued_buffer;
+    std::shared_ptr<mg::Buffer> dequeued_buffer;
 
     if (!compositor_queue.empty())
     {
@@ -111,7 +112,7 @@
     return dequeued_buffer;
 }
 
-void mc::BufferSwapperMulti::compositor_release(std::shared_ptr<Buffer> const& released_buffer)
+void mc::BufferSwapperMulti::compositor_release(std::shared_ptr<mg::Buffer> const& released_buffer)
 {
     std::unique_lock<std::mutex> lk(swapper_mutex);
     client_queue.push_back(released_buffer);
@@ -152,7 +153,7 @@
 }
 
 
-void mc::BufferSwapperMulti::end_responsibility(std::vector<std::shared_ptr<Buffer>>& buffers,
+void mc::BufferSwapperMulti::end_responsibility(std::vector<std::shared_ptr<mg::Buffer>>& buffers,
                                                 size_t& size)
 {
     std::unique_lock<std::mutex> lk(swapper_mutex);
 
=== modified file 'src/server/compositor/buffer_swapper_spin.cpp'
--- src/server/compositor/buffer_swapper_spin.cpp	2013-06-12 16:56:32 +0000
+++ src/server/compositor/buffer_swapper_spin.cpp	2013-07-17 14:20:33 +0000
@@ -19,10 +19,10 @@
 #include "mir/compositor/buffer_swapper_spin.h"
 
 namespace mc = mir::compositor;
-
+namespace mg = mir::graphics;
 
 mc::BufferSwapperSpin::BufferSwapperSpin(
-    std::vector<std::shared_ptr<mc::Buffer>>& buffer_list, size_t swapper_size)
+    std::vector<std::shared_ptr<mg::Buffer>>& buffer_list, size_t swapper_size)
     : buffer_queue{buffer_list.begin(), buffer_list.end()},
       in_use_by_client{0},
       swapper_size{swapper_size}
@@ -34,7 +34,7 @@
     }
 }
 
-std::shared_ptr<mc::Buffer> mc::BufferSwapperSpin::client_acquire()
+std::shared_ptr<mg::Buffer> mc::BufferSwapperSpin::client_acquire()
 {
     std::lock_guard<std::mutex> lg{swapper_mutex};
 
@@ -54,7 +54,7 @@
     return dequeued_buffer;
 }
 
-void mc::BufferSwapperSpin::client_release(std::shared_ptr<Buffer> const& queued_buffer)
+void mc::BufferSwapperSpin::client_release(std::shared_ptr<mg::Buffer> const& queued_buffer)
 {
     std::lock_guard<std::mutex> lg{swapper_mutex};
 
@@ -63,7 +63,7 @@
     client_submitted_new_buffer = true;
 }
 
-std::shared_ptr<mc::Buffer> mc::BufferSwapperSpin::compositor_acquire()
+std::shared_ptr<mg::Buffer> mc::BufferSwapperSpin::compositor_acquire()
 {
     std::lock_guard<std::mutex> lg{swapper_mutex};
 
@@ -74,7 +74,7 @@
     return dequeued_buffer;
 }
 
-void mc::BufferSwapperSpin::compositor_release(std::shared_ptr<Buffer> const& released_buffer)
+void mc::BufferSwapperSpin::compositor_release(std::shared_ptr<mg::Buffer> const& released_buffer)
 {
     std::lock_guard<std::mutex> lg{swapper_mutex};
 
@@ -99,7 +99,7 @@
 }
 
 
-void mc::BufferSwapperSpin::end_responsibility(std::vector<std::shared_ptr<Buffer>>& buffers,
+void mc::BufferSwapperSpin::end_responsibility(std::vector<std::shared_ptr<mg::Buffer>>& buffers,
                                                 size_t& size)
 {
     std::lock_guard<std::mutex> lg{swapper_mutex};
 
=== modified file 'src/server/compositor/multi_acquisition_back_buffer_strategy.cpp'
--- src/server/compositor/multi_acquisition_back_buffer_strategy.cpp	2013-06-19 09:55:54 +0000
+++ src/server/compositor/multi_acquisition_back_buffer_strategy.cpp	2013-07-17 14:20:33 +0000
@@ -23,6 +23,7 @@
 #include <algorithm>
 
 namespace mc = mir::compositor;
+namespace mg = mir::graphics;
 
 mc::MultiAcquisitionBackBufferStrategy::MultiAcquisitionBackBufferStrategy(
     std::shared_ptr<BufferBundle> const& buffer_bundle)
@@ -30,7 +31,7 @@
 {
 }
 
-std::shared_ptr<mc::Buffer> mc::MultiAcquisitionBackBufferStrategy::acquire()
+std::shared_ptr<mg::Buffer> mc::MultiAcquisitionBackBufferStrategy::acquire()
 {
     std::lock_guard<std::mutex> lg{mutex};
 
@@ -41,7 +42,7 @@
                         return info.partly_released == false;
                     });
 
-    std::shared_ptr<mc::Buffer> buffer;
+    std::shared_ptr<mg::Buffer> buffer;
 
     if (iter != acquired_buffers.end())
     {
@@ -78,7 +79,7 @@
     return buffer;
 }
 
-void mc::MultiAcquisitionBackBufferStrategy::release(std::shared_ptr<Buffer> const& buffer)
+void mc::MultiAcquisitionBackBufferStrategy::release(std::shared_ptr<mg::Buffer> const& buffer)
 {
     std::lock_guard<std::mutex> lg{mutex};
 
@@ -108,7 +109,7 @@
 }
 
 std::vector<mc::detail::AcquiredBufferInfo>::iterator
-mc::MultiAcquisitionBackBufferStrategy::find_info(std::shared_ptr<Buffer> const& buffer)
+mc::MultiAcquisitionBackBufferStrategy::find_info(std::shared_ptr<mg::Buffer> const& buffer)
 {
     return std::find_if(acquired_buffers.begin(), acquired_buffers.end(),
                         [&buffer] (detail::AcquiredBufferInfo const& info)
 
=== modified file 'src/server/compositor/swapper_factory.cpp'
--- src/server/compositor/swapper_factory.cpp	2013-06-22 00:25:47 +0000
+++ src/server/compositor/swapper_factory.cpp	2013-07-17 14:20:33 +0000
@@ -22,7 +22,7 @@
 #include "mir/compositor/graphic_buffer_allocator.h"
 #include "mir/compositor/buffer_swapper_multi.h"
 #include "mir/compositor/buffer_swapper_spin.h"
-#include "mir/compositor/buffer_id.h"
+#include "mir/graphics/buffer_id.h"
 #include "mir/geometry/dimensions.h"
 #include "switching_bundle.h"
 
@@ -31,6 +31,7 @@
 #include <cassert>
 
 namespace mc = mir::compositor;
+namespace mg = mir::graphics;
 
 mc::SwapperFactory::SwapperFactory(
         std::shared_ptr<GraphicBufferAllocator> const& gr_alloc,
@@ -48,7 +49,7 @@
 }
 
 void mc::SwapperFactory::change_swapper_size(
-    std::vector<std::shared_ptr<mc::Buffer>>& list,
+    std::vector<std::shared_ptr<mg::Buffer>>& list,
     size_t const desired_size, size_t current_size, BufferProperties const& buffer_properties) const
 {
     while (current_size < desired_size)
@@ -72,7 +73,7 @@
 }
 
 std::shared_ptr<mc::BufferSwapper> mc::SwapperFactory::create_swapper_reuse_buffers(
-    BufferProperties const& buffer_properties, std::vector<std::shared_ptr<Buffer>>& list,
+    BufferProperties const& buffer_properties, std::vector<std::shared_ptr<mg::Buffer>>& list,
     size_t buffer_num, SwapperType type) const
 {
     if (type == mc::SwapperType::synchronous)
@@ -91,7 +92,7 @@
     BufferProperties& actual_buffer_properties,
     BufferProperties const& requested_buffer_properties, SwapperType type) const
 {
-    std::vector<std::shared_ptr<mc::Buffer>> list;
+    std::vector<std::shared_ptr<mg::Buffer>> list;
     std::shared_ptr<mc::BufferSwapper> new_swapper;
 
     if (type == mc::SwapperType::synchronous)
 
=== modified file 'src/server/compositor/switching_bundle.cpp'
--- src/server/compositor/switching_bundle.cpp	2013-06-17 19:40:58 +0000
+++ src/server/compositor/switching_bundle.cpp	2013-07-17 14:20:33 +0000
@@ -25,6 +25,7 @@
 #include <boost/throw_exception.hpp>
 
 namespace mc=mir::compositor;
+namespace mg = mir::graphics;
 
 mc::SwitchingBundle::SwitchingBundle(
     std::shared_ptr<BufferAllocationStrategy> const& swapper_factory, BufferProperties const& property_request)
@@ -34,12 +35,12 @@
 {
 }
 
-std::shared_ptr<mc::Buffer> mc::SwitchingBundle::client_acquire()
+std::shared_ptr<mg::Buffer> mc::SwitchingBundle::client_acquire()
 {
     /* lock is for use of 'swapper' below' */
     std::unique_lock<mc::ReadLock> lk(rw_lock);
 
-    std::shared_ptr<mc::Buffer> buffer = nullptr;
+    std::shared_ptr<mg::Buffer> buffer = nullptr;
     while (!buffer) 
     {
         try
@@ -55,19 +56,19 @@
     return buffer;
 }
 
-void mc::SwitchingBundle::client_release(std::shared_ptr<mc::Buffer> const& released_buffer)
+void mc::SwitchingBundle::client_release(std::shared_ptr<mg::Buffer> const& released_buffer)
 {
     std::unique_lock<mc::ReadLock> lk(rw_lock);
     return swapper->client_release(released_buffer);
 }
 
-std::shared_ptr<mc::Buffer> mc::SwitchingBundle::compositor_acquire()
+std::shared_ptr<mg::Buffer> mc::SwitchingBundle::compositor_acquire()
 {
     std::unique_lock<mc::ReadLock> lk(rw_lock);
     return swapper->compositor_acquire();
 }
 
-void mc::SwitchingBundle::compositor_release(std::shared_ptr<mc::Buffer> const& released_buffer)
+void mc::SwitchingBundle::compositor_release(std::shared_ptr<mg::Buffer> const& released_buffer)
 {
     std::unique_lock<mc::ReadLock> lk(rw_lock);
     return swapper->compositor_release(released_buffer);
@@ -87,7 +88,7 @@
     }
 
     std::unique_lock<mc::WriteLock> lk(rw_lock);
-    std::vector<std::shared_ptr<mc::Buffer>> list{};
+    std::vector<std::shared_ptr<mg::Buffer>> list{};
     size_t size = 0;
     swapper->end_responsibility(list, size);
 
 
=== modified file 'src/server/compositor/switching_bundle.h'
--- src/server/compositor/switching_bundle.h	2013-06-15 11:09:16 +0000
+++ src/server/compositor/switching_bundle.h	2013-07-17 14:20:33 +0000
@@ -41,10 +41,10 @@
 
     BufferProperties properties() const;
 
-    std::shared_ptr<Buffer> client_acquire();
-    void client_release(std::shared_ptr<Buffer> const&);
-    std::shared_ptr<Buffer> compositor_acquire();
-    void compositor_release(std::shared_ptr<Buffer> const& released_buffer);
+    std::shared_ptr<graphics::Buffer> client_acquire();
+    void client_release(std::shared_ptr<graphics::Buffer> const&);
+    std::shared_ptr<graphics::Buffer> compositor_acquire();
+    void compositor_release(std::shared_ptr<graphics::Buffer> const& released_buffer);
     void force_requests_to_complete();
     void allow_framedropping(bool dropping_allowed);
 
 
=== modified file 'src/server/compositor/temporary_buffers.cpp'
--- src/server/compositor/temporary_buffers.cpp	2013-06-18 09:44:11 +0000
+++ src/server/compositor/temporary_buffers.cpp	2013-07-17 14:20:33 +0000
@@ -22,9 +22,10 @@
 #include "temporary_buffers.h"
 
 namespace mc=mir::compositor;
+namespace mg=mir::graphics;
 namespace geom=mir::geometry;
 
-mc::TemporaryBuffer::TemporaryBuffer(std::shared_ptr<Buffer> const& real_buffer)
+mc::TemporaryBuffer::TemporaryBuffer(std::shared_ptr<mg::Buffer> const& real_buffer)
     : buffer(real_buffer)
 {
 }
@@ -69,7 +70,7 @@
     return buffer->pixel_format();
 }
 
-mc::BufferID mc::TemporaryBuffer::id() const
+mg::BufferID mc::TemporaryBuffer::id() const
 {
     return buffer->id();
 }
 
=== modified file 'src/server/compositor/temporary_buffers.h'
--- src/server/compositor/temporary_buffers.h	2013-06-18 09:44:11 +0000
+++ src/server/compositor/temporary_buffers.h	2013-07-17 14:20:33 +0000
@@ -19,31 +19,32 @@
 #ifndef MIR_COMPOSITOR_TEMPORARY_BUFFERS_H_
 #define MIR_COMPOSITOR_TEMPORARY_BUFFERS_H_
 
-#include "mir/compositor/buffer.h"
-#include "mir/compositor/buffer_id.h"
+#include "mir/graphics/buffer.h"
+#include "mir/graphics/buffer_id.h"
+
+namespace mg = mir::graphics;
 
 namespace mir
 {
 namespace compositor
 {
 
-class BufferID;
 class BufferBundle;
 class BackBufferStrategy;
 
-class TemporaryBuffer : public Buffer
+class TemporaryBuffer : public mg::Buffer
 {
 public:
     geometry::Size size() const;
     geometry::Stride stride() const;
     geometry::PixelFormat pixel_format() const;
-    BufferID id() const;
+    mg::BufferID id() const;
     void bind_to_texture();
     std::shared_ptr<MirNativeBuffer> native_buffer_handle() const;
 
 protected:
-    explicit TemporaryBuffer(std::shared_ptr<Buffer> const& real_buffer);
-    std::shared_ptr<Buffer> const buffer;
+    explicit TemporaryBuffer(std::shared_ptr<mg::Buffer> const& real_buffer);
+    std::shared_ptr<mg::Buffer> const buffer;
 };
 
 class TemporaryClientBuffer : public TemporaryBuffer
 
=== modified file 'src/server/default_server_configuration.cpp'
--- src/server/default_server_configuration.cpp	2013-07-16 18:34:20 +0000
+++ src/server/default_server_configuration.cpp	2013-07-17 14:20:33 +0000
@@ -405,7 +405,7 @@
         });
 }
 
-std::shared_ptr<msh::PixelBuffer>
+std::shared_ptr<mg::PixelBuffer>
 mir::DefaultServerConfiguration::the_shell_pixel_buffer()
 {
     return shell_pixel_buffer(
 
=== modified file 'src/server/frontend/client_buffer_tracker.cpp'
--- src/server/frontend/client_buffer_tracker.cpp	2013-04-24 05:22:20 +0000
+++ src/server/frontend/client_buffer_tracker.cpp	2013-07-17 14:20:33 +0000
@@ -19,10 +19,10 @@
 #include <algorithm>
 
 #include "client_buffer_tracker.h"
-#include "mir/compositor/buffer_id.h"
+#include "mir/graphics/buffer_id.h"
 
 namespace mf = mir::frontend;
-namespace mc = mir::compositor;
+namespace mg = mir::graphics;
 
 mf::ClientBufferTracker::ClientBufferTracker(unsigned int client_cache_size)
     : ids(),
@@ -30,7 +30,7 @@
 {
 }
 
-void mf::ClientBufferTracker::add(mc::BufferID const& id)
+void mf::ClientBufferTracker::add(mg::BufferID const& id)
 {
     auto existing_id = std::find(ids.begin(), ids.end(), id);
 
@@ -47,7 +47,7 @@
         ids.pop_back();
 }
 
-bool mf::ClientBufferTracker::client_has(mc::BufferID const& id) const
+bool mf::ClientBufferTracker::client_has(mg::BufferID const& id) const
 {
     return std::find(ids.begin(), ids.end(), id) != ids.end();
 }
 
=== modified file 'src/server/frontend/client_buffer_tracker.h'
--- src/server/frontend/client_buffer_tracker.h	2013-04-24 05:22:20 +0000
+++ src/server/frontend/client_buffer_tracker.h	2013-07-17 14:20:33 +0000
@@ -25,7 +25,7 @@
 namespace mir
 {
 
-namespace compositor
+namespace graphics
 {
 class BufferID;
 }
@@ -48,11 +48,11 @@
     /// Add a BufferID to the list of buffers known by the client.
     ///
     /// Typically this should be done just prior to or just after sending the buffer information
-    void add(compositor::BufferID const& id);
-    bool client_has(compositor::BufferID const& id) const;
+    void add(graphics::BufferID const& id);
+    bool client_has(graphics::BufferID const& id) const;
 private:
 
-    std::list<compositor::BufferID> ids;
+    std::list<graphics::BufferID> ids;
     unsigned int const cache_size;
 };
 
 
=== modified file 'src/server/frontend/session_mediator.cpp'
--- src/server/frontend/session_mediator.cpp	2013-07-09 18:53:16 +0000
+++ src/server/frontend/session_mediator.cpp	2013-07-17 14:20:33 +0000
@@ -24,8 +24,8 @@
 #include "mir/shell/surface_creation_parameters.h"
 #include "mir/frontend/resource_cache.h"
 #include "mir_toolkit/common.h"
-#include "mir/compositor/buffer_id.h"
-#include "mir/compositor/buffer.h"
+#include "mir/graphics/buffer_id.h"
+#include "mir/graphics/buffer.h"
 #include "mir/surfaces/buffer_stream.h"
 #include "mir/compositor/graphic_buffer_allocator.h"
 #include "mir/geometry/dimensions.h"
 
=== modified file 'src/server/graphics/android/android_buffer_allocator.cpp'
--- src/server/graphics/android/android_buffer_allocator.cpp	2013-06-14 18:20:39 +0000
+++ src/server/graphics/android/android_buffer_allocator.cpp	2013-07-17 14:20:33 +0000
@@ -70,7 +70,7 @@
     alloc_device = std::shared_ptr<mga::GraphicAllocAdaptor>(new AndroidAllocAdaptor(alloc_dev_ptr));
 }
 
-std::shared_ptr<mc::Buffer> mga::AndroidGraphicBufferAllocator::alloc_buffer(
+std::shared_ptr<mg::Buffer> mga::AndroidGraphicBufferAllocator::alloc_buffer(
     mc::BufferProperties const& buffer_properties)
 {
     auto usage = convert_from_compositor_usage(buffer_properties.usage);
 
=== modified file 'src/server/graphics/android/android_graphic_buffer_allocator.h'
--- src/server/graphics/android/android_graphic_buffer_allocator.h	2013-06-14 18:20:39 +0000
+++ src/server/graphics/android/android_graphic_buffer_allocator.h	2013-07-17 14:20:33 +0000
@@ -45,7 +45,7 @@
     AndroidGraphicBufferAllocator(
         std::shared_ptr<BufferInitializer> const& buffer_initializer);
 
-    std::shared_ptr<compositor::Buffer> alloc_buffer(
+    std::shared_ptr<graphics::Buffer> alloc_buffer(
         compositor::BufferProperties const& buffer_properties);
 
     std::shared_ptr<Buffer> alloc_buffer_platform(
 
=== modified file 'src/server/graphics/android/android_platform.cpp'
--- src/server/graphics/android/android_platform.cpp	2013-07-10 08:50:53 +0000
+++ src/server/graphics/android/android_platform.cpp	2013-07-17 14:20:33 +0000
@@ -26,7 +26,7 @@
 #include "internal_client.h"
 #include "mir/graphics/platform_ipc_package.h"
 #include "mir/graphics/buffer_initializer.h"
-#include "mir/compositor/buffer_id.h"
+#include "mir/graphics/buffer_id.h"
 #include "mir/compositor/buffer_ipc_packer.h"
 #include "mir/options/option.h"
 
@@ -78,7 +78,7 @@
 }
 
 void mga::AndroidPlatform::fill_ipc_package(std::shared_ptr<compositor::BufferIPCPacker> const& packer,
-                                            std::shared_ptr<mc::Buffer> const& buffer) const
+                                            std::shared_ptr<mg::Buffer> const& buffer) const
 {
     auto native_buffer = buffer->native_buffer_handle();
     auto buffer_handle = native_buffer->handle;
 
=== modified file 'src/server/graphics/android/android_platform.h'
--- src/server/graphics/android/android_platform.h	2013-07-10 08:50:53 +0000
+++ src/server/graphics/android/android_platform.h	2013-07-17 14:20:33 +0000
@@ -44,7 +44,7 @@
     std::shared_ptr<PlatformIPCPackage> get_ipc_package();
     std::shared_ptr<InternalClient> create_internal_client();
     void fill_ipc_package(std::shared_ptr<compositor::BufferIPCPacker> const& packer,
-                          std::shared_ptr<compositor::Buffer> const& buffer) const;
+                          std::shared_ptr<graphics::Buffer> const& buffer) const;
 
 private:
     // TODO a design that has this and create_buffer_allocator is missing simplicity
 
=== modified file 'src/server/graphics/android/default_framebuffer_factory.cpp'
--- src/server/graphics/android/default_framebuffer_factory.cpp	2013-05-29 15:28:27 +0000
+++ src/server/graphics/android/default_framebuffer_factory.cpp	2013-07-17 14:20:33 +0000
@@ -30,6 +30,7 @@
 #include <stdexcept>
 #include <vector>
 
+namespace mg = mir::graphics;
 namespace mga=mir::graphics::android;
 namespace mc=mir::compositor;
 
@@ -39,13 +40,13 @@
 {
 }
 
-std::vector<std::shared_ptr<mc::Buffer>> mga::DefaultFramebufferFactory::create_buffers(
+std::vector<std::shared_ptr<mg::Buffer>> mga::DefaultFramebufferFactory::create_buffers(
     std::shared_ptr<DisplaySupportProvider> const& info_provider) const
 {
     auto size = info_provider->display_size();
     auto pf = info_provider->display_format();
     auto num_framebuffers = info_provider->number_of_framebuffers_available();
-    std::vector<std::shared_ptr<mc::Buffer>> buffers;
+    std::vector<std::shared_ptr<mg::Buffer>> buffers;
     for (auto i = 0u; i < num_framebuffers; ++i)
     {
         buffers.push_back(buffer_allocator->alloc_buffer_platform(size, pf, mga::BufferUsage::use_framebuffer_gles));
@@ -54,7 +55,7 @@
 }
 
 std::shared_ptr<mga::FBSwapper> mga::DefaultFramebufferFactory::create_swapper(
-    std::vector<std::shared_ptr<mc::Buffer>> const& buffers) const
+    std::vector<std::shared_ptr<mg::Buffer>> const& buffers) const
 {
     return std::make_shared<mga::FBSimpleSwapper>(buffers);
 }
 
=== modified file 'src/server/graphics/android/default_framebuffer_factory.h'
--- src/server/graphics/android/default_framebuffer_factory.h	2013-05-29 15:28:27 +0000
+++ src/server/graphics/android/default_framebuffer_factory.h	2013-07-17 14:20:33 +0000
@@ -25,9 +25,10 @@
 
 namespace mir
 {
-namespace compositor { class Buffer; }
 namespace graphics
 {
+class Buffer;
+
 namespace android
 {
 
@@ -43,11 +44,11 @@
 private:
     std::shared_ptr<GraphicBufferAllocator> const buffer_allocator;
 
-    virtual std::vector<std::shared_ptr<compositor::Buffer>> create_buffers(
+    virtual std::vector<std::shared_ptr<graphics::Buffer>> create_buffers(
         std::shared_ptr<DisplaySupportProvider> const& info_provider) const;
 
     virtual std::shared_ptr<FBSwapper> create_swapper(
-        std::vector<std::shared_ptr<compositor::Buffer>> const& buffers) const;
+        std::vector<std::shared_ptr<graphics::Buffer>> const& buffers) const;
 };
 
 }
 
=== modified file 'src/server/graphics/android/display_support_provider.h'
--- src/server/graphics/android/display_support_provider.h	2013-05-16 20:04:58 +0000
+++ src/server/graphics/android/display_support_provider.h	2013-07-17 14:20:33 +0000
@@ -25,12 +25,10 @@
 
 namespace mir
 {
-namespace compositor
+namespace graphics
 {
 class Buffer;
-}
-namespace graphics
-{
+
 namespace android
 {
 
@@ -44,7 +42,7 @@
     virtual unsigned int number_of_framebuffers_available() const = 0;
     //this function schedules the next frontbuffer to be "buffer" parameter. depending on implementation, it may
     //post immediately, or be deferred.
-    virtual void set_next_frontbuffer(std::shared_ptr<compositor::Buffer> const& buffer) = 0;
+    virtual void set_next_frontbuffer(std::shared_ptr<graphics::Buffer> const& buffer) = 0;
     virtual void sync_to_display(bool sync) = 0;
 protected:
     DisplaySupportProvider() = default;
 
=== modified file 'src/server/graphics/android/fb_device.cpp'
--- src/server/graphics/android/fb_device.cpp	2013-07-11 16:54:41 +0000
+++ src/server/graphics/android/fb_device.cpp	2013-07-17 14:20:33 +0000
@@ -16,7 +16,7 @@
  * Authored by: Kevin DuBois <[e-mail]>
  */
 
-#include "mir/compositor/buffer.h"
+#include "mir/graphics/buffer.h"
 
 #include "fb_device.h"
 #include "buffer.h"
@@ -26,10 +26,10 @@
 #include <boost/throw_exception.hpp>
 #include <stdexcept>
 
-namespace mc=mir::compositor;
+namespace mg = mir::graphics;
 namespace mga=mir::graphics::android;
 namespace geom=mir::geometry;
- 
+
 mga::FBDevice::FBDevice(std::shared_ptr<framebuffer_device_t> const& fbdev)
     : fb_device(fbdev)
 {
@@ -39,7 +39,7 @@
     }
 }
 
-void mga::FBDevice::set_next_frontbuffer(std::shared_ptr<mc::Buffer> const& buffer)
+void mga::FBDevice::set_next_frontbuffer(std::shared_ptr<mg::Buffer> const& buffer)
 {
     auto handle = buffer->native_buffer_handle();
     if (fb_device->post(fb_device.get(), handle->handle) != 0)
 
=== modified file 'src/server/graphics/android/fb_device.h'
--- src/server/graphics/android/fb_device.h	2013-05-16 20:04:58 +0000
+++ src/server/graphics/android/fb_device.h	2013-07-17 14:20:33 +0000
@@ -39,7 +39,7 @@
     geometry::PixelFormat display_format() const; 
     unsigned int number_of_framebuffers_available() const;
 
-    void set_next_frontbuffer(std::shared_ptr<compositor::Buffer> const& buffer);
+    void set_next_frontbuffer(std::shared_ptr<graphics::Buffer> const& buffer);
     void sync_to_display(bool sync);
 private:
     std::shared_ptr<framebuffer_device_t> const fb_device;
 
=== modified file 'src/server/graphics/android/fb_simple_swapper.cpp'
--- src/server/graphics/android/fb_simple_swapper.cpp	2013-05-02 00:34:03 +0000
+++ src/server/graphics/android/fb_simple_swapper.cpp	2013-07-17 14:20:33 +0000
@@ -22,10 +22,10 @@
 #include <boost/throw_exception.hpp>
 #include <stdexcept>
 
-namespace mc=mir::compositor;
+namespace mg = mir::graphics;
 namespace mga=mir::graphics::android;
 
-std::shared_ptr<mc::Buffer> mga::FBSimpleSwapper::compositor_acquire()
+std::shared_ptr<mg::Buffer> mga::FBSimpleSwapper::compositor_acquire()
 {
     std::unique_lock<std::mutex> lk(queue_lock);
     while (queue.empty())
@@ -38,7 +38,7 @@
     return buffer;
 }
 
-void mga::FBSimpleSwapper::compositor_release(std::shared_ptr<mc::Buffer> const& released_buffer)
+void mga::FBSimpleSwapper::compositor_release(std::shared_ptr<mg::Buffer> const& released_buffer)
 {
     std::unique_lock<std::mutex> lk(queue_lock);
 
 
=== modified file 'src/server/graphics/android/fb_simple_swapper.h'
--- src/server/graphics/android/fb_simple_swapper.h	2013-05-02 00:34:03 +0000
+++ src/server/graphics/android/fb_simple_swapper.h	2013-07-17 14:20:33 +0000
@@ -46,14 +46,14 @@
         }
     }
 
-    std::shared_ptr<compositor::Buffer> compositor_acquire();
-    void compositor_release(std::shared_ptr<compositor::Buffer> const& released_buffer);
+    std::shared_ptr<Buffer> compositor_acquire();
+    void compositor_release(std::shared_ptr<Buffer> const& released_buffer);
 
 private:
     std::mutex queue_lock;
     std::condition_variable cv;
 
-    std::queue<std::shared_ptr<compositor::Buffer>> queue;
+    std::queue<std::shared_ptr<graphics::Buffer>> queue;
 };
 
 }
 
=== modified file 'src/server/graphics/android/fb_swapper.h'
--- src/server/graphics/android/fb_swapper.h	2013-05-02 16:29:48 +0000
+++ src/server/graphics/android/fb_swapper.h	2013-07-17 14:20:33 +0000
@@ -24,24 +24,19 @@
 
 namespace mir
 {
-namespace compositor
-{
-class Buffer;
-}
 namespace graphics
 {
+class Buffer;
+
 namespace android
 {
-
-class Buffer;
-
 //TODO: remove this interface. FBSimpleSwapper should inherit from mc::BufferSwapper
 class FBSwapper{
 public:
     virtual ~FBSwapper() = default;
 
-    virtual std::shared_ptr<compositor::Buffer> compositor_acquire() = 0;
-    virtual void compositor_release(std::shared_ptr<compositor::Buffer> const& released_buffer) = 0;
+    virtual std::shared_ptr<Buffer> compositor_acquire() = 0;
+    virtual void compositor_release(std::shared_ptr<Buffer> const& released_buffer) = 0;
 protected:
     FBSwapper() = default;
     FBSwapper(FBSwapper const&) = delete;
 
=== modified file 'src/server/graphics/android/hwc10_device.cpp'
--- src/server/graphics/android/hwc10_device.cpp	2013-05-17 20:43:23 +0000
+++ src/server/graphics/android/hwc10_device.cpp	2013-07-17 14:20:33 +0000
@@ -23,7 +23,7 @@
 #include <boost/throw_exception.hpp>
 #include <stdexcept>
 
-namespace mc=mir::compositor;
+namespace mg = mir::graphics;
 namespace mga=mir::graphics::android;
 namespace geom=mir::geometry;
 
@@ -55,7 +55,7 @@
     return fb_device->number_of_framebuffers_available();
 }
 
-void mga::HWC10Device::set_next_frontbuffer(std::shared_ptr<mc::Buffer> const& buffer)
+void mga::HWC10Device::set_next_frontbuffer(std::shared_ptr<mg::Buffer> const& buffer)
 {
     fb_device->set_next_frontbuffer(buffer);
 }
 
=== modified file 'src/server/graphics/android/hwc10_device.h'
--- src/server/graphics/android/hwc10_device.h	2013-05-17 20:43:23 +0000
+++ src/server/graphics/android/hwc10_device.h	2013-07-17 14:20:33 +0000
@@ -40,7 +40,7 @@
     geometry::Size display_size() const; 
     geometry::PixelFormat display_format() const;
     unsigned int number_of_framebuffers_available() const;
-    void set_next_frontbuffer(std::shared_ptr<compositor::Buffer> const& buffer);
+    void set_next_frontbuffer(std::shared_ptr<Buffer> const& buffer);
     void sync_to_display(bool sync);
  
     void commit_frame(EGLDisplay dpy, EGLSurface sur);
 
=== modified file 'src/server/graphics/android/hwc11_device.cpp'
--- src/server/graphics/android/hwc11_device.cpp	2013-07-11 16:54:41 +0000
+++ src/server/graphics/android/hwc11_device.cpp	2013-07-17 14:20:33 +0000
@@ -23,7 +23,7 @@
 #include <boost/throw_exception.hpp>
 #include <stdexcept>
 
-namespace mc=mir::compositor;
+namespace mg = mir::graphics;
 namespace mga=mir::graphics::android;
 namespace geom=mir::geometry;
 
@@ -74,8 +74,8 @@
     //us a hint to triple buffer. Taking this hint is currently not supported.
     return 2u;
 }
- 
-void mga::HWC11Device::set_next_frontbuffer(std::shared_ptr<mc::Buffer> const& buffer)
+
+void mga::HWC11Device::set_next_frontbuffer(std::shared_ptr<mg::Buffer> const& buffer)
 {
     layer_organizer->set_fb_target(buffer);
 
 
=== modified file 'src/server/graphics/android/hwc11_device.h'
--- src/server/graphics/android/hwc11_device.h	2013-05-17 20:17:16 +0000
+++ src/server/graphics/android/hwc11_device.h	2013-07-17 14:20:33 +0000
@@ -25,6 +25,8 @@
 {
 namespace graphics
 {
+class Buffer;
+
 namespace android
 {
 class HWCLayerOrganizer;
@@ -42,7 +44,7 @@
     geometry::Size display_size() const; 
     geometry::PixelFormat display_format() const;
     unsigned int number_of_framebuffers_available() const;
-    void set_next_frontbuffer(std::shared_ptr<compositor::Buffer> const& buffer);
+    void set_next_frontbuffer(std::shared_ptr<Buffer> const& buffer);
     void sync_to_display(bool sync);
  
     void commit_frame(EGLDisplay dpy, EGLSurface sur);
 
=== modified file 'src/server/graphics/android/hwc_common_device.h'
--- src/server/graphics/android/hwc_common_device.h	2013-05-16 19:04:50 +0000
+++ src/server/graphics/android/hwc_common_device.h	2013-07-17 14:20:33 +0000
@@ -47,7 +47,7 @@
     unsigned int number_of_framebuffers_available() const; 
 
     virtual geometry::Size display_size() const = 0;
-    virtual void set_next_frontbuffer(std::shared_ptr<compositor::Buffer> const& buffer) = 0;
+    virtual void set_next_frontbuffer(std::shared_ptr<Buffer> const& buffer) = 0;
     virtual void commit_frame(EGLDisplay dpy, EGLSurface sur) = 0;
 
     void notify_vsync();
 
=== modified file 'src/server/graphics/android/hwc_device.h'
--- src/server/graphics/android/hwc_device.h	2013-05-16 18:40:30 +0000
+++ src/server/graphics/android/hwc_device.h	2013-07-17 14:20:33 +0000
@@ -39,7 +39,7 @@
     virtual geometry::Size display_size() const = 0; 
     virtual geometry::PixelFormat display_format() const = 0; 
     virtual unsigned int number_of_framebuffers_available() const = 0;
-    virtual void set_next_frontbuffer(std::shared_ptr<compositor::Buffer> const& buffer) = 0;
+    virtual void set_next_frontbuffer(std::shared_ptr<Buffer> const& buffer) = 0;
 
     virtual void commit_frame(EGLDisplay dpy, EGLSurface sur) = 0;
 private:
 
=== modified file 'src/server/graphics/android/hwc_layerlist.cpp'
--- src/server/graphics/android/hwc_layerlist.cpp	2013-07-10 17:06:37 +0000
+++ src/server/graphics/android/hwc_layerlist.cpp	2013-07-17 14:20:33 +0000
@@ -21,7 +21,7 @@
 
 #include <cstring>
 
-namespace mc=mir::compositor;
+namespace mg=mir::graphics;
 namespace mga=mir::graphics::android;
 namespace geom=mir::geometry;
 
@@ -95,7 +95,7 @@
     return layer_list;
 }
 
-void mga::HWCLayerList::set_fb_target(std::shared_ptr<mc::Buffer> const& buffer)
+void mga::HWCLayerList::set_fb_target(std::shared_ptr<mg::Buffer> const& buffer)
 {
     auto handle = buffer->native_buffer_handle();
 
 
=== modified file 'src/server/graphics/android/hwc_layerlist.h'
--- src/server/graphics/android/hwc_layerlist.h	2013-05-03 22:53:42 +0000
+++ src/server/graphics/android/hwc_layerlist.h	2013-07-17 14:20:33 +0000
@@ -26,15 +26,12 @@
 #include <initializer_list>
 namespace mir
 {
-namespace compositor
+namespace graphics
 {
 class Buffer;
-}
-namespace graphics
-{
+
 namespace android
 {
-
 class HWCDefaultLayer;
 typedef struct std::vector<std::shared_ptr<HWCDefaultLayer>> LayerList;
  
@@ -75,7 +72,7 @@
 public:
     virtual ~HWCLayerOrganizer() = default;
     virtual const LayerList& native_list() const = 0;
-    virtual void set_fb_target(std::shared_ptr<compositor::Buffer> const&) = 0;
+    virtual void set_fb_target(std::shared_ptr<Buffer> const&) = 0;
 
 protected:
     HWCLayerOrganizer() = default;
@@ -90,7 +87,7 @@
     HWCLayerList();
     const LayerList& native_list() const;
 
-    void set_fb_target(std::shared_ptr<compositor::Buffer> const&);
+    void set_fb_target(std::shared_ptr<Buffer> const&);
 
 private:
     LayerList layer_list;
 
=== modified file 'src/server/graphics/android/internal_client_window.cpp'
--- src/server/graphics/android/internal_client_window.cpp	2013-06-25 05:42:49 +0000
+++ src/server/graphics/android/internal_client_window.cpp	2013-07-17 14:20:33 +0000
@@ -17,7 +17,7 @@
  */
 
 #include "mir/frontend/surface.h"
-#include "mir/compositor/buffer.h"
+#include "mir/graphics/buffer.h"
 #include "internal_client_window.h"
 #include "interpreter_resource_cache.h"
 #include "android_format_conversion-inl.h"
 
=== modified file 'src/server/graphics/android/interpreter_cache.cpp'
--- src/server/graphics/android/interpreter_cache.cpp	2013-05-06 22:35:54 +0000
+++ src/server/graphics/android/interpreter_cache.cpp	2013-07-17 14:20:33 +0000
@@ -20,15 +20,15 @@
 #include <boost/throw_exception.hpp>
 #include <stdexcept>
 
+namespace mg = mir::graphics;
 namespace mga=mir::graphics::android;
-namespace mc=mir::compositor;
 
-void mga::InterpreterCache::store_buffer(std::shared_ptr<compositor::Buffer>const& buffer, ANativeWindowBuffer* key)
+void mga::InterpreterCache::store_buffer(std::shared_ptr<mg::Buffer>const& buffer, ANativeWindowBuffer* key)
 {
     buffers_in_driver[key] = buffer;
 }
 
-std::shared_ptr<mc::Buffer> mga::InterpreterCache::retrieve_buffer(ANativeWindowBuffer* returned_handle)
+std::shared_ptr<mg::Buffer> mga::InterpreterCache::retrieve_buffer(ANativeWindowBuffer* returned_handle)
 {
     auto buffer_it = buffers_in_driver.find(returned_handle); 
     if (buffer_it == buffers_in_driver.end())
 
=== modified file 'src/server/graphics/android/interpreter_cache.h'
--- src/server/graphics/android/interpreter_cache.h	2013-05-09 18:46:57 +0000
+++ src/server/graphics/android/interpreter_cache.h	2013-07-17 14:20:33 +0000
@@ -33,11 +33,11 @@
 public:
     InterpreterCache() {}
 
-    void store_buffer(std::shared_ptr<compositor::Buffer>const& buffer, ANativeWindowBuffer* key);
-    std::shared_ptr<compositor::Buffer> retrieve_buffer(ANativeWindowBuffer* key);
+    void store_buffer(std::shared_ptr<graphics::Buffer>const& buffer, ANativeWindowBuffer* key);
+    std::shared_ptr<graphics::Buffer> retrieve_buffer(ANativeWindowBuffer* key);
 
 private:
-    std::unordered_map<ANativeWindowBuffer*, std::shared_ptr<compositor::Buffer>> buffers_in_driver;
+    std::unordered_map<ANativeWindowBuffer*, std::shared_ptr<graphics::Buffer>> buffers_in_driver;
 };
 }
 }
 
=== modified file 'src/server/graphics/android/interpreter_resource_cache.h'
--- src/server/graphics/android/interpreter_resource_cache.h	2013-05-06 21:25:47 +0000
+++ src/server/graphics/android/interpreter_resource_cache.h	2013-07-17 14:20:33 +0000
@@ -23,12 +23,10 @@
 
 namespace mir
 {
-namespace compositor
+namespace graphics
 {
 class Buffer;
-}
-namespace graphics
-{
+
 namespace android
 {
 class InterpreterResourceCache
@@ -36,8 +34,8 @@
 public:
     InterpreterResourceCache() {}
 
-    virtual void store_buffer(std::shared_ptr<compositor::Buffer>const& buffer, ANativeWindowBuffer* key) = 0;
-    virtual std::shared_ptr<compositor::Buffer> retrieve_buffer(ANativeWindowBuffer* key) = 0;
+    virtual void store_buffer(std::shared_ptr<graphics::Buffer>const& buffer, ANativeWindowBuffer* key) = 0;
+    virtual std::shared_ptr<graphics::Buffer> retrieve_buffer(ANativeWindowBuffer* key) = 0;
 
 protected:
     virtual ~InterpreterResourceCache() {}
 
=== modified file 'src/server/graphics/android/server_render_window.cpp'
--- src/server/graphics/android/server_render_window.cpp	2013-05-17 20:17:16 +0000
+++ src/server/graphics/android/server_render_window.cpp	2013-07-17 14:20:33 +0000
@@ -17,7 +17,7 @@
  *   Kevin DuBois <[e-mail]>
  */
 
-#include "mir/compositor/buffer.h"
+#include "mir/graphics/buffer.h"
 #include "server_render_window.h"
 #include "display_support_provider.h"
 #include "fb_swapper.h"
 
=== modified file 'src/server/graphics/gbm/gbm_buffer_allocator.cpp'
--- src/server/graphics/gbm/gbm_buffer_allocator.cpp	2013-06-14 17:16:31 +0000
+++ src/server/graphics/gbm/gbm_buffer_allocator.cpp	2013-07-17 14:20:33 +0000
@@ -116,7 +116,7 @@
     assert(buffer_initializer.get() != 0);
 }
 
-std::shared_ptr<mc::Buffer> mgg::GBMBufferAllocator::alloc_buffer(
+std::shared_ptr<mg::Buffer> mgg::GBMBufferAllocator::alloc_buffer(
     mc::BufferProperties const& buffer_properties)
 {
     uint32_t bo_flags{GBM_BO_USE_RENDERING};
@@ -141,7 +141,7 @@
         new EGLImageBufferTextureBinder{bo, egl_extensions}};
 
     /* Create the GBMBuffer */
-    std::shared_ptr<mc::Buffer> buffer{new GBMBuffer{bo, std::move(texture_binder)}};
+    std::shared_ptr<mg::Buffer> buffer{new GBMBuffer{bo, std::move(texture_binder)}};
 
     (*buffer_initializer)(*buffer);
 
 
=== modified file 'src/server/graphics/gbm/gbm_buffer_allocator.h'
--- src/server/graphics/gbm/gbm_buffer_allocator.h	2013-06-14 17:16:31 +0000
+++ src/server/graphics/gbm/gbm_buffer_allocator.h	2013-07-17 14:20:33 +0000
@@ -20,7 +20,7 @@
 #define MIR_PLATFORM_GBM_GBM_BUFFER_ALLOCATOR_H_
 
 #include "mir/compositor/graphic_buffer_allocator.h"
-#include "mir/compositor/buffer_id.h"
+#include "mir/graphics/buffer_id.h"
 
 #include <memory>
 
@@ -41,7 +41,7 @@
     GBMBufferAllocator(const std::shared_ptr<GBMPlatform>& platform,
                        const std::shared_ptr<BufferInitializer>& buffer_initializer);
 
-    virtual std::shared_ptr<compositor::Buffer> alloc_buffer(
+    virtual std::shared_ptr<Buffer> alloc_buffer(
         compositor::BufferProperties const& buffer_properties);
 
     std::vector<geometry::PixelFormat> supported_pixel_formats();
 
=== modified file 'src/server/graphics/gbm/gbm_platform.cpp'
--- src/server/graphics/gbm/gbm_platform.cpp	2013-07-10 08:50:53 +0000
+++ src/server/graphics/gbm/gbm_platform.cpp	2013-07-17 14:20:33 +0000
@@ -120,7 +120,7 @@
 }
 
 void mgg::GBMPlatform::fill_ipc_package(std::shared_ptr<compositor::BufferIPCPacker> const& packer,
-                                        std::shared_ptr<compositor::Buffer> const& buffer) const
+                                        std::shared_ptr<Buffer> const& buffer) const
 {
     auto native_handle = buffer->native_buffer_handle();
     for(auto i=0; i<native_handle->data_items; i++)
 
=== modified file 'src/server/graphics/gbm/gbm_platform.h'
--- src/server/graphics/gbm/gbm_platform.h	2013-07-10 08:50:53 +0000
+++ src/server/graphics/gbm/gbm_platform.h	2013-07-17 14:20:33 +0000
@@ -52,7 +52,7 @@
     std::shared_ptr<InternalClient> create_internal_client();
 
     void fill_ipc_package(std::shared_ptr<compositor::BufferIPCPacker> const& packer,
-                          std::shared_ptr<compositor::Buffer> const& buffer) const;
+                          std::shared_ptr<Buffer> const& buffer) const;
 
     /* From DRMAuthenticator */
     void drm_auth_magic(drm_magic_t magic);
 
=== modified file 'src/server/graphics/gbm/internal_native_display.cpp'
--- src/server/graphics/gbm/internal_native_display.cpp	2013-06-13 21:24:29 +0000
+++ src/server/graphics/gbm/internal_native_display.cpp	2013-07-17 14:20:33 +0000
@@ -21,7 +21,7 @@
 #include "mir/graphics/platform_ipc_package.h"
 #include "mir/graphics/platform.h"
 #include "mir/frontend/surface.h"
-#include "mir/compositor/buffer.h"
+#include "mir/graphics/buffer.h"
 
 #include "mir_toolkit/mesa/native_display.h"
 
 
=== modified file 'src/server/graphics/gbm/internal_native_surface.cpp'
--- src/server/graphics/gbm/internal_native_surface.cpp	2013-06-25 05:42:49 +0000
+++ src/server/graphics/gbm/internal_native_surface.cpp	2013-07-17 14:20:33 +0000
@@ -17,7 +17,7 @@
  */
 
 #include "mir/frontend/surface.h"
-#include "mir/compositor/buffer.h"
+#include "mir/graphics/buffer.h"
 #include "internal_native_surface.h"
 #include <cstring>
 namespace mgg = mir::graphics::gbm;
 
=== modified file 'src/server/graphics/gbm/internal_native_surface.h'
--- src/server/graphics/gbm/internal_native_surface.h	2013-06-18 00:21:15 +0000
+++ src/server/graphics/gbm/internal_native_surface.h	2013-07-17 14:20:33 +0000
@@ -28,7 +28,7 @@
 {
 class Surface;
 }
-namespace compositor
+namespace graphics
 {
 class Buffer;
 }
@@ -53,7 +53,7 @@
                                       MirSurfaceParameters* parameters);
 
     std::shared_ptr<frontend::Surface> surface;
-    std::shared_ptr<compositor::Buffer> current_buffer;
+    std::shared_ptr<graphics::Buffer> current_buffer;
 };
 
 }
 
=== modified file 'src/server/graphics/gl_pixel_buffer.cpp'
--- src/server/graphics/gl_pixel_buffer.cpp	2013-06-25 10:44:13 +0000
+++ src/server/graphics/gl_pixel_buffer.cpp	2013-07-17 14:20:33 +0000
@@ -18,7 +18,7 @@
 
 #include "mir/graphics/gl_context.h"
 #include "mir/graphics/gl_pixel_buffer.h"
-#include "mir/compositor/buffer.h"
+#include "mir/graphics/buffer.h"
 
 #include <stdexcept>
 #include <boost/throw_exception.hpp>
@@ -26,7 +26,6 @@
 #include <GLES2/gl2ext.h>
 
 namespace mg = mir::graphics;
-namespace msh = mir::shell;
 namespace geom = mir::geometry;
 
 namespace
@@ -79,7 +78,7 @@
     glBindFramebuffer(GL_FRAMEBUFFER, fbo);
 }
 
-void mg::GLPixelBuffer::fill_from(compositor::Buffer& buffer)
+void mg::GLPixelBuffer::fill_from(Buffer& buffer)
 {
     auto width = buffer.size().width.as_uint32_t();
     auto height = buffer.size().height.as_uint32_t();
 
=== modified file 'src/server/graphics/gl_renderer.cpp'
--- src/server/graphics/gl_renderer.cpp	2013-07-12 22:04:13 +0000
+++ src/server/graphics/gl_renderer.cpp	2013-07-17 14:20:33 +0000
@@ -1,7 +1,7 @@
 #include "mir/graphics/gl_renderer.h"
 #include "mir/graphics/compositing_criteria.h"
 #include "mir/surfaces/buffer_stream.h"
-#include "mir/compositor/buffer.h"
+#include "mir/graphics/buffer.h"
 
 #include <glm/gtc/matrix_transform.hpp>
 #include <glm/gtc/type_ptr.hpp>
 
=== modified file 'src/server/shell/surface.cpp'
--- src/server/shell/surface.cpp	2013-07-09 18:55:47 +0000
+++ src/server/shell/surface.cpp	2013-07-17 14:20:33 +0000
@@ -31,6 +31,7 @@
 
 namespace msh = mir::shell;
 namespace mc = mir::compositor;
+namespace mg = mir::graphics;
 namespace mi = mir::input;
 namespace ms = mir::surfaces;
 namespace geom = mir::geometry;
@@ -166,7 +167,7 @@
     }
 }
 
-std::shared_ptr<mc::Buffer> msh::Surface::advance_client_buffer()
+std::shared_ptr<mg::Buffer> msh::Surface::advance_client_buffer()
 {
     if (auto const& s = surface.lock())
     {
@@ -187,7 +188,7 @@
 }
  
 void msh::Surface::with_most_recent_buffer_do(
-    std::function<void(mc::Buffer&)> const& exec)
+    std::function<void(mg::Buffer&)> const& exec)
 {
     if (auto const& s = surface.lock())
     {
 
=== modified file 'src/server/shell/threaded_snapshot_strategy.cpp'
--- src/server/shell/threaded_snapshot_strategy.cpp	2013-06-25 13:19:14 +0000
+++ src/server/shell/threaded_snapshot_strategy.cpp	2013-07-17 14:20:33 +0000
@@ -17,7 +17,7 @@
  */
 
 #include "mir/shell/threaded_snapshot_strategy.h"
-#include "mir/shell/pixel_buffer.h"
+#include "mir/graphics/pixel_buffer.h"
 #include "mir/shell/surface_buffer_access.h"
 
 #include <deque>
@@ -41,7 +41,7 @@
 class SnapshottingFunctor
 {
 public:
-    SnapshottingFunctor(std::shared_ptr<PixelBuffer> const& pixels)
+    SnapshottingFunctor(std::shared_ptr<graphics::PixelBuffer> const& pixels)
         : running{true}, pixels{pixels}
     {
     }
@@ -72,7 +72,7 @@
     void take_snapshot(WorkItem const& wi)
     {
         wi.surface_buffer_access->with_most_recent_buffer_do(
-            [this](compositor::Buffer& buffer)
+            [this](graphics::Buffer& buffer)
             {
                 pixels->fill_from(buffer);
             });
@@ -100,7 +100,7 @@
 
 private:
     bool running;
-    std::shared_ptr<PixelBuffer> const pixels;
+    std::shared_ptr<graphics::PixelBuffer> const pixels;
     std::mutex work_mutex;
     std::condition_variable work_cv;
     std::deque<WorkItem> work;
@@ -110,7 +110,7 @@
 }
 
 msh::ThreadedSnapshotStrategy::ThreadedSnapshotStrategy(
-    std::shared_ptr<PixelBuffer> const& pixels)
+    std::shared_ptr<graphics::PixelBuffer> const& pixels)
     : pixels{pixels},
       functor{new SnapshottingFunctor{pixels}},
       thread{std::ref(*functor)}
 
=== modified file 'src/server/surfaces/surface.cpp'
--- src/server/surfaces/surface.cpp	2013-07-16 15:49:19 +0000
+++ src/server/surfaces/surface.cpp	2013-07-17 14:20:33 +0000
@@ -22,7 +22,7 @@
 #include "mir/surfaces/surface_state.h"
 #include "mir/surfaces/buffer_stream.h"
 #include "mir/input/input_channel.h"
-#include "mir/compositor/buffer.h"
+#include "mir/graphics/buffer.h"
 
 #include <boost/throw_exception.hpp>
 
@@ -104,7 +104,7 @@
     return surface_buffer_stream->get_stream_pixel_format();
 }
 
-std::shared_ptr<mc::Buffer> ms::Surface::advance_client_buffer()
+std::shared_ptr<mg::Buffer> ms::Surface::advance_client_buffer()
 {
     if (surface_in_startup)
     {
@@ -123,7 +123,7 @@
     surface_buffer_stream->allow_framedropping(allow);
 }
 
-std::shared_ptr<mc::Buffer> ms::Surface::compositor_buffer() const
+std::shared_ptr<mg::Buffer> ms::Surface::compositor_buffer() const
 {
     return surface_buffer_stream->lock_back_buffer();
 }
 
=== modified file 'tests/integration-tests/client/test_client_render.cpp'
--- tests/integration-tests/client/test_client_render.cpp	2013-07-11 16:54:41 +0000
+++ tests/integration-tests/client/test_client_render.cpp	2013-07-17 14:20:33 +0000
@@ -480,16 +480,16 @@
 
     geom::Size size;
     geom::PixelFormat pf;
-    mc::BufferID id1;
-    mc::BufferID id2;
+    mg::BufferID id1;
+    mg::BufferID id2;
     std::shared_ptr<mtd::TestGrallocMapper> buffer_converter;
     std::shared_ptr<mtf::Process> client_process;
 
     std::shared_ptr<MirNativeBuffer> handle;
     std::shared_ptr<MirNativeBuffer> second_handle;
 
-    std::shared_ptr<mc::Buffer> android_buffer;
-    std::shared_ptr<mc::Buffer> second_android_buffer;
+    std::shared_ptr<mg::Buffer> android_buffer;
+    std::shared_ptr<mg::Buffer> second_android_buffer;
     std::shared_ptr<mga::AndroidGraphicBufferAllocator>  allocator;
 
     static std::shared_ptr<mtf::Process> render_single_client_process;
 
=== modified file 'tests/integration-tests/compositor/test_buffer_stream.cpp'
--- tests/integration-tests/compositor/test_buffer_stream.cpp	2013-07-11 16:54:41 +0000
+++ tests/integration-tests/compositor/test_buffer_stream.cpp	2013-07-17 14:20:33 +0000
@@ -31,6 +31,7 @@
 #include <chrono>
 
 namespace mc = mir::compositor;
+namespace mg = mir::graphics;
 namespace ms = mir::surfaces;
 namespace mt = mir::testing;
 namespace mtd = mir::test::doubles;
@@ -43,7 +44,7 @@
 {
     StubBufferAllocator() : id{1} {}
 
-    std::shared_ptr<mc::Buffer> alloc_buffer(mc::BufferProperties const&)
+    std::shared_ptr<mg::Buffer> alloc_buffer(mc::BufferProperties const&)
     {
         mc::BufferProperties properties{geom::Size{id, id},
                                         geom::PixelFormat::abgr_8888,
@@ -156,7 +157,7 @@
 namespace
 {
 
-void client_request_loop(std::shared_ptr<mc::Buffer>& out_buffer,
+void client_request_loop(std::shared_ptr<mg::Buffer>& out_buffer,
                          mt::SynchronizerSpawned& synchronizer,
                          ms::BufferStream& stream)
 {
@@ -210,7 +211,7 @@
     std::vector<std::unique_ptr<CompositorInfo>> compositors;
 
     mt::Synchronizer client_sync;
-    std::shared_ptr<mc::Buffer> client_buffer;
+    std::shared_ptr<mg::Buffer> client_buffer;
     auto client_thread = std::thread(client_request_loop,  std::ref(client_buffer),
                                      std::ref(client_sync), std::ref(buffer_stream));
 
 
=== modified file 'tests/integration-tests/compositor/test_stress_buffer_swapper.cpp'
--- tests/integration-tests/compositor/test_stress_buffer_swapper.cpp	2013-05-29 23:49:32 +0000
+++ tests/integration-tests/compositor/test_stress_buffer_swapper.cpp	2013-07-17 14:20:33 +0000
@@ -20,12 +20,13 @@
 #include "multithread_harness.h"
 
 #include "mir/compositor/buffer_swapper_multi.h"
-#include "mir/compositor/buffer_id.h"
+#include "mir/graphics/buffer_id.h"
 
 #include <thread>
 #include <chrono>
 
 namespace mc = mir::compositor;
+namespace mg = mir::graphics;
 namespace mt = mir::testing;
 namespace geom = mir::geometry;
 namespace mtd = mir::test::doubles;
@@ -60,15 +61,15 @@
 
     void test_distinct_buffers(mc::BufferSwapper& swapper);
     void test_valid_buffers(mc::BufferSwapper& swapper);
-    void test_wait_situation(std::vector<std::shared_ptr<mc::Buffer>>& compositor_output_buffers,
-                             std::vector<std::shared_ptr<mc::Buffer>>& client_output_buffers,
+    void test_wait_situation(std::vector<std::shared_ptr<mg::Buffer>>& compositor_output_buffers,
+                             std::vector<std::shared_ptr<mg::Buffer>>& client_output_buffers,
                              mc::BufferSwapper& swapper,
                              unsigned int number_of_client_requests_to_make);
     void test_last_posted(mc::BufferSwapper& swapper);
 
-    std::shared_ptr<mc::Buffer> buffer_a;
-    std::shared_ptr<mc::Buffer> buffer_b;
-    std::shared_ptr<mc::Buffer> buffer_c;
+    std::shared_ptr<mg::Buffer> buffer_a;
+    std::shared_ptr<mg::Buffer> buffer_b;
+    std::shared_ptr<mg::Buffer> buffer_c;
 };
 
 void main_test_loop_pause(std::chrono::microseconds duration)
@@ -76,7 +77,7 @@
     std::this_thread::sleep_for(duration);
 }
 
-void client_request_loop(std::shared_ptr<mc::Buffer>& out_buffer, mt::SynchronizerSpawned& synchronizer,
+void client_request_loop(std::shared_ptr<mg::Buffer>& out_buffer, mt::SynchronizerSpawned& synchronizer,
                          mc::BufferSwapper& swapper)
 {
     for(;;)
@@ -92,7 +93,7 @@
     }
 }
 
-void compositor_grab_loop(std::shared_ptr<mc::Buffer>& out_buffer, mt::SynchronizerSpawned& synchronizer,
+void compositor_grab_loop(std::shared_ptr<mg::Buffer>& out_buffer, mt::SynchronizerSpawned& synchronizer,
                           mc::BufferSwapper& swapper)
 {
     for(;;)
@@ -111,8 +112,8 @@
    buffer */
 void BufferSwapperStress::test_distinct_buffers(mc::BufferSwapper& swapper)
 {
-    std::shared_ptr<mc::Buffer> compositor_buffer;
-    std::shared_ptr<mc::Buffer> client_buffer;
+    std::shared_ptr<mg::Buffer> compositor_buffer;
+    std::shared_ptr<mg::Buffer> client_buffer;
 
     thread1 = std::thread(compositor_grab_loop, std::ref(compositor_buffer),
                           std::ref(compositor_controller), std::ref(swapper));
@@ -140,18 +141,18 @@
 
 TEST_F(BufferSwapperStress, distinct_and_valid_double_buffers_in_client_and_compositor)
 {
-    auto double_list = std::vector<std::shared_ptr<mc::Buffer>>{buffer_a, buffer_b};
+    auto double_list = std::vector<std::shared_ptr<mg::Buffer>>{buffer_a, buffer_b};
     mc::BufferSwapperMulti double_swapper(double_list, double_list.size());
     test_distinct_buffers(double_swapper);
 }
 TEST_F(BufferSwapperStress, distinct_and_valid_triple_buffers_in_client_and_compositor)
 {
-    auto triple_list = std::vector<std::shared_ptr<mc::Buffer>>{buffer_a, buffer_b, buffer_c};
+    auto triple_list = std::vector<std::shared_ptr<mg::Buffer>>{buffer_a, buffer_b, buffer_c};
     mc::BufferSwapperMulti triple_swapper(triple_list, triple_list.size());
     test_distinct_buffers(triple_swapper);
 }
 
-void client_request_loop_finite(std::vector<std::shared_ptr<mc::Buffer>>& buffers,
+void client_request_loop_finite(std::vector<std::shared_ptr<mg::Buffer>>& buffers,
                       mt::SynchronizerSpawned& synchronizer,
                       mc::BufferSwapper& swapper,
                       int const number_of_requests_to_make)
@@ -167,7 +168,7 @@
     synchronizer.child_enter_wait();
 }
 
-void compositor_grab(std::vector<std::shared_ptr<mc::Buffer>>& buffers,
+void compositor_grab(std::vector<std::shared_ptr<mg::Buffer>>& buffers,
                      mt::SynchronizerSpawned& synchronizer,
                      mc::BufferSwapper& swapper)
 {
@@ -180,8 +181,8 @@
     synchronizer.child_enter_wait();
 }
 
-void BufferSwapperStress::test_wait_situation(std::vector<std::shared_ptr<mc::Buffer>>& compositor_output_buffers,
-                                              std::vector<std::shared_ptr<mc::Buffer>>& client_output_buffers,
+void BufferSwapperStress::test_wait_situation(std::vector<std::shared_ptr<mg::Buffer>>& compositor_output_buffers,
+                                              std::vector<std::shared_ptr<mg::Buffer>>& client_output_buffers,
                                               mc::BufferSwapper& swapper,
                                               unsigned int const number_of_client_requests_to_make)
 {
@@ -209,10 +210,10 @@
 
 TEST_F(BufferSwapperStress, double_test_wait_situation)
 {
-    std::vector<std::shared_ptr<mc::Buffer>> client_buffers;
-    std::vector<std::shared_ptr<mc::Buffer>> compositor_buffers;
+    std::vector<std::shared_ptr<mg::Buffer>> client_buffers;
+    std::vector<std::shared_ptr<mg::Buffer>> compositor_buffers;
     /* a double buffered client should stall on the second request without the compositor running */
-    auto double_list = std::vector<std::shared_ptr<mc::Buffer>>{buffer_a, buffer_b};
+    auto double_list = std::vector<std::shared_ptr<mg::Buffer>>{buffer_a, buffer_b};
     mc::BufferSwapperMulti double_swapper(double_list, double_list.size());
     test_wait_situation(compositor_buffers, client_buffers, double_swapper, 2);
 
@@ -221,9 +222,9 @@
 
 TEST_F(BufferSwapperStress, triple_test_wait_situation)
 {
-    std::vector<std::shared_ptr<mc::Buffer>> client_buffers;
-    std::vector<std::shared_ptr<mc::Buffer>> compositor_buffers;
-    auto triple_list = std::vector<std::shared_ptr<mc::Buffer>>{buffer_a, buffer_b, buffer_c};
+    std::vector<std::shared_ptr<mg::Buffer>> client_buffers;
+    std::vector<std::shared_ptr<mg::Buffer>> compositor_buffers;
+    auto triple_list = std::vector<std::shared_ptr<mg::Buffer>>{buffer_a, buffer_b, buffer_c};
     mc::BufferSwapperMulti triple_swapper(triple_list, triple_list.size());
     /* a triple buffered client should stall on the third request without the compositor running */
     test_wait_situation(compositor_buffers, client_buffers, triple_swapper, 3);
@@ -231,7 +232,7 @@
     EXPECT_EQ(client_buffers.at(0), compositor_buffers.at(0));
 }
 
-void client_request_loop_with_wait(std::shared_ptr<mc::Buffer>& out_buffer, mt::SynchronizerSpawned& synchronizer,
+void client_request_loop_with_wait(std::shared_ptr<mg::Buffer>& out_buffer, mt::SynchronizerSpawned& synchronizer,
                                    mc::BufferSwapper& swapper)
 {
     bool wait_request = false;
@@ -249,10 +250,10 @@
     }
 }
 
-void compositor_grab_loop_with_wait(std::shared_ptr<mc::Buffer>& out_buffer, mt::SynchronizerSpawned& synchronizer,
+void compositor_grab_loop_with_wait(std::shared_ptr<mg::Buffer>& out_buffer, mt::SynchronizerSpawned& synchronizer,
                                     mc::BufferSwapper& swapper)
 {
-    std::shared_ptr<mc::Buffer> buffer_ref;
+    std::shared_ptr<mg::Buffer> buffer_ref;
     bool wait_request = false;
     for(;;)
     {
@@ -274,8 +275,8 @@
 
 void BufferSwapperStress::test_last_posted(mc::BufferSwapper& swapper)
 {
-    std::shared_ptr<mc::Buffer> compositor_buffer;
-    std::shared_ptr<mc::Buffer> client_buffer;
+    std::shared_ptr<mg::Buffer> compositor_buffer;
+    std::shared_ptr<mg::Buffer> client_buffer;
 
     thread1 = std::thread(compositor_grab_loop_with_wait, std::ref(compositor_buffer), std::ref(compositor_controller), std::ref(swapper));
     thread2 = std::thread(client_request_loop_with_wait,  std::ref(client_buffer), std::ref(client_controller), std::ref(swapper));
@@ -301,7 +302,7 @@
 
 TEST_F(BufferSwapperStress, double_test_last_posted)
 {
-    auto double_list = std::vector<std::shared_ptr<mc::Buffer>>{buffer_a, buffer_b};
+    auto double_list = std::vector<std::shared_ptr<mg::Buffer>>{buffer_a, buffer_b};
     mc::BufferSwapperMulti double_swapper(double_list, double_list.size());
     test_last_posted(double_swapper);
 }
 
=== modified file 'tests/integration-tests/compositor/test_swapping_swappers.cpp'
--- tests/integration-tests/compositor/test_swapping_swappers.cpp	2013-07-11 16:54:41 +0000
+++ tests/integration-tests/compositor/test_swapping_swappers.cpp	2013-07-17 14:20:33 +0000
@@ -32,6 +32,7 @@
 #include <chrono>
 
 namespace mc = mir::compositor;
+namespace mg = mir::graphics;
 namespace mt = mir::testing;
 namespace geom = mir::geometry;
 namespace mtd = mir::test::doubles;
@@ -49,7 +50,7 @@
     }
     ~MockBufferAllocator() noexcept{}
 
-    MOCK_METHOD1(alloc_buffer, std::shared_ptr<mc::Buffer>(mc::BufferProperties const&));
+    MOCK_METHOD1(alloc_buffer, std::shared_ptr<mg::Buffer>(mc::BufferProperties const&));
     MOCK_METHOD0(supported_pixel_formats, std::vector<geom::PixelFormat>());
 };
 
 
=== modified file 'tests/integration-tests/graphics/gbm/test_buffer_integration.cpp'
--- tests/integration-tests/graphics/gbm/test_buffer_integration.cpp	2013-07-11 16:54:41 +0000
+++ tests/integration-tests/graphics/gbm/test_buffer_integration.cpp	2013-07-17 14:20:33 +0000
@@ -20,7 +20,7 @@
 #include "src/server/graphics/gbm/gbm_display.h"
 #include "src/server/graphics/gbm/gbm_buffer_allocator.h"
 #include "mir/compositor/buffer_basic.h"
-#include "mir/compositor/buffer_id.h"
+#include "mir/graphics/buffer_id.h"
 #include "mir/compositor/buffer_properties.h"
 #include "mir/graphics/buffer_initializer.h"
 #include "mir_test_doubles/stub_buffer.h"
@@ -72,9 +72,9 @@
 class StubGraphicBufferAllocator : public mc::GraphicBufferAllocator
 {
  public:
-    std::shared_ptr<mc::Buffer> alloc_buffer(mc::BufferProperties const&)
+    std::shared_ptr<mg::Buffer> alloc_buffer(mc::BufferProperties const&)
     {
-        return std::shared_ptr<mc::Buffer>(new StubBufferThread());
+        return std::shared_ptr<mg::Buffer>(new StubBufferThread());
     }
 
     std::vector<geom::PixelFormat> supported_pixel_formats()
@@ -139,13 +139,13 @@
     }
 
     std::shared_ptr<mc::GraphicBufferAllocator> allocator;
-    std::shared_ptr<mc::Buffer> buffer;
+    std::shared_ptr<mg::Buffer> buffer;
     mc::BufferProperties buffer_properties;
 };
 
 struct BufferDestructorThread
 {
-    BufferDestructorThread(std::shared_ptr<mc::Buffer> buffer)
+    BufferDestructorThread(std::shared_ptr<mg::Buffer> buffer)
         : buffer{std::move(buffer)}
     {
     }
@@ -157,12 +157,12 @@
         ASSERT_EQ(EGL_SUCCESS, eglGetError());
     }
 
-    std::shared_ptr<mc::Buffer> buffer;
+    std::shared_ptr<mg::Buffer> buffer;
 };
 
 struct BufferTextureInstantiatorThread
 {
-    BufferTextureInstantiatorThread(const std::shared_ptr<mc::Buffer>& buffer)
+    BufferTextureInstantiatorThread(const std::shared_ptr<mg::Buffer>& buffer)
         : buffer(buffer), exception_thrown(false)
     {
     }
@@ -183,7 +183,7 @@
         ASSERT_NE(EGL_SUCCESS, eglGetError());
     }
 
-    const std::shared_ptr<mc::Buffer>& buffer;
+    const std::shared_ptr<mg::Buffer>& buffer;
     bool exception_thrown;
 };
 
 
=== modified file 'tests/integration-tests/shell/test_session.cpp'
--- tests/integration-tests/shell/test_session.cpp	2013-07-12 20:18:19 +0000
+++ tests/integration-tests/shell/test_session.cpp	2013-07-17 14:20:33 +0000
@@ -21,7 +21,7 @@
 #include "mir/compositor/graphic_buffer_allocator.h"
 #include "mir/compositor/compositor.h"
 #include "mir/shell/application_session.h"
-#include "mir/shell/pixel_buffer.h"
+#include "mir/graphics/pixel_buffer.h"
 #include "mir/shell/placement_strategy.h"
 #include "mir/shell/surface.h"
 #include "mir/shell/surface_creation_parameters.h"
@@ -73,7 +73,7 @@
     {
         struct StubBufferAllocator : public mc::GraphicBufferAllocator
         {
-            std::shared_ptr<mc::Buffer> alloc_buffer(mc::BufferProperties const& buffer_properties)
+            std::shared_ptr<mg::Buffer> alloc_buffer(mc::BufferProperties const& buffer_properties)
             {
                 return std::make_shared<mtd::StubBuffer>(buffer_properties);
             }
@@ -106,11 +106,11 @@
     }
 
 
-    std::shared_ptr<msh::PixelBuffer> the_shell_pixel_buffer() override
+    std::shared_ptr<mg::PixelBuffer> the_shell_pixel_buffer() override
     {
-        struct StubPixelBuffer : public msh::PixelBuffer
+        struct StubPixelBuffer : public mg::PixelBuffer
         {
-            void fill_from(mc::Buffer&) {}
+            void fill_from(mg::Buffer&) {}
             void const* as_argb_8888() { return nullptr; }
             geom::Size size() const { return geom::Size(); }
             geom::Stride stride() const { return geom::Stride(); }
 
=== modified file 'tests/integration-tests/test_display_info.cpp'
--- tests/integration-tests/test_display_info.cpp	2013-07-11 16:54:41 +0000
+++ tests/integration-tests/test_display_info.cpp	2013-07-17 14:20:33 +0000
@@ -17,7 +17,7 @@
  */
 
 #include "mir/graphics/display.h"
-#include "mir/compositor/buffer.h"
+#include "mir/graphics/buffer.h"
 #include "mir/compositor/graphic_buffer_allocator.h"
 
 #include "mir_test_framework/display_server_test_fixture.h"
@@ -65,9 +65,9 @@
 class StubGraphicBufferAllocator : public mc::GraphicBufferAllocator
 {
 public:
-    std::shared_ptr<mc::Buffer> alloc_buffer(mc::BufferProperties const&)
+    std::shared_ptr<mg::Buffer> alloc_buffer(mc::BufferProperties const&)
     {
-        return std::shared_ptr<mc::Buffer>(new mtd::StubBuffer());
+        return std::shared_ptr<mg::Buffer>(new mtd::StubBuffer());
     }
 
     std::vector<geom::PixelFormat> supported_pixel_formats()
 
=== modified file 'tests/integration-tests/test_drm_auth_magic.cpp'
--- tests/integration-tests/test_drm_auth_magic.cpp	2013-06-20 08:27:10 +0000
+++ tests/integration-tests/test_drm_auth_magic.cpp	2013-07-17 14:20:33 +0000
@@ -48,9 +48,9 @@
 class StubGraphicBufferAllocator : public mc::GraphicBufferAllocator
 {
  public:
-    std::shared_ptr<mc::Buffer> alloc_buffer(mc::BufferProperties const&)
+    std::shared_ptr<mg::Buffer> alloc_buffer(mc::BufferProperties const&)
     {
-        return std::shared_ptr<mc::Buffer>(new mtd::StubBuffer());
+        return std::shared_ptr<mg::Buffer>(new mtd::StubBuffer());
     }
 
     std::vector<geom::PixelFormat> supported_pixel_formats()
 
=== modified file 'tests/integration-tests/test_surfaceloop.cpp'
--- tests/integration-tests/test_surfaceloop.cpp	2013-07-11 16:54:41 +0000
+++ tests/integration-tests/test_surfaceloop.cpp	2013-07-17 14:20:33 +0000
@@ -21,7 +21,7 @@
 #include "src/server/compositor/switching_bundle.h"
 #include "mir/compositor/buffer_swapper_multi.h"
 #include "mir/compositor/buffer_properties.h"
-#include "mir/compositor/buffer_id.h"
+#include "mir/graphics/buffer_id.h"
 #include "mir/compositor/buffer_basic.h"
 #include "mir/graphics/display.h"
 
@@ -68,7 +68,7 @@
 
     MOCK_METHOD1(
         alloc_buffer,
-        std::shared_ptr<mc::Buffer> (mc::BufferProperties const&));
+        std::shared_ptr<mg::Buffer> (mc::BufferProperties const&));
 
 
     std::vector<geom::PixelFormat> supported_pixel_formats()
@@ -76,9 +76,9 @@
         return std::vector<geom::PixelFormat>();
     }
 
-    std::unique_ptr<mc::Buffer> on_create_swapper(mc::BufferProperties const&)
+    std::unique_ptr<mg::Buffer> on_create_swapper(mc::BufferProperties const&)
     {
-        return std::unique_ptr<mc::Buffer>(new mtd::StubBuffer(::buffer_properties));
+        return std::unique_ptr<mg::Buffer>(new mtd::StubBuffer(::buffer_properties));
     }
 
     ~MockGraphicBufferAllocator() noexcept {}
@@ -235,7 +235,7 @@
             actual = requested;
             auto stub_buffer_a = std::make_shared<mtd::StubBuffer>(::buffer_properties);
             auto stub_buffer_b = std::make_shared<mtd::StubBuffer>(::buffer_properties);
-            std::vector<std::shared_ptr<mc::Buffer>> list = {stub_buffer_a, stub_buffer_b};
+            std::vector<std::shared_ptr<mg::Buffer>> list = {stub_buffer_a, stub_buffer_b};
             return std::make_shared<mc::BufferSwapperMulti>(list, list.size());
         }
 
@@ -416,10 +416,10 @@
     class StubGraphicBufferAllocator : public mc::GraphicBufferAllocator
     {
      public:
-        virtual std::shared_ptr<mc::Buffer> alloc_buffer(
+        virtual std::shared_ptr<mg::Buffer> alloc_buffer(
             mc::BufferProperties const&)
         {
-            return std::unique_ptr<mc::Buffer>(new CountingStubBuffer());
+            return std::unique_ptr<mg::Buffer>(new CountingStubBuffer());
         }
 
         std::vector<geom::PixelFormat> supported_pixel_formats()
 
=== modified file 'tests/integration-tests/test_swapinterval.cpp'
--- tests/integration-tests/test_swapinterval.cpp	2013-07-09 21:59:01 +0000
+++ tests/integration-tests/test_swapinterval.cpp	2013-07-17 14:20:33 +0000
@@ -56,8 +56,8 @@
     {
     }
 
-    std::shared_ptr<mc::Buffer> secure_client_buffer() { return std::make_shared<mtd::StubBuffer>(); }
-    std::shared_ptr<mc::Buffer> lock_back_buffer() { return std::make_shared<mtd::StubBuffer>(); }
+    std::shared_ptr<mg::Buffer> secure_client_buffer() { return std::make_shared<mtd::StubBuffer>(); }
+    std::shared_ptr<mg::Buffer> lock_back_buffer() { return std::make_shared<mtd::StubBuffer>(); }
     geom::PixelFormat get_stream_pixel_format() { return geom::PixelFormat::abgr_8888; }
     geom::Size stream_size() { return geom::Size{}; }
     void force_requests_to_complete() {}
 
=== modified file 'tests/mir_test_framework/testing_server_options.cpp'
--- tests/mir_test_framework/testing_server_options.cpp	2013-07-12 21:48:58 +0000
+++ tests/mir_test_framework/testing_server_options.cpp	2013-07-17 14:20:33 +0000
@@ -54,9 +54,9 @@
 class StubGraphicBufferAllocator : public mc::GraphicBufferAllocator
 {
  public:
-    std::shared_ptr<mc::Buffer> alloc_buffer(mc::BufferProperties const& properties)
+    std::shared_ptr<mg::Buffer> alloc_buffer(mc::BufferProperties const& properties)
     {
-        return std::unique_ptr<mc::Buffer>(new mtd::StubBuffer(properties));
+        return std::unique_ptr<mg::Buffer>(new mtd::StubBuffer(properties));
     }
 
     std::vector<geom::PixelFormat> supported_pixel_formats()
 
=== modified file 'tests/unit-tests/compositor/test_buffer_id.cpp'
--- tests/unit-tests/compositor/test_buffer_id.cpp	2013-04-24 05:22:20 +0000
+++ tests/unit-tests/compositor/test_buffer_id.cpp	2013-07-17 14:20:33 +0000
@@ -16,18 +16,19 @@
  * Authored by: Kevin DuBois <[e-mail]>
  */
 
-#include "mir/compositor/buffer_id.h"
+#include "mir/graphics/buffer_id.h"
 #include "mir_test_doubles/stub_buffer.h"
 
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 
 namespace mc=mir::compositor;
+namespace mg = mir::graphics;
 
 TEST(buffer_id, value_set )
 {
     unsigned int id_as_int = 44;
-    mc::BufferID id{id_as_int};
+    mg::BufferID id{id_as_int};
     EXPECT_EQ(id_as_int, id.as_uint32_t());
 }
 
@@ -36,8 +37,8 @@
     unsigned int id_as_int0 = 44;
     unsigned int id_as_int1 = 41;
 
-    mc::BufferID id0{id_as_int0};
-    mc::BufferID id1{id_as_int1};
+    mg::BufferID id0{id_as_int0};
+    mg::BufferID id1{id_as_int1};
 
     EXPECT_EQ(id0, id0);
     EXPECT_EQ(id1, id1);
@@ -50,8 +51,8 @@
     unsigned int id_as_int0 = 44;
     unsigned int id_as_int1 = 41;
 
-    mc::BufferID id0{id_as_int0};
-    mc::BufferID id1{id_as_int1};
+    mg::BufferID id0{id_as_int0};
+    mg::BufferID id1{id_as_int1};
 
     EXPECT_LT(id1, id0);
 }
@@ -60,14 +61,14 @@
 {
     using mir::test::doubles::StubBuffer;
     int const ids = 542;
-    std::vector<mc::BufferID> generated_ids;
+    std::vector<mg::BufferID> generated_ids;
 
     for (auto i=0; i < ids; i++)
         generated_ids.push_back(StubBuffer().id());
 
     while (!generated_ids.empty())
     {
-        mc::BufferID test_id = generated_ids.back();
+        mg::BufferID test_id = generated_ids.back();
 
         generated_ids.pop_back();
 
 
=== modified file 'tests/unit-tests/compositor/test_buffer_swapper.cpp'
--- tests/unit-tests/compositor/test_buffer_swapper.cpp	2013-06-12 16:15:05 +0000
+++ tests/unit-tests/compositor/test_buffer_swapper.cpp	2013-07-17 14:20:33 +0000
@@ -22,6 +22,7 @@
 #include <gtest/gtest.h>
 
 namespace mc = mir::compositor;
+namespace mg = mir::graphics;
 namespace geom = mir::geometry;
 namespace mtd = mir::test::doubles;
 
@@ -34,14 +35,14 @@
         buffer_c = std::make_shared<mtd::StubBuffer>();
     }
 
-    std::shared_ptr<mc::Buffer> buffer_a;
-    std::shared_ptr<mc::Buffer> buffer_b;
-    std::shared_ptr<mc::Buffer> buffer_c;
+    std::shared_ptr<mg::Buffer> buffer_a;
+    std::shared_ptr<mg::Buffer> buffer_b;
+    std::shared_ptr<mg::Buffer> buffer_c;
 };
 
 TEST_F(BufferSwapperConstruction, basic_double_construction_vector)
 {
-    std::vector<std::shared_ptr<mc::Buffer>> buffers{buffer_a, buffer_b, buffer_c};
+    std::vector<std::shared_ptr<mg::Buffer>> buffers{buffer_a, buffer_b, buffer_c};
 
     auto use_count_before_a  = buffer_a.use_count();
     auto use_count_before_b  = buffer_b.use_count();
@@ -56,7 +57,7 @@
 
 TEST_F(BufferSwapperConstruction, basic_double_construction_initializer)
 {
-    std::vector<std::shared_ptr<mc::Buffer>> buffers{buffer_a, buffer_b};
+    std::vector<std::shared_ptr<mg::Buffer>> buffers{buffer_a, buffer_b};
 
     auto use_count_before_a  = buffer_a.use_count();
     auto use_count_before_b  = buffer_b.use_count();
@@ -72,7 +73,7 @@
 
 TEST_F(BufferSwapperConstruction, basic_triple_construction_initializer)
 {
-    std::vector<std::shared_ptr<mc::Buffer>> buffers{buffer_a, buffer_b, buffer_c};
+    std::vector<std::shared_ptr<mg::Buffer>> buffers{buffer_a, buffer_b, buffer_c};
     auto use_count_before_a  = buffer_a.use_count();
     auto use_count_before_b  = buffer_b.use_count();
     auto use_count_before_c  = buffer_c.use_count();
@@ -88,7 +89,7 @@
 
 TEST_F(BufferSwapperConstruction, buffers_out_come_from_init_double)
 {
-    std::vector<std::shared_ptr<mc::Buffer>> buffers{buffer_a, buffer_b};
+    std::vector<std::shared_ptr<mg::Buffer>> buffers{buffer_a, buffer_b};
     mc::BufferSwapperMulti swapper(buffers, buffers.size());
 
     auto buffer_1 = swapper.compositor_acquire();
@@ -101,7 +102,7 @@
 
 TEST_F(BufferSwapperConstruction, buffers_out_come_from_init_triple)
 {
-    std::vector<std::shared_ptr<mc::Buffer>> buffers{buffer_a, buffer_b, buffer_c};
+    std::vector<std::shared_ptr<mg::Buffer>> buffers{buffer_a, buffer_b, buffer_c};
     mc::BufferSwapperMulti swapper(buffers, buffers.size());
 
     auto buffer_1 = swapper.compositor_acquire();
@@ -118,11 +119,11 @@
 
 TEST_F(BufferSwapperConstruction, buffer_transfer_triple_all_owned)
 {
-    std::vector<std::shared_ptr<mc::Buffer>> buffers{buffer_a, buffer_b, buffer_c};
+    std::vector<std::shared_ptr<mg::Buffer>> buffers{buffer_a, buffer_b, buffer_c};
     mc::BufferSwapperMulti swapper(buffers, buffers.size());
 
     size_t test_size;
-    std::vector<std::shared_ptr<mc::Buffer>> list;
+    std::vector<std::shared_ptr<mg::Buffer>> list;
     swapper.end_responsibility(list, test_size);
 
     auto res1 = std::find(list.begin(), list.end(), buffer_a);
@@ -138,13 +139,13 @@
 
 TEST_F(BufferSwapperConstruction, buffer_transfer_triple_some_not_owned)
 {
-    std::vector<std::shared_ptr<mc::Buffer>> buffers{buffer_a, buffer_b, buffer_c};
+    std::vector<std::shared_ptr<mg::Buffer>> buffers{buffer_a, buffer_b, buffer_c};
     mc::BufferSwapperMulti swapper(buffers, buffers.size());
 
     auto acquired_buffer = swapper.client_acquire();
 
     size_t test_size;
-    std::vector<std::shared_ptr<mc::Buffer>> list;
+    std::vector<std::shared_ptr<mg::Buffer>> list;
     swapper.end_responsibility(list, test_size);
 
     auto res1 = std::find(list.begin(), list.end(), acquired_buffer);
 
=== modified file 'tests/unit-tests/compositor/test_buffer_swapper_double.cpp'
--- tests/unit-tests/compositor/test_buffer_swapper_double.cpp	2013-06-15 11:09:16 +0000
+++ tests/unit-tests/compositor/test_buffer_swapper_double.cpp	2013-07-17 14:20:33 +0000
@@ -20,7 +20,7 @@
 #include "mir_test_doubles/stub_buffer.h"
 
 #include "mir/compositor/buffer_swapper_multi.h"
-#include "mir/compositor/buffer_id.h"
+#include "mir/graphics/buffer_id.h"
 
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
@@ -29,6 +29,7 @@
 #include <thread>
 
 namespace mc = mir::compositor;
+namespace mg = mir::graphics;
 namespace geom = mir::geometry;
 namespace mtd = mir::test::doubles;
 
@@ -41,13 +42,13 @@
         buffer_a = std::make_shared<mtd::StubBuffer>();
         buffer_b = std::make_shared<mtd::StubBuffer>();
 
-        auto double_list = std::vector<std::shared_ptr<mc::Buffer>>{buffer_a, buffer_b};
+        auto double_list = std::vector<std::shared_ptr<mg::Buffer>>{buffer_a, buffer_b};
         swapper = std::make_shared<mc::BufferSwapperMulti>(double_list, double_list.size());
 
     }
 
-    std::shared_ptr<mc::Buffer> buffer_a;
-    std::shared_ptr<mc::Buffer> buffer_b;
+    std::shared_ptr<mg::Buffer> buffer_a;
+    std::shared_ptr<mg::Buffer> buffer_b;
 
     std::shared_ptr<mc::BufferSwapper> swapper;
 };
 
=== modified file 'tests/unit-tests/compositor/test_buffer_swapper_spin_triple.cpp'
--- tests/unit-tests/compositor/test_buffer_swapper_spin_triple.cpp	2013-05-29 23:55:41 +0000
+++ tests/unit-tests/compositor/test_buffer_swapper_spin_triple.cpp	2013-07-17 14:20:33 +0000
@@ -26,6 +26,7 @@
 #include <algorithm>
 
 namespace mc = mir::compositor;
+namespace mg = mir::graphics;
 namespace mtd = mir::test::doubles;
 
 namespace
@@ -38,13 +39,13 @@
           buffer_b{std::make_shared<mtd::StubBuffer>()},
           buffer_c{std::make_shared<mtd::StubBuffer>()}
     {
-          auto list = std::vector<std::shared_ptr<mc::Buffer>>{buffer_a, buffer_b, buffer_c};
+          auto list = std::vector<std::shared_ptr<mg::Buffer>>{buffer_a, buffer_b, buffer_c};
           swapper = std::make_shared<mc::BufferSwapperSpin>(list, list.size());
     }
 
-    std::shared_ptr<mc::Buffer> const buffer_a;
-    std::shared_ptr<mc::Buffer> const buffer_b;
-    std::shared_ptr<mc::Buffer> const buffer_c;
+    std::shared_ptr<mg::Buffer> const buffer_a;
+    std::shared_ptr<mg::Buffer> const buffer_b;
+    std::shared_ptr<mg::Buffer> const buffer_c;
 
     std::shared_ptr<mc::BufferSwapper> swapper;
 };
@@ -53,7 +54,7 @@
 
 TEST_F(BufferSwapperSpinTriple, client_can_always_get_new_buffer)
 {
-    std::vector<std::shared_ptr<mc::Buffer>> expected_buffers;
+    std::vector<std::shared_ptr<mg::Buffer>> expected_buffers;
 
     for (unsigned int i = 0; i < 10; i++)
     {
@@ -81,7 +82,7 @@
 
 TEST_F(BufferSwapperSpinTriple, client_can_always_get_new_buffer_while_compositor_has_one)
 {
-    std::vector<std::shared_ptr<mc::Buffer>> expected_buffers;
+    std::vector<std::shared_ptr<mg::Buffer>> expected_buffers;
 
     auto comp_buf = swapper->compositor_acquire();
 
@@ -165,7 +166,7 @@
     swapper->compositor_release(comp_buf);
 
     /* After the release, the compositor's buffer should be available to the client */
-    std::vector<std::shared_ptr<mc::Buffer>> client_buffers;
+    std::vector<std::shared_ptr<mg::Buffer>> client_buffers;
 
     for (auto i = 0; i < 3; i++)
     {
@@ -182,7 +183,7 @@
 TEST_F(BufferSwapperSpinTriple, buffer_transfer_triple_all_owned)
 {
     size_t test_size;
-    std::vector<std::shared_ptr<mc::Buffer>> list;
+    std::vector<std::shared_ptr<mg::Buffer>> list;
     swapper->end_responsibility(list, test_size);
 
     auto res1 = std::find(list.begin(), list.end(), buffer_a);
@@ -201,7 +202,7 @@
     auto acquired_buffer = swapper->client_acquire();
 
     size_t test_size;
-    std::vector<std::shared_ptr<mc::Buffer>> list;
+    std::vector<std::shared_ptr<mg::Buffer>> list;
     swapper->end_responsibility(list, test_size);
 
     auto res1 = std::find(list.begin(), list.end(), acquired_buffer);
 
=== modified file 'tests/unit-tests/compositor/test_buffer_swapper_triple.cpp'
--- tests/unit-tests/compositor/test_buffer_swapper_triple.cpp	2013-05-29 23:49:32 +0000
+++ tests/unit-tests/compositor/test_buffer_swapper_triple.cpp	2013-07-17 14:20:33 +0000
@@ -19,12 +19,13 @@
 #include "mir_test_doubles/stub_buffer.h"
 
 #include "mir/compositor/buffer_swapper_multi.h"
-#include "mir/compositor/buffer_id.h"
+#include "mir/graphics/buffer_id.h"
 
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 
 namespace mc = mir::compositor;
+namespace mg = mir::graphics;
 namespace geom = mir::geometry;
 namespace mtd = mir::test::doubles;
 namespace
@@ -38,14 +39,14 @@
         buffer_b = std::make_shared<mtd::StubBuffer>();
         buffer_c = std::make_shared<mtd::StubBuffer>();
 
-        auto triple_list = std::vector<std::shared_ptr<mc::Buffer>>{buffer_a, buffer_b, buffer_c};
+        auto triple_list = std::vector<std::shared_ptr<mg::Buffer>>{buffer_a, buffer_b, buffer_c};
         swapper = std::make_shared<mc::BufferSwapperMulti>(triple_list, triple_list.size());
 
     }
 
-    std::shared_ptr<mc::Buffer> buffer_a;
-    std::shared_ptr<mc::Buffer> buffer_b;
-    std::shared_ptr<mc::Buffer> buffer_c;
+    std::shared_ptr<mg::Buffer> buffer_a;
+    std::shared_ptr<mg::Buffer> buffer_b;
+    std::shared_ptr<mg::Buffer> buffer_c;
 
     std::shared_ptr<mc::BufferSwapper> swapper;
 };
 
=== modified file 'tests/unit-tests/compositor/test_swapper_factory.cpp'
--- tests/unit-tests/compositor/test_swapper_factory.cpp	2013-07-11 16:54:41 +0000
+++ tests/unit-tests/compositor/test_swapper_factory.cpp	2013-07-17 14:20:33 +0000
@@ -28,6 +28,7 @@
 #include <gtest/gtest.h>
 
 namespace mc = mir::compositor;
+namespace mg = mir::graphics;
 namespace geom = mir::geometry;
 namespace mtd = mir::test::doubles;
 
@@ -46,7 +47,7 @@
         ON_CALL(*this, alloc_buffer(_))
             .WillByDefault(Return(std::make_shared<mtd::StubBuffer>(properties)));
     }
-    MOCK_METHOD1(alloc_buffer, std::shared_ptr<mc::Buffer>(mc::BufferProperties const&));
+    MOCK_METHOD1(alloc_buffer, std::shared_ptr<mg::Buffer>(mc::BufferProperties const&));
     MOCK_METHOD0(supported_pixel_formats, std::vector<geom::PixelFormat>());
 
     ~MockGraphicBufferAllocator() noexcept {}
@@ -148,7 +149,7 @@
     using namespace testing;
 
     mc::BufferProperties properties;
-    std::vector<std::shared_ptr<mc::Buffer>> list {};
+    std::vector<std::shared_ptr<mg::Buffer>> list {};
     size_t size = 3;
 
     EXPECT_CALL(*mock_buffer_allocator, alloc_buffer(properties))
@@ -163,7 +164,7 @@
     using namespace testing;
 
     mc::BufferProperties properties;
-    std::vector<std::shared_ptr<mc::Buffer>> list;
+    std::vector<std::shared_ptr<mg::Buffer>> list;
     size_t size = 3;
 
     EXPECT_CALL(*mock_buffer_allocator, alloc_buffer(properties))
@@ -182,7 +183,7 @@
     auto buffer = std::make_shared<mtd::StubBuffer>();
     {
         size_t size = 3;
-        std::vector<std::shared_ptr<mc::Buffer>> list{buffer};
+        std::vector<std::shared_ptr<mg::Buffer>> list{buffer};
 
         auto swapper = strategy.create_swapper_reuse_buffers(
             properties, list, size, mc::SwapperType::synchronous);
@@ -197,7 +198,7 @@
     mc::SwapperFactory strategy(mock_buffer_allocator, 2);
 
     size_t size = 3;
-    std::vector<std::shared_ptr<mc::Buffer>> list{};
+    std::vector<std::shared_ptr<mg::Buffer>> list{};
 
     EXPECT_THROW({
         strategy.create_swapper_reuse_buffers(
@@ -214,7 +215,7 @@
     mc::SwapperFactory strategy(mock_buffer_allocator);
 
     size_t size = 2;
-    std::vector<std::shared_ptr<mc::Buffer>> list{};
+    std::vector<std::shared_ptr<mg::Buffer>> list{};
     auto swapper = strategy.create_swapper_reuse_buffers(
         properties, list, size, mc::SwapperType::framedropping);
 }
 
=== modified file 'tests/unit-tests/compositor/test_switching_bundle.cpp'
--- tests/unit-tests/compositor/test_switching_bundle.cpp	2013-07-11 16:54:41 +0000
+++ tests/unit-tests/compositor/test_switching_bundle.cpp	2013-07-17 14:20:33 +0000
@@ -27,6 +27,7 @@
 namespace geom=mir::geometry;
 namespace mtd=mir::test::doubles;
 namespace mc=mir::compositor;
+namespace mg = mir::graphics;
 
 struct SwitchingBundleTest : public ::testing::Test
 {
@@ -47,7 +48,7 @@
     std::shared_ptr<mtd::MockSwapperFactory> mock_swapper_factory;
     std::shared_ptr<mtd::MockSwapper> mock_default_swapper;
     std::shared_ptr<mtd::MockSwapper> mock_secondary_swapper;
-    std::shared_ptr<mc::Buffer> stub_buffer;
+    std::shared_ptr<mg::Buffer> stub_buffer;
     mc::BufferProperties properties;
 };
 
 
=== modified file 'tests/unit-tests/compositor/test_temporary_buffers.cpp'
--- tests/unit-tests/compositor/test_temporary_buffers.cpp	2013-07-11 16:54:41 +0000
+++ tests/unit-tests/compositor/test_temporary_buffers.cpp	2013-07-17 14:20:33 +0000
@@ -25,6 +25,7 @@
 #include <stdexcept>
 
 namespace mtd=mir::test::doubles;
+namespace mg = mir::graphics;
 namespace mc=mir::compositor;
 namespace geom=mir::geometry;
 
@@ -33,7 +34,7 @@
 class TemporaryTestBuffer : public mc::TemporaryBuffer
 {
 public:
-    TemporaryTestBuffer(const std::shared_ptr<mc::Buffer>& buf)
+    TemporaryTestBuffer(const std::shared_ptr<mg::Buffer>& buf)
         : TemporaryBuffer(buf)
     {
     }
@@ -43,8 +44,8 @@
 {
 public:
     ~MockBackBufferStrategy() noexcept {}
-    MOCK_METHOD0(acquire, std::shared_ptr<mc::Buffer>());
-    MOCK_METHOD1(release, void(std::shared_ptr<mc::Buffer> const&));
+    MOCK_METHOD0(acquire, std::shared_ptr<mg::Buffer>());
+    MOCK_METHOD1(release, void(std::shared_ptr<mg::Buffer> const&));
 };
 
 class TemporaryBuffersTest : public ::testing::Test
 
=== modified file 'tests/unit-tests/frontend/test_client_buffer_tracker.cpp'
--- tests/unit-tests/frontend/test_client_buffer_tracker.cpp	2013-04-24 05:22:20 +0000
+++ tests/unit-tests/frontend/test_client_buffer_tracker.cpp	2013-07-17 14:20:33 +0000
@@ -17,17 +17,17 @@
  */
 
 #include "../../src/server/frontend/client_buffer_tracker.h"
-#include "mir/compositor/buffer_id.h"
+#include "mir/graphics/buffer_id.h"
 
 #include <gtest/gtest.h>
 
 namespace mf = mir::frontend;
-namespace mc = mir::compositor;
+namespace mg = mir::graphics;
 
 TEST(ClientBufferTracker, just_added_buffer_is_known_by_client)
 {
     mf::ClientBufferTracker tracker(3);
-    mc::BufferID const id{5};
+    mg::BufferID const id{5};
 
     tracker.add(id);
     EXPECT_TRUE(tracker.client_has(id));
@@ -37,17 +37,17 @@
 {
     mf::ClientBufferTracker tracker(3);
 
-    tracker.add(mc::BufferID{5});
-    EXPECT_FALSE(tracker.client_has(mc::BufferID{6}));
+    tracker.add(mg::BufferID{5});
+    EXPECT_FALSE(tracker.client_has(mg::BufferID{6}));
 }
 
 TEST(ClientBufferTracker, tracks_sequence_of_buffers)
 {
     mf::ClientBufferTracker tracker(3);
-    mc::BufferID const one{1};
-    mc::BufferID const two{2};
-    mc::BufferID const three{3};
-    mc::BufferID const four{4};
+    mg::BufferID const one{1};
+    mg::BufferID const two{2};
+    mg::BufferID const three{3};
+    mg::BufferID const four{4};
 
     tracker.add(one);
     tracker.add(two);
@@ -63,10 +63,10 @@
 {
     mf::ClientBufferTracker tracker(3);
 
-    mc::BufferID const one{1};
-    mc::BufferID const two{2};
-    mc::BufferID const three{3};
-    mc::BufferID const four{4};
+    mg::BufferID const one{1};
+    mg::BufferID const two{2};
+    mg::BufferID const three{3};
+    mg::BufferID const four{4};
 
     tracker.add(one);
     tracker.add(two);
@@ -88,9 +88,9 @@
 
 TEST(ClientBufferTracker, tracks_correct_number_of_buffers)
 {
-    mc::BufferID ids[10];
+    mg::BufferID ids[10];
     for (unsigned int i = 0; i < 10; ++i)
-        ids[i] = mc::BufferID{i};
+        ids[i] = mg::BufferID{i};
 
     for (unsigned int tracker_size = 2; tracker_size < 10; ++tracker_size)
     {
 
=== modified file 'tests/unit-tests/frontend/test_session_mediator.cpp'
--- tests/unit-tests/frontend/test_session_mediator.cpp	2013-07-15 09:29:14 +0000
+++ tests/unit-tests/frontend/test_session_mediator.cpp	2013-07-17 14:20:33 +0000
@@ -95,9 +95,9 @@
             .WillByDefault(testing::Return(std::vector<geom::PixelFormat>()));
     }
 
-    std::shared_ptr<mc::Buffer> alloc_buffer(mc::BufferProperties const&)
+    std::shared_ptr<mg::Buffer> alloc_buffer(mc::BufferProperties const&)
     {
-        return std::shared_ptr<mc::Buffer>();
+        return std::shared_ptr<mg::Buffer>();
     }
 
     MOCK_METHOD0(supported_pixel_formats, std::vector<geom::PixelFormat>());
@@ -125,7 +125,7 @@
     MOCK_METHOD0(get_ipc_package, std::shared_ptr<mg::PlatformIPCPackage>());
     MOCK_METHOD0(create_internal_client, std::shared_ptr<mg::InternalClient>());
     MOCK_CONST_METHOD2(fill_ipc_package, void(std::shared_ptr<mc::BufferIPCPacker> const&,
-                                              std::shared_ptr<mc::Buffer> const&));
+                                              std::shared_ptr<mg::Buffer> const&));
 };
 
 class NullEventSink : public mir::events::EventSink
@@ -377,16 +377,16 @@
 
     {
         EXPECT_CALL(*stubbed_session->mock_buffer, id())
-            .WillOnce(Return(mc::BufferID{4}))
-            .WillOnce(Return(mc::BufferID{5}))
-            .WillOnce(Return(mc::BufferID{4}))
-            .WillOnce(Return(mc::BufferID{5}));
+            .WillOnce(Return(mg::BufferID{4}))
+            .WillOnce(Return(mg::BufferID{5}))
+            .WillOnce(Return(mg::BufferID{4}))
+            .WillOnce(Return(mg::BufferID{5}));
 
         mp::Surface surface_response;
         mp::SurfaceId buffer_request;
         mp::Buffer buffer_response[3];
 
-        std::shared_ptr<mc::Buffer> tmp_buffer = stubbed_session->mock_buffer;
+        std::shared_ptr<mg::Buffer> tmp_buffer = stubbed_session->mock_buffer;
         EXPECT_CALL(*graphics_platform, fill_ipc_package(_, tmp_buffer))
             .Times(2);
 
 
=== modified file 'tests/unit-tests/frontend/test_session_mediator_android.cpp'
--- tests/unit-tests/frontend/test_session_mediator_android.cpp	2013-07-08 21:49:48 +0000
+++ tests/unit-tests/frontend/test_session_mediator_android.cpp	2013-07-17 14:20:33 +0000
@@ -52,9 +52,9 @@
 class StubGraphicBufferAllocator : public mc::GraphicBufferAllocator
 {
 public:
-    std::shared_ptr<mc::Buffer> alloc_buffer(mc::BufferProperties const&)
+    std::shared_ptr<mg::Buffer> alloc_buffer(mc::BufferProperties const&)
     {
-        return std::shared_ptr<mc::Buffer>();
+        return std::shared_ptr<mg::Buffer>();
     }
 
     virtual std::vector<geom::PixelFormat> supported_pixel_formats()
 
=== modified file 'tests/unit-tests/frontend/test_session_mediator_gbm.cpp'
--- tests/unit-tests/frontend/test_session_mediator_gbm.cpp	2013-07-08 21:49:48 +0000
+++ tests/unit-tests/frontend/test_session_mediator_gbm.cpp	2013-07-17 14:20:33 +0000
@@ -51,9 +51,9 @@
 class StubGraphicBufferAllocator : public mc::GraphicBufferAllocator
 {
 public:
-    std::shared_ptr<mc::Buffer> alloc_buffer(mc::BufferProperties const&)
+    std::shared_ptr<mg::Buffer> alloc_buffer(mc::BufferProperties const&)
     {
-        return std::shared_ptr<mc::Buffer>();
+        return std::shared_ptr<mg::Buffer>();
     }
 
     virtual std::vector<geom::PixelFormat> supported_pixel_formats()
 
=== modified file 'tests/unit-tests/graphics/android/test_fb_simple_swapper.cpp'
--- tests/unit-tests/graphics/android/test_fb_simple_swapper.cpp	2013-05-02 00:34:03 +0000
+++ tests/unit-tests/graphics/android/test_fb_simple_swapper.cpp	2013-07-17 14:20:33 +0000
@@ -26,6 +26,7 @@
 #include <gtest/gtest.h>
 
 namespace mc=mir::compositor;
+namespace mg=mir::graphics;
 namespace mga=mir::graphics::android;
 namespace mtd=mir::test::doubles;
 
@@ -39,14 +40,14 @@
         buffer3 = std::make_shared<mtd::MockBuffer>();
     }
 
-    std::shared_ptr<mc::Buffer> buffer1;
-    std::shared_ptr<mc::Buffer> buffer2;
-    std::shared_ptr<mc::Buffer> buffer3;
+    std::shared_ptr<mg::Buffer> buffer1;
+    std::shared_ptr<mg::Buffer> buffer2;
+    std::shared_ptr<mg::Buffer> buffer3;
 };
 
 TEST_F(FBSimpleSwapperTest, simple_swaps_returns_valid)
 {
-    std::initializer_list<std::shared_ptr<mc::Buffer>> double_list{buffer1, buffer2};
+    std::initializer_list<std::shared_ptr<mg::Buffer>> double_list{buffer1, buffer2};
     mga::FBSimpleSwapper fb_swapper(double_list);
 
     auto test_buffer = fb_swapper.compositor_acquire();
@@ -56,7 +57,7 @@
 
 TEST_F(FBSimpleSwapperTest, simple_swaps_return_aba_pattern)
 {
-    std::initializer_list<std::shared_ptr<mc::Buffer>> double_list{buffer1, buffer2};
+    std::initializer_list<std::shared_ptr<mg::Buffer>> double_list{buffer1, buffer2};
     mga::FBSimpleSwapper fb_swapper(double_list);
 
     auto test_buffer_1 = fb_swapper.compositor_acquire();
@@ -74,7 +75,7 @@
 
 TEST_F(FBSimpleSwapperTest, triple_swaps_return_abcab_pattern)
 {
-    std::initializer_list<std::shared_ptr<mc::Buffer>> triple_list{buffer1, buffer2, buffer3};
+    std::initializer_list<std::shared_ptr<mg::Buffer>> triple_list{buffer1, buffer2, buffer3};
     mga::FBSimpleSwapper fb_swapper(triple_list);
 
     auto test_buffer_1 = fb_swapper.compositor_acquire();
@@ -103,10 +104,10 @@
 
 TEST_F(FBSimpleSwapperTest, synctest)
 {
-    std::vector<std::shared_ptr<mc::Buffer>> test_buffers{buffer1, buffer2};
+    std::vector<std::shared_ptr<mg::Buffer>> test_buffers{buffer1, buffer2};
     mga::FBSimpleSwapper fb_swapper(test_buffers);
 
-    std::vector<std::shared_ptr<mc::Buffer>> blist;
+    std::vector<std::shared_ptr<mg::Buffer>> blist;
     std::mutex mut;
     for(auto i=0u; i < 150; ++i)
     {
 
=== modified file 'tests/unit-tests/graphics/android/test_framebuffer_factory.cpp'
--- tests/unit-tests/graphics/android/test_framebuffer_factory.cpp	2013-07-11 16:54:41 +0000
+++ tests/unit-tests/graphics/android/test_framebuffer_factory.cpp	2013-07-17 14:20:33 +0000
@@ -27,6 +27,7 @@
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 
+namespace mg=mir::graphics;
 namespace mga=mir::graphics::android;
 namespace mtd=mir::test::doubles;
 namespace mt=mir::test;
@@ -39,7 +40,7 @@
 class MockAndroidGraphicBufferAllocator : public mga::GraphicBufferAllocator
 {
 public:
-    MOCK_METHOD1(alloc_buffer, std::shared_ptr<mc::Buffer>(mc::BufferProperties const&)); 
+    MOCK_METHOD1(alloc_buffer, std::shared_ptr<mg::Buffer>(mc::BufferProperties const&));
     MOCK_METHOD3(alloc_buffer_platform, std::shared_ptr<mga::Buffer>(geom::Size, geom::PixelFormat, mga::BufferUsage));
     MOCK_METHOD0(supported_pixel_formats, std::vector<geom::PixelFormat>());
 
 
=== modified file 'tests/unit-tests/graphics/android/test_hwc10_device.cpp'
--- tests/unit-tests/graphics/android/test_hwc10_device.cpp	2013-07-11 16:54:41 +0000
+++ tests/unit-tests/graphics/android/test_hwc10_device.cpp	2013-07-17 14:20:33 +0000
@@ -26,6 +26,7 @@
 #include <stdexcept>
 
 namespace mc=mir::compositor;
+namespace mg=mir::graphics;
 namespace mga=mir::graphics::android;
 namespace mtd=mir::test::doubles;
 namespace geom=mir::geometry;
@@ -90,7 +91,7 @@
 
 TEST_F(HWC10Device, hwc10_set_next_frontbuffer)
 {
-    std::shared_ptr<mc::Buffer> mock_buffer = std::make_shared<mtd::MockBuffer>();
+    std::shared_ptr<mg::Buffer> mock_buffer = std::make_shared<mtd::MockBuffer>();
     EXPECT_CALL(*mock_fbdev, set_next_frontbuffer(mock_buffer))
         .Times(1);
 
 
=== modified file 'tests/unit-tests/graphics/android/test_hwc11_device.cpp'
--- tests/unit-tests/graphics/android/test_hwc11_device.cpp	2013-05-22 06:30:39 +0000
+++ tests/unit-tests/graphics/android/test_hwc11_device.cpp	2013-07-17 14:20:33 +0000
@@ -28,6 +28,7 @@
 #include <stdexcept>
 
 namespace mc=mir::compositor;
+namespace mg=mir::graphics;
 namespace mga=mir::graphics::android;
 namespace mtd=mir::test::doubles;
 
@@ -258,7 +259,7 @@
 
 TEST_F(HWC11Device, hwc_device_set_next_frontbuffer_adds_to_layerlist)
 {
-    std::shared_ptr<mc::Buffer> mock_buffer = std::make_shared<mtd::MockBuffer>();
+    std::shared_ptr<mg::Buffer> mock_buffer = std::make_shared<mtd::MockBuffer>();
     EXPECT_CALL(*this->mock_organizer, set_fb_target(mock_buffer))
         .Times(1);
  
@@ -268,7 +269,7 @@
 
 TEST_F(HWC11Device, hwc_device_set_next_frontbuffer_posts_vsync)
 {
-    std::shared_ptr<mc::Buffer> mock_buffer = std::make_shared<mtd::MockBuffer>();
+    std::shared_ptr<mg::Buffer> mock_buffer = std::make_shared<mtd::MockBuffer>();
     EXPECT_CALL(*this->mock_display_support_provider, set_next_frontbuffer(mock_buffer))
         .Times(1);
 
@@ -278,7 +279,7 @@
 
 TEST_F(HWC11Device, hwc_device_set_next_frontbuffer_posts_no_sync)
 {
-    std::shared_ptr<mc::Buffer> mock_buffer = std::make_shared<mtd::MockBuffer>();
+    std::shared_ptr<mg::Buffer> mock_buffer = std::make_shared<mtd::MockBuffer>();
     EXPECT_CALL(*this->mock_display_support_provider, set_next_frontbuffer(mock_buffer))
         .Times(0);
 
 
=== modified file 'tests/unit-tests/graphics/android/test_internal_client.cpp'
--- tests/unit-tests/graphics/android/test_internal_client.cpp	2013-07-11 16:54:41 +0000
+++ tests/unit-tests/graphics/android/test_internal_client.cpp	2013-07-17 14:20:33 +0000
@@ -22,7 +22,7 @@
 #include <gtest/gtest.h>
 
 namespace geom=mir::geometry;
-namespace mc=mir::compositor;
+namespace mg=mir::graphics;
 namespace mga=mir::graphics::android;
 
 namespace
@@ -43,9 +43,9 @@
     {
         return geom::PixelFormat::xbgr_8888;
     }
-    std::shared_ptr<mc::Buffer> advance_client_buffer()
+    std::shared_ptr<mg::Buffer> advance_client_buffer()
     {
-        return std::shared_ptr<mc::Buffer>();
+        return std::shared_ptr<mg::Buffer>();
     }
     bool supports_input() const
     {
 
=== modified file 'tests/unit-tests/graphics/android/test_internal_client_interpreter.cpp'
--- tests/unit-tests/graphics/android/test_internal_client_interpreter.cpp	2013-07-11 16:54:41 +0000
+++ tests/unit-tests/graphics/android/test_internal_client_interpreter.cpp	2013-07-17 14:20:33 +0000
@@ -25,7 +25,7 @@
 #include <gtest/gtest.h>
 #include <stdexcept>
 
-namespace mc=mir::compositor;
+namespace mg=mir::graphics;
 namespace mtd=mir::test::doubles;
 namespace mga=mir::graphics::android;
 namespace geom=mir::geometry;
@@ -40,7 +40,7 @@
     MOCK_CONST_METHOD0(size, geom::Size());
     MOCK_CONST_METHOD0(pixel_format, geom::PixelFormat());
 
-    MOCK_METHOD0(advance_client_buffer, std::shared_ptr<mc::Buffer>());
+    MOCK_METHOD0(advance_client_buffer, std::shared_ptr<mg::Buffer>());
 
     MOCK_CONST_METHOD0(supports_input, bool());
     MOCK_CONST_METHOD0(client_input_fd, int());
@@ -83,7 +83,7 @@
         .Times(1);
     EXPECT_CALL(*mock_buffer, native_buffer_handle())
         .Times(1);
-    std::shared_ptr<mc::Buffer> tmp = mock_buffer;
+    std::shared_ptr<mg::Buffer> tmp = mock_buffer;
     EXPECT_CALL(*mock_cache, store_buffer(tmp, stub_anw.get()))
         .Times(1);
 
 
=== modified file 'tests/unit-tests/graphics/android/test_server_interpreter.cpp'
--- tests/unit-tests/graphics/android/test_server_interpreter.cpp	2013-07-11 16:54:41 +0000
+++ tests/unit-tests/graphics/android/test_server_interpreter.cpp	2013-07-17 14:20:33 +0000
@@ -29,6 +29,7 @@
 
 namespace mtd=mir::test::doubles;
 namespace geom=mir::geometry;
+namespace mg=mir::graphics;
 namespace mga=mir::graphics::android;
 namespace mc=mir::compositor;
 
@@ -44,8 +45,8 @@
 struct MockFBSwapper : public mga::FBSwapper
 {
     ~MockFBSwapper() noexcept {}
-    MOCK_METHOD0(compositor_acquire, std::shared_ptr<mc::Buffer>());
-    MOCK_METHOD1(compositor_release, void(std::shared_ptr<mc::Buffer> const& released_buffer));
+    MOCK_METHOD0(compositor_acquire, std::shared_ptr<mg::Buffer>());
+    MOCK_METHOD1(compositor_release, void(std::shared_ptr<mg::Buffer> const& released_buffer));
 };
 
 struct ServerRenderWindowTest : public ::testing::Test
@@ -88,7 +89,7 @@
         .Times(1)
         .WillOnce(Return(stub_anw));
 
-    std::shared_ptr<mc::Buffer> tmp = mock_buffer1;
+    std::shared_ptr<mg::Buffer> tmp = mock_buffer1;
     EXPECT_CALL(*mock_cache, store_buffer(tmp, stub_anw.get()))
         .Times(1);
 
@@ -115,7 +116,7 @@
     render_window.driver_requests_buffer();
     testing::Mock::VerifyAndClearExpectations(mock_swapper.get());
 
-    std::shared_ptr<mc::Buffer> buf1 = mock_buffer1;
+    std::shared_ptr<mg::Buffer> buf1 = mock_buffer1;
     EXPECT_CALL(*mock_swapper, compositor_release(buf1))
         .Times(1);
     EXPECT_CALL(*stub_sync, wait())
@@ -134,13 +135,13 @@
         .WillOnce(Return(mock_buffer1));
     mga::ServerRenderWindow render_window(mock_swapper, mock_display_poster, mock_cache);
 
-    mc::BufferID id{442}, returned_id;
+    mg::BufferID id{442}, returned_id;
     EXPECT_CALL(*mock_swapper, compositor_acquire())
         .Times(1)
         .WillOnce(Return(mock_buffer1));
     EXPECT_CALL(*mock_swapper, compositor_release(_))
         .Times(1);
-    std::shared_ptr<mc::Buffer> buf1 = mock_buffer1;
+    std::shared_ptr<mg::Buffer> buf1 = mock_buffer1;
     EXPECT_CALL(*mock_buffer1, native_buffer_handle())
         .Times(1)
         .WillOnce(Return(stub_anw));
 
=== modified file 'tests/unit-tests/graphics/gbm/test_internal_client.cpp'
--- tests/unit-tests/graphics/gbm/test_internal_client.cpp	2013-06-20 08:27:10 +0000
+++ tests/unit-tests/graphics/gbm/test_internal_client.cpp	2013-07-17 14:20:33 +0000
@@ -25,7 +25,6 @@
 #include <gtest/gtest.h>
 
 namespace geom=mir::geometry;
-namespace mc=mir::compositor;
 namespace mgg=mir::graphics::gbm;
 namespace mtd=mir::test::doubles;
 
 
=== modified file 'tests/unit-tests/graphics/gbm/test_internal_native_surface.cpp'
--- tests/unit-tests/graphics/gbm/test_internal_native_surface.cpp	2013-07-11 16:54:41 +0000
+++ tests/unit-tests/graphics/gbm/test_internal_native_surface.cpp	2013-07-17 14:20:33 +0000
@@ -50,7 +50,7 @@
     MOCK_METHOD0(force_requests_to_complete, void());
     MOCK_CONST_METHOD0(size, geom::Size());
     MOCK_CONST_METHOD0(pixel_format, geom::PixelFormat());
-    MOCK_METHOD0(advance_client_buffer, std::shared_ptr<mc::Buffer>());
+    MOCK_METHOD0(advance_client_buffer, std::shared_ptr<mg::Buffer>());
     MOCK_CONST_METHOD0(supports_input, bool());
     MOCK_CONST_METHOD0(client_input_fd, int());
     MOCK_METHOD2(configure, int(MirSurfaceAttrib, int));
 
=== modified file 'tests/unit-tests/shell/test_application_session.cpp'
--- tests/unit-tests/shell/test_application_session.cpp	2013-07-01 06:36:33 +0000
+++ tests/unit-tests/shell/test_application_session.cpp	2013-07-17 14:20:33 +0000
@@ -17,7 +17,7 @@
  */
 
 #include "mir/shell/application_session.h"
-#include "mir/compositor/buffer.h"
+#include "mir/graphics/buffer.h"
 #include "mir/shell/surface_creation_parameters.h"
 #include "mir_test/fake_shared.h"
 #include "mir_test_doubles/mock_surface_factory.h"
 
=== modified file 'tests/unit-tests/shell/test_surface.cpp'
--- tests/unit-tests/shell/test_surface.cpp	2013-07-12 20:33:47 +0000
+++ tests/unit-tests/shell/test_surface.cpp	2013-07-17 14:20:33 +0000
@@ -40,6 +40,7 @@
 namespace msh = mir::shell;
 namespace mf = mir::frontend;
 namespace mc = mir::compositor;
+namespace mg = mir::graphics;
 namespace mi = mir::input;
 namespace geom = mir::geometry;
 namespace mt = mir::test;
@@ -484,10 +485,10 @@
         mt::fake_shared(surface_builder),
         msh::a_surface());
 
-    mc::Buffer* buf_ptr{nullptr};
+    mg::Buffer* buf_ptr{nullptr};
 
     test.with_most_recent_buffer_do(
-        [&](mc::Buffer& buffer)
+        [&](mg::Buffer& buffer)
         {
             buf_ptr = &buffer;
         });
 
=== modified file 'tests/unit-tests/shell/test_threaded_snapshot_strategy.cpp'
--- tests/unit-tests/shell/test_threaded_snapshot_strategy.cpp	2013-07-11 16:54:41 +0000
+++ tests/unit-tests/shell/test_threaded_snapshot_strategy.cpp	2013-07-17 14:20:33 +0000
@@ -17,9 +17,9 @@
  */
 
 #include "mir/shell/threaded_snapshot_strategy.h"
-#include "mir/shell/pixel_buffer.h"
+#include "mir/graphics/pixel_buffer.h"
 #include "mir/shell/surface_buffer_access.h"
-#include "mir/compositor/buffer.h"
+#include "mir/graphics/buffer.h"
 
 #include "mir_test_doubles/stub_buffer.h"
 #include "mir_test/fake_shared.h"
@@ -32,6 +32,7 @@
 #include <atomic>
 
 namespace mc = mir::compositor;
+namespace mg = mir::graphics;
 namespace msh = mir::shell;
 namespace mt = mir::test;
 namespace mtd = mir::test::doubles;
@@ -43,7 +44,7 @@
     ~StubSurfaceBufferAccess() noexcept {}
 
     void with_most_recent_buffer_do(
-        std::function<void(mc::Buffer&)> const& exec)
+        std::function<void(mg::Buffer&)> const& exec)
     {
         exec(buffer);
     }
@@ -51,12 +52,12 @@
     mtd::StubBuffer buffer;
 };
 
-class MockPixelBuffer : public msh::PixelBuffer
+class MockPixelBuffer : public mg::PixelBuffer
 {
 public:
     ~MockPixelBuffer() noexcept {}
 
-    MOCK_METHOD1(fill_from, void(mc::Buffer& buffer));
+    MOCK_METHOD1(fill_from, void(mg::Buffer& buffer));
     MOCK_METHOD0(as_argb_8888, void const*());
     MOCK_CONST_METHOD0(size, geom::Size());
     MOCK_CONST_METHOD0(stride, geom::Stride());
 
=== modified file 'tests/unit-tests/surfaces/test_surface_stack.cpp'
--- tests/unit-tests/surfaces/test_surface_stack.cpp	2013-07-12 21:48:58 +0000
+++ tests/unit-tests/surfaces/test_surface_stack.cpp	2013-07-17 14:20:33 +0000
@@ -65,10 +65,10 @@
 class NullBufferBundle : public mc::BufferBundle
 {
 public:
-    virtual std::shared_ptr<mc::Buffer> client_acquire() { return std::shared_ptr<mc::Buffer>(); }
-    virtual void client_release(std::shared_ptr<mc::Buffer> const&) {}
-    virtual std::shared_ptr<mc::Buffer> compositor_acquire(){ return std::shared_ptr<mc::Buffer>(); };
-    virtual void compositor_release(std::shared_ptr<mc::Buffer> const&){}
+    virtual std::shared_ptr<mg::Buffer> client_acquire() { return std::shared_ptr<mg::Buffer>(); }
+    virtual void client_release(std::shared_ptr<mg::Buffer> const&) {}
+    virtual std::shared_ptr<mg::Buffer> compositor_acquire(){ return std::shared_ptr<mg::Buffer>(); };
+    virtual void compositor_release(std::shared_ptr<mg::Buffer> const&){}
     virtual void force_client_abort() {}
     void force_requests_to_complete() {}
     virtual void allow_framedropping(bool) {}