Merge lp:mir/0.17 into lp:mir/ubuntu

[Alberto Aguirre]

Mir 0.17.1 release

Mir 0.17.1 release

[lp:mir/0.17]

3017. By Alberto Aguirre on 2015-11-04

Avoid __attribute__((weak)) as that will fail to resolve symbols from
lazily loaded libraries (like Qt platform plugins apparently).

Cherry picked from lp:mir r3060

3018. By Alberto Aguirre on 2015-11-04

Update changelog

3019. By Brandon Schaefer on 2015-11-04

Add missing shlibs:Depends entry to libmircookie1 package dependency list

3020. By Alberto Aguirre on 2015-11-04

Update changelog, new bugfix entry

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:3016
http://jenkins.qa.ubuntu.com/job/mir-ubuntu-ci/87/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-android-wily-i386-build/43/console
    FAILURE: http://s-jenkins.ubuntu-ci:8080/job/mir-clang-ts-wily-amd64-build/460/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-clang-wily-amd64-build/1132/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-ubuntu-wily-amd64-ci/42
        deb: http://jenkins.qa.ubuntu.com/job/mir-ubuntu-wily-amd64-ci/42/artifact/work/output/*zip*/output.zip
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-ubuntu-wily-armhf-ci/45/console

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

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:3020
http://jenkins.qa.ubuntu.com/job/mir-ubuntu-ci/88/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-android-wily-i386-build/44/console
    FAILURE: http://s-jenkins.ubuntu-ci:8080/job/mir-clang-ts-wily-amd64-build/461/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-clang-wily-amd64-build/1133/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-ubuntu-wily-amd64-ci/43
        deb: http://jenkins.qa.ubuntu.com/job/mir-ubuntu-wily-amd64-ci/43/artifact/work/output/*zip*/output.zip
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-ubuntu-wily-armhf-ci/46/console

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

review: Needs Fixing (continuous-integration)

[lp:mir/0.17]

3021. By Alexandros Frantzis on 2015-11-05

input: Return an empty input region bounding rectangle when there are no outputs.

Cherry picked from lp:mir r3085

3022. By Alberto Aguirre on 2015-11-05

Update changelog

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:3022
http://jenkins.qa.ubuntu.com/job/mir-ubuntu-ci/89/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-android-wily-i386-build/45/console
    FAILURE: http://s-jenkins.ubuntu-ci:8080/job/mir-clang-ts-wily-amd64-build/462/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-clang-wily-amd64-build/1134/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-ubuntu-wily-amd64-ci/44
        deb: http://jenkins.qa.ubuntu.com/job/mir-ubuntu-wily-amd64-ci/44/artifact/work/output/*zip*/output.zip
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-ubuntu-wily-armhf-ci/47/console

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

review: Needs Fixing (continuous-integration)

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2015-10-08 09:48:35 +0000
+++ CMakeLists.txt	2015-11-05 16:01:02 +0000
@@ -28,7 +28,7 @@
 
 set(MIR_VERSION_MAJOR 0)
 set(MIR_VERSION_MINOR 17)
-set(MIR_VERSION_PATCH 0)
+set(MIR_VERSION_PATCH 1)
 
 add_definitions(-DMIR_VERSION_MAJOR=${MIR_VERSION_MAJOR})
 add_definitions(-DMIR_VERSION_MINOR=${MIR_VERSION_MINOR})
 
