Merge lp:~afrantzis/mir/introduce-c++14 into lp:mir

[Alexandros Frantzis]

Introduce C++14 by using std::make_unique<> in our core code

Introduce C++14 by using std::make_unique<> in our core code

[Andreas Pokorny (andreas-pokorny)]

Should I write needs fixing because you did not replace optional_value with std::optional?

looks good.

review: Approve

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:2324
http://jenkins.qa.ubuntu.com/job/mir-ci/2992/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-vivid-i386-build/1322
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-vivid-amd64-build/1321
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-vivid-touch/1278
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-vivid-amd64-ci/989
        deb: http://jenkins.qa.ubuntu.com/job/mir-vivid-amd64-ci/989/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-vivid-armhf/1278
        deb: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-vivid-armhf/1278/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-runner-mako/4313
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/touch-flash-device/18113

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

review: Approve (continuous-integration)

[Alan Griffiths (alan-griffiths)]

*Needs Discussion*

We need to agree whether using language features that are not available in the LTS is acceptable before landing this. (See related discussion on mir-devel mailing list.)

review: Needs Fixing

[Alan Griffiths (alan-griffiths)]

> *Needs Discussion*
>
> We need to agree whether using language features that are not available in the
> LTS is acceptable before landing this. (See related discussion on mir-devel
> mailing list.)

review: Needs Information

[Alberto Aguirre (albaguirre)]

"Should I write needs fixing because you did not replace optional_value with std::optional?"

Currently mir::optional is part of SurfaceCreationParameters which is public.

std::optional is not in C++14, so I would not want to expose std::experimental::optional in a public interface.

[Alberto Aguirre (albaguirre)]

LGTM.

review: Approve

[Cemil Azizoglu (cemil-azizoglu)]

Let's give everybody a chance to comment, if they feel like it, on supporting C++14 before TAing.

review: Approve

[Robert Carr (robertcarr)]

I have no concerns beyond the outstanding decision on Trusty.

review: Abstain

[Chris Halse Rogers (raof)]

Given the existence of:
https://launchpad.net/~ubuntu-toolchain-r/+archive/ubuntu/test?field.series_filter=trusty

I'm very much in favour.

review: Approve

[Daniel van Vugt (vanvugt)]

As discussed yesterday, I think this is a bad idea.

Here we've gone out of our way to make helping trusty users impossible. Just as soon as I mentioned in the meeting that I was going out of my way to help them.

review: Disapprove

[Alan Griffiths (alan-griffiths)]

> Given the existence of:
> https://launchpad.net/~ubuntu-
> toolchain-r/+archive/ubuntu/test?field.series_filter=trusty
>
> I'm very much in favour.

Works for me

review: Approve

[Cemil Azizoglu (cemil-azizoglu)]

Compiler is one aspect of supporting Trusty and with the PPA Chris pointed out, we seem to be fairly okay in that aspect. I don't see any reason not to move to C++14.

review: Approve

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2015-02-13 06:12:34 +0000
+++ CMakeLists.txt	2015-02-17 12:25:13 +0000
@@ -59,7 +59,7 @@
 set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS "${build_types}")
 
 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -pthread -g -Werror -Wall -pedantic -Wextra -fPIC")
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pthread -g -std=c++0x -Werror -Wall -fno-strict-aliasing -pedantic -Wnon-virtual-dtor -Wextra -fPIC")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pthread -g -std=c++14 -Werror -Wall -fno-strict-aliasing -pedantic -Wnon-virtual-dtor -Wextra -fPIC")
 
 if ("${CMAKE_CXX_COMPILER}" MATCHES "clang")
   set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-return-type-c-linkage -Wno-mismatched-tags")

