Merge lp:~mterry/unity-system-compositor/greeter-depth into lp:unity-system-compositor

[Michael Terry]

Make sure that the active session has focus when multiple sessions are opened.

Make sure that the active session has focus.

This branch fixes a few problems when using USC with multiple sessions:

1) There is a race between when LightDM tells us what the active session should be and when that session might get around to registering with us. This branch solves that by keeping track of the requested session name and focusing it when it is opened.

2) If later sessions open, Mir gives them the focus by default. This branch makes sure that as new sessions open, we give focus back to the proper active session, as determined by LightDM.

3) This branch implements set_next_session, which was previously merely TODO. This way LightDM can tell us which session to stack underneath the active one.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:104
http://jenkins.qa.ubuntu.com/job/unity-system-compositor-ci/82/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-system-compositor-trusty-amd64-ci/34
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-system-compositor-trusty-armhf-ci/34

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/unity-system-compositor-ci/82/rebuild

review: Approve (continuous-integration)

[Alberto Aguirre (albaguirre)]

Looks good, I had seen this race.

review: Approve

=== modified file 'src/system_compositor.cpp'
--- src/system_compositor.cpp	2014-02-10 14:55:13 +0000
+++ src/system_compositor.cpp	2014-02-26 18:33:00 +0000
@@ -45,13 +45,36 @@
 class SystemCompositorShell : public mf::Shell
 {
 public:
-    SystemCompositorShell(std::shared_ptr<mf::Shell> const& self) : self(self) {}
+    SystemCompositorShell(std::shared_ptr<mf::Shell> const& self,
+                          std::shared_ptr<msh::FocusController> const& focus_controller)
+        : self(self), focus_controller{focus_controller} {}
 
     std::shared_ptr<mf::Session> session_named(std::string const& name)
     {
         return sessions[name];
     }
 
+    void set_active_session(std::string const& name)
+    {
+        active_session = name;
+
+        if (auto session = std::static_pointer_cast<msh::Session>(session_named(name)))
+            focus_controller->set_focus_to(session);
+        else
+            std::cerr << "Unable to set active session, unknown client name " << name << std::endl;
+    }
+
+    void set_next_session(std::string const& name)
+    {
+        if (auto const session = std::static_pointer_cast<msh::Session>(session_named(name)))
+        {
+            focus_controller->set_focus_to(session); // raise session inside its depth id set
+            set_active_session(active_session); // to restore input focus to where it should be
+        }
+        else
+            std::cerr << "Unable to set next session, unknown client name " << name << std::endl;
+    }
+
 private:
     std::shared_ptr<mf::Session> open_session(
         pid_t client_pid,
@@ -60,6 +83,11 @@
     {
         auto result = self->open_session(client_pid, name, sink);
         sessions[name] = result;
+
+        // Opening a new session will steal focus from our active session, so
+        // restore the focus if needed.
+        set_active_session(active_session);
+
         return result;
     }
 
@@ -82,7 +110,9 @@
     }
 
     std::shared_ptr<mf::Shell> const self;
+    std::shared_ptr<msh::FocusController> const focus_controller;
     std::map<std::string, std::shared_ptr<mf::Session>> sessions;
+    std::string active_session;
 };
 
 class SystemCompositorServerConfiguration : public mir::DefaultServerConfiguration
@@ -180,7 +210,8 @@
         return sc_shell([this]
         {
             return std::make_shared<SystemCompositorShell>(
-                mir::DefaultServerConfiguration::the_frontend_shell());
+                mir::DefaultServerConfiguration::the_frontend_shell(),
+                the_focus_controller());
         });
     }
 
@@ -279,7 +310,7 @@
 {
     std::cerr << "pause" << std::endl;
 
-    if (active_session)
+    if (auto active_session = config->the_focus_controller()->focussed_application().lock())
         active_session->set_lifecycle_state(mir_lifecycle_state_will_suspend);
 }
 
@@ -287,30 +318,20 @@
 {
     std::cerr << "resume" << std::endl;
 
-    if (active_session)
+    if (auto active_session = config->the_focus_controller()->focussed_application().lock())
         active_session->set_lifecycle_state(mir_lifecycle_state_resumed);
 }
 
 void SystemCompositor::set_active_session(std::string client_name)
 {
     std::cerr << "set_active_session" << std::endl;
-
-    active_session = std::static_pointer_cast<mir::shell::Session>(shell->session_named(client_name));
-
-    if (active_session)
-        config->the_focus_controller()->set_focus_to(active_session);
-    else
-        std::cerr << "Unable to set active session, unknown client name " << client_name << std::endl;
+    shell->set_active_session(client_name);
 }
 
 void SystemCompositor::set_next_session(std::string client_name)
 {
     std::cerr << "set_next_session" << std::endl;
-
-    if (auto const session = shell->session_named(client_name))
-        ; // TODO: implement this
-    else
-        std::cerr << "Unable to set next session, unknown client name " << client_name << std::endl;
+    shell->set_next_session(client_name);
 }
 
 void SystemCompositor::main()

=== modified file 'src/system_compositor.h'
--- src/system_compositor.h	2013-11-22 16:53:52 +0000
+++ src/system_compositor.h	2014-02-26 18:33:00 +0000
@@ -38,7 +38,6 @@
     std::shared_ptr<SystemCompositorShell> shell;
     boost::asio::io_service io_service;
     std::shared_ptr<DMConnection> dm_connection;
-    std::shared_ptr<mir::shell::Session> active_session;
 
     void set_active_session(std::string client_name);
     void set_next_session(std::string client_name);