1
=== modified file 'include/server/mir/shell/application_session.h'
2
--- include/server/mir/shell/application_session.h	2013-08-28 03:41:48 +0000
3
+++ include/server/mir/shell/application_session.h	2013-09-26 22:16:32 +0000
4
@@ -67,6 +67,9 @@
5
67
67
6
68
    void set_lifecycle_state(MirLifecycleState state);
68
    void set_lifecycle_state(MirLifecycleState state);
7
69
69
8
70
    void receive_focus(std::shared_ptr<InputTargeter> const& targeter, std::shared_ptr<SurfaceController> const& controller);
9
71
    void relinquish_focus();
10
72
11
70
protected:
73
protected:
12
71
    ApplicationSession(ApplicationSession const&) = delete;
74
    ApplicationSession(ApplicationSession const&) = delete;
13
72
    ApplicationSession& operator=(ApplicationSession const&) = delete;
75
    ApplicationSession& operator=(ApplicationSession const&) = delete;
14
@@ -79,6 +82,7 @@
15
79
    std::shared_ptr<frontend::EventSink> const event_sink;
82
    std::shared_ptr<frontend::EventSink> const event_sink;
16
80
83
17
81
    frontend::SurfaceId next_id();
84
    frontend::SurfaceId next_id();
18
85
    std::shared_ptr<Surface> default_surface_locked(std::unique_lock<std::mutex> const& lock) const;
19
82
86
20
83
    std::atomic<int> next_surface_id;
87
    std::atomic<int> next_surface_id;
21
84
88
22
@@ -86,6 +90,8 @@
23
86
    Surfaces::const_iterator checked_find(frontend::SurfaceId id) const;
90
    Surfaces::const_iterator checked_find(frontend::SurfaceId id) const;
24
87
    std::mutex mutable surfaces_mutex;
91
    std::mutex mutable surfaces_mutex;
25
88
    Surfaces surfaces;
92
    Surfaces surfaces;
26
93
    
27
94
    std::weak_ptr<Surface> last_focused_surface;
28
89
};
95
};
29
90
96
30
91
}
97
}
31
92
98
32
=== modified file 'include/server/mir/shell/default_focus_mechanism.h'
33
--- include/server/mir/shell/default_focus_mechanism.h	2013-08-28 03:41:48 +0000
34
+++ include/server/mir/shell/default_focus_mechanism.h	2013-09-26 22:16:32 +0000
35
@@ -50,8 +50,8 @@
36
50
    std::shared_ptr<InputTargeter> const input_targeter;
50
    std::shared_ptr<InputTargeter> const input_targeter;
37
51
    std::shared_ptr<SurfaceController> const surface_controller;
51
    std::shared_ptr<SurfaceController> const surface_controller;
38
52
52
41
53
    std::mutex surface_focus_lock;
53
    std::mutex focus_lock;
42
54
    std::weak_ptr<Surface> currently_focused_surface;
54
    std::weak_ptr<Session> currently_focused_session;
43
55
};
55
};
44
56
56
45
57
}
57
}
46
58
58
47
=== modified file 'include/server/mir/shell/session.h'
48
--- include/server/mir/shell/session.h	2013-08-28 03:41:48 +0000
49
+++ include/server/mir/shell/session.h	2013-09-26 22:16:32 +0000
50
@@ -28,6 +28,8 @@
51
28
namespace shell
28
namespace shell
52
29
{
29
{
53
30
class Surface;
30
class Surface;
54
31
class InputTargeter;
55
32
class SurfaceController;
56
31
33
57
32
class Session : public frontend::Session
34
class Session : public frontend::Session
58
33
{
35
{
59
@@ -37,6 +39,9 @@
60
37
39
61
38
    virtual void take_snapshot(SnapshotCallback const& snapshot_taken) = 0;
40
    virtual void take_snapshot(SnapshotCallback const& snapshot_taken) = 0;
62
39
    virtual std::shared_ptr<Surface> default_surface() const = 0;
41
    virtual std::shared_ptr<Surface> default_surface() const = 0;
63
42
    
64
43
    virtual void receive_focus(std::shared_ptr<InputTargeter> const& targeter, std::shared_ptr<SurfaceController> const& controller) = 0;
65
44
    virtual void relinquish_focus() = 0;
66
40
};
45
};
67
41
46
68
42
}
47
}
69
43
48
70
=== modified file 'include/test/mir_test_doubles/mock_shell_session.h'
71
--- include/test/mir_test_doubles/mock_shell_session.h	2013-08-28 03:41:48 +0000
72
+++ include/test/mir_test_doubles/mock_shell_session.h	2013-09-26 22:16:32 +0000
73
@@ -49,6 +49,9 @@
74
49
    
49
    
75
50
    MOCK_METHOD1(send_display_config, void(graphics::DisplayConfiguration const&));
50
    MOCK_METHOD1(send_display_config, void(graphics::DisplayConfiguration const&));
76
51
    MOCK_METHOD3(configure_surface, int(frontend::SurfaceId, MirSurfaceAttrib, int));
51
    MOCK_METHOD3(configure_surface, int(frontend::SurfaceId, MirSurfaceAttrib, int));
77
52
    
