Merge lp:~afrantzis/mir/vt-switching-1 into lp:~mir-team/mir/trunk

[Alexandros Frantzis]

server,gbm: Support VT switching

Since VT switching is a desktop specific concept at the moment, this branch
introduces it in more generic terms, as pause/resume in the high level
interfaces. Note that the mechanisms that implement pausing/resuming are
not tied to VT switching in particular. We can reuse them to pause/resume
arbitrarily.

In order for VT switching (pause/resume) to work properly, mir needs to be
run with root privileges, since this is required for drm{Drop,Set}Master().
However, if no VT switch (pause/resume) is performed, mir can be happily
run without root priveleges (as before, assuming appropriate device
permissions).

server,gbm: Support VT switching

Since VT switching is a desktop specific concept, this branch introduces it in more generic terms, as pause/resume in the high level interfaces. Note that the mechanisms that implement pausing/resuming are not tied to VT switching in particular. We can reuse them to pause/resume arbitrarily.

In order for VT switching (pause/resume) to work properly, mir needs to be run with root privileges, since this is required for drm{Drop,Set}Master(). However, if no VT switch (pause/resume) is performed, mir can be happily run without root priveleges (as before, assuming appropriate device permissions).

There is a bit of code churn in this branch because of the interface changes in mg::Display and mg::Platform, that caused a barrage of amendments to related stub and mock classes.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:581
http://jenkins.qa.ubuntu.com/job/mir-ci/348/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-raring-i386-build/334
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-raring-amd64-build/217
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-quantal-amd64-ci/353
        deb: http://jenkins.qa.ubuntu.com/job/mir-quantal-amd64-ci/353/artifact/work/output/*zip*/output.zip

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

review: Approve (continuous-integration)

[Robert Carr (robertcarr)]

Around + display->pause();

Do we need to pause input?

review: Needs Information

[Alexandros Frantzis (afrantzis)]

> Around + display->pause();
>
> Do we need to pause input?

Good question, we probably do, but I am not familiar with input details and how moving to another VT affects input. I guess from the perspective of pause/resume, it makes sense to stop processing/sending input events anyway when paused.

In any case, I'd rather leave it out of this MP (and let you implement it in an upcoming MP as needed ;))

[Kevin DuBois (kdub)]

The concepts of pause/resume (although not coded to do anything in android) are useful for what we'll want to do when the display is turned off on android, so I like the general idea

I kept thinking the pause/resume for the platform and the display could be consilidated, however I think its ok as it is

[Alexandros Frantzis (afrantzis)]

> I kept thinking the pause/resume for the platform and the display could be
> consilidated, however I think its ok as it is

This is doable, although less explicit, but on second thought I prefer it this way too.
We can also move register_pause_resume_handlers() to mg::Display too, thus leaving the mg::Platform interface unchanged.

[Robert Ancell (robert-ancell)]

review: Approve

[Daniel van Vugt (vanvugt)]

Text conflict in include/server/mir/graphics/platform.h
Text conflict in src/server/graphics/android/android_platform.h
Text conflict in src/server/graphics/gbm/gbm_platform.cpp
Text conflict in src/server/graphics/gbm/gbm_platform.h
Text conflict in tests/integration-tests/graphics/gbm/test_buffer_integration.cpp
Text conflict in tests/integration-tests/test_display_info.cpp
Text conflict in tests/integration-tests/test_drm_auth_magic.cpp
Text conflict in tests/integration-tests/test_surfaceloop.cpp
Text conflict in tests/mir_test_framework/testing_server_options.cpp
Text conflict in tests/unit-tests/frontend/test_session_mediator.cpp
Text conflict in tests/unit-tests/frontend/test_session_mediator_android.cpp
Text conflict in tests/unit-tests/frontend/test_session_mediator_gbm.cpp
Text conflict in tests/unit-tests/graphics/gbm/mock_drm.cpp
Text conflict in tests/unit-tests/graphics/gbm/mock_drm.h
14 conflicts encountered.

review: Needs Fixing

[Alexandros Frantzis (afrantzis)]

> I kept thinking the pause/resume for the platform and the display could be consilidated

Fixed.

> Text conflict in include/server/mir/graphics/platform.h
...

Fixed.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:584
http://jenkins.qa.ubuntu.com/job/mir-ci/358/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-raring-i386-build/347
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-raring-amd64-build/230
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-quantal-amd64-ci/363
        deb: http://jenkins.qa.ubuntu.com/job/mir-quantal-amd64-ci/363/artifact/work/output/*zip*/output.zip

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

review: Approve (continuous-integration)

[Kevin DuBois (kdub)]

okay, with the consolidated pause/resume, this looks good to me

review: Approve

[Robert Carr (robertcarr)]

I like the changes to consolidate pause/resume on display...was going to ask about this :)

I think it lgtm to me as it stands!

I wonder if LinuxVirtualTerminal should use some interface for the ioctls so it can be unit tested for interaction.

review: Approve

[Daniel van Vugt (vanvugt)]

I can't test this any more. Blocked by bug 1167828 for now.

review: Abstain

[Alexandros Frantzis (afrantzis)]

> I like the changes to consolidate pause/resume on display...was going to ask
> about this :)
>
> I think it lgtm to me as it stands!
>
> I wonder if LinuxVirtualTerminal should use some interface for the ioctls so
> it can be unit tested for interaction.

Yes, ideally it should. I considered adding an, e.g., FileOperations dependency on LinuxVirtualTerminal, but decided against it for this MP to keep it small. In retrospect, I should have proposed this differently: use a DummyVirtualTerminal for this MP, and add the real VT implementation in a different one. Anyway, I will fix this in an upcoming MP.

[PS Jenkins bot (ps-jenkins)]

review: Approve (continuous-integration)

=== modified file 'include/server/mir/graphics/display.h'
--- include/server/mir/graphics/display.h	2013-03-13 04:54:15 +0000
+++ include/server/mir/graphics/display.h	2013-04-11 11:00:30 +0000
@@ -26,6 +26,9 @@
 
 namespace mir
 {
+
+class MainLoop;
+
 namespace graphics
 {
 
@@ -40,6 +43,14 @@
 
     virtual std::shared_ptr<DisplayConfiguration> configuration() = 0;
 
+    virtual void register_pause_resume_handlers(
+        MainLoop& main_loop,
+        std::function<void()> const& pause_handler,
+        std::function<void()> const& resume_handler) = 0;
+
+    virtual void pause() = 0;
+    virtual void resume() = 0;
+
 protected:
     Display() = default;
     ~Display() = default;
 
=== modified file 'include/test/mir_test_doubles/mock_display.h'
--- include/test/mir_test_doubles/mock_display.h	2013-03-13 04:54:15 +0000
+++ include/test/mir_test_doubles/mock_display.h	2013-04-11 11:00:30 +0000
@@ -35,6 +35,11 @@
     MOCK_CONST_METHOD0(view_area, geometry::Rectangle ());
     MOCK_METHOD1(for_each_display_buffer, void (std::function<void(graphics::DisplayBuffer&)> const&));
     MOCK_METHOD0(configuration, std::shared_ptr<graphics::DisplayConfiguration>());
+    MOCK_METHOD3(register_pause_resume_handlers, void(MainLoop&,
+                                                      std::function<void()> const&,
+                                                      std::function<void()> const&));
+    MOCK_METHOD0(pause, void());
+    MOCK_METHOD0(resume, void());
 };
 
 }
 
=== modified file 'include/test/mir_test_doubles/null_display.h'
--- include/test/mir_test_doubles/null_display.h	2013-03-13 04:54:15 +0000
+++ include/test/mir_test_doubles/null_display.h	2013-04-11 11:00:30 +0000
@@ -42,6 +42,13 @@
     {
         return std::shared_ptr<graphics::DisplayConfiguration>();
     }
+    void register_pause_resume_handlers(MainLoop&,
+                                        std::function<void()> const&,
+                                        std::function<void()> const&)
+    {
+    }
+    void pause() {}
+    void resume() {}
 };
 
 }
 
=== added file 'include/test/mir_test_doubles/null_virtual_terminal.h'
--- include/test/mir_test_doubles/null_virtual_terminal.h	1970-01-01 00:00:00 +0000
+++ include/test/mir_test_doubles/null_virtual_terminal.h	2013-04-11 11:00:30 +0000
@@ -0,0 +1,47 @@
+/*
+ * Copyright © 2013 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Alexandros Frantzis <[e-mail]>
+ */
+
+#ifndef MIR_TEST_DOUBLES_NULL_VIRTUAL_TERMINAL_H_
+#define MIR_TEST_DOUBLES_NULL_VIRTUAL_TERMINAL_H_
+
+#include "src/server/graphics/gbm/virtual_terminal.h"
+
+namespace mir
+{
+namespace test
+{
+namespace doubles
+{
+
+class NullVirtualTerminal : public graphics::gbm::VirtualTerminal
+{
+public:
+    void set_graphics_mode() {}
+
+    void register_switch_handlers(MainLoop&,
+                                  std::function<void()> const&,
+                                  std::function<void()> const&)
+    {
+    }
+};
+
+}
+}
+}
+
+#endif /* MIR_TEST_DOUBLES_NULL_VIRTUAL_TERMINAL_H_ */
 
