← Back to branch summary

~brandontschaefer/mir/first-round-deprecation

« back to all changes in this revision

Viewing changes to src/server/frontend/session_mediator.cpp

  • Committer: Brandon Schaefer
  • Date: 2016-12-13 17:59:30 UTC
  • mfrom: (3787.1.93 development-branch)
  • Revision ID: brandon.schaefer@canonical.com-20161213175930-j9o7qn0b11n3kzlm
* Merge trunk, fix conflicts

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/server/frontend/session_mediator.cpp
20
20
#include "reordering_message_sender.h"
21
21
#include "event_sink_factory.h"
22
22
 
23
 
#include "mir/frontend/session_mediator_report.h"
 
23
#include "mir/frontend/session_mediator_observer.h"
24
24
#include "mir/frontend/shell.h"
25
25
#include "mir/frontend/session.h"
26
26
#include "mir/frontend/surface.h"
56
56
 
57
57
#include "mir/geometry/rectangles.h"
58
58
#include "protobuf_buffer_packer.h"
 
59
#include "protobuf_input_converter.h"
59
60
 
60
61
#include "mir_toolkit/client_types.h"
61
62
 
78
79
 
79
80
namespace
80
81
{
 
82
//TODO: accept other pixel format types
 
83
void throw_if_unsuitable_for_cursor(mf::BufferStream& stream)
 
84
{
 
85
    if (stream.pixel_format() != mir_pixel_format_argb_8888)
 
86
        BOOST_THROW_EXCEPTION(std::logic_error("Only argb8888 buffer streams may currently be attached to the cursor"));
 
87
}
 
88
 
81
89
mg::GammaCurve convert_string_to_gamma_curve(std::string const& str_bytes)
82
90
{
83
91
    mg::GammaCurve out(str_bytes.size() / (sizeof(mg::GammaCurve::value_type) / sizeof(char)));
91
99
    std::shared_ptr<mg::PlatformIpcOperations> const& ipc_operations,
92
100
    std::shared_ptr<mf::DisplayChanger> const& display_changer,
93
101
    std::vector<MirPixelFormat> const& surface_pixel_formats,
94
 
    std::shared_ptr<SessionMediatorReport> const& report,
 
102
    std::shared_ptr<SessionMediatorObserver> const& observer,
95
103
    std::shared_ptr<mf::EventSinkFactory> const& sink_factory,
96
104
    std::shared_ptr<mf::MessageSender> const& message_sender,
97
105
    std::shared_ptr<MessageResourceCache> const& resource_cache,
107
115
    ipc_operations(ipc_operations),
108
116
    surface_pixel_formats(surface_pixel_formats),
109
117
    display_changer(display_changer),
110
 
    report(report),
 
118
    observer(observer),
111
119
    sink_factory{sink_factory},
112
120
    event_sink{sink_factory->create_sink(message_sender)},
113
121
    message_sender{message_sender},
126
134
{
127
135
    if (auto session = weak_session.lock())
128
136
    {
129
 
        report->session_error(session->name(), __PRETTY_FUNCTION__, "connection dropped without disconnect");
 
137
        observer->session_error(session->name(), __PRETTY_FUNCTION__, "connection dropped without disconnect");
130
138
        shell->close_session(session);
131
139
    }
132
140
    destroy_screencast_sessions();
142
150
    ::mir::protobuf::Connection* response,
143
151
    ::google::protobuf::Closure* done)
144
152
{
145
 
    report->session_connect_called(request->application_name());
 
153
    observer->session_connect_called(request->application_name());
146
154
 
147
155
    auto const session = shell->open_session(client_pid_, request->application_name(), event_sink);
148
156
    weak_session = session;
172
180
    auto protobuf_config = response->mutable_display_configuration();
173
181
    mfd::pack_protobuf_display_configuration(*protobuf_config, *display_config);
174
182
 
 
183
    auto input_devices = response->mutable_input_devices();
175
184
    hub->for_each_input_device(
176
 
        [response](auto const& dev)
 
185
        [input_devices](auto const& dev)
177
186
        {
178
 
            auto dev_info = response->add_input_devices();
179
 
            dev_info->set_name(dev.name());
180
 
            dev_info->set_id(dev.id());
181
 
            dev_info->set_unique_id(dev.unique_id());
182
 
            dev_info->set_capabilities(dev.capabilities().value());
 
187
            auto dev_info = input_devices->add_device_info();
 
188
            detail::pack_protobuf_input_device_info(*dev_info, dev);
183
189
        });
184
190
 
185
191
    for (auto pf : surface_pixel_formats)
221
227
    if (session.get() == nullptr)
222
228
        BOOST_THROW_EXCEPTION(std::logic_error("Invalid application session"));
223
229
 
224
 
    report->session_create_surface_called(session->name());
 
230
    observer->session_create_surface_called(session->name());
225
231
 
226
232
    auto params = ms::SurfaceCreationParameters()
227
233
        .of_size(request->width(), request->height())
372
378
{
373
379
    auto const session = weak_session.lock();
374
380
    if (!session) BOOST_THROW_EXCEPTION(std::logic_error("Invalid application session"));
375
 
    report->session_submit_buffer_called(session->name());
 
381
    observer->session_submit_buffer_called(session->name());
376
382
    
377
383
    mf::BufferStreamId const stream_id{request->id().value()};
378
384
    mg::BufferID const buffer_id{static_cast<uint32_t>(request->buffer().buffer_id())};
382
388
    auto b = session->get_buffer(buffer_id);
383
389
    ipc_operations->unpack_buffer(request_msg, *b);
384
390
 
385
 
    stream->swap_buffers(b.get(), [](mg::Buffer*) {});
 
391
    stream->submit_buffer(b);
386
392
 
387
393
    done->Run();
388
394
}
396
402
    if (!session)
397
403
        BOOST_THROW_EXCEPTION(std::logic_error("Invalid application session"));
398
404
 
399
 
    report->session_allocate_buffers_called(session->name());
 
405
    observer->session_allocate_buffers_called(session->name());
400
406
    for (auto i = 0; i < request->buffer_requests().size(); i++)
401
407
    {
402
408
        auto const& req = request->buffer_requests(i);
424
430
    if (!session)
425
431
        BOOST_THROW_EXCEPTION(std::logic_error("Invalid application session"));
426
432
 
427
 
    report->session_release_buffers_called(session->name());
 
433
    observer->session_release_buffers_called(session->name());
428
434
    if (request->has_id())
429
435
    {
430
436
        auto stream_id = mf::BufferStreamId{request->id().value()};
459
465
    if (session.get() == nullptr)
460
466
        BOOST_THROW_EXCEPTION(std::logic_error("Invalid application session"));
461
467
 
462
 
    report->session_release_surface_called(session->name());
 
468
    observer->session_release_surface_called(session->name());
463
469
 
464
470
    auto const id = SurfaceId(request->value());
465
471
 
487
493
        if (session.get() == nullptr)
488
494
            BOOST_THROW_EXCEPTION(std::logic_error("Invalid application session"));
489
495
 
490
 
        report->session_disconnect_called(session->name());
 
496
        observer->session_disconnect_called(session->name());
491
497
 
492
498
        shell->close_session(session);
493
499
        destroy_screencast_sessions();
513
519
    if (session.get() == nullptr)
514
520
        BOOST_THROW_EXCEPTION(std::logic_error("Invalid application session"));
515
521
 
516
 
    report->session_configure_surface_called(session->name());
 
522
    observer->session_configure_surface_called(session->name());
517
523
 
518
524
    auto const id = mf::SurfaceId(request->surfaceid().value());
519
525
    int value = request->ivalue();
615
621
            surface_specification.max_aspect().height()
616
622
        };
617
623
 
 
624
    if (surface_specification.has_cursor_name())
 
625
    {
 
626
        mods.cursor_image = cursor_images->image(surface_specification.cursor_name(), mi::default_cursor_size);
 
627
    }
 
628
 
 
629
    if (surface_specification.has_cursor_id() &&
 
630
        surface_specification.has_hotspot_x() &&
 
631
        surface_specification.has_hotspot_y())
 
632
    {
 
633
        mf::BufferStreamId id{surface_specification.cursor_id().value()};
 
634
        throw_if_unsuitable_for_cursor(*session->get_buffer_stream(id));
 
635
        mods.stream_cursor = msh::StreamCursor{
 
636
            id, geom::Displacement{surface_specification.hotspot_x(), surface_specification.hotspot_y()} }; 
 
637
    }
 
638
 
618
639
    mods.input_shape = extract_input_shape_from(&surface_specification);
619
640
 
620
641
    auto const id = mf::SurfaceId(request->surface_id().value());
634
655
    if (session.get() == nullptr)
635
656
        BOOST_THROW_EXCEPTION(std::logic_error("Invalid application session"));
636
657
 
637
 
    report->session_configure_display_called(session->name());
 
658
    observer->session_configure_display_called(session->name());
638
659
 
639
660
    auto const config = unpack_and_sanitize_display_configuration(request);
640
661
    display_changer->configure(session, config);
655
676
    if (session.get() == nullptr)
656
677
        BOOST_THROW_EXCEPTION(std::logic_error("Invalid application session"));
657
678
 
658
 
    report->session_set_base_display_configuration_called(session->name());
 
679
    observer->session_set_base_display_configuration_called(session->name());
659
680
 
660
681
    auto const config = unpack_and_sanitize_display_configuration(request);
661
682
    display_changer->set_base_configuration(config);
673
694
    if (session.get() == nullptr)
674
695
        BOOST_THROW_EXCEPTION(std::logic_error("Invalid application session"));
675
696
 
676
 
    report->session_preview_base_display_configuration_called(session->name());
 
697
    observer->session_preview_base_display_configuration_called(session->name());
677
698
 
678
699
    auto const config = unpack_and_sanitize_display_configuration(&request->configuration());
679
700
    display_changer->preview_base_configuration(
694
715
    if (session.get() == nullptr)
695
716
        BOOST_THROW_EXCEPTION(std::logic_error("Invalid application session"));
696
717
 
697
 
    report->session_confirm_base_display_configuration_called(session->name());
 
718
    observer->session_confirm_base_display_configuration_called(session->name());
698
719
 
699
720
    auto const config = unpack_and_sanitize_display_configuration(request);
700
721
 
797
818
    if (session.get() == nullptr)
798
819
        BOOST_THROW_EXCEPTION(std::logic_error("Invalid application session"));
799
820
 
800
 
    report->session_create_buffer_stream_called(session->name());
 
821
    observer->session_create_buffer_stream_called(session->name());
801
822
    
802
823
    auto const usage = (request->buffer_usage() == mir_buffer_usage_hardware) ?
803
824
        mg::BufferUsage::hardware : mg::BufferUsage::software;
828
849
    if (session.get() == nullptr)
829
850
        BOOST_THROW_EXCEPTION(std::logic_error("Invalid application session"));
830
851
 
831
 
    report->session_release_buffer_stream_called(session->name());
 
852
    observer->session_release_buffer_stream_called(session->name());
832
853
 
833
854
    auto const id = BufferStreamId(request->value());
834
855
 
850
871
    };
851
872
}
852
873
 
853
 
namespace
854
 
{
855
 
void throw_if_unsuitable_for_cursor(mf::BufferStream& stream)
856
 
{
857
 
    if (stream.pixel_format() != mir_pixel_format_argb_8888)
858
 
        BOOST_THROW_EXCEPTION(std::logic_error("Only argb8888 buffer streams may currently be attached to the cursor"));
859
 
}
860
 
}
861
 
 
862
874
void mf::SessionMediator::configure_cursor(
863
875
    mir::protobuf::CursorSetting const* cursor_request,
864
876
    mir::protobuf::Void* /* void_response */,
869
881
    if (session.get() == nullptr)
870
882
        BOOST_THROW_EXCEPTION(std::logic_error("Invalid application session"));
871
883
 
872
 
    report->session_configure_surface_cursor_called(session->name());
 
884
    observer->session_configure_surface_cursor_called(session->name());
873
885
 
874
886
    auto const id = mf::SurfaceId(cursor_request->surfaceid().value());
875
887
    auto const surface = session->get_surface(id);
1008
1020
    ms::PromptSessionCreationParameters parameters;
1009
1021
    parameters.application_pid = request->application_pid();
1010
1022
 
1011
 
    report->session_start_prompt_session_called(session->name(), parameters.application_pid);
 
1023
    observer->session_start_prompt_session_called(session->name(), parameters.application_pid);
1012
1024
 
1013
1025
    weak_prompt_session = shell->start_prompt_session_for(session, parameters);
1014
1026
 
1032
1044
 
1033
1045
    weak_prompt_session.reset();
1034
1046
 
1035
 
    report->session_stop_prompt_session_called(session->name());
 
1047
    observer->session_stop_prompt_session_called(session->name());
1036
1048
 
1037
1049
    shell->stop_prompt_session(prompt_session);
1038
1050