78
53
    MOCK_METHOD2(receive_focus, void(std::shared_ptr<shell::InputTargeter> const&, std::shared_ptr<shell::SurfaceController> const&));
79
54
    MOCK_METHOD0(relinquish_focus, void());
80
52
};
55
};
81
53
56
82
54
}
57
}
83
55
58
84
=== modified file 'include/test/mir_test_doubles/stub_shell_session.h'
85
--- include/test/mir_test_doubles/stub_shell_session.h	2013-08-13 22:20:37 +0000
86
+++ include/test/mir_test_doubles/stub_shell_session.h	2013-09-26 22:16:32 +0000
87
@@ -71,6 +71,14 @@
88
71
    {
71
    {
89
72
        return std::shared_ptr<shell::Surface>();
72
        return std::shared_ptr<shell::Surface>();
90
73
    }
73
    }
91
74
92
75
    void receive_focus(std::shared_ptr<shell::InputTargeter> const&,
93
76
                       std::shared_ptr<shell::SurfaceController> const&)
94
77
    {
95
78
    }
96
79
    void relinquish_focus()
97
80
    {
98
81
    }
99
74
};
82
};
100
75
83
101
76
}
84
}
102
77
85
103
=== modified file 'src/server/shell/application_session.cpp'
104
--- src/server/shell/application_session.cpp	2013-08-28 03:41:48 +0000
105
+++ src/server/shell/application_session.cpp	2013-09-26 22:16:32 +0000
106
@@ -21,6 +21,7 @@
107
21
#include "mir/shell/surface_factory.h"
21
#include "mir/shell/surface_factory.h"
108
22
#include "mir/shell/snapshot_strategy.h"
22
#include "mir/shell/snapshot_strategy.h"
109
23
#include "mir/shell/session_listener.h"
23
#include "mir/shell/session_listener.h"
110
24
#include "mir/shell/input_targeter.h"
111
24
#include "mir/frontend/event_sink.h"
25
#include "mir/frontend/event_sink.h"
112
25
26
113
26
#include <boost/throw_exception.hpp>
27
#include <boost/throw_exception.hpp>
114
@@ -99,16 +100,21 @@
115
99
    snapshot_strategy->take_snapshot_of(default_surface(), snapshot_taken);
100
    snapshot_strategy->take_snapshot_of(default_surface(), snapshot_taken);