=== modified file 'src/server/display_server.cpp'
--- src/server/display_server.cpp	2013-04-10 16:23:54 +0000
+++ src/server/display_server.cpp	2013-04-11 11:00:30 +0000
@@ -44,6 +44,18 @@
           input_manager{config.the_input_manager()},
           main_loop{config.the_main_loop()}
     {
+        display->register_pause_resume_handlers(
+            *main_loop,
+            [this]
+            {
+                compositor->stop();
+                display->pause();
+            },
+            [this]
+            {
+                display->resume();
+                compositor->start();
+            });
     }
 
     std::shared_ptr<mg::Display> display;
 
=== modified file 'src/server/graphics/android/android_display.cpp'
--- src/server/graphics/android/android_display.cpp	2013-03-21 03:32:59 +0000
+++ src/server/graphics/android/android_display.cpp	2013-04-11 11:00:30 +0000
@@ -142,6 +142,21 @@
     return std::make_shared<NullDisplayConfiguration>();
 }
 
+void mga::AndroidDisplay::register_pause_resume_handlers(
+    MainLoop& /*main_loop*/,
+    std::function<void()> const& /*pause_handler*/,
+    std::function<void()> const& /*resume_handler*/)
+{
+}
+
+void mga::AndroidDisplay::pause()
+{
+}
+
+void mga::AndroidDisplay::resume()
+{
+}
+
 void mga::AndroidDisplay::make_current()
 {
     if (eglMakeCurrent(egl_display, egl_surface, egl_surface, egl_context) == EGL_FALSE)
 
=== modified file 'src/server/graphics/android/android_display.h'
--- src/server/graphics/android/android_display.h	2013-03-22 18:33:51 +0000
+++ src/server/graphics/android/android_display.h	2013-04-11 11:00:30 +0000
@@ -50,6 +50,14 @@
 
     std::shared_ptr<DisplayConfiguration> configuration();
 
+    void register_pause_resume_handlers(
+        MainLoop& main_loop,
+        std::function<void()> const& pause_handler,
+        std::function<void()> const& resume_handler);
+
+    void pause();
+    void resume();
+
     void make_current();
 private:
     std::shared_ptr<AndroidFramebufferWindowQuery> native_window;
 
=== modified file 'src/server/graphics/gbm/CMakeLists.txt'
--- src/server/graphics/gbm/CMakeLists.txt	2013-03-13 04:54:15 +0000
+++ src/server/graphics/gbm/CMakeLists.txt	2013-04-11 11:00:30 +0000
@@ -24,6 +24,7 @@
   kms_output.cpp
   kms_output_container.cpp
   kms_page_flipper.cpp
+  linux_virtual_terminal.cpp
 )
 
 target_link_libraries(
 
=== modified file 'src/server/graphics/gbm/gbm_display.cpp'
--- src/server/graphics/gbm/gbm_display.cpp	2013-03-13 04:54:15 +0000
+++ src/server/graphics/gbm/gbm_display.cpp	2013-04-11 11:00:30 +0000
@@ -22,6 +22,7 @@
 #include "kms_display_configuration.h"
 #include "kms_output.h"
 #include "kms_page_flipper.h"
+#include "virtual_terminal.h"
 
 #include "mir/geometry/rectangle.h"
 
@@ -36,6 +37,8 @@
       output_container{platform->drm.fd,
                        std::make_shared<KMSPageFlipper>(platform->drm.fd)}
 {
+    platform->vt->set_graphics_mode();
+
     shared_egl.setup(platform->gbm);
 
     configure(configuration());
@@ -43,6 +46,10 @@
     shared_egl.make_current();
 }
 
+mgg::GBMDisplay::~GBMDisplay()
+{
+}
+
 geom::Rectangle mgg::GBMDisplay::view_area() const
 {
     return display_buffers[0]->view_area();
@@ -92,8 +99,29 @@
                                                         max_size.height.as_uint32_t());
 
     /* Create a single DisplayBuffer that displays the surface on all the outputs */
-    std::unique_ptr<DisplayBuffer> db{new GBMDisplayBuffer{platform, listener, enabled_outputs,
-                                                           std::move(surface), max_size,
-                                                           shared_egl.context()}};
+    std::unique_ptr<GBMDisplayBuffer> db{new GBMDisplayBuffer{platform, listener, enabled_outputs,
+                                                              std::move(surface), max_size,
+                                                              shared_egl.context()}};
     display_buffers.push_back(std::move(db));
 }
+
+void mgg::GBMDisplay::register_pause_resume_handlers(
+    MainLoop& main_loop,
+    std::function<void()> const& pause_handler,
+    std::function<void()> const& resume_handler)
+{
+    platform->vt->register_switch_handlers(main_loop, pause_handler, resume_handler);
+}
+
+void mgg::GBMDisplay::pause()
+{
+    platform->drm.drop_master();
+}
+
+void mgg::GBMDisplay::resume()
+{
+    platform->drm.set_master();
+
+    for (auto& db_ptr : display_buffers)
+        db_ptr->schedule_set_crtc();
+}
 
=== modified file 'src/server/graphics/gbm/gbm_display.h'
--- src/server/graphics/gbm/gbm_display.h	2013-03-21 03:32:59 +0000
+++ src/server/graphics/gbm/gbm_display.h	2013-04-11 11:00:30 +0000
@@ -20,7 +20,6 @@
 #define MIR_GRAPHICS_GBM_GBM_DISPLAY_H_
 
 #include "mir/graphics/display.h"
-#include "mir/graphics/display_buffer.h"
 #include "kms_output_container.h"
 #include "gbm_display_helpers.h"
 