=== modified file 'debian/changelog'
--- debian/changelog	2015-10-08 16:12:19 +0000
+++ debian/changelog	2015-11-05 16:01:02 +0000
@@ -1,3 +1,23 @@
+mir (0.17.1) UNRELEASED; urgency=medium
+
+  * New upstream release 0.17.1 (https://launchpad.net/mir/+milestone/0.17.1)
+    - No ABI changes. Bug fix release only.
+    - Bugs fixed:
+      . compositing never stops when external monitor is connected
+        (LP: #1499039)
+      . half screen on external monitor (LP: #1511538)
+      . Nested servers don't apply their display configuration at startup
+        (LP: #1492269)
+      . libmircookie1 package does not list libnettle as dependency
+        (LP: #1513225)
+      . unity-system-compositor crash, no interaction on windowed mode
+        (LP: #1511095)
+      . mir_connection_get_egl_pixel_format() crashes (LP: #1510218)
+      . [regression] mir-client-platform-mesa-dev pkg-config file dropped
+        (LP: #1509005)
+
+ -- Alberto Aguirre <[e-mail]>  Wed, 04 Nov 2015 15:08:54 -0600
+
 mir (0.17.0+15.10.20151008.2-0ubuntu1) wily; urgency=medium
 
   [ Alexandros Frantzis ]
 
=== modified file 'debian/control'
--- debian/control	2015-10-05 02:18:18 +0000
+++ debian/control	2015-11-05 16:01:02 +0000
@@ -424,6 +424,7 @@
 Multi-Arch: same
 Pre-Depends: ${misc:Pre-Depends}
 Depends: ${misc:Depends},
+         ${shlibs:Depends}
 Description: Produce and verify spoof-resistant timestamps - runtime library
  libmircookie provides a simple mechanism for a group of cooperating processes
  to hand out and verify difficult-to-forge timestamps to untrusted 3rd parties.
 
=== modified file 'debian/mir-client-platform-mesa-dev.install'
--- debian/mir-client-platform-mesa-dev.install	2015-09-24 22:30:09 +0000
+++ debian/mir-client-platform-mesa-dev.install	2015-11-05 16:01:02 +0000
@@ -1,2 +1,3 @@
 usr/include/mirplatform/mir_toolkit/mesa
+usr/lib/*/pkgconfig/mir-client-platform-mesa-dev.pc
 usr/lib/*/pkgconfig/mir-client-platform-mesa.pc
 
=== modified file 'include/platform/mir/graphics/display_configuration.h'
--- include/platform/mir/graphics/display_configuration.h	2015-10-05 05:22:49 +0000
+++ include/platform/mir/graphics/display_configuration.h	2015-11-05 16:01:02 +0000
@@ -181,6 +181,9 @@
     DisplayConfiguration& operator=(DisplayConfiguration const& c) = delete;
 };
 
+bool operator==(DisplayConfiguration const& lhs, DisplayConfiguration const& rhs);
+bool operator!=(DisplayConfiguration const& lhs, DisplayConfiguration const& rhs);
+
 std::ostream& operator<<(std::ostream& out, DisplayConfiguration const& val);
 
 }
 
=== modified file 'src/platform/graphics/display_configuration.cpp'
--- src/platform/graphics/display_configuration.cpp	2015-10-02 05:14:37 +0000
+++ src/platform/graphics/display_configuration.cpp	2015-11-05 16:01:02 +0000
@@ -145,6 +145,7 @@
 
     out << "\tscale: " << val.scale << std::endl;
     out << "\tform factor: " << as_string(val.form_factor) << std::endl;
+    out << "\torientation: " << val.orientation << '\n';
     out << "}" << std::endl;
 
     return out;
@@ -219,6 +220,28 @@
     return !(val1 == val2);
 }
 
+bool mg::operator==(DisplayConfiguration const& lhs, DisplayConfiguration const& rhs)
+{
+    std::vector<DisplayConfigurationCard> lhs_cards;
+    std::vector<DisplayConfigurationOutput> lhs_outputs;
+
+    lhs.for_each_card([&lhs_cards](DisplayConfigurationCard const& card) { lhs_cards.emplace_back(card); });
+    lhs.for_each_output([&lhs_outputs](DisplayConfigurationOutput const& output) { lhs_outputs.emplace_back(output); });
+
+    std::vector<DisplayConfigurationCard> rhs_cards;
+    std::vector<DisplayConfigurationOutput> rhs_outputs;
+
+    rhs.for_each_card([&rhs_cards](DisplayConfigurationCard const& card) { rhs_cards.emplace_back(card); });
+    rhs.for_each_output([&rhs_outputs](DisplayConfigurationOutput const& output) { rhs_outputs.emplace_back(output); });
+
+    return lhs_cards == rhs_cards && lhs_outputs == rhs_outputs;
+}
+
+bool mg::operator!=(DisplayConfiguration const& lhs, DisplayConfiguration const& rhs)
+{
+    return !(lhs == rhs);
+}
+
 namespace
 {
 mir::geometry::Rectangle extents_of(
 
=== modified file 'src/platforms/android/client/android_client_platform.cpp'
--- src/platforms/android/client/android_client_platform.cpp	2015-07-21 04:30:03 +0000
+++ src/platforms/android/client/android_client_platform.cpp	2015-11-05 16:01:02 +0000
@@ -24,6 +24,7 @@
 #include "android_client_buffer_factory.h"
 #include "egl_native_surface_interpreter.h"
 
+#include "mir/weak_egl.h"
 #include <EGL/egl.h>
 
 #include <boost/throw_exception.hpp>
@@ -124,19 +125,6 @@
     return buf->anwb();
 }
 
-/*
- * Driver modules get dlopened with RTLD_NOW, meaning that if the below egl
- * functions aren't found in memory the driver fails to load. This would
- * normally prevent software clients (those not linked to libEGL) from
- * successfully loading our client module, but if we mark the undefined
- * egl function symbols as "weak" then their absence is no longer an error,
- * even with RTLD_NOW.
- */
-extern "C" EGLAPI EGLBoolean EGLAPIENTRY
-    eglGetConfigAttrib(EGLDisplay dpy, EGLConfig config,
-                       EGLint attribute, EGLint *value)
-    __attribute__((weak));
-
 MirPixelFormat mcla::AndroidClientPlatform::get_egl_pixel_format(
     EGLDisplay disp, EGLConfig conf) const
 {
@@ -144,7 +132,8 @@
 
     // EGL_KHR_platform_android says this will always work...
     EGLint vis = 0;
-    if (eglGetConfigAttrib(disp, conf, EGL_NATIVE_VISUAL_ID, &vis))
+    mcl::WeakEGL weak;
+    if (weak.eglGetConfigAttrib(disp, conf, EGL_NATIVE_VISUAL_ID, &vis))
         mir_format = mir::graphics::android::to_mir_format(vis);
 
     return mir_format;
 
=== modified file 'src/platforms/common/client/mir/CMakeLists.txt'
--- src/platforms/common/client/mir/CMakeLists.txt	2015-01-19 14:16:46 +0000
+++ src/platforms/common/client/mir/CMakeLists.txt	2015-11-05 16:01:02 +0000
@@ -2,4 +2,5 @@
 
 add_library(client_platform_common OBJECT
   aging_buffer.cpp
+  weak_egl.cpp
 )
 
=== added file 'src/platforms/common/client/mir/weak_egl.cpp'
--- src/platforms/common/client/mir/weak_egl.cpp	1970-01-01 00:00:00 +0000
+++ src/platforms/common/client/mir/weak_egl.cpp	2015-11-05 16:01:02 +0000
@@ -0,0 +1,65 @@
+/*
+ * EGL without any linkage requirements!
+ * ~~~
+ * Copyright © 2015 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Daniel van Vugt <[e-mail]>
+ */
+
+#include "weak_egl.h"
+#include <dlfcn.h>
+
+namespace mir { namespace client {
+
+WeakEGL::WeakEGL()
+    : egl1(nullptr)
+    , pGetConfigAttrib(nullptr)
+{
+}
+
+WeakEGL::~WeakEGL()
+{
+    if (egl1)
+        dlclose(egl1);
+}
+
+EGLBoolean WeakEGL::eglGetConfigAttrib(EGLDisplay dpy, EGLConfig config,
+                                       EGLint attribute, EGLint* value)
+{
+    if (find("eglGetConfigAttrib", (void**)&pGetConfigAttrib))
+        return pGetConfigAttrib(dpy, config, attribute, value);
+    else
+        return EGL_FALSE;
+}
+
+bool WeakEGL::find(char const* name, void** func)
+{
+    if (!*func)
+    {
+        // RTLD_DEFAULT is first choice to support wrappers like MockEGL
+        if (!(*func = dlsym(RTLD_DEFAULT, name)))
+        {
+            // This will work more in real-world situations if the library
+            // is hidden behind an RTLD_LOCAL (e.g. a Qt plugin)
+            if (!egl1)
+                egl1 = dlopen("libEGL.so.1", RTLD_NOLOAD|RTLD_LAZY);
+            if (egl1)
+                *func = dlsym(egl1, name);
+        }
+    }
+    return *func != nullptr;
+}
+
+}} // namespace mir::client
 
=== added file 'src/platforms/common/client/mir/weak_egl.h'
--- src/platforms/common/client/mir/weak_egl.h	1970-01-01 00:00:00 +0000
+++ src/platforms/common/client/mir/weak_egl.h	2015-11-05 16:01:02 +0000
@@ -0,0 +1,47 @@
+/*
+ * EGL without any linkage requirements!
+ * ~~~
+ * Copyright © 2015 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Daniel van Vugt <[e-mail]>
+ */
+
+#ifndef MIR_CLIENT_WEAK_EGL_H_
+#define MIR_CLIENT_WEAK_EGL_H_
+
+#include <EGL/egl.h>
+#include <dlfcn.h>
+
+namespace mir { namespace client {
+
+class WeakEGL
+{
+public:
+    WeakEGL();
+    ~WeakEGL();
+    EGLBoolean eglGetConfigAttrib(EGLDisplay dpy, EGLConfig config,
+                                  EGLint attribute, EGLint* value);
+
+private:
+    bool find(char const* name, void** func);
+
+    void* egl1;
+    EGLBoolean (*pGetConfigAttrib)(EGLDisplay dpy, EGLConfig config,
+                                   EGLint attribute, EGLint* value);
+};
+
+}} // namespace mir::client
+
+#endif // MIR_CLIENT_WEAK_EGL_H_
 
=== modified file 'src/platforms/mesa/CMakeLists.txt'
--- src/platforms/mesa/CMakeLists.txt	2015-09-24 22:30:09 +0000
+++ src/platforms/mesa/CMakeLists.txt	2015-11-05 16:01:02 +0000
@@ -1,6 +1,12 @@
 set(INCLUDEDIR "${CMAKE_INSTALL_PREFIX}/include")
 
 configure_file(
+  ${CMAKE_CURRENT_SOURCE_DIR}/mir-client-platform-mesa-dev.pc.in
+  ${CMAKE_CURRENT_BINARY_DIR}/mir-client-platform-mesa-dev.pc
+  @ONLY
+)
+
+configure_file(
   ${CMAKE_CURRENT_SOURCE_DIR}/mir-client-platform-mesa.pc.in
   ${CMAKE_CURRENT_BINARY_DIR}/mir-client-platform-mesa.pc
   @ONLY
@@ -20,6 +26,9 @@
 )
 
 install(
-  FILES ${CMAKE_CURRENT_BINARY_DIR}/mir-client-platform-mesa.pc
+  FILES
+  ${CMAKE_CURRENT_BINARY_DIR}/mir-client-platform-mesa-dev.pc
+  ${CMAKE_CURRENT_BINARY_DIR}/mir-client-platform-mesa.pc
+
   DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig
 )
 
=== modified file 'src/platforms/mesa/client/client_platform.cpp'
--- src/platforms/mesa/client/client_platform.cpp	2015-07-17 08:08:44 +0000
+++ src/platforms/mesa/client/client_platform.cpp	2015-11-05 16:01:02 +0000
@@ -23,6 +23,7 @@
 #include "native_surface.h"
 #include "mir/client_buffer_factory.h"
 #include "mir/client_context.h"
+#include "mir/weak_egl.h"
 #include "mir_toolkit/mesa/platform_operation.h"
 
 #include <cstring>
@@ -179,19 +180,6 @@
 }
 
 
-/*
- * Driver modules get dlopened with RTLD_NOW, meaning that if the below egl
- * functions aren't found in memory the driver fails to load. This would
- * normally prevent software clients (those not linked to libEGL) from
- * successfully loading our client module, but if we mark the undefined
- * egl function symbols as "weak" then their absence is no longer an error,
- * even with RTLD_NOW.
- */
-extern "C" EGLAPI EGLBoolean EGLAPIENTRY
-    eglGetConfigAttrib(EGLDisplay dpy, EGLConfig config,
-                       EGLint attribute, EGLint *value)
-    __attribute__((weak));
-
 MirPixelFormat mclm::ClientPlatform::get_egl_pixel_format(
     EGLDisplay disp, EGLConfig conf) const
 {
@@ -208,10 +196,11 @@
      * EGL_NATIVE_VISUAL_ID, so ignore that for now.
      */
     EGLint r = 0, g = 0, b = 0, a = 0;
-    eglGetConfigAttrib(disp, conf, EGL_RED_SIZE, &r);
-    eglGetConfigAttrib(disp, conf, EGL_GREEN_SIZE, &g);
-    eglGetConfigAttrib(disp, conf, EGL_BLUE_SIZE, &b);
-    eglGetConfigAttrib(disp, conf, EGL_ALPHA_SIZE, &a);
+    mcl::WeakEGL weak;
+    weak.eglGetConfigAttrib(disp, conf, EGL_RED_SIZE, &r);
+    weak.eglGetConfigAttrib(disp, conf, EGL_GREEN_SIZE, &g);
+    weak.eglGetConfigAttrib(disp, conf, EGL_BLUE_SIZE, &b);
+    weak.eglGetConfigAttrib(disp, conf, EGL_ALPHA_SIZE, &a);
 
     if (r == 8 && g == 8 && b == 8)
     {
 
=== renamed file 'src/platforms/mesa/mir-client-platform-mesa.pc.in' => 'src/platforms/mesa/mir-client-platform-mesa-dev.pc.in'
--- src/platforms/mesa/mir-client-platform-mesa.pc.in	2015-10-07 12:53:33 +0000
+++ src/platforms/mesa/mir-client-platform-mesa-dev.pc.in	2015-11-05 16:01:02 +0000
@@ -1,6 +1,6 @@
 includedir=@INCLUDEDIR@/mirplatform
 
-Name: mir-client-platform-mesa
+Name: mir-client-platform-mesa-dev
 Description: Mir Mesa client platform development files
 Version: @MIR_VERSION@
 Requires.private: mirclient
 
=== added file 'src/platforms/mesa/mir-client-platform-mesa.pc.in'
--- src/platforms/mesa/mir-client-platform-mesa.pc.in	1970-01-01 00:00:00 +0000
+++ src/platforms/mesa/mir-client-platform-mesa.pc.in	2015-11-05 16:01:02 +0000
@@ -0,0 +1,7 @@
+includedir=@INCLUDEDIR@/mirplatform
+
+Name: mir-client-platform-mesa
+Description: Mir Mesa client platform development files
+Version: @MIR_VERSION@
+Requires.private: mirclient
+Cflags: -I${includedir}
 
=== modified file 'src/server/graphics/nested/display.cpp'
--- src/server/graphics/nested/display.cpp	2015-10-06 09:28:48 +0000
+++ src/server/graphics/nested/display.cpp	2015-11-05 16:01:02 +0000
@@ -29,6 +29,9 @@
 #include "mir/graphics/overlapping_output_grouping.h"
 #include "mir/graphics/gl_config.h"
 #include "mir/graphics/egl_error.h"
+#include "mir_toolkit/mir_blob.h"
+#include "mir_toolkit/mir_connection.h"
+#include "mir/raii.h"
 
 #include <boost/throw_exception.hpp>
 #include <stdexcept>
@@ -145,6 +148,20 @@
     return std::chrono::milliseconds::zero();
 }
 
+namespace
+{
+auto copy_config(MirDisplayConfiguration* conf) -> std::shared_ptr<MirDisplayConfiguration>
+{
+    auto const blob = mir::raii::deleter_for(
+        mir_blob_from_display_configuration(conf),
+        [] (MirBlob* b) { mir_blob_release(b); });
+
+    return std::shared_ptr<MirDisplayConfiguration>{
+        mir_blob_to_display_configuration(blob.get()),
+        [] (MirDisplayConfiguration* c) { if (c) mir_display_config_destroy(c); }};
+}
+}
+
 mgn::Display::Display(
     std::shared_ptr<mg::Platform> const& platform,
     std::shared_ptr<HostConnection> const& connection,
@@ -159,10 +176,15 @@
     display_report{display_report},
     egl_display{connection->egl_native_display(), gl_config},
     cursor_listener{cursor_listener},
-    outputs{}
+    outputs{},
+    current_configuration(std::make_unique<NestedDisplayConfiguration>(connection->create_display_config()))
 {
     std::shared_ptr<DisplayConfiguration> conf(configuration());
     initial_conf_policy->apply_to(*conf);
+
+    if (*current_configuration != *conf)
+        apply_to_connection(*conf);
+
     create_surfaces(*conf);
 }
 
@@ -181,8 +203,8 @@
 
 std::unique_ptr<mg::DisplayConfiguration> mgn::Display::configuration() const
 {
-    return std::make_unique<NestedDisplayConfiguration>(
-        connection->create_display_config());
+    std::lock_guard<std::mutex> lock(configuration_mutex);
+    return std::make_unique<NestedDisplayConfiguration>(copy_config(*current_configuration));
 }
 
 void mgn::Display::complete_display_initialization(MirPixelFormat format)
@@ -195,8 +217,12 @@
 
 void mgn::Display::configure(mg::DisplayConfiguration const& configuration)
 {
-    create_surfaces(configuration);
-    apply_to_connection(configuration);
+    std::lock_guard<std::mutex> lock(configuration_mutex);
+    if (*current_configuration != configuration)
+    {
+        apply_to_connection(configuration);
+        create_surfaces(configuration);
+    }
 }
 
 void mgn::Display::create_surfaces(mg::DisplayConfiguration const& configuration)
@@ -254,13 +280,20 @@
     auto const& conf = dynamic_cast<NestedDisplayConfiguration const&>(configuration);
 
     connection->apply_display_config(*conf);
+
+    current_configuration = std::make_unique<NestedDisplayConfiguration>(copy_config(conf));
 }
 
 void mgn::Display::register_configuration_change_handler(
         EventHandlerRegister& /*handlers*/,
         DisplayConfigurationChangeHandler const& conf_change_handler)
 {
-    connection->set_display_config_change_callback(conf_change_handler);
+    auto const handler = [this, conf_change_handler] { 
+        current_configuration = std::make_unique<NestedDisplayConfiguration>(connection->create_display_config());
+        conf_change_handler();
+    };
+
+    connection->set_display_config_change_callback(handler);
 }
 
 void mgn::Display::register_pause_resume_handlers(
 
=== modified file 'src/server/graphics/nested/display.h'
--- src/server/graphics/nested/display.h	2015-08-20 02:44:54 +0000
+++ src/server/graphics/nested/display.h	2015-11-05 16:01:02 +0000
@@ -52,6 +52,8 @@
 
 namespace nested
 {
+class NestedDisplayConfiguration;
+
 namespace detail
 {
 
@@ -151,6 +153,10 @@
 
     std::mutex outputs_mutex;
     std::unordered_map<DisplayConfigurationOutputId, std::shared_ptr<detail::DisplaySyncGroup>> outputs;
+
+    std::mutex mutable configuration_mutex;
+    std::unique_ptr<NestedDisplayConfiguration> current_configuration;
+
     void create_surfaces(mir::graphics::DisplayConfiguration const& configuration);
     void apply_to_connection(mir::graphics::DisplayConfiguration const& configuration);
     void complete_display_initialization(MirPixelFormat format);
 
=== modified file 'src/server/input/display_input_region.cpp'
--- src/server/input/display_input_region.cpp	2015-09-24 02:16:12 +0000
+++ src/server/input/display_input_region.cpp	2015-11-05 16:01:02 +0000
@@ -51,7 +51,10 @@
     // to group a touchscreen with a display. So for now, just return the view area
     // of the first display, as that matches the most common systems (laptops with touchscreens,
     // phone/tablets with touchscreens).
-    return *rectangles.begin();
+    if (rectangles.size() != 0)
+        return *rectangles.begin();
+    else
+        return geom::Rectangle{};
 }
 
 void mi::DisplayInputRegion::confine(geom::Point& point)
 
=== modified file 'src/server/scene/rendering_tracker.cpp'
--- src/server/scene/rendering_tracker.cpp	2015-02-22 07:46:25 +0000
+++ src/server/scene/rendering_tracker.cpp	2015-11-05 16:01:02 +0000
@@ -68,6 +68,18 @@
         configure_visibility(mir_surface_visibility_occluded);
 }
 
+bool ms::RenderingTracker::is_exposed_in(mc::CompositorID cid) const
+{
+    std::lock_guard<std::mutex> lock{guard};
+
+    ensure_is_active_compositor(cid);
+
+    if (occlusions.size() == 0)
+        return true;
+
+    return occlusions.find(cid) == occlusions.end();
+}
+
 bool ms::RenderingTracker::occluded_in_all_active_compositors()
 {
     return occlusions == active_compositors_;
 
=== modified file 'src/server/scene/rendering_tracker.h'
--- src/server/scene/rendering_tracker.h	2015-02-22 07:46:25 +0000
+++ src/server/scene/rendering_tracker.h	2015-11-05 16:01:02 +0000
@@ -42,6 +42,7 @@
     void rendered_in(compositor::CompositorID cid);
     void occluded_in(compositor::CompositorID cid);
     void active_compositors(std::set<compositor::CompositorID> const& cids);
+    bool is_exposed_in(compositor::CompositorID cid) const;
 
 private:
     bool occluded_in_all_active_compositors();
@@ -52,7 +53,7 @@
     std::weak_ptr<Surface> const weak_surface;
     std::set<compositor::CompositorID> occlusions;
     std::set<compositor::CompositorID> active_compositors_;
-    std::mutex guard;
+    std::mutex mutable guard;
 };
 
 }
 
=== modified file 'src/server/scene/surface_stack.cpp'
--- src/server/scene/surface_stack.cpp	2015-06-18 02:46:16 +0000
+++ src/server/scene/surface_stack.cpp	2015-11-05 16:01:02 +0000
@@ -168,15 +168,18 @@
             // TODO: Rename mir_surface_attrib_visibility as it's obviously
             //       confusing with visible()
             if (surface->visible() &&
-                surface->query(mir_surface_attrib_visibility) ==
-                    mir_surface_visibility_exposed)
+                surface->query(mir_surface_attrib_visibility) == mir_surface_visibility_exposed)
             {
-                // Note that we ask the surface and not a Renderable.
-                // This is because we don't want to waste time and resources
-                // on a snapshot till we're sure we need it...
-                int ready = surface->buffers_ready_for_compositor(id);
-                if (ready > result)
-                    result = ready;
+                auto const tracker = rendering_trackers.find(surface.get());
+                if (tracker != rendering_trackers.end() && tracker->second->is_exposed_in(id))
+                {
+                    // Note that we ask the surface and not a Renderable.
+                    // This is because we don't want to waste time and resources
+                    // on a snapshot till we're sure we need it...
+                    int ready = surface->buffers_ready_for_compositor(id);
+                    if (ready > result)
+                        result = ready;
+                }
             }
         }
     }
 
=== modified file 'tests/acceptance-tests/test_nested_mir.cpp'
--- tests/acceptance-tests/test_nested_mir.cpp	2015-10-07 17:08:36 +0000
+++ tests/acceptance-tests/test_nested_mir.cpp	2015-11-05 16:01:02 +0000
@@ -22,12 +22,14 @@
 #include "mir/input/cursor_images.h"
 #include "mir/graphics/display.h"
 #include "mir/graphics/display_configuration.h"
+#include "mir/graphics/display_configuration_policy.h"
 #include "mir/graphics/display_configuration_report.h"
 #include "mir/input/cursor_listener.h"
 #include "mir/cached_ptr.h"
 #include "mir/main_loop.h"
 #include "mir/scene/session_coordinator.h"
 #include "mir/scene/session.h"
+#include "mir/shell/display_configuration_controller.h"
 #include "mir/shell/host_lifecycle_event_listener.h"
 
 #include "mir_test_framework/headless_in_process_server.h"
@@ -183,10 +185,41 @@
     bool hidden{false};
 };
 
+struct MockDisplayConfigurationPolicy : mg::DisplayConfigurationPolicy
+{
+    MOCK_METHOD1(apply_to, void (mg::DisplayConfiguration&));
+};
+
 class NestedMirRunner : public mtf::HeadlessNestedServerRunner
 {
 public:
     NestedMirRunner(std::string const& connection_string)
+        : NestedMirRunner(connection_string, true)
+    {
+        start_server();
+    }
+
+    virtual ~NestedMirRunner()
+    {
+        stop_server();
+    }
+
+    std::shared_ptr<MockHostLifecycleEventListener> the_mock_host_lifecycle_event_listener()
+    {
+        return mock_host_lifecycle_event_listener([]
+            { return std::make_shared<NiceMock<MockHostLifecycleEventListener>>(); });
+    }
+
+    std::shared_ptr<CursorWrapper> cursor_wrapper;
+
+    virtual std::shared_ptr<MockDisplayConfigurationPolicy> mock_display_configuration_policy()
+    {
+        return mock_display_configuration_policy_([this]
+            { return std::make_shared<NiceMock<MockDisplayConfigurationPolicy>>(); });
+    }
+
+protected:
+    NestedMirRunner(std::string const& connection_string, bool)
         : mtf::HeadlessNestedServerRunner(connection_string)
     {
         server.override_the_host_lifecycle_event_listener([this]
@@ -197,24 +230,15 @@
 
         server.override_the_cursor_images([] { return std::make_shared<CursorImages>(); });
 
-        start_server();
-    }
-
-    ~NestedMirRunner()
-    {
-        stop_server();
-    }
-
-    std::shared_ptr<MockHostLifecycleEventListener> the_mock_host_lifecycle_event_listener()
-    {
-        return mock_host_lifecycle_event_listener([]
-            { return std::make_shared<NiceMock<MockHostLifecycleEventListener>>(); });
-    }
-
-    std::shared_ptr<CursorWrapper> cursor_wrapper;
+        server.wrap_display_configuration_policy([this]
+            (std::shared_ptr<mg::DisplayConfigurationPolicy> const&)
+            { return mock_display_configuration_policy(); });
+    }
 
 private:
     mir::CachedPtr<MockHostLifecycleEventListener> mock_host_lifecycle_event_listener;
+    
+    mir::CachedPtr<MockDisplayConfigurationPolicy> mock_display_configuration_policy_;
 };
 
 struct NestedServer : mtf::HeadlessInProcessServer
@@ -376,6 +400,7 @@
     // No post on surface creation
     EXPECT_CALL(*mock_session_mediator_report, session_submit_buffer_called(_)).Times(0);
     NestedMirRunner nested_mir{new_connection()};
+
     auto const connection = mir_connect_sync(nested_mir.new_connection().c_str(), __PRETTY_FUNCTION__);
     auto const surface = mtf::make_any_surface(connection);
 
@@ -692,3 +717,72 @@
     // surface as the host cursor then reverts to default.
     Mock::VerifyAndClearExpectations(mock_cursor.get());
 }
+
+TEST_F(NestedServer, applies_display_config_on_startup)
+{
+    mt::WaitCondition condition;
+
+    auto const expected_config = server.the_display()->configuration();
+    expected_config->for_each_output([](mg::UserDisplayConfigurationOutput& output)
+        { output.orientation = mir_orientation_inverted;});
+
+    EXPECT_CALL(*the_mock_display_configuration_report(), new_configuration(mt::DisplayConfigMatches(std::ref(*expected_config))))
+        .WillRepeatedly(InvokeWithoutArgs([&] { condition.wake_up_everyone(); }));
+
+    struct MyNestedMirRunner : NestedMirRunner
+    {
+        MyNestedMirRunner(std::string const& connection_string) :
+            NestedMirRunner(connection_string, true)
+        {
+            start_server();
+        }
+
+        std::shared_ptr<MockDisplayConfigurationPolicy> mock_display_configuration_policy() override
+        {
+            auto result = std::make_unique<MockDisplayConfigurationPolicy>();
+            EXPECT_CALL(*result, apply_to(_)).Times(AnyNumber())
+                .WillOnce(Invoke([](mg::DisplayConfiguration& config)
+                     {
+                        config.for_each_output([](mg::UserDisplayConfigurationOutput& output)
+                            { output.orientation = mir_orientation_inverted; });
+                     }));
+
+            return std::shared_ptr<MockDisplayConfigurationPolicy>(std::move(result));
+        }
+    } nested_mir{new_connection()};
+
+    auto const connection = mir_connect_sync(nested_mir.new_connection().c_str(), __PRETTY_FUNCTION__);
+    auto const surface = make_and_paint_surface(connection);
+
+    condition.wait_for_at_most_seconds(1);
+    Mock::VerifyAndClearExpectations(the_mock_display_configuration_report().get());
+
+    EXPECT_TRUE(condition.woken());
+
+    mir_surface_release_sync(surface);
+    mir_connection_release(connection);
+}
+
+TEST_F(NestedServer, base_configuration_change_in_host_is_seen_in_nested)
+{
+    NestedMirRunner nested_mir{new_connection()};
+    auto const connection = mir_connect_sync(nested_mir.new_connection().c_str(), __PRETTY_FUNCTION__);
+    auto const surface = make_and_paint_surface(connection);
+    auto const config_policy = nested_mir.mock_display_configuration_policy();
+    std::shared_ptr<mg::DisplayConfiguration> const new_config{server.the_display()->configuration()};
+    new_config->for_each_output([](mg::UserDisplayConfigurationOutput& output)
+                                    { output.orientation = mir_orientation_inverted;});
+
+    mt::WaitCondition condition;
+    EXPECT_CALL(*config_policy, apply_to(mt::DisplayConfigMatches(std::ref(*new_config))))
+        .WillOnce(InvokeWithoutArgs([&] { condition.wake_up_everyone(); }));
+
+    server.the_display_configuration_controller()->set_default_display_configuration(new_config);
+
+    condition.wait_for_at_most_seconds(1);
+    Mock::VerifyAndClearExpectations(config_policy.get());
+    EXPECT_TRUE(condition.woken());
+
+    mir_surface_release_sync(surface);
+    mir_connection_release(connection);
+}
 
=== modified file 'tests/unit-tests/input/test_display_input_region.cpp'
--- tests/unit-tests/input/test_display_input_region.cpp	2015-09-24 02:16:12 +0000
+++ tests/unit-tests/input/test_display_input_region.cpp	2015-11-05 16:01:02 +0000
@@ -80,3 +80,14 @@
     }
 
 }