=== modified file 'src/client/lttng/rpc_report.cpp'
--- src/client/lttng/rpc_report.cpp	2015-01-21 07:34:50 +0000
+++ src/client/lttng/rpc_report.cpp	2015-02-17 12:25:13 +0000
@@ -96,7 +96,7 @@
     google::protobuf::Message const& /*response*/,
     std::vector<Fd> const& fds)
 {
-    std::unique_ptr<int[]> handles{new int[fds.size()]};
+    auto handles = std::make_unique<int[]>(fds.size());
     for (unsigned i = 0 ; i < fds.size() ; ++i)
     {
         handles[i] = fds[i];

=== modified file 'src/client/mir_connection_api.cpp'
--- src/client/mir_connection_api.cpp	2015-02-13 06:12:34 +0000
+++ src/client/mir_connection_api.cpp	2015-02-17 12:25:13 +0000
@@ -77,7 +77,7 @@
 
             auto const conf = configuration(sock);
 
-            std::unique_ptr<MirConnection> connection{new MirConnection(*conf)};
+            auto connection = std::make_unique<MirConnection>(*conf);
             auto const result = connection->connect(name, callback, context);
             connection.release();
             return result;

=== modified file 'src/client/rpc/make_socket_rpc_channel.cpp'
--- src/client/rpc/make_socket_rpc_channel.cpp	2015-01-21 07:34:50 +0000
+++ src/client/rpc/make_socket_rpc_channel.cpp	2015-02-17 12:25:13 +0000
@@ -52,11 +52,11 @@
     if (fd_prefix.is_start_of(name))
     {
         auto const fd = atoi(name.c_str()+fd_prefix.size);
-        transport = std::unique_ptr<mclr::StreamTransport>{new mclr::StreamSocketTransport{mir::Fd{fd}}};
+        transport = std::make_unique<mclr::StreamSocketTransport>(mir::Fd{fd});
     }
     else
     {
-        transport = std::unique_ptr<mclr::StreamTransport>{new mclr::StreamSocketTransport{name}};
+        transport = std::make_unique<mclr::StreamSocketTransport>(name);
     }
     return std::make_shared<MirProtobufRpcChannel>(std::move(transport), map, disp_conf, rpc_report, lifecycle_control, event_sink);
 }

=== modified file 'src/server/compositor/compositing_screencast.cpp'
--- src/server/compositor/compositing_screencast.cpp	2014-10-21 12:40:38 +0000
+++ src/server/compositor/compositing_screencast.cpp	2015-02-17 12:25:13 +0000
@@ -163,8 +163,7 @@
         [&] { gl_context_raw->release_current(); });
 
     auto buffer = buffer_allocator->alloc_buffer(buffer_properties);
-    auto display_buffer = std::unique_ptr<ScreencastDisplayBuffer>(
-        new ScreencastDisplayBuffer{rect, *buffer});
+    auto display_buffer = std::make_unique<ScreencastDisplayBuffer>(rect, *buffer);
     auto db_compositor = db_compositor_factory->create_compositor_for(*display_buffer);
 
     return std::shared_ptr<detail::ScreencastSessionContext>(

=== modified file 'src/server/compositor/default_display_buffer_compositor_factory.cpp'
--- src/server/compositor/default_display_buffer_compositor_factory.cpp	2015-01-21 07:34:50 +0000
+++ src/server/compositor/default_display_buffer_compositor_factory.cpp	2015-02-17 12:25:13 +0000
@@ -42,6 +42,6 @@
     auto dest_alpha = display_buffer.uses_alpha() ?
         DestinationAlpha::generate_from_source : DestinationAlpha::opaque;
     auto renderer = renderer_factory->create_renderer_for(display_buffer.view_area(), dest_alpha);
-    return std::unique_ptr<DisplayBufferCompositor>(
-         new DefaultDisplayBufferCompositor{display_buffer, std::move(renderer), report});
+    return std::make_unique<DefaultDisplayBufferCompositor>(
+         display_buffer, std::move(renderer), report);
 }