116
100
}
101
}
117
101
102
119
102
std::shared_ptr<msh::Surface> msh::ApplicationSession::default_surface() const
103
std::shared_ptr<msh::Surface> msh::ApplicationSession::default_surface_locked(std::unique_lock<std::mutex> const& /* lock */) const
120
103
{
104
{
121
104
    std::unique_lock<std::mutex> lock(surfaces_mutex);
122
105
123
106
    if (surfaces.size())
105
    if (surfaces.size())
124
107
        return surfaces.begin()->second;
106
        return surfaces.begin()->second;
125
108
    else
107
    else
126
109
        return std::shared_ptr<msh::Surface>();
108
        return std::shared_ptr<msh::Surface>();
127
110
}
109
}
128
111
110
129
111
std::shared_ptr<msh::Surface> msh::ApplicationSession::default_surface() const
130
112
{
131
113
    std::unique_lock<std::mutex> lock(surfaces_mutex);
132
114
133
115
    return default_surface_locked(lock);
134
116
}
135
117
136
112
void msh::ApplicationSession::destroy_surface(mf::SurfaceId id)
118
void msh::ApplicationSession::destroy_surface(mf::SurfaceId id)
137
113
{
119
{
138
114
    std::unique_lock<std::mutex> lock(surfaces_mutex);
120
    std::unique_lock<std::mutex> lock(surfaces_mutex);
139
@@ -171,3 +177,33 @@
140
171
{
177
{
141
172
    event_sink->handle_lifecycle_event(state);
178
    event_sink->handle_lifecycle_event(state);
142
173
}
179
}
143
180
144
181
void msh::ApplicationSession::receive_focus(std::shared_ptr<msh::InputTargeter> const& targeter,
145
182
                                            std::shared_ptr<SurfaceController> const& controller)
146
183
{
147
184
    std::unique_lock<std::mutex> lock(surfaces_mutex);
148
185
    if (surfaces.size() == 0)
149
186
    {
150
187
        targeter->focus_cleared();
151
188
        return;
152
189
    }
153
190
    // Use default_surface_locked idiom instead
154
191
    auto focus_surface = surfaces.begin()->second;
155
192
    
156
193
    focus_surface->raise(controller);
157
194
    focus_surface->take_input_focus(targeter);
158
195
    focus_surface->configure(mir_surface_attrib_focus, mir_surface_focused);
159
196
160
197
    last_focused_surface = focus_surface;
161
198
}
162
199
163
200
void msh::ApplicationSession::relinquish_focus()
164
201
{
165
202
    std::unique_lock<std::mutex> lock(surfaces_mutex);
166
203
    auto surf = last_focused_surface.lock();
167
204
    if (surf)
168
205
    {
169
206
        surf->configure(mir_surface_attrib_focus, mir_surface_unfocused);
170
207
    }
171
208
    last_focused_surface.reset();
172
209
}
173
174
210
174
=== modified file 'src/server/shell/default_focus_mechanism.cpp'
175
--- src/server/shell/default_focus_mechanism.cpp	2013-08-28 03:41:48 +0000
176
+++ src/server/shell/default_focus_mechanism.cpp	2013-09-26 22:16:32 +0000
177
@@ -35,28 +35,20 @@
178
35
35
179
36
void msh::DefaultFocusMechanism::set_focus_to(std::shared_ptr<Session> const& focus_session)
36
void msh::DefaultFocusMechanism::set_focus_to(std::shared_ptr<Session> const& focus_session)
180
37
{
37
{
181
38
    std::lock_guard<std::mutex> lg(focus_lock);
182
39
183
40
    auto last_session = currently_focused_session.lock();
184
41
    if (last_session)
185
42
    {
186
43
        last_session->relinquish_focus();
187
44
    }
188
45
189
38
    // TODO: This path should be encapsulated in a seperate clear_focus message
46
    // TODO: This path should be encapsulated in a seperate clear_focus message
190
39
    if (!focus_session)
47
    if (!focus_session)
191
40
    {
48
    {
192
41
        input_targeter->focus_cleared();
49
        input_targeter->focus_cleared();
193
42
        return;
50
        return;
194
43
    }
51
    }
213
44
    
52
    focus_session->receive_focus(input_targeter, surface_controller);
214
45
    auto surface = focus_session->default_surface();
53
    currently_focused_session = focus_session;
197
46
    if (surface)
198
47
    {
199
48
        std::lock_guard<std::mutex> lg(surface_focus_lock);
200
49
        auto current_focus = currently_focused_surface.lock();
201
50
        if (current_focus)
202
51
            current_focus->configure(mir_surface_attrib_focus, mir_surface_unfocused);
203
52
        surface->configure(mir_surface_attrib_focus, mir_surface_focused);
204
53
        currently_focused_surface = surface;
205
54
        
206
55
        surface->raise(surface_controller);
207
56
        surface->take_input_focus(input_targeter);
208
57
    }
209
58
    else
210
59
    {
211
60
        input_targeter->focus_cleared();
212
61
    }
215
62
}
54
}
216
63
55
217
=== modified file 'tests/acceptance-tests/test_client_focus_notification.cpp'
218
--- tests/acceptance-tests/test_client_focus_notification.cpp	2013-09-17 14:31:42 +0000
219
+++ tests/acceptance-tests/test_client_focus_notification.cpp	2013-09-26 22:16:32 +0000
220
@@ -159,7 +159,9 @@
221
159
        void expect_events(mt::WaitCondition* all_events_received) override
159
        void expect_events(mt::WaitCondition* all_events_received) override
222
160
        {
160
        {
223
161
            EXPECT_CALL(*observer, see(Pointee(mt::SurfaceEvent(mir_surface_attrib_focus, mir_surface_focused)))).Times(1)
161
            EXPECT_CALL(*observer, see(Pointee(mt::SurfaceEvent(mir_surface_attrib_focus, mir_surface_focused)))).Times(1)
225
162
                .WillOnce(mt::WakeUp(all_events_received));
162
                .WillOnce(mt::WakeUp(all_events_received)); // Now we close the surface generating an unfocused event
226
163
            // libmirclient guarantees we will see this before mir_surface_release finishes, so we don't need further
227
164
            // synchronization
228
163
            EXPECT_CALL(*observer, see(Pointee(mt::SurfaceEvent(mir_surface_attrib_focus, mir_surface_unfocused)))).Times(1);
165
            EXPECT_CALL(*observer, see(Pointee(mt::SurfaceEvent(mir_surface_attrib_focus, mir_surface_unfocused)))).Times(1);
229
164
        }
166
        }
230
165
    } client_config;
167
    } client_config;