@@ -36,31 +35,42 @@
 {
 
 class DisplayReport;
+class DisplayBuffer;
 
 namespace gbm
 {
 
 class GBMPlatform;
 class KMSOutput;
+class GBMDisplayBuffer;
 
 class GBMDisplay : public Display
 {
 public:
     GBMDisplay(std::shared_ptr<GBMPlatform> const& platform,
                std::shared_ptr<DisplayReport> const& listener);
+    ~GBMDisplay();
 
     geometry::Rectangle view_area() const;
     void for_each_display_buffer(std::function<void(DisplayBuffer&)> const& f);
 
     std::shared_ptr<DisplayConfiguration> configuration();
 
+    void register_pause_resume_handlers(
+        MainLoop& main_loop,
+        std::function<void()> const& pause_handler,
+        std::function<void()> const& resume_handler);
+
+    void pause();
+    void resume();
+
 private:
     void configure(std::shared_ptr<DisplayConfiguration> const& conf);
 
     std::shared_ptr<GBMPlatform> const platform;
     std::shared_ptr<DisplayReport> const listener;
     helpers::EGLHelper shared_egl;
-    std::vector<std::unique_ptr<DisplayBuffer>> display_buffers;
+    std::vector<std::unique_ptr<GBMDisplayBuffer>> display_buffers;
     KMSOutputContainer output_container;
 };
 
 
=== modified file 'src/server/graphics/gbm/gbm_display_buffer.cpp'
--- src/server/graphics/gbm/gbm_display_buffer.cpp	2013-03-21 03:32:59 +0000
+++ src/server/graphics/gbm/gbm_display_buffer.cpp	2013-04-11 11:00:30 +0000
@@ -105,7 +105,8 @@
       drm(platform->drm),
       outputs(outputs),
       surface_gbm{std::move(surface_gbm_param)},
-      size(size)
+      size(size),
+      needs_set_crtc{false}
 {
     egl.setup(platform->gbm, surface_gbm.get(), shared_context);
 
@@ -180,11 +181,20 @@
      * If the flip fails, release the buffer object to make it available
      * for future rendering.
      */
-    if (!schedule_and_wait_for_page_flip(bufobj))
+    if (!needs_set_crtc && !schedule_and_wait_for_page_flip(bufobj))
     {
         bufobj->release();
         return false;
     }
+    else if (needs_set_crtc)
+    {
+        for (auto& output : outputs)
+        {
+            if (!output->set_crtc(bufobj->get_drm_fb_id()))
+                BOOST_THROW_EXCEPTION(std::runtime_error("Failed to set DRM crtc"));
+        }
+        needs_set_crtc = false;
+    }
 
     /*
      * Release the last flipped buffer object (which is not displayed anymore)
@@ -265,3 +275,8 @@
         BOOST_THROW_EXCEPTION(std::runtime_error("Failed to make EGL surface current"));
     }
 }
+
+void mgg::GBMDisplayBuffer::schedule_set_crtc()
+{
+    needs_set_crtc = true;
+}
 
=== modified file 'src/server/graphics/gbm/gbm_display_buffer.h'
--- src/server/graphics/gbm/gbm_display_buffer.h	2013-03-13 04:54:15 +0000
+++ src/server/graphics/gbm/gbm_display_buffer.h	2013-04-11 11:00:30 +0000
@@ -24,6 +24,7 @@
 
 #include <vector>
 #include <memory>
+#include <atomic>
 
 namespace mir
 {
@@ -55,6 +56,8 @@
     void clear();
     bool post_update();
 
+    void schedule_set_crtc();
+
 private:
     BufferObject* get_front_buffer_object();
     bool schedule_and_wait_for_page_flip(BufferObject* bufobj);
@@ -68,6 +71,7 @@
     GBMSurfaceUPtr surface_gbm;
     helpers::EGLHelper egl;
     geometry::Size size;
+    std::atomic<bool> needs_set_crtc;
 };
 
 }
 
=== modified file 'src/server/graphics/gbm/gbm_display_helpers.cpp'
--- src/server/graphics/gbm/gbm_display_helpers.cpp	2013-03-13 04:54:15 +0000
+++ src/server/graphics/gbm/gbm_display_helpers.cpp	2013-04-11 11:00:30 +0000
@@ -96,6 +96,46 @@
     }
 }
 
+void mggh::DRMHelper::drop_master() const
+{
+    /* We must have our own device fd first, so that it has become the DRM master */
+    if (fd < 0)
+    {
+        BOOST_THROW_EXCEPTION(
+            std::runtime_error("Tried to drop DRM master without a DRM device"));
+    }
+
+    int ret = drmDropMaster(fd);
+
+    if (ret < 0)
+    {
+        BOOST_THROW_EXCEPTION(
+            boost::enable_error_info(
+                std::runtime_error("Failed to drop DRM master"))
+                    << boost::errinfo_errno(ret));
+    }
+}
+
+void mggh::DRMHelper::set_master() const
+{
+    /* We must have our own device fd first, so that it has become the DRM master */
+    if (fd < 0)
+    {
+        BOOST_THROW_EXCEPTION(
+            std::runtime_error("Tried to set DRM master without a DRM device"));
+    }
+
+    int ret = drmSetMaster(fd);
+
+    if (ret < 0)
+    {
+        BOOST_THROW_EXCEPTION(
+            boost::enable_error_info(
+                std::runtime_error("Failed to set DRM master"))
+                    << boost::errinfo_errno(ret));
+    }
+}
+
 int mggh::DRMHelper::open_drm_device()
 {
     static const char *drivers[] = {
 
=== modified file 'src/server/graphics/gbm/gbm_display_helpers.h'
--- src/server/graphics/gbm/gbm_display_helpers.h	2013-03-21 03:32:59 +0000
+++ src/server/graphics/gbm/gbm_display_helpers.h	2013-04-11 11:00:30 +0000
@@ -57,6 +57,9 @@
     int get_authenticated_fd();
     void auth_magic(drm_magic_t magic) const;
 
+    void drop_master() const;
+    void set_master() const;
+
     int fd;
 
 private:
 
=== modified file 'src/server/graphics/gbm/gbm_platform.cpp'
--- src/server/graphics/gbm/gbm_platform.cpp	2013-04-09 18:00:48 +0000
+++ src/server/graphics/gbm/gbm_platform.cpp	2013-04-11 11:00:30 +0000
@@ -21,6 +21,7 @@
 #include <boost/throw_exception.hpp>
 #include "gbm_buffer_allocator.h"
 #include "gbm_display.h"
+#include "linux_virtual_terminal.h"
 #include "mir/graphics/platform_ipc_package.h"
 #include "mir/graphics/egl/mesa_native_display.h"
 #include "mir/logging/logger.h"
@@ -54,9 +55,11 @@
 
 }
 
-mgg::GBMPlatform::GBMPlatform(std::shared_ptr<DisplayReport> const& listener) :
-    listener(listener),
-    native_display(0)
+mgg::GBMPlatform::GBMPlatform(std::shared_ptr<DisplayReport> const& listener,
+                              std::shared_ptr<VirtualTerminal> const& vt)
+    : listener(listener),
+      vt{vt},
+      native_display(0)
 {
     drm.setup();
     gbm.setup(drm);
@@ -97,5 +100,7 @@
 
 std::shared_ptr<mg::Platform> mg::create_platform(std::shared_ptr<DisplayReport> const& report)
 {
-    return std::make_shared<mgg::GBMPlatform>(report);
+    return std::make_shared<mgg::GBMPlatform>(
+        report,
+        std::make_shared<mgg::LinuxVirtualTerminal>());
 }
 
=== modified file 'src/server/graphics/gbm/gbm_platform.h'
--- src/server/graphics/gbm/gbm_platform.h	2013-04-09 18:00:48 +0000
+++ src/server/graphics/gbm/gbm_platform.h	2013-04-11 11:00:30 +0000
@@ -32,12 +32,15 @@
 namespace gbm
 {
 
+class VirtualTerminal;
+
 class GBMPlatform : public Platform,
                     public DRMAuthenticator,
                     public std::enable_shared_from_this<GBMPlatform>
 {
 public:
-    explicit GBMPlatform(std::shared_ptr<DisplayReport> const& reporter);
+    explicit GBMPlatform(std::shared_ptr<DisplayReport> const& reporter,
+                         std::shared_ptr<VirtualTerminal> const& vt);
 
     /* From Platform */
     std::shared_ptr<compositor::GraphicBufferAllocator> create_buffer_allocator(
@@ -53,7 +56,9 @@
     helpers::DRMHelper drm;
     helpers::GBMHelper gbm;
 
-    std::shared_ptr<DisplayReport> listener;
+    std::shared_ptr<DisplayReport> const listener;
+    std::shared_ptr<VirtualTerminal> const vt;
+
 private:
     std::shared_ptr<MirMesaEGLNativeDisplay> native_display;
 };
 
=== added file 'src/server/graphics/gbm/linux_virtual_terminal.cpp'
--- src/server/graphics/gbm/linux_virtual_terminal.cpp	1970-01-01 00:00:00 +0000
+++ src/server/graphics/gbm/linux_virtual_terminal.cpp	2013-04-11 11:00:30 +0000
@@ -0,0 +1,180 @@
+/*
+ * Copyright © 2013 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Alexandros Frantzis <[e-mail]>
+ */
+
+#include "linux_virtual_terminal.h"
+#include "mir/main_loop.h"
+
+#include <boost/throw_exception.hpp>
+#include <boost/exception/errinfo_errno.hpp>
+#include <boost/exception/errinfo_file_name.hpp>
+
+#include <vector>
+#include <string>
+#include <sstream>
+#include <stdexcept>
+#include <csignal>
+
+#include <fcntl.h>
+#include <linux/vt.h>
+#include <linux/kd.h>
+#include <sys/ioctl.h>
+
+namespace mgg = mir::graphics::gbm;
+
+namespace
+{
+
+int find_active_vt_number()
+{
+    static std::vector<std::string> const paths{"/dev/tty", "/dev/tty0"};
+    int active_vt{-1};
+
+    for (auto& p : paths)
+    {
+        auto fd = open(p.c_str(), O_RDONLY, 0);
+        if (fd < 0)
+            fd = open(p.c_str(), O_WRONLY, 0);
+
+        if (fd >= 0)
+        {
+            struct vt_stat vts;
+            auto status = ioctl(fd, VT_GETSTATE, &vts);
+            close(fd);
+
+            if (status >= 0)
+            {
+                active_vt = vts.v_active;
+                break;
+            }
+        }
+    }
+
+    if (active_vt < 0)
+    {
+        BOOST_THROW_EXCEPTION(
+            std::runtime_error("Failed to find the current VT"));
+    }
+
+    return active_vt;
+}
+
+int open_vt(int vt_number)
+{
+    std::stringstream vt_path_stream;
+    vt_path_stream << "/dev/tty" << vt_number;
+
+    std::string const active_vt_path{vt_path_stream.str()};
+
+    auto vt_fd = open(active_vt_path.c_str(), O_RDONLY | O_NDELAY, 0);
+
+    if (vt_fd < 0)
+    {
+        BOOST_THROW_EXCEPTION(
+            boost::enable_error_info(
+                std::runtime_error("Failed to open current VT"))
+                    << boost::errinfo_file_name(active_vt_path)
+                    << boost::errinfo_errno(errno));
+    }
+
+    return vt_fd;
+}
+
+}
+
+mgg::LinuxVirtualTerminal::LinuxVirtualTerminal()
+    : vt_fd{open_vt(find_active_vt_number())},
+      prev_kd_mode{0},
+      prev_vt_mode(),
+      active{true}
+{
+    if (ioctl(vt_fd.fd(), KDGETMODE, &prev_kd_mode) < 0)
+    {
+        BOOST_THROW_EXCEPTION(
+            boost::enable_error_info(
+                std::runtime_error("Failed to get current VT mode"))
+                    << boost::errinfo_errno(errno));
+    }
+
+    if (ioctl(vt_fd.fd(), VT_GETMODE, &prev_vt_mode) < 0)
+    {
+        BOOST_THROW_EXCEPTION(
+            boost::enable_error_info(
+                std::runtime_error("Failed to get the current VT")) << boost::errinfo_errno(errno));
+    }
+}
+
+mgg::LinuxVirtualTerminal::~LinuxVirtualTerminal() noexcept(true)
+{
+    if (vt_fd.fd() > 0)
+    {
+        ioctl(vt_fd.fd(), KDSETMODE, prev_kd_mode);
+        ioctl(vt_fd.fd(), VT_SETMODE, &prev_vt_mode);
+    }
+}
+
+void mgg::LinuxVirtualTerminal::set_graphics_mode()
+{
+    if (ioctl(vt_fd.fd(), KDSETMODE, KD_GRAPHICS) < 0)
+    {
+        BOOST_THROW_EXCEPTION(
+            boost::enable_error_info(
+                std::runtime_error("Failed to set VT to graphics mode"))
+                    << boost::errinfo_errno(errno));
+    }
+}
+
+void mgg::LinuxVirtualTerminal::register_switch_handlers(
+    MainLoop& main_loop,
+    std::function<void()> const& switch_away,
+    std::function<void()> const& switch_back)
+{
+    main_loop.register_signal_handler(
+        {SIGUSR1},
+        [this, switch_away, switch_back](int)
+        {
+            active = !active;
+            if (active)
+            {
+                static int const allow_switch{2};
+                switch_back();
+                ioctl(vt_fd.fd(), VT_RELDISP, allow_switch);
+            }
+            else
+            {
+                switch_away();
+                ioctl(vt_fd.fd(), VT_RELDISP, VT_ACKACQ);
+            }
+        });
+
+    struct vt_mode vtm
+    {
+        VT_PROCESS,
+        0,
+        SIGUSR1,
+        SIGUSR1,
+        0
+    };
+
+    if (ioctl(vt_fd.fd(), VT_SETMODE, &vtm) < 0)
+    {
+        BOOST_THROW_EXCEPTION(
+            boost::enable_error_info(
+                std::runtime_error("Failed to set the current VT mode"))
+                    << boost::errinfo_errno(errno));
+    }
+}
 
=== added file 'src/server/graphics/gbm/linux_virtual_terminal.h'
--- src/server/graphics/gbm/linux_virtual_terminal.h	1970-01-01 00:00:00 +0000
+++ src/server/graphics/gbm/linux_virtual_terminal.h	2013-04-11 11:00:30 +0000
@@ -0,0 +1,67 @@
+/*
+ * Copyright © 2013 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Alexandros Frantzis <[e-mail]>
+ */
+
+#ifndef MIR_GRAPHICS_GBM_LINUX_VIRTUAL_TERMINAL_H_
+#define MIR_GRAPHICS_GBM_LINUX_VIRTUAL_TERMINAL_H_
+
+#include "virtual_terminal.h"
+
+#include <linux/vt.h>
+#include <unistd.h>
+
+namespace mir
+{
+namespace graphics
+{
+namespace gbm
+{
+
+class LinuxVirtualTerminal : public VirtualTerminal
+{
+public:
+    LinuxVirtualTerminal();
+    ~LinuxVirtualTerminal() noexcept(true);
+
+    void set_graphics_mode();
+    void register_switch_handlers(
+        MainLoop& main_loop,
+        std::function<void()> const& switch_away,
+        std::function<void()> const& switch_back);
+
+private:
+    class FDWrapper
+    {
+    public:
+        FDWrapper(int fd) : fd_{fd} {}
+        ~FDWrapper() { if (fd_ >= 0) close(fd_); }
+        int fd() const { return fd_; }
+    private:
+        int const fd_;
+    };
+
+    FDWrapper const vt_fd;
+    int prev_kd_mode;
+    struct vt_mode prev_vt_mode;
+    bool active;
+};
+
+}
+}
+}
+
+#endif /* MIR_GRAPHICS_GBM_LINUX_VIRTUAL_TERMINAL_H_ */
 
=== added file 'src/server/graphics/gbm/virtual_terminal.h'
--- src/server/graphics/gbm/virtual_terminal.h	1970-01-01 00:00:00 +0000
+++ src/server/graphics/gbm/virtual_terminal.h	2013-04-11 11:00:30 +0000
@@ -0,0 +1,55 @@
+/*
+ * Copyright © 2013 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Alexandros Frantzis <[e-mail]>
+ */
+
+#ifndef MIR_GRAPHICS_GBM_VIRTUAL_TERMINAL_H_
+#define MIR_GRAPHICS_GBM_VIRTUAL_TERMINAL_H_
+
+#include <functional>
+
+namespace mir
+{
+
+class MainLoop;
+
+namespace graphics
+{
+namespace gbm
+{
+
+class VirtualTerminal
+{
+public:
+    virtual ~VirtualTerminal() = default;
+
+    virtual void set_graphics_mode() = 0;
+    virtual void register_switch_handlers(
+        MainLoop& main_loop,
+        std::function<void()> const& switch_away,
+        std::function<void()> const& switch_back) = 0;
+
+protected:
+    VirtualTerminal() = default;
+    VirtualTerminal(VirtualTerminal const&) = delete;
+    VirtualTerminal& operator=(VirtualTerminal const&) = delete;
+};
+
+}
+}
+}
+
+#endif /* MIR_GRAPHICS_GBM_VIRTUAL_TERMINAL_H_ */
 
=== modified file 'tests/behavior-tests/session_management_context.cpp'
--- tests/behavior-tests/session_management_context.cpp	2013-04-01 16:11:03 +0000
+++ tests/behavior-tests/session_management_context.cpp	2013-04-11 11:00:30 +0000
@@ -105,6 +105,15 @@
         return std::shared_ptr<mg::DisplayConfiguration>();
     }
 
+    void register_pause_resume_handlers(MainLoop&,
+                                        std::function<void()> const&,
+                                        std::function<void()> const&)
+    {
+    }
+
+    void pause() {}
+    void resume() {}
+
     geom::Rectangle area;
 };
 
 
=== modified file 'tests/integration-tests/test_display_server_main_loop_events.cpp'
--- tests/integration-tests/test_display_server_main_loop_events.cpp	2013-04-08 16:20:33 +0000
+++ tests/integration-tests/test_display_server_main_loop_events.cpp	2013-04-11 11:00:30 +0000
@@ -17,6 +17,8 @@
  */
 
 #include "mir/compositor/compositor.h"
+#include "mir/graphics/display.h"
+#include "mir/main_loop.h"
 
 #include "mir_test_framework/testing_server_configuration.h"
 #include "mir_test_doubles/mock_input_manager.h"
@@ -30,6 +32,7 @@
 
 namespace mi = mir::input;
 namespace mc = mir::compositor;
+namespace mg = mir::graphics;
 namespace mtd = mir::test::doubles;
 namespace mtf = mir_test_framework;
 
@@ -43,6 +46,54 @@
     MOCK_METHOD0(stop, void());
 };
 
+class MockDisplay : public mg::Display
+{
+public:
+    MockDisplay(std::shared_ptr<mg::Display> const& display,
+                int pause_signal, int resume_signal)
+        : display{display},
+          pause_signal{pause_signal},
+          resume_signal{resume_signal}
+    {
+    }
+
+    mir::geometry::Rectangle view_area() const
+    {
+        return display->view_area();
+    }
+
+    void for_each_display_buffer(std::function<void(mg::DisplayBuffer&)> const& f)
+    {
+        display->for_each_display_buffer(f);
+    }
+
+    std::shared_ptr<mg::DisplayConfiguration> configuration()
+    {
+        return display->configuration();
+    }
+
+    void register_pause_resume_handlers(
+        mir::MainLoop& main_loop,
+        std::function<void()> const& pause_handler,
+        std::function<void()> const& resume_handler)
+    {
+        main_loop.register_signal_handler(
+            {pause_signal},
+            [pause_handler](int) { pause_handler(); });
+        main_loop.register_signal_handler(
+            {resume_signal},
+            [resume_handler](int) { resume_handler(); });
+    }
+
+    MOCK_METHOD0(pause, void());
+    MOCK_METHOD0(resume, void());
+
+private:
+    std::shared_ptr<mg::Display> const display;
+    int const pause_signal;
+    int const resume_signal;
+};
+
 class ServerConfig : public mtf::TestingServerConfiguration
 {
 public:
@@ -77,6 +128,66 @@
     std::shared_ptr<MockCompositor> mock_compositor;
 };
 
+
+class PauseResumeServerConfig : public mtf::TestingServerConfiguration
+{
+public:
+    PauseResumeServerConfig()
+        : pause_signal{SIGUSR1}, resume_signal{SIGUSR2}
+    {
+    }
+
+    std::shared_ptr<mg::Display> the_display() override
+    {
+        if (!mock_display)
+        {
+            auto display = mtf::TestingServerConfiguration::the_display();
+            mock_display = std::make_shared<MockDisplay>(display,
+                                                         pause_signal,
+                                                         resume_signal);
+        }
+
+        return mock_display;
+    }
+
+    std::shared_ptr<mc::Compositor> the_compositor() override
+    {
+        if (!mock_compositor)
+            mock_compositor = std::make_shared<MockCompositor>();
+
+        return mock_compositor;
+    }
+
+    std::shared_ptr<MockDisplay> the_mock_display()
+    {
+        the_display();
+        return mock_display;
+    }
+
+    std::shared_ptr<MockCompositor> the_mock_compositor()
+    {
+        the_compositor();
+        return mock_compositor;
+    }
+
+    void emit_pause_event()
+    {
+        kill(getpid(), pause_signal);
+    }
+
+    void emit_resume_event()
+    {
+        kill(getpid(), resume_signal);
+    }
+
+private:
+    std::shared_ptr<MockCompositor> mock_compositor;
+    std::shared_ptr<MockDisplay> mock_display;
+
+    int const pause_signal;
+    int const resume_signal;
+};
+
 }
 
 TEST(DisplayServerMainLoopEvents, display_server_shuts_down_properly_on_sigint)
@@ -100,3 +211,70 @@
                     kill(getpid(), SIGTERM);
                  });
 }