=== modified file 'src/server/compositor/gl_renderer_factory.cpp'
--- src/server/compositor/gl_renderer_factory.cpp	2015-01-21 07:34:50 +0000
+++ src/server/compositor/gl_renderer_factory.cpp	2015-02-17 12:25:13 +0000
@@ -30,8 +30,7 @@
 mc::GLRendererFactory::create_renderer_for(geom::Rectangle const& rect,
         DestinationAlpha dest_alpha)
 {
-    auto raw = new GLRenderer(
-        std::unique_ptr<mg::GLTextureCache>(new RecentlyUsedCache()),
+    return std::make_unique<GLRenderer>(
+        std::make_unique<RecentlyUsedCache>(),
         rect, dest_alpha);
-    return std::unique_ptr<mc::Renderer>(raw);
 }

=== modified file 'src/server/compositor/multi_threaded_compositor.cpp'
--- src/server/compositor/multi_threaded_compositor.cpp	2015-01-21 11:20:14 +0000
+++ src/server/compositor/multi_threaded_compositor.cpp	2015-02-17 12:25:13 +0000
@@ -307,8 +307,8 @@
     /* Start the display buffer compositing threads */
     display->for_each_display_buffer([this](mg::DisplayBuffer& buffer)
     {
-        auto thread_functor_raw = new mc::CompositingFunctor{display_buffer_compositor_factory, buffer, scene, report};
-        auto thread_functor = std::unique_ptr<mc::CompositingFunctor>(thread_functor_raw);
+        auto thread_functor = std::make_unique<mc::CompositingFunctor>(
+            display_buffer_compositor_factory, buffer, scene, report);
 
         futures.push_back(thread_pool.run(std::ref(*thread_functor), &buffer));
         thread_functors.push_back(std::move(thread_functor));

=== modified file 'src/server/compositor/timeout_frame_dropping_policy_factory.cpp'
--- src/server/compositor/timeout_frame_dropping_policy_factory.cpp	2015-01-21 07:34:50 +0000
+++ src/server/compositor/timeout_frame_dropping_policy_factory.cpp	2015-02-17 12:25:13 +0000
@@ -91,5 +91,5 @@
 
 std::unique_ptr<mc::FrameDroppingPolicy> mc::TimeoutFrameDroppingPolicyFactory::create_policy(std::function<void ()> drop_frame) const
 {
-    return std::unique_ptr<mc::FrameDroppingPolicy>{new TimeoutFrameDroppingPolicy{timer, timeout, drop_frame}};
+    return std::make_unique<TimeoutFrameDroppingPolicy>(timer, timeout, drop_frame);
 }

=== modified file 'src/server/glib_main_loop.cpp'
--- src/server/glib_main_loop.cpp	2015-01-21 07:34:50 +0000
+++ src/server/glib_main_loop.cpp	2015-02-17 12:25:13 +0000
@@ -253,8 +253,8 @@
             catch (...) { handle_exception(std::current_exception()); }
         };
 
-    return std::unique_ptr<mir::time::Alarm>{
-        new AlarmImpl(main_context, clock, callback_with_exception_handling)};
+    return std::make_unique<AlarmImpl>(
+        main_context, clock, callback_with_exception_handling);
 }
 
 void mir::GLibMainLoop::reprocess_all_sources()

=== modified file 'src/server/graphics/nested/nested_display.cpp'
--- src/server/graphics/nested/nested_display.cpp	2015-02-13 06:12:34 +0000
+++ src/server/graphics/nested/nested_display.cpp	2015-02-17 12:25:13 +0000
@@ -153,11 +153,8 @@
 
 std::unique_ptr<mg::DisplayConfiguration> mgn::NestedDisplay::configuration() const
 {
-    return std::unique_ptr<mg::DisplayConfiguration>(
-        new NestedDisplayConfiguration(
-            connection->create_display_config()
-        )
-    );
+    return std::make_unique<NestedDisplayConfiguration>(
+        connection->create_display_config());
 }
 
 void mgn::NestedDisplay::complete_display_initialization(MirPixelFormat format)
@@ -267,5 +264,5 @@
 
 std::unique_ptr<mg::GLContext> mgn::NestedDisplay::create_gl_context()
 {
-    return std::unique_ptr<mg::GLContext>{new SurfacelessEGLContext(egl_display, EGL_NO_CONTEXT)};
+    return std::make_unique<SurfacelessEGLContext>(egl_display, EGL_NO_CONTEXT);
 }

=== modified file 'src/server/graphics/offscreen/display.cpp'
--- src/server/graphics/offscreen/display.cpp	2015-01-21 07:34:50 +0000
+++ src/server/graphics/offscreen/display.cpp	2015-02-17 12:25:13 +0000
@@ -106,9 +106,8 @@
 std::unique_ptr<mg::DisplayConfiguration> mgo::Display::configuration() const
 {
     std::lock_guard<std::mutex> lock{configuration_mutex};
-    return std::unique_ptr<mg::DisplayConfiguration>(
-        new mgo::DisplayConfiguration(current_display_configuration)
-    );
+    return std::make_unique<mgo::DisplayConfiguration>(
+        current_display_configuration);
 }
 
 void mgo::Display::configure(mg::DisplayConfiguration const& conf)
@@ -165,6 +164,5 @@
 
 std::unique_ptr<mg::GLContext> mgo::Display::create_gl_context()
 {
-    return std::unique_ptr<GLContext>{
-        new SurfacelessEGLContext{egl_display, egl_context_shared}};
+    return std::make_unique<SurfacelessEGLContext>(egl_display, egl_context_shared);
 }

=== modified file 'src/server/graphics/program_factory.cpp'
--- src/server/graphics/program_factory.cpp	2015-01-21 07:34:50 +0000
+++ src/server/graphics/program_factory.cpp	2015-02-17 12:25:13 +0000
@@ -29,12 +29,11 @@
     std::string const& fragment_shader) const
 {
     std::lock_guard<decltype(mutex)> lock(mutex);
-    return std::unique_ptr<mg::GLProgram>(
-        new SimpleGLProgram(vertex_shader.c_str(), fragment_shader.c_str()));
+    return std::make_unique<SimpleGLProgram>(
+        vertex_shader.c_str(), fragment_shader.c_str());
 }
 
 std::unique_ptr<mg::GLTextureCache> mg::ProgramFactory::create_texture_cache() const
 {
-    return std::unique_ptr<mg::GLTextureCache>(
-        new mir::compositor::RecentlyUsedCache());
+    return std::make_unique<mir::compositor::RecentlyUsedCache>();
 }

