← Back to branch summary

~ubuntu-branches/ubuntu/wily/mir/wily-proposed

« back to all changes in this revision

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

  • Committer: Package Import Robot
  • Author(s): Ubuntu daily release
  • Date: 2014-10-10 14:01:26 UTC
  • mto: This revision was merged to the branch mainline in revision 84.
  • Revision ID: package-import@ubuntu.com-20141010140126-n1czko8na1kuz4ll
Tags: upstream-0.8.0+14.10.20141010
Import upstream version 0.8.0+14.10.20141010

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/server/frontend/session_mediator.cpp
70
70
    std::vector<MirPixelFormat> const& surface_pixel_formats,
71
71
    std::shared_ptr<SessionMediatorReport> const& report,
72
72
    std::shared_ptr<EventSink> const& sender,
73
 
    std::shared_ptr<ResourceCache> const& resource_cache,
 
73
    std::shared_ptr<MessageResourceCache> const& resource_cache,
74
74
    std::shared_ptr<Screencast> const& screencast,
75
75
    ConnectionContext const& connection_context,
76
76
    std::shared_ptr<mi::CursorImages> const& cursor_images) :
77
77
    client_pid_(0),
78
78
    shell(shell),
79
79
    graphics_platform(graphics_platform),
 
80
    ipc_operations(graphics_platform->make_ipc_operations()),
80
81
    surface_pixel_formats(surface_pixel_formats),
81
82
    display_changer(display_changer),
82
83
    report(report),
118
119
    }
119
120
    connection_context.handle_client_connect(session);
120
121
 
121
 
    auto ipc_package = graphics_platform->get_ipc_package();
 
122
    auto ipc_package = ipc_operations->connection_ipc_package();
122
123
    auto platform = response->mutable_platform();
123
124
 
124
125
    for (auto& data : ipc_package->ipc_data)
144
145
    Surface& surface,
145
146
    std::function<void(graphics::Buffer*, graphics::BufferIpcMsgType)> complete)
146
147
{
147
 
    surface.swap_buffers( 
148
 
        surface_tracker.last_buffer(surf_id),
 
148
    auto client_buffer = surface_tracker.last_buffer(surf_id);
 
149
    if (client_buffer)
 
150
    {
 
151
        //TODO: once we are doing an exchange_buffer, we should use the request buffer
 
152
        static mir::protobuf::Buffer dummy_raw_msg;
 
153
        mfd::ProtobufBufferPacker dummy_msg{&dummy_raw_msg};
 
154
        ipc_operations->unpack_buffer(dummy_msg, *client_buffer);
 
155
    }
 
156
 
 
157
    surface.swap_buffers(
 
158
        client_buffer, 
149
159
        [this, surf_id, complete](mg::Buffer* new_buffer)
150
160
        {
151
161
            if (surface_tracker.track_buffer(surf_id, new_buffer))
155
165
        });
156
166
}
157
167
 
158
 
 
159
168
void mf::SessionMediator::create_surface(
160
169
    google::protobuf::RpcController* /*controller*/,
161
170
    const mir::protobuf::SurfaceParameters* request,
248
257
        });
249
258
}
250
259
 
 
260
void mf::SessionMediator::exchange_buffer(
 
261
    google::protobuf::RpcController*,
 
262
    mir::protobuf::BufferRequest const* request,
 
263
    mir::protobuf::Buffer* response,
 
264
    google::protobuf::Closure* done)
 
265
{
 
266
    mf::SurfaceId const surface_id{request->id().value()};
 
267
    mg::BufferID const buffer_id{static_cast<uint32_t>(request->buffer().buffer_id())};
 
268
 
 
269
    auto const lock = std::make_shared<std::unique_lock<std::mutex>>(session_mutex);
 
270
    auto const session = weak_session.lock();
 
271
    if (!session)
 
272
        BOOST_THROW_EXCEPTION(std::logic_error("Invalid application session"));
 
273
 
 
274
    report->session_exchange_buffer_called(session->name());
 
275
 
 
276
    auto const& surface = session->get_surface(surface_id);
 
277
    surface->swap_buffers(
 
278
        surface_tracker.buffer_from(buffer_id),
 
279
        [this, surface_id, lock, response, done](mg::Buffer* new_buffer)
 
280
        {
 
281
            lock->unlock();
 
282
 
 
283
            if (surface_tracker.track_buffer(surface_id, new_buffer))
 
284
                pack_protobuf_buffer(*response, new_buffer, mg::BufferIpcMsgType::update_msg);
 
285
            else
 
286
                pack_protobuf_buffer(*response, new_buffer, mg::BufferIpcMsgType::full_msg);
 
287
 
 
288
            done->Run();
 
289
        });
 
290
}
 
291
 
251
292
void mf::SessionMediator::release_surface(
252
293
    google::protobuf::RpcController* /*controller*/,
253
294
    const mir::protobuf::SurfaceId* request,
527
568
    }
528
569
 
529
570
    auto const magic = static_cast<unsigned int>(request->magic());
 
571
    //FIXME: don't dynamic cast like this drm_auth_magic should be a part of PlatformIpcOperations 
530
572
    auto authenticator = std::dynamic_pointer_cast<mg::DRMAuthenticator>(graphics_platform);
531
573
    if (!authenticator)
532
574
        BOOST_THROW_EXCEPTION(std::logic_error("drm_auth_magic request not supported by the active platform"));
609
651
{
610
652
    protobuf_buffer.set_buffer_id(graphics_buffer->id().as_value());
611
653
 
612
 
    mfd::ProtobufBufferPacker packer{&protobuf_buffer, resource_cache};
613
 
    graphics_platform->fill_buffer_package(&packer, graphics_buffer, buffer_msg_type);
 
654
    mfd::ProtobufBufferPacker packer{&protobuf_buffer};
 
655
    ipc_operations->pack_buffer(packer, *graphics_buffer, buffer_msg_type);
 
656
 
 
657
    for(auto const& fd : packer.fds())
 
658
        resource_cache->save_fd(&protobuf_buffer, fd);
614
659
}