+
+TEST(DisplayServerMainLoopEvents, display_server_components_pause_and_resume)
+{
+    using namespace testing;
+
+    PauseResumeServerConfig server_config;
+
+    auto mock_compositor = server_config.the_mock_compositor();
+    auto mock_display = server_config.the_mock_display();
+
+    {
+        InSequence s;
+
+        /* Start */
+        EXPECT_CALL(*mock_compositor, start()).Times(1);
+
+        /* Pause */
+        EXPECT_CALL(*mock_compositor, stop()).Times(1);
+        EXPECT_CALL(*mock_display, pause()).Times(1);
+
+        /* Resume */
+        EXPECT_CALL(*mock_display, resume()).Times(1);
+        EXPECT_CALL(*mock_compositor, start()).Times(1);
+
+        /* Stop */
+        EXPECT_CALL(*mock_compositor, stop()).Times(1);
+    }
+
+    mir::run_mir(server_config,
+                 [&server_config](mir::DisplayServer&)
+                 {
+                    server_config.emit_pause_event();
+                    server_config.emit_resume_event();
+                    kill(getpid(), SIGTERM);
+                 });
+}
+
+TEST(DisplayServerMainLoopEvents, display_server_quits_when_paused)
+{
+    using namespace testing;
+
+    PauseResumeServerConfig server_config;
+
+    auto mock_compositor = server_config.the_mock_compositor();
+    auto mock_display = server_config.the_mock_display();
+
+    {
+        InSequence s;
+
+        /* Start */
+        EXPECT_CALL(*mock_compositor, start()).Times(1);
+
+        /* Pause */
+        EXPECT_CALL(*mock_compositor, stop()).Times(1);
+        EXPECT_CALL(*mock_display, pause()).Times(1);
+
+        /* Stop */
+        EXPECT_CALL(*mock_compositor, stop()).Times(1);
+    }
+
+    mir::run_mir(server_config,
+                 [&server_config](mir::DisplayServer&)
+                 {
+                    server_config.emit_pause_event();
+                    kill(getpid(), SIGTERM);
+                 });
+}
 