231
166
168
232
=== modified file 'tests/unit-tests/shell/test_default_focus_mechanism.cpp'
233
--- tests/unit-tests/shell/test_default_focus_mechanism.cpp	2013-08-28 03:41:48 +0000
234
+++ tests/unit-tests/shell/test_default_focus_mechanism.cpp	2013-09-26 22:16:32 +0000
235
@@ -47,80 +47,34 @@
236
47
namespace mt = mir::test;
47
namespace mt = mir::test;
237
48
namespace mtd = mir::test::doubles;
48
namespace mtd = mir::test::doubles;
238
49
49
315
50
TEST(DefaultFocusMechanism, raises_default_surface)
50
TEST(DefaultFocusMechanism, hands_focus_to_session)
316
51
{
51
{
317
52
    using namespace ::testing;
52
    using namespace ::testing;
318
53
    
53
    
319
54
    NiceMock<mtd::MockShellSession> app1;
54
    mtd::MockShellSession app1;
320
55
    mtd::MockSurface mock_surface(&app1, std::make_shared<mtd::StubSurfaceBuilder>());
55
    EXPECT_CALL(app1, receive_focus(_, _)).Times(1);
321
56
    {
56
    
322
57
        InSequence seq;
57
    msh::DefaultFocusMechanism focus_mechanism(std::make_shared<mtd::StubInputTargeter>(), std::make_shared<mtd::StubSurfaceController>());
323
58
        EXPECT_CALL(app1, default_surface()).Times(1)
58
324
59
            .WillOnce(Return(mt::fake_shared(mock_surface)));
59
    focus_mechanism.set_focus_to(mt::fake_shared(app1));
325
60
    }
60
}
326
61
61
327
62
    auto controller = std::make_shared<mtd::StubSurfaceController>();
62
TEST(DefaultFocusMechanism, relinquishes_focus_from_last_session)
328
63
    EXPECT_CALL(mock_surface, raise(Eq(controller))).Times(1);
63
{
329
64
    mtd::StubInputTargeter targeter;
64
    using namespace ::testing;
330
65
    msh::DefaultFocusMechanism focus_mechanism(mt::fake_shared(targeter), controller);
65
    
331
66
    
66
    auto app1 = std::make_shared<mtd::MockShellSession>();
332
67
    focus_mechanism.set_focus_to(mt::fake_shared(app1));
67
    auto app2 = std::make_shared<mtd::MockShellSession>();
333
68
}
68
    
334
69
69
    {
335
70
TEST(DefaultFocusMechanism, mechanism_notifies_default_surface_of_focus_changes)
70
        InSequence seq;
336
71
{
71
        EXPECT_CALL(*app1, receive_focus(_, _)).Times(1);
337
72
    using namespace ::testing;
72
        EXPECT_CALL(*app1, relinquish_focus()).Times(1);
338
73
73
        EXPECT_CALL(*app2, receive_focus(_, _)).Times(1);
339
74
    NiceMock<mtd::MockShellSession> app1, app2;
74
    }
340
75
    mtd::MockSurface mock_surface1(&app1, std::make_shared<mtd::StubSurfaceBuilder>());
75
    
341
76
    mtd::MockSurface mock_surface2(&app2, std::make_shared<mtd::StubSurfaceBuilder>());
76
    msh::DefaultFocusMechanism focus_mechanism(std::make_shared<mtd::StubInputTargeter>(), std::make_shared<mtd::StubSurfaceController>());
342
77
    
77
343
78
    ON_CALL(app1, default_surface()).WillByDefault(Return(mt::fake_shared(mock_surface1)));
78
    focus_mechanism.set_focus_to(app1);
344
79
    ON_CALL(app2, default_surface()).WillByDefault(Return(mt::fake_shared(mock_surface2)));
79
    focus_mechanism.set_focus_to(app2);
269
80
270
81
    
271
82
    {
272
83
        InSequence seq;
273
84
        EXPECT_CALL(mock_surface1, configure(mir_surface_attrib_focus, mir_surface_focused)).Times(1);
274
85
        EXPECT_CALL(mock_surface1, configure(mir_surface_attrib_focus, mir_surface_unfocused)).Times(1);
275
86
        EXPECT_CALL(mock_surface2, configure(mir_surface_attrib_focus, mir_surface_focused)).Times(1);
276
87
    }
277
88
278
89
    msh::DefaultFocusMechanism focus_mechanism(std::make_shared<mtd::StubInputTargeter>(),
279
90
                                                        std::make_shared<mtd::StubSurfaceController>());
280
91
281
92
    focus_mechanism.set_focus_to(mt::fake_shared(app1));
282
93
    focus_mechanism.set_focus_to(mt::fake_shared(app2));
283
94
}
284
95
285
96
TEST(DefaultFocusMechanism, sets_input_focus)
286
97
{
287
98
    using namespace ::testing;
288
99
    
289
100
    NiceMock<mtd::MockShellSession> app1;
290
101
    mtd::MockSurface mock_surface(&app1, std::make_shared<mtd::StubSurfaceBuilder>());
291
102
    {
292
103
        InSequence seq;
293
104
        EXPECT_CALL(app1, default_surface()).Times(1)
294
105
            .WillOnce(Return(mt::fake_shared(mock_surface)));
295
106
        EXPECT_CALL(app1, default_surface()).Times(1)
296
107
            .WillOnce(Return(std::shared_ptr<msh::Surface>()));
297
108
    }
298
109
299
110
    mtd::MockInputTargeter targeter;
300
111
    
301
112
    msh::DefaultFocusMechanism focus_mechanism(mt::fake_shared(targeter), std::make_shared<mtd::StubSurfaceController>());
302
113
    
303
114
    {
304
115
        InSequence seq;
305
116
        EXPECT_CALL(mock_surface, take_input_focus(_)).Times(1);
306
117
        // When we have no default surface.
307
118
        EXPECT_CALL(targeter, focus_cleared()).Times(1);
308
119
        // When we have no session.
309
120
        EXPECT_CALL(targeter, focus_cleared()).Times(1);
310
121
    }
311
122
    
312
123
    focus_mechanism.set_focus_to(mt::fake_shared(app1));
313
124
    focus_mechanism.set_focus_to(mt::fake_shared(app1));
314
125
    focus_mechanism.set_focus_to(std::shared_ptr<msh::Session>());
345
126
}
80
}
Status:	Superseded
Proposed branch:	lp:~robertcarr/mir/focus-tell-dont-ask
Merge into:	lp:mir
Prerequisite:	lp:~robertcarr/mir/socket-messenger-reporting
Diff against target:	345 lines (+106/-100) 9 files modified include/server/mir/shell/application_session.h (+6/-0) include/server/mir/shell/default_focus_mechanism.h (+2/-2) include/server/mir/shell/session.h (+5/-0) include/test/mir_test_doubles/mock_shell_session.h (+3/-0) include/test/mir_test_doubles/stub_shell_session.h (+8/-0) src/server/shell/application_session.cpp (+39/-3) src/server/shell/default_focus_mechanism.cpp (+10/-18) tests/acceptance-tests/test_client_focus_notification.cpp (+3/-1) tests/unit-tests/shell/test_default_focus_mechanism.cpp (+30/-76)
To merge this branch:	bzr merge lp:~robertcarr/mir/focus-tell-dont-ask
Related bugs:	Link a bug report
Reviewer	Review Type	Date Requested	Status
Daniel van Vugt		2013-09-26	Needs Fixing on 2013-09-30
Alan Griffiths		2013-09-26	Abstain on 2013-09-27
PS Jenkins bot (community)	continuous-integration	2013-09-26	Approve on 2013-09-26
Alexandros Frantzis		2013-09-26	Pending
kevin gunn		2013-09-26	Pending
Review via email: mp+187943@code.launchpad.net
1	=== modified file 'include/server/mir/shell/application_session.h'
2	--- include/server/mir/shell/application_session.h 2013-08-28 03:41:48 +0000
3	+++ include/server/mir/shell/application_session.h 2013-09-26 22:16:32 +0000
4	@@ -67,6 +67,9 @@
5	67		67
6	68	void set_lifecycle_state(MirLifecycleState state);	68	void set_lifecycle_state(MirLifecycleState state);
7	69		69
8			70	void receive_focus(std::shared_ptr<InputTargeter> const& targeter, std::shared_ptr<SurfaceController> const& controller);
9			71	void relinquish_focus();
10			72
11	70	protected:	73	protected:
12	71	ApplicationSession(ApplicationSession const&) = delete;	74	ApplicationSession(ApplicationSession const&) = delete;
13	72	ApplicationSession& operator=(ApplicationSession const&) = delete;	75	ApplicationSession& operator=(ApplicationSession const&) = delete;
14	@@ -79,6 +82,7 @@
15	79	std::shared_ptr<frontend::EventSink> const event_sink;	82	std::shared_ptr<frontend::EventSink> const event_sink;
16	80		83
17	81	frontend::SurfaceId next_id();	84	frontend::SurfaceId next_id();
18			85	std::shared_ptr<Surface> default_surface_locked(std::unique_lock<std::mutex> const& lock) const;
19	82		86
20	83	std::atomic<int> next_surface_id;	87	std::atomic<int> next_surface_id;
21	84		88
22	@@ -86,6 +90,8 @@
23	86	Surfaces::const_iterator checked_find(frontend::SurfaceId id) const;	90	Surfaces::const_iterator checked_find(frontend::SurfaceId id) const;
24	87	std::mutex mutable surfaces_mutex;	91	std::mutex mutable surfaces_mutex;
25	88	Surfaces surfaces;	92	Surfaces surfaces;
26			93
27			94	std::weak_ptr<Surface> last_focused_surface;
28	89	};	95	};
29	90		96
30	91	}	97	}
31	92		98
32	=== modified file 'include/server/mir/shell/default_focus_mechanism.h'
33	--- include/server/mir/shell/default_focus_mechanism.h 2013-08-28 03:41:48 +0000
34	+++ include/server/mir/shell/default_focus_mechanism.h 2013-09-26 22:16:32 +0000
35	@@ -50,8 +50,8 @@
36	50	std::shared_ptr<InputTargeter> const input_targeter;	50	std::shared_ptr<InputTargeter> const input_targeter;
37	51	std::shared_ptr<SurfaceController> const surface_controller;	51	std::shared_ptr<SurfaceController> const surface_controller;
38	52		52
41	53	std::mutex surface_focus_lock;	53	std::mutex focus_lock;
42	54	std::weak_ptr<Surface> currently_focused_surface;	54	std::weak_ptr<Session> currently_focused_session;
43	55	};	55	};
44	56		56
45	57	}	57	}
46	58		58
47	=== modified file 'include/server/mir/shell/session.h'
48	--- include/server/mir/shell/session.h 2013-08-28 03:41:48 +0000
49	+++ include/server/mir/shell/session.h 2013-09-26 22:16:32 +0000
50	@@ -28,6 +28,8 @@
51	28	namespace shell	28	namespace shell
52	29	{	29	{
53	30	class Surface;	30	class Surface;
54			31	class InputTargeter;
55			32	class SurfaceController;
56	31		33
57	32	class Session : public frontend::Session	34	class Session : public frontend::Session
58	33	{	35	{
59	@@ -37,6 +39,9 @@
60	37		39
61	38	virtual void take_snapshot(SnapshotCallback const& snapshot_taken) = 0;	40	virtual void take_snapshot(SnapshotCallback const& snapshot_taken) = 0;
62	39	virtual std::shared_ptr<Surface> default_surface() const = 0;	41	virtual std::shared_ptr<Surface> default_surface() const = 0;
63			42
64			43	virtual void receive_focus(std::shared_ptr<InputTargeter> const& targeter, std::shared_ptr<SurfaceController> const& controller) = 0;
65			44	virtual void relinquish_focus() = 0;
66	40	};	45	};
67	41		46
68	42	}	47	}
69	43		48
70	=== modified file 'include/test/mir_test_doubles/mock_shell_session.h'
71	--- include/test/mir_test_doubles/mock_shell_session.h 2013-08-28 03:41:48 +0000
72	+++ include/test/mir_test_doubles/mock_shell_session.h 2013-09-26 22:16:32 +0000
73	@@ -49,6 +49,9 @@
74	49		49
75	50	MOCK_METHOD1(send_display_config, void(graphics::DisplayConfiguration const&));	50	MOCK_METHOD1(send_display_config, void(graphics::DisplayConfiguration const&));
76	51	MOCK_METHOD3(configure_surface, int(frontend::SurfaceId, MirSurfaceAttrib, int));	51	MOCK_METHOD3(configure_surface, int(frontend::SurfaceId, MirSurfaceAttrib, int));
77			52
78			53	MOCK_METHOD2(receive_focus, void(std::shared_ptr<shell::InputTargeter> const&, std::shared_ptr<shell::SurfaceController> const&));
79			54	MOCK_METHOD0(relinquish_focus, void());
80	52	};	55	};
81	53		56
82	54	}	57	}
83	55		58
84	=== modified file 'include/test/mir_test_doubles/stub_shell_session.h'
85	--- include/test/mir_test_doubles/stub_shell_session.h 2013-08-13 22:20:37 +0000
86	+++ include/test/mir_test_doubles/stub_shell_session.h 2013-09-26 22:16:32 +0000
87	@@ -71,6 +71,14 @@
88	71	{	71	{
89	72	return std::shared_ptr<shell::Surface>();	72	return std::shared_ptr<shell::Surface>();
90	73	}	73	}
91			74
92			75	void receive_focus(std::shared_ptr<shell::InputTargeter> const&,
93			76	std::shared_ptr<shell::SurfaceController> const&)
94			77	{
95			78	}
96			79	void relinquish_focus()
97			80	{
98			81	}
99	74	};	82	};
100	75		83
101	76	}	84	}
102	77		85
103	=== modified file 'src/server/shell/application_session.cpp'
104	--- src/server/shell/application_session.cpp 2013-08-28 03:41:48 +0000
105	+++ src/server/shell/application_session.cpp 2013-09-26 22:16:32 +0000
106	@@ -21,6 +21,7 @@
107	21	#include "mir/shell/surface_factory.h"	21	#include "mir/shell/surface_factory.h"
108	22	#include "mir/shell/snapshot_strategy.h"	22	#include "mir/shell/snapshot_strategy.h"
109	23	#include "mir/shell/session_listener.h"	23	#include "mir/shell/session_listener.h"
110			24	#include "mir/shell/input_targeter.h"
111	24	#include "mir/frontend/event_sink.h"	25	#include "mir/frontend/event_sink.h"
112	25		26
113	26	#include <boost/throw_exception.hpp>	27	#include <boost/throw_exception.hpp>
114	@@ -99,16 +100,21 @@
115	99	snapshot_strategy->take_snapshot_of(default_surface(), snapshot_taken);	100	snapshot_strategy->take_snapshot_of(default_surface(), snapshot_taken);
116	100	}	101	}
117	101		102
119	102	std::shared_ptr<msh::Surface> msh::ApplicationSession::default_surface() const	103	std::shared_ptr<msh::Surface> msh::ApplicationSession::default_surface_locked(std::unique_lock<std::mutex> const& /* lock */) const
120	103	{	104	{
121	104	std::unique_lock<std::mutex> lock(surfaces_mutex);
122	105
123	106	if (surfaces.size())	105	if (surfaces.size())
124	107	return surfaces.begin()->second;	106	return surfaces.begin()->second;
125	108	else	107	else
126	109	return std::shared_ptr<msh::Surface>();	108	return std::shared_ptr<msh::Surface>();
127	110	}	109	}
128	111		110
129			111	std::shared_ptr<msh::Surface> msh::ApplicationSession::default_surface() const
130			112	{
131			113	std::unique_lock<std::mutex> lock(surfaces_mutex);
132			114
133			115	return default_surface_locked(lock);
134			116	}
135			117
136	112	void msh::ApplicationSession::destroy_surface(mf::SurfaceId id)	118	void msh::ApplicationSession::destroy_surface(mf::SurfaceId id)
137	113	{	119	{
138	114	std::unique_lock<std::mutex> lock(surfaces_mutex);	120	std::unique_lock<std::mutex> lock(surfaces_mutex);
139	@@ -171,3 +177,33 @@
140	171	{	177	{
141	172	event_sink->handle_lifecycle_event(state);	178	event_sink->handle_lifecycle_event(state);
142	173	}	179	}
143			180
144			181	void msh::ApplicationSession::receive_focus(std::shared_ptr<msh::InputTargeter> const& targeter,
145			182	std::shared_ptr<SurfaceController> const& controller)
146			183	{
147			184	std::unique_lock<std::mutex> lock(surfaces_mutex);
148			185	if (surfaces.size() == 0)
149			186	{
150			187	targeter->focus_cleared();
151			188	return;
152			189	}
153			190	// Use default_surface_locked idiom instead
154			191	auto focus_surface = surfaces.begin()->second;
155			192
156			193	focus_surface->raise(controller);
157			194	focus_surface->take_input_focus(targeter);
158			195	focus_surface->configure(mir_surface_attrib_focus, mir_surface_focused);
159			196
160			197	last_focused_surface = focus_surface;
161			198	}
162			199
163			200	void msh::ApplicationSession::relinquish_focus()
164			201	{
165			202	std::unique_lock<std::mutex> lock(surfaces_mutex);
166			203	auto surf = last_focused_surface.lock();
167			204	if (surf)
168			205	{
169			206	surf->configure(mir_surface_attrib_focus, mir_surface_unfocused);
170			207	}
171			208	last_focused_surface.reset();
172			209	}
173	174		210
174	=== modified file 'src/server/shell/default_focus_mechanism.cpp'
175	--- src/server/shell/default_focus_mechanism.cpp 2013-08-28 03:41:48 +0000
176	+++ src/server/shell/default_focus_mechanism.cpp 2013-09-26 22:16:32 +0000
177	@@ -35,28 +35,20 @@
178	35		35
179	36	void msh::DefaultFocusMechanism::set_focus_to(std::shared_ptr<Session> const& focus_session)	36	void msh::DefaultFocusMechanism::set_focus_to(std::shared_ptr<Session> const& focus_session)
180	37	{	37	{
181			38	std::lock_guard<std::mutex> lg(focus_lock);
182			39
183			40	auto last_session = currently_focused_session.lock();
184			41	if (last_session)
185			42	{
186			43	last_session->relinquish_focus();
187			44	}
188			45
189	38	// TODO: This path should be encapsulated in a seperate clear_focus message	46	// TODO: This path should be encapsulated in a seperate clear_focus message
190	39	if (!focus_session)	47	if (!focus_session)
191	40	{	48	{
192	41	input_targeter->focus_cleared();	49	input_targeter->focus_cleared();
193	42	return;	50	return;
194	43	}	51	}
213	44		52	focus_session->receive_focus(input_targeter, surface_controller);
214	45	auto surface = focus_session->default_surface();	53	currently_focused_session = focus_session;
197	46	if (surface)
198	47	{
199	48	std::lock_guard<std::mutex> lg(surface_focus_lock);
200	49	auto current_focus = currently_focused_surface.lock();
201	50	if (current_focus)
202	51	current_focus->configure(mir_surface_attrib_focus, mir_surface_unfocused);
203	52	surface->configure(mir_surface_attrib_focus, mir_surface_focused);
204	53	currently_focused_surface = surface;
205	54
206	55	surface->raise(surface_controller);
207	56	surface->take_input_focus(input_targeter);
208	57	}
209	58	else
210	59	{
211	60	input_targeter->focus_cleared();
212	61	}
215	62	}	54	}
216	63		55
217	=== modified file 'tests/acceptance-tests/test_client_focus_notification.cpp'
218	--- tests/acceptance-tests/test_client_focus_notification.cpp 2013-09-17 14:31:42 +0000
219	+++ tests/acceptance-tests/test_client_focus_notification.cpp 2013-09-26 22:16:32 +0000
220	@@ -159,7 +159,9 @@
221	159	void expect_events(mt::WaitCondition* all_events_received) override	159	void expect_events(mt::WaitCondition* all_events_received) override
222	160	{	160	{
223	161	EXPECT_CALL(*observer, see(Pointee(mt::SurfaceEvent(mir_surface_attrib_focus, mir_surface_focused)))).Times(1)	161	EXPECT_CALL(*observer, see(Pointee(mt::SurfaceEvent(mir_surface_attrib_focus, mir_surface_focused)))).Times(1)
225	162	.WillOnce(mt::WakeUp(all_events_received));	162	.WillOnce(mt::WakeUp(all_events_received)); // Now we close the surface generating an unfocused event
226			163	// libmirclient guarantees we will see this before mir_surface_release finishes, so we don't need further
227			164	// synchronization
228	163	EXPECT_CALL(*observer, see(Pointee(mt::SurfaceEvent(mir_surface_attrib_focus, mir_surface_unfocused)))).Times(1);	165	EXPECT_CALL(*observer, see(Pointee(mt::SurfaceEvent(mir_surface_attrib_focus, mir_surface_unfocused)))).Times(1);
229	164	}	166	}
230	165	} client_config;	167	} client_config;
231	166		168
232	=== modified file 'tests/unit-tests/shell/test_default_focus_mechanism.cpp'
233	--- tests/unit-tests/shell/test_default_focus_mechanism.cpp 2013-08-28 03:41:48 +0000
234	+++ tests/unit-tests/shell/test_default_focus_mechanism.cpp 2013-09-26 22:16:32 +0000
235	@@ -47,80 +47,34 @@
236	47	namespace mt = mir::test;	47	namespace mt = mir::test;
237	48	namespace mtd = mir::test::doubles;	48	namespace mtd = mir::test::doubles;
238	49		49
315	50	TEST(DefaultFocusMechanism, raises_default_surface)	50	TEST(DefaultFocusMechanism, hands_focus_to_session)
316	51	{	51	{
317	52	using namespace ::testing;	52	using namespace ::testing;
318	53		53
319	54	NiceMock<mtd::MockShellSession> app1;	54	mtd::MockShellSession app1;
320	55	mtd::MockSurface mock_surface(&app1, std::make_shared<mtd::StubSurfaceBuilder>());	55	EXPECT_CALL(app1, receive_focus(_, _)).Times(1);
321	56	{	56
322	57	InSequence seq;	57	msh::DefaultFocusMechanism focus_mechanism(std::make_shared<mtd::StubInputTargeter>(), std::make_shared<mtd::StubSurfaceController>());
323	58	EXPECT_CALL(app1, default_surface()).Times(1)	58
324	59	.WillOnce(Return(mt::fake_shared(mock_surface)));	59	focus_mechanism.set_focus_to(mt::fake_shared(app1));
325	60	}	60	}
326	61		61
327	62	auto controller = std::make_shared<mtd::StubSurfaceController>();	62	TEST(DefaultFocusMechanism, relinquishes_focus_from_last_session)
328	63	EXPECT_CALL(mock_surface, raise(Eq(controller))).Times(1);	63	{
329	64	mtd::StubInputTargeter targeter;	64	using namespace ::testing;
330	65	msh::DefaultFocusMechanism focus_mechanism(mt::fake_shared(targeter), controller);	65
331	66		66	auto app1 = std::make_shared<mtd::MockShellSession>();
332	67	focus_mechanism.set_focus_to(mt::fake_shared(app1));	67	auto app2 = std::make_shared<mtd::MockShellSession>();
333	68	}	68
334	69		69	{
335	70	TEST(DefaultFocusMechanism, mechanism_notifies_default_surface_of_focus_changes)	70	InSequence seq;
336	71	{	71	EXPECT_CALL(*app1, receive_focus(_, _)).Times(1);
337	72	using namespace ::testing;	72	EXPECT_CALL(*app1, relinquish_focus()).Times(1);
338	73		73	EXPECT_CALL(*app2, receive_focus(_, _)).Times(1);
339	74	NiceMock<mtd::MockShellSession> app1, app2;	74	}
340	75	mtd::MockSurface mock_surface1(&app1, std::make_shared<mtd::StubSurfaceBuilder>());	75
341	76	mtd::MockSurface mock_surface2(&app2, std::make_shared<mtd::StubSurfaceBuilder>());	76	msh::DefaultFocusMechanism focus_mechanism(std::make_shared<mtd::StubInputTargeter>(), std::make_shared<mtd::StubSurfaceController>());
342	77		77
343	78	ON_CALL(app1, default_surface()).WillByDefault(Return(mt::fake_shared(mock_surface1)));	78	focus_mechanism.set_focus_to(app1);
344	79	ON_CALL(app2, default_surface()).WillByDefault(Return(mt::fake_shared(mock_surface2)));	79	focus_mechanism.set_focus_to(app2);
269	80
270	81
271	82	{
272	83	InSequence seq;
273	84	EXPECT_CALL(mock_surface1, configure(mir_surface_attrib_focus, mir_surface_focused)).Times(1);
274	85	EXPECT_CALL(mock_surface1, configure(mir_surface_attrib_focus, mir_surface_unfocused)).Times(1);
275	86	EXPECT_CALL(mock_surface2, configure(mir_surface_attrib_focus, mir_surface_focused)).Times(1);
276	87	}
277	88
278	89	msh::DefaultFocusMechanism focus_mechanism(std::make_shared<mtd::StubInputTargeter>(),
279	90	std::make_shared<mtd::StubSurfaceController>());
280	91
281	92	focus_mechanism.set_focus_to(mt::fake_shared(app1));
282	93	focus_mechanism.set_focus_to(mt::fake_shared(app2));
283	94	}
284	95
285	96	TEST(DefaultFocusMechanism, sets_input_focus)
286	97	{
287	98	using namespace ::testing;
288	99
289	100	NiceMock<mtd::MockShellSession> app1;
290	101	mtd::MockSurface mock_surface(&app1, std::make_shared<mtd::StubSurfaceBuilder>());
291	102	{
292	103	InSequence seq;
293	104	EXPECT_CALL(app1, default_surface()).Times(1)
294	105	.WillOnce(Return(mt::fake_shared(mock_surface)));
295	106	EXPECT_CALL(app1, default_surface()).Times(1)
296	107	.WillOnce(Return(std::shared_ptr<msh::Surface>()));
297	108	}
298	109
299	110	mtd::MockInputTargeter targeter;
300	111
301	112	msh::DefaultFocusMechanism focus_mechanism(mt::fake_shared(targeter), std::make_shared<mtd::StubSurfaceController>());
302	113
303	114	{
304	115	InSequence seq;
305	116	EXPECT_CALL(mock_surface, take_input_focus(_)).Times(1);
306	117	// When we have no default surface.
307	118	EXPECT_CALL(targeter, focus_cleared()).Times(1);
308	119	// When we have no session.
309	120	EXPECT_CALL(targeter, focus_cleared()).Times(1);
310	121	}
311	122
312	123	focus_mechanism.set_focus_to(mt::fake_shared(app1));
313	124	focus_mechanism.set_focus_to(mt::fake_shared(app1));
314	125	focus_mechanism.set_focus_to(std::shared_ptr<msh::Session>());
345	126	}	80	}