=== modified file 'src/server/report/default_server_configuration.cpp'
--- src/server/report/default_server_configuration.cpp	2015-02-13 06:12:34 +0000
+++ src/server/report/default_server_configuration.cpp	2015-02-17 12:25:13 +0000
@@ -37,15 +37,15 @@
 
     if (opt == options::log_opt_value)
     {
-        return std::unique_ptr<mir::report::ReportFactory>(new report::LoggingReportFactory(the_logger(), the_clock()));
+        return std::make_unique<report::LoggingReportFactory>(the_logger(), the_clock());
     }
     else if (opt == options::lttng_opt_value)
     {
-        return std::unique_ptr<mir::report::ReportFactory>(new report::LttngReportFactory());
+        return std::make_unique<report::LttngReportFactory>();
     }
     else if (opt == options::off_opt_value)
     {
-        return std::unique_ptr<mir::report::ReportFactory>(new report::NullReportFactory());
+        return std::make_unique<report::NullReportFactory>();
     }
     else
     {

=== modified file 'src/server/scene/basic_surface.cpp'
--- src/server/scene/basic_surface.cpp	2015-02-03 15:07:44 +0000
+++ src/server/scene/basic_surface.cpp	2015-02-17 12:25:13 +0000
@@ -722,15 +722,14 @@
 {
     std::unique_lock<std::mutex> lk(guard);
 
-    return std::unique_ptr<mg::Renderable>(
-        new SurfaceSnapshot(
-            surface_buffer_stream,
-            compositor_id,
-            surface_rect,
-            transformation_matrix,
-            surface_alpha,
-            nonrectangular, 
-            this));
+    return std::make_unique<SurfaceSnapshot>(
+        surface_buffer_stream,
+        compositor_id,
+        surface_rect,
+        transformation_matrix,
+        surface_alpha,
+        nonrectangular,
+        this);
 }
 
 int ms::BasicSurface::buffers_ready_for_compositor(void const* id) const

=== modified file 'src/server/server.cpp'
--- src/server/server.cpp	2015-02-13 06:12:34 +0000
+++ src/server/server.cpp	2015-02-17 12:25:13 +0000
@@ -173,7 +173,7 @@
     auto create_renderer_for(mir::geometry::Rectangle const&, mir::compositor::DestinationAlpha)
     -> std::unique_ptr<mir::compositor::Renderer>
     {
-        return std::unique_ptr<mir::compositor::Renderer>(new StubRenderer());
+        return std::make_unique<StubRenderer>();
     }
 };
 }

=== modified file 'src/server/thread/basic_thread_pool.cpp'
--- src/server/thread/basic_thread_pool.cpp	2015-01-21 07:34:50 +0000
+++ src/server/thread/basic_thread_pool.cpp	2015-02-17 12:25:13 +0000
@@ -204,7 +204,7 @@
     if (worker_thread == nullptr)
     {
         // No idle threads available so create a new one
-        std::unique_ptr<WorkerThread> new_worker_thread{new WorkerThread{id}};
+        auto new_worker_thread = std::make_unique<WorkerThread>(id);
         threads.push_back(std::move(new_worker_thread));
         worker_thread = threads.back().get();
     }