=== modified file 'tests/integration-tests/test_surfaceloop.cpp'
--- tests/integration-tests/test_surfaceloop.cpp	2013-04-10 16:40:04 +0000
+++ tests/integration-tests/test_surfaceloop.cpp	2013-04-11 11:00:30 +0000
@@ -133,6 +133,13 @@
         auto null_configuration = std::shared_ptr<mg::DisplayConfiguration>();
         return null_configuration;
     }
+    void register_pause_resume_handlers(mir::MainLoop&,
+                                        std::function<void()> const&,
+                                        std::function<void()> const&)
+    {
+    }
+    void pause() {}
+    void resume() {}
 };
 
 struct SurfaceSync
 
=== modified file 'tests/mir_test_framework/testing_server_options.cpp'
--- tests/mir_test_framework/testing_server_options.cpp	2013-04-09 18:00:48 +0000
+++ tests/mir_test_framework/testing_server_options.cpp	2013-04-11 11:00:30 +0000
@@ -86,6 +86,13 @@
         auto null_configuration = std::shared_ptr<mg::DisplayConfiguration>();
         return null_configuration;
     }
+    void register_pause_resume_handlers(mir::MainLoop&,
+                                        std::function<void()> const&,
+                                        std::function<void()> const&)
+    {
+    }
+    void pause() {}
+    void resume() {}
 };
 
 class StubGraphicPlatform : public mg::Platform
 
=== modified file 'tests/unit-tests/compositor/test_multi_threaded_compositor.cpp'
--- tests/unit-tests/compositor/test_multi_threaded_compositor.cpp	2013-03-27 15:12:09 +0000
+++ tests/unit-tests/compositor/test_multi_threaded_compositor.cpp	2013-04-11 11:00:30 +0000
@@ -53,6 +53,13 @@
     {
         return std::shared_ptr<mg::DisplayConfiguration>();
     }
+    void register_pause_resume_handlers(mir::MainLoop&,
+                                        std::function<void()> const&,
+                                        std::function<void()> const&)
+    {
+    }
+    void pause() {}
+    void resume() {}
 
 private:
     std::vector<mtd::NullDisplayBuffer> buffers;
 
=== modified file 'tests/unit-tests/graphics/gbm/mock_drm.cpp'
--- tests/unit-tests/graphics/gbm/mock_drm.cpp	2013-03-07 06:00:18 +0000
+++ tests/unit-tests/graphics/gbm/mock_drm.cpp	2013-04-11 11:00:30 +0000
@@ -351,3 +351,13 @@
 {
     return global_mock->drmPrimeFDToHandle(fd, prime_fd, handle);
 }
+
+int drmSetMaster(int fd)
+{
+    return global_mock->drmSetMaster(fd);
+}
+
+int drmDropMaster(int fd)
+{
+    return global_mock->drmDropMaster(fd);
+}
 
=== modified file 'tests/unit-tests/graphics/gbm/mock_drm.h'
--- tests/unit-tests/graphics/gbm/mock_drm.h	2013-03-07 06:00:18 +0000
+++ tests/unit-tests/graphics/gbm/mock_drm.h	2013-04-11 11:00:30 +0000
@@ -117,6 +117,9 @@
     MOCK_METHOD4(drmPrimeHandleToFD, int(int fd, uint32_t handle, uint32_t flags, int *prime_fd));
     MOCK_METHOD3(drmPrimeFDToHandle, int(int fd, int prime_fd, uint32_t *handle));
 
+    MOCK_METHOD1(drmSetMaster, int(int fd));
+    MOCK_METHOD1(drmDropMaster, int(int fd));
+
     FakeDRMResources fake_drm;
 };
 
 
=== modified file 'tests/unit-tests/graphics/gbm/test_gbm_buffer.cpp'
--- tests/unit-tests/graphics/gbm/test_gbm_buffer.cpp	2013-03-27 04:39:27 +0000
+++ tests/unit-tests/graphics/gbm/test_gbm_buffer.cpp	2013-04-11 11:00:30 +0000
@@ -27,6 +27,7 @@
 #include "mir/graphics/buffer_initializer.h"
 #include "mir/compositor/buffer_ipc_package.h"
 #include "mir/compositor/buffer_properties.h"
+#include "mir_test_doubles/null_virtual_terminal.h"
 
 #include "mir/graphics/null_display_report.h"
 
@@ -42,6 +43,7 @@
 namespace mg=mir::graphics;
 namespace mgg=mir::graphics::gbm;
 namespace geom=mir::geometry;