+
+TEST(DisplayInputRegionTest, returns_empty_bounding_rectangle_when_there_are_no_outputs)
+{
+    geom::Rectangle const empty_rect{};
+    auto const stub_display = std::make_shared<mtd::StubDisplay>(0);
+
+    mi::DisplayInputRegion input_region{stub_display};
+
+    auto const bounding_rect = input_region.bounding_rectangle();
+    EXPECT_EQ(empty_rect, bounding_rect);
+}
 
=== modified file 'tests/unit-tests/scene/test_surface_stack.cpp'
--- tests/unit-tests/scene/test_surface_stack.cpp	2015-06-26 08:00:59 +0000
+++ tests/unit-tests/scene/test_surface_stack.cpp	2015-11-05 16:01:02 +0000
@@ -339,6 +339,7 @@
 {
     using namespace testing;
     ms::SurfaceStack stack{report};
+    stack.register_compositor(this);
     mtd::StubBuffer stub_buffer;
     int ready = 0;
     auto mock_queue = std::make_shared<testing::NiceMock<mtd::MockBufferBundle>>();
@@ -384,6 +385,7 @@
     using namespace testing;
 
     ms::SurfaceStack stack{report};
+    stack.register_compositor(this);
     auto surface = std::make_shared<ms::BasicSurface>(
         std::string("stub"),
         geom::Rectangle{{},{}},
@@ -405,6 +407,48 @@
     EXPECT_EQ(0, stack.frames_pending(this));
 }
 
+TEST_F(SurfaceStack, scene_doesnt_count_pending_frames_from_partially_exposed_surfaces)
+{  // Regression test for LP: #1499039
+    using namespace testing;
+
+    // Partially exposed means occluded in one compositor but not another
+    ms::SurfaceStack stack{report};
+    auto const comp1 = reinterpret_cast<mc::CompositorID>(0);
+    auto const comp2 = reinterpret_cast<mc::CompositorID>(1);
+
+    stack.register_compositor(comp1);
+    stack.register_compositor(comp2);
+    auto surface = std::make_shared<ms::BasicSurface>(
+        std::string("stub"),
+        geom::Rectangle{{},{}},
+        false,
+        std::make_shared<mtd::StubBufferStream>(),
+        std::shared_ptr<mir::input::InputChannel>(),
+        std::shared_ptr<mir::input::InputSender>(),
+        std::shared_ptr<mg::CursorImage>(),
+        report);
+
+    stack.add_surface(surface, default_params.depth, default_params.input_mode);
+    post_a_frame(*surface);
+    post_a_frame(*surface);
+    post_a_frame(*surface);
+
+    EXPECT_EQ(3, stack.frames_pending(comp2));
+    auto elements = stack.scene_elements_for(comp1);
+    for (auto const& elem : elements)
+    {
+        elem->rendered();
+    }
+
+    elements = stack.scene_elements_for(comp2);
+    for (auto const& elem : elements)
+    {
+        elem->occluded();
+    }
+
+    EXPECT_EQ(0, stack.frames_pending(comp2));
+}
+
 TEST_F(SurfaceStack, surfaces_are_emitted_by_layer)
 {
     using namespace testing;