+namespace mtd=mir::test::doubles;
 
 class GBMGraphicBufferBasic : public ::testing::Test
 {
@@ -77,7 +79,8 @@
         ON_CALL(mock_egl, eglGetProcAddress(StrEq("glEGLImageTargetTexture2DOES")))
             .WillByDefault(Return(reinterpret_cast<func_ptr_t>(glEGLImageTargetTexture2DOES)));
 
-        platform = std::make_shared<mgg::GBMPlatform>(std::make_shared<mg::NullDisplayReport>());
+        platform = std::make_shared<mgg::GBMPlatform>(std::make_shared<mg::NullDisplayReport>(),
+                                                      std::make_shared<mtd::NullVirtualTerminal>());
         null_init = std::make_shared<mg::NullBufferInitializer>();
         allocator.reset(new mgg::GBMBufferAllocator(platform, null_init));
     }
 
=== modified file 'tests/unit-tests/graphics/gbm/test_gbm_buffer_allocator.cpp'
--- tests/unit-tests/graphics/gbm/test_gbm_buffer_allocator.cpp	2013-03-13 08:09:52 +0000
+++ tests/unit-tests/graphics/gbm/test_gbm_buffer_allocator.cpp	2013-04-11 11:00:30 +0000
@@ -27,6 +27,7 @@
 #include "mir_test/egl_mock.h"
 #include "mir_test/gl_mock.h"
 #include "mir_test_doubles/mock_buffer_initializer.h"
+#include "mir_test_doubles/null_virtual_terminal.h"
 #include "mir/graphics/null_display_report.h"
 
 #include <memory>
@@ -67,7 +68,8 @@
         ON_CALL(mock_egl, eglGetProcAddress(StrEq("glEGLImageTargetTexture2DOES")))
             .WillByDefault(Return(reinterpret_cast<func_ptr_t>(glEGLImageTargetTexture2DOES)));
 
-        platform = std::make_shared<mgg::GBMPlatform>(std::make_shared<mg::NullDisplayReport>());
+        platform = std::make_shared<mgg::GBMPlatform>(std::make_shared<mg::NullDisplayReport>(),
+                                                      std::make_shared<mtd::NullVirtualTerminal>());
         mock_buffer_initializer = std::make_shared<testing::NiceMock<mtd::MockBufferInitializer>>();
         allocator.reset(new mgg::GBMBufferAllocator(platform, mock_buffer_initializer));
     }
 
=== modified file 'tests/unit-tests/graphics/gbm/test_gbm_display.cpp'
--- tests/unit-tests/graphics/gbm/test_gbm_display.cpp	2013-03-22 11:37:34 +0000
+++ tests/unit-tests/graphics/gbm/test_gbm_display.cpp	2013-04-11 11:00:30 +0000
@@ -18,13 +18,17 @@
 #include <boost/throw_exception.hpp>
 #include "src/server/graphics/gbm/gbm_platform.h"
 #include "src/server/graphics/gbm/gbm_display.h"
+#include "src/server/graphics/gbm/virtual_terminal.h"
 #include "mir/logging/display_report.h"
 #include "mir/logging/logger.h"
+#include "mir/graphics/display_buffer.h"
+#include "mir/main_loop.h"
 
 #include "mir_test/egl_mock.h"
 #include "mir_test/gl_mock.h"
 #include "mir/graphics/null_display_report.h"
 #include "mir_test_doubles/mock_display_report.h"
+#include "mir_test_doubles/null_virtual_terminal.h"
 
 #include "mock_drm.h"
 #include "mock_gbm.h"
@@ -48,11 +52,24 @@
     ~MockLogger() noexcept(true) {}
 };
 
+class MockVirtualTerminal : public mgg::VirtualTerminal
+{
+public:
+    ~MockVirtualTerminal() noexcept(true) {}
+
+    MOCK_METHOD0(set_graphics_mode, void());
+    MOCK_METHOD3(register_switch_handlers,
+                 void(mir::MainLoop&,
+                      std::function<void()> const&,
+                      std::function<void()> const&));
+};
+
 class GBMDisplayTest : public ::testing::Test
 {
 public:
     GBMDisplayTest() :
-        mock_report(new ::testing::NiceMock<mtd::MockDisplayReport>())
+        mock_report{std::make_shared<testing::NiceMock<mtd::MockDisplayReport>>()},
+        null_report{std::make_shared<mg::NullDisplayReport>()}
     {
         using namespace testing;
         ON_CALL(mock_egl, eglChooseConfig(_,_,_,1,_))
@@ -78,6 +95,12 @@
         .Times(AtLeast(0));
     }
 
+    std::shared_ptr<mgg::GBMPlatform> create_platform()
+    {
+        return std::make_shared<mgg::GBMPlatform>(
+            null_report,
+            std::make_shared<mtd::NullVirtualTerminal>());
+    }
 
     void setup_post_update_expectations()
     {
@@ -167,7 +190,8 @@
     ::testing::NiceMock<mir::GLMock> mock_gl;
     ::testing::NiceMock<mgg::MockDRM> mock_drm;
     ::testing::NiceMock<mgg::MockGBM> mock_gbm;
-    std::shared_ptr<testing::NiceMock<mtd::MockDisplayReport>> mock_report;
+    std::shared_ptr<testing::NiceMock<mtd::MockDisplayReport>> const mock_report;
+    std::shared_ptr<mg::DisplayReport> const null_report;
 };
 
 }
@@ -232,8 +256,8 @@
 
     EXPECT_NO_THROW(
     {
-        auto platform = std::make_shared<mgg::GBMPlatform>(std::make_shared<mg::NullDisplayReport>());
-        auto display = std::make_shared<mgg::GBMDisplay>(platform, mock_report);
+        auto platform = create_platform();
+        auto display = std::make_shared<mgg::GBMDisplay>(platform, null_report);
     });
 }
 
@@ -273,8 +297,8 @@
 
     EXPECT_NO_THROW(
     {
-        auto platform = std::make_shared<mgg::GBMPlatform>(std::make_shared<mg::NullDisplayReport>());
-        auto display = std::make_shared<mgg::GBMDisplay>(platform, mock_report);
+        auto platform = create_platform();
+        auto display = std::make_shared<mgg::GBMDisplay>(platform, null_report);
     });
 }
 
@@ -291,8 +315,8 @@
 
     EXPECT_THROW(
     {
-        auto platform = std::make_shared<mgg::GBMPlatform>(std::make_shared<mg::NullDisplayReport>());
-        auto display = std::make_shared<mgg::GBMDisplay>(platform, mock_report);
+        auto platform = create_platform();
+        auto display = std::make_shared<mgg::GBMDisplay>(platform, null_report);
     }, std::runtime_error);
 }
 
@@ -310,10 +334,10 @@
     EXPECT_CALL(mock_drm, drmClose(_))
         .Times(Exactly(1));
 
-    auto platform = std::make_shared<mgg::GBMPlatform>(std::make_shared<mg::NullDisplayReport>());
+    auto platform = create_platform();
 
     EXPECT_THROW({
-        auto display = std::make_shared<mgg::GBMDisplay>(platform, mock_report);
+        auto display = std::make_shared<mgg::GBMDisplay>(platform, null_report);
     }, std::runtime_error) << "Expected that c'tor of GBMDisplay throws";
 }
 
@@ -332,8 +356,8 @@
         .Times(Exactly(1));
 
     EXPECT_THROW({
-        auto platform = std::make_shared<mgg::GBMPlatform>(std::make_shared<mg::NullDisplayReport>());
-    }, std::runtime_error) << "Expected c'tor of GBMDisplay to throw an exception";
+        auto platform = create_platform();
+    }, std::runtime_error) << "Expected c'tor of GBMPlatform to throw an exception";
 }
 
 namespace
@@ -394,8 +418,8 @@
 
     EXPECT_NO_THROW(
     {
-        auto platform = std::make_shared<mgg::GBMPlatform>(std::make_shared<mg::NullDisplayReport>());
-        auto display = std::make_shared<mgg::GBMDisplay>(platform, mock_report);
+        auto platform = create_platform();
+        auto display = std::make_shared<mgg::GBMDisplay>(platform, null_report);
 
         display->for_each_display_buffer([](mg::DisplayBuffer& db)
         {
@@ -434,8 +458,8 @@
 
     EXPECT_NO_THROW(
     {
-        auto platform = std::make_shared<mgg::GBMPlatform>(std::make_shared<mg::NullDisplayReport>());
-        auto display = std::make_shared<mgg::GBMDisplay>(platform, mock_report);
+        auto platform = create_platform();
+        auto display = std::make_shared<mgg::GBMDisplay>(platform, null_report);
 
         display->for_each_display_buffer([](mg::DisplayBuffer& db)
         {
@@ -469,7 +493,7 @@
 
     EXPECT_NO_THROW(
     {
-        auto platform = std::make_shared<mgg::GBMPlatform>(std::make_shared<mg::NullDisplayReport>());
+        auto platform = create_platform();
         auto display = std::make_shared<mgg::GBMDisplay>(platform, mock_report);
     });
 }
@@ -478,11 +502,11 @@
 {
     using namespace ::testing;
 
-    auto platform = std::make_shared<mgg::GBMPlatform>(std::make_shared<mg::NullDisplayReport>());
+    auto platform = create_platform();
     auto logger = std::make_shared<MockLogger>();
 
     auto reporter = std::make_shared<ml::DisplayReport>(logger);
-    auto display = std::make_shared<mgg::GBMDisplay>(platform, mock_report);
+    auto display = std::make_shared<mgg::GBMDisplay>(platform, null_report);
 
     EXPECT_CALL(
         *logger,
@@ -497,11 +521,11 @@
 {
     using namespace ::testing;
 
-    auto platform = std::make_shared<mgg::GBMPlatform>(std::make_shared<mg::NullDisplayReport>());
+    auto platform = create_platform();
     auto logger = std::make_shared<MockLogger>();
 
     auto reporter = std::make_shared<ml::DisplayReport>(logger);
-    auto display = std::make_shared<mgg::GBMDisplay>(platform, mock_report);
+    auto display = std::make_shared<mgg::GBMDisplay>(platform, null_report);
 
     EXPECT_CALL(
         *logger,
@@ -516,11 +540,11 @@
 {
     using namespace ::testing;
 
-    auto platform = std::make_shared<mgg::GBMPlatform>(std::make_shared<mg::NullDisplayReport>());
+    auto platform = create_platform();
     auto logger = std::make_shared<MockLogger>();
 
     auto reporter = std::make_shared<ml::DisplayReport>(logger);
-    auto display = std::make_shared<mgg::GBMDisplay>(platform, mock_report);
+    auto display = std::make_shared<mgg::GBMDisplay>(platform, null_report);
 
     EXPECT_CALL(
         *logger,
@@ -535,11 +559,11 @@
 {
     using namespace ::testing;
 
-    auto platform = std::make_shared<mgg::GBMPlatform>(std::make_shared<mg::NullDisplayReport>());
+    auto platform = create_platform();
     auto logger = std::make_shared<MockLogger>();
 
     auto reporter = std::make_shared<ml::DisplayReport>(logger);
-    auto display = std::make_shared<mgg::GBMDisplay>(platform, mock_report);
+    auto display = std::make_shared<mgg::GBMDisplay>(platform, null_report);
 
     EXPECT_CALL(
         *logger,
@@ -561,8 +585,8 @@
 
     EXPECT_THROW(
     {
-        auto platform = std::make_shared<mgg::GBMPlatform>(std::make_shared<mg::NullDisplayReport>());
-        auto display = std::make_shared<mgg::GBMDisplay>(platform, mock_report);
+        auto platform = create_platform();
+        auto display = std::make_shared<mgg::GBMDisplay>(platform, null_report);
     }, std::runtime_error);
 }
 
@@ -577,8 +601,8 @@
 
     EXPECT_THROW(
     {
-        auto platform = std::make_shared<mgg::GBMPlatform>(std::make_shared<mg::NullDisplayReport>());
-        auto display = std::make_shared<mgg::GBMDisplay>(platform, mock_report);
+        auto platform = create_platform();
+        auto display = std::make_shared<mgg::GBMDisplay>(platform, null_report);
     }, std::runtime_error);
 }
 
@@ -586,8 +610,8 @@
 {
     using namespace ::testing;
 
-    auto platform = std::make_shared<mgg::GBMPlatform>(std::make_shared<mg::NullDisplayReport>());
-    auto display = std::make_shared<mgg::GBMDisplay>(platform, mock_report);
+    auto platform = create_platform();
+    auto display = std::make_shared<mgg::GBMDisplay>(platform, null_report);
 
     int callback_count{0};
 
@@ -598,3 +622,65 @@
 
     EXPECT_NE(0, callback_count);
 }
+
+TEST_F(GBMDisplayTest, constructor_sets_vt_graphics_mode)
+{
+    using namespace testing;
+
+    auto mock_vt = std::make_shared<MockVirtualTerminal>();
+
+    EXPECT_CALL(*mock_vt, set_graphics_mode())
+        .Times(1);
+
+    auto platform = std::make_shared<mgg::GBMPlatform>(null_report, mock_vt);
+
+    auto display = std::make_shared<mgg::GBMDisplay>(platform, null_report);
+}
+
+TEST_F(GBMDisplayTest, pause_drops_drm_master)
+{
+    using namespace testing;
+
+    EXPECT_CALL(mock_drm, drmDropMaster(mock_drm.fake_drm.fd()))
+        .Times(1);
+
+    auto platform = create_platform();
+    auto display = std::make_shared<mgg::GBMDisplay>(platform, null_report);
+
+    display->pause();
+}
+
+TEST_F(GBMDisplayTest, resume_sets_drm_master)
+{
+    using namespace testing;
+
+    EXPECT_CALL(mock_drm, drmSetMaster(mock_drm.fake_drm.fd()))
+        .Times(1);
+
+    auto platform = create_platform();
+    auto display = std::make_shared<mgg::GBMDisplay>(platform, null_report);
+
+    display->resume();
+}
+
+TEST_F(GBMDisplayTest, set_or_drop_drm_master_failure_throws)
+{
+    using namespace testing;
+
+    EXPECT_CALL(mock_drm, drmDropMaster(_))
+        .WillOnce(Return(-1));
+
+    EXPECT_CALL(mock_drm, drmSetMaster(_))
+        .WillOnce(Return(-1));
+
+    auto platform = create_platform();
+    auto display = std::make_shared<mgg::GBMDisplay>(platform, null_report);
+
+    EXPECT_THROW({
+        display->pause();
+    }, std::runtime_error);
+
+    EXPECT_THROW({
+        display->resume();
+    }, std::runtime_error);
+}
 
=== modified file 'tests/unit-tests/graphics/gbm/test_gbm_display_configuration.cpp'
--- tests/unit-tests/graphics/gbm/test_gbm_display_configuration.cpp	2013-03-13 08:09:52 +0000
+++ tests/unit-tests/graphics/gbm/test_gbm_display_configuration.cpp	2013-04-11 11:00:30 +0000
@@ -25,6 +25,7 @@
 #include "mir_test/egl_mock.h"
 #include "mir_test/gl_mock.h"
 #include "mir/graphics/null_display_report.h"
+#include "mir_test_doubles/null_virtual_terminal.h"
 
 #include "mock_drm.h"
 #include "mock_gbm.h"
@@ -37,6 +38,7 @@
 namespace mg = mir::graphics;
 namespace mgg = mir::graphics::gbm;
 namespace geom = mir::geometry;
+namespace mtd = mir::test::doubles;
 
 namespace
 {
@@ -59,8 +61,7 @@
 class GBMDisplayConfigurationTest : public ::testing::Test
 {
 public:
-    GBMDisplayConfigurationTest() :
-        null_listener{std::make_shared<mg::NullDisplayReport>()}
+    GBMDisplayConfigurationTest()
     {
         using namespace testing;
 
@@ -81,6 +82,13 @@
         setup_sample_modes();
     }
 
+    std::shared_ptr<mgg::GBMPlatform> create_platform()
+    {
+        return std::make_shared<mgg::GBMPlatform>(
+            std::make_shared<mg::NullDisplayReport>(),
+            std::make_shared<mtd::NullVirtualTerminal>());
+    }
+
     void setup_sample_modes()
     {
         /* Add DRM modes */
@@ -98,7 +106,6 @@
     ::testing::NiceMock<mir::GLMock> mock_gl;
     ::testing::NiceMock<mgg::MockDRM> mock_drm;
     ::testing::NiceMock<mgg::MockGBM> mock_gbm;
-    std::shared_ptr<mg::DisplayReport> const null_listener;
 
     std::vector<drmModeModeInfo> modes0;
     std::vector<mg::DisplayConfigurationMode> conf_modes0;
@@ -176,7 +183,7 @@
     };
 
     /* Test body */
-    auto platform = std::make_shared<mgg::GBMPlatform>(null_listener);
+    auto platform = create_platform();
     auto display = platform->create_display();
 
     auto conf = display->configuration();
@@ -214,7 +221,7 @@
     resources.prepare();
 
     /* Test body */
-    auto platform = std::make_shared<mgg::GBMPlatform>(null_listener);
+    auto platform = create_platform();
     auto display = platform->create_display();
 
     auto conf = display->configuration();
@@ -253,7 +260,7 @@
     resources.prepare();
 
     /* Test body */
-    auto platform = std::make_shared<mgg::GBMPlatform>(null_listener);
+    auto platform = create_platform();
     auto display = platform->create_display();
 
     auto conf = display->configuration();
 
=== modified file 'tests/unit-tests/graphics/gbm/test_gbm_display_multi_monitor.cpp'
--- tests/unit-tests/graphics/gbm/test_gbm_display_multi_monitor.cpp	2013-03-13 08:09:52 +0000
+++ tests/unit-tests/graphics/gbm/test_gbm_display_multi_monitor.cpp	2013-04-11 11:00:30 +0000
@@ -23,6 +23,7 @@
 #include "mir_test/egl_mock.h"
 #include "mir_test/gl_mock.h"
 #include "mir/graphics/null_display_report.h"
+#include "mir_test_doubles/null_virtual_terminal.h"
 
 #include "mock_drm.h"
 #include "mock_gbm.h"
@@ -33,6 +34,7 @@
 namespace mg = mir::graphics;
 namespace mgg = mir::graphics::gbm;
 namespace geom = mir::geometry;
+namespace mtd = mir::test::doubles;
 
 namespace
 {
@@ -41,7 +43,6 @@
 {
 public:
     GBMDisplayMultiMonitorTest()
-        : null_listener{std::make_shared<mg::NullDisplayReport>()}
     {
         using namespace testing;
 
@@ -69,6 +70,13 @@
             .Times(AtLeast(0));
     }
 
+    std::shared_ptr<mgg::GBMPlatform> create_platform()
+    {
+        return std::make_shared<mgg::GBMPlatform>(
+            std::make_shared<mg::NullDisplayReport>(),
+            std::make_shared<mtd::NullVirtualTerminal>());
+    }
+
     void setup_outputs(int n)
     {
         mgg::FakeDRMResources& resources(mock_drm.fake_drm);
@@ -117,7 +125,6 @@
     testing::NiceMock<mir::GLMock> mock_gl;
     testing::NiceMock<mgg::MockDRM> mock_drm;
     testing::NiceMock<mgg::MockGBM> mock_gbm;
-    std::shared_ptr<mg::DisplayReport> const null_listener;
 
     std::vector<drmModeModeInfo> modes0;
     std::vector<drmModeModeInfo> modes_empty;
@@ -168,7 +175,7 @@
             .After(crtc_setups);
     }
 
-    auto platform = std::make_shared<mgg::GBMPlatform>(null_listener);
+    auto platform = create_platform();
     auto display = platform->create_display();
 }
 
@@ -201,7 +208,7 @@
             .Times(1);
     }
 
-    auto platform = std::make_shared<mgg::GBMPlatform>(null_listener);
+    auto platform = create_platform();
     auto display = platform->create_display();
 }
 
@@ -254,7 +261,7 @@
         .WillOnce(DoAll(InvokePageFlipHandler(&user_data[1]), Return(0)))
         .WillOnce(DoAll(InvokePageFlipHandler(&user_data[2]), Return(0)));
 
-    auto platform = std::make_shared<mgg::GBMPlatform>(null_listener);
+    auto platform = create_platform();
     auto display = platform->create_display();
 
     display->for_each_display_buffer([](mg::DisplayBuffer& buffer)
 
=== modified file 'tests/unit-tests/graphics/gbm/test_gbm_platform.cpp'
--- tests/unit-tests/graphics/gbm/test_gbm_platform.cpp	2013-03-13 04:54:15 +0000
+++ tests/unit-tests/graphics/gbm/test_gbm_platform.cpp	2013-04-11 11:00:30 +0000
@@ -16,9 +16,10 @@
  * Authored by: Alexandros Frantzis <[e-mail]>
  */
 
-#include "mir/graphics/platform.h"
 #include "mir/graphics/platform_ipc_package.h"
 #include "mir/graphics/drm_authenticator.h"
+#include "src/server/graphics/gbm/gbm_platform.h"
+#include "mir_test_doubles/null_virtual_terminal.h"
 
 #include "mir/graphics/null_display_report.h"
 
@@ -28,13 +29,17 @@
 #include "mock_gbm.h"
 
 #include <gtest/gtest.h>
+#include <gmock/gmock.h>
 
 #include <stdexcept>
 
 namespace mg = mir::graphics;
+namespace mgg = mir::graphics::gbm;
+namespace mtd = mir::test::doubles;
 
 namespace
 {
+
 class GBMGraphicsPlatform : public ::testing::Test
 {
 public:
@@ -43,6 +48,14 @@
         ::testing::Mock::VerifyAndClearExpectations(&mock_drm);
         ::testing::Mock::VerifyAndClearExpectations(&mock_gbm);
     }
+
+    std::shared_ptr<mg::Platform> create_platform()
+    {
+        return std::make_shared<mgg::GBMPlatform>(
+            std::make_shared<mg::NullDisplayReport>(),
+            std::make_shared<mtd::NullVirtualTerminal>());
+    }
+
     ::testing::NiceMock<mg::gbm::MockDRM> mock_drm;
     ::testing::NiceMock<mg::gbm::MockGBM> mock_gbm;
 };
@@ -69,7 +82,7 @@
     EXPECT_CALL(mock_drm, drmClose(auth_fd));
 
     EXPECT_NO_THROW (
-        auto platform = mg::create_platform(std::make_shared<mg::NullDisplayReport>());
+        auto platform = create_platform();
         auto pkg = platform->get_ipc_package();
 
         ASSERT_TRUE(pkg.get());
@@ -87,7 +100,7 @@
 
     try
     {
-        auto platform = mg::create_platform(std::make_shared<mg::NullDisplayReport>());
+        auto platform = create_platform();
     } catch(...)
     {
         return;
@@ -105,7 +118,7 @@
     EXPECT_CALL(mock_drm, drmAuthMagic(mock_drm.fake_drm.fd(),magic))
         .WillOnce(Return(0));
 
-    auto platform = mg::create_platform(std::make_shared<mg::NullDisplayReport>());
+    auto platform = create_platform();
     auto authenticator = std::dynamic_pointer_cast<mg::DRMAuthenticator>(platform);
     authenticator->drm_auth_magic(magic);
 }
@@ -119,7 +132,7 @@
     EXPECT_CALL(mock_drm, drmAuthMagic(mock_drm.fake_drm.fd(),magic))
         .WillOnce(Return(-1));
 
-    auto platform = mg::create_platform(std::make_shared<mg::NullDisplayReport>());
+    auto platform = create_platform();
     auto authenticator = std::dynamic_pointer_cast<mg::DRMAuthenticator>(platform);
 
     EXPECT_THROW({
 
=== modified file 'tests/unit-tests/graphics/test_graphics_platform.cpp'
--- tests/unit-tests/graphics/test_graphics_platform.cpp	2013-03-22 17:08:01 +0000
+++ tests/unit-tests/graphics/test_graphics_platform.cpp	2013-04-11 11:00:30 +0000
@@ -25,6 +25,8 @@
 #ifndef ANDROID
 #include "gbm/mock_drm.h"
 #include "gbm/mock_gbm.h"
+#include "mir_test_doubles/null_virtual_terminal.h"
+#include "src/server/graphics/gbm/gbm_platform.h"
 #else
 #include "mir_test/hw_mock.h"
 #endif
@@ -69,6 +71,17 @@
 #endif
     }
 
+    std::shared_ptr<mg::Platform> create_platform()
+    {
+#ifdef ANDROID
+        return mg::create_platform(std::make_shared<mg::NullDisplayReport>());
+#else
+        return std::make_shared<mg::gbm::GBMPlatform>(
+            std::make_shared<mg::NullDisplayReport>(),
+            std::make_shared<mir::test::doubles::NullVirtualTerminal>());
+#endif
+    }
+
     std::shared_ptr<ml::Logger> logger;
     std::shared_ptr<mg::BufferInitializer> buffer_initializer;
 
@@ -87,7 +100,7 @@
     using namespace testing;
 
     EXPECT_NO_THROW (
-        auto platform = mg::create_platform(std::make_shared<mg::NullDisplayReport>());
+        auto platform = create_platform();
         auto allocator = platform->create_buffer_allocator(buffer_initializer);
 
         EXPECT_TRUE(allocator.get());
@@ -97,7 +110,7 @@
 
 TEST_F(GraphicsPlatform, buffer_creation)
 {
-    auto platform = mg::create_platform(std::make_shared<mg::NullDisplayReport>());
+    auto platform = create_platform();
     auto allocator = platform->create_buffer_allocator(buffer_initializer);
     auto supported_pixel_formats = allocator->supported_pixel_formats();
 
@@ -119,7 +132,7 @@
 
 TEST_F(GraphicsPlatform, get_ipc_package)
 {
-    auto platform = mg::create_platform(std::make_shared<mg::NullDisplayReport>());
+    auto platform = create_platform();
     auto pkg = platform->get_ipc_package();
 
     ASSERT_TRUE(pkg.get() != NULL);