Unity

Merge lp:~azzar1/unity/lp-1238063 into lp:unity

  1. lp-1238063
  2. Merge into trunk
Proposed by Andrea Azzarone
Status: Merged
Approved by: Stephen M. Webb
Approved revision: no longer in the source branch.
Merged at revision: 3904
Proposed branch: lp:~azzar1/unity/lp-1238063
Merge into: lp:unity
Diff against target: 977 lines (+197/-192)
13 files modified
launcher/EdgeBarrierController.cpp (+11/-6)
launcher/EdgeBarrierController.h (+1/-1)
launcher/EdgeBarrierControllerPrivate.h (+3/-3)
launcher/Launcher.cpp (+1/-1)
launcher/Launcher.h (+1/-1)
launcher/PointerBarrier.cpp (+1/-1)
launcher/PointerBarrier.h (+2/-2)
panel/PanelView.cpp (+1/-1)
panel/PanelView.h (+1/-1)
tests/test_edge_barrier_controller.cpp (+134/-134)
tests/test_launcher.cpp (+7/-7)
tests/test_panel_view.cpp (+2/-2)
tests/test_pointer_barrier.cpp (+32/-32)
To merge this branch: bzr merge lp:~azzar1/unity/lp-1238063
Reviewer Review Type Date Requested Status
Marco Trevisan (Treviño) Approve
Stephen M. Webb (community) Approve
PS Jenkins bot (community) continuous-integration Needs Fixing
Review via email: mp+244236@code.launchpad.net

Commit message

Use std::weak_ptr to avoid referencing an invalid barrier.

To post a comment you must log in.
Revision history for this message
PS Jenkins bot (ps-jenkins) wrote :

FAILED: Continuous integration, rev:3894
http://jenkins.qa.ubuntu.com/job/unity-ci/1120/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-vivid-amd64-ci/7/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-vivid-armhf-ci/7/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-vivid-i386-ci/7/console

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

review: Needs Fixing (continuous-integration)
Revision history for this message
PS Jenkins bot (ps-jenkins) wrote :

FAILED: Continuous integration, rev:3894
http://jenkins.qa.ubuntu.com/job/unity-ci/1123/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-vivid-amd64-ci/10/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-vivid-armhf-ci/10/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-vivid-i386-ci/10/console

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

review: Needs Fixing (continuous-integration)
Revision history for this message
Marco Trevisan (Treviño) (3v1n0) wrote :

Looks very nice, check my comments.

Revision history for this message
Andrea Azzarone (azzar1) wrote :

Done

Revision history for this message
PS Jenkins bot (ps-jenkins) wrote :

FAILED: Continuous integration, rev:3895
http://jenkins.qa.ubuntu.com/job/unity-ci/1124/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-vivid-amd64-ci/11/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-vivid-armhf-ci/11/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-vivid-i386-ci/11/console

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

review: Needs Fixing (continuous-integration)
Revision history for this message
PS Jenkins bot (ps-jenkins) wrote :

FAILED: Continuous integration, rev:3895
http://jenkins.qa.ubuntu.com/job/unity-ci/1126/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-vivid-amd64-ci/13/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-vivid-armhf-ci/13/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-vivid-i386-ci/13/console

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

review: Needs Fixing (continuous-integration)
Revision history for this message
Stephen M. Webb (bregma) wrote :

OK.

review: Approve
Revision history for this message
Marco Trevisan (Treviño) (3v1n0) :
review: Approve

Preview Diff

[H/L] Next/Prev Comment, [J/K] Next/Prev File, [N/P] Next/Prev Hunk
1=== modified file 'launcher/EdgeBarrierController.cpp'
2--- launcher/EdgeBarrierController.cpp 2014-02-27 05:30:25 +0000
3+++ launcher/EdgeBarrierController.cpp 2015-01-14 02:47:10 +0000
4@@ -318,7 +318,7 @@
5 decaymulator_.value = 0;
6 }
7
8-void EdgeBarrierController::Impl::BarrierPush(PointerBarrierWrapper* owner, BarrierEvent::Ptr const& event)
9+void EdgeBarrierController::Impl::BarrierPush(PointerBarrierWrapper::Ptr const& owner, BarrierEvent::Ptr const& event)
10 {
11 if ((owner->orientation == VERTICAL and EventIsInsideYBreakZone(event)) or
12 (owner->orientation == HORIZONTAL and EventIsInsideXBreakZone(event)))
13@@ -368,7 +368,7 @@
14 return false;
15 }
16
17-void EdgeBarrierController::Impl::OnPointerBarrierEvent(PointerBarrierWrapper* owner, BarrierEvent::Ptr const& event)
18+void EdgeBarrierController::Impl::OnPointerBarrierEvent(PointerBarrierWrapper::Ptr const& owner, BarrierEvent::Ptr const& event)
19 {
20 if (owner->released)
21 {
22@@ -418,7 +418,7 @@
23 }
24 }
25
26-void EdgeBarrierController::Impl::BarrierRelease(PointerBarrierWrapper* owner, int event)
27+void EdgeBarrierController::Impl::BarrierRelease(PointerBarrierWrapper::Ptr const& owner, int event)
28 {
29 owner->ReleaseBarrier(event);
30 owner->released = true;
31@@ -428,9 +428,14 @@
32 (owner->release_once() && (!release_timeout_ || !release_timeout_->IsRunning())))
33 {
34 unsigned duration = parent_->options()->edge_passed_disabled_ms;
35- release_timeout_.reset(new glib::Timeout(duration, [owner] {
36- owner->released = false;
37- owner->release_once = false;
38+
39+ std::weak_ptr<PointerBarrierWrapper> owner_weak(owner);
40+ release_timeout_.reset(new glib::Timeout(duration, [owner_weak] {
41+ if (PointerBarrierWrapper::Ptr const& owner = owner_weak.lock())
42+ {
43+ owner->released = false;
44+ owner->release_once = false;
45+ }
46 return false;
47 }));
48 }
49
50=== modified file 'launcher/EdgeBarrierController.h'
51--- launcher/EdgeBarrierController.h 2013-11-06 11:21:43 +0000
52+++ launcher/EdgeBarrierController.h 2015-01-14 02:47:10 +0000
53@@ -37,7 +37,7 @@
54 };
55
56 virtual ~EdgeBarrierSubscriber() {}
57- virtual Result HandleBarrierEvent(PointerBarrierWrapper* owner, BarrierEvent::Ptr event) = 0;
58+ virtual Result HandleBarrierEvent(PointerBarrierWrapper::Ptr const& owner, BarrierEvent::Ptr event) = 0;
59 };
60
61 class EdgeBarrierController : public sigc::trackable
62
63=== modified file 'launcher/EdgeBarrierControllerPrivate.h'
64--- launcher/EdgeBarrierControllerPrivate.h 2014-02-27 05:30:25 +0000
65+++ launcher/EdgeBarrierControllerPrivate.h 2015-01-14 02:47:10 +0000
66@@ -44,9 +44,9 @@
67 void OnUScreenChanged(int primary, std::vector<nux::Geometry> const& layout);
68 void OnOptionsChanged();
69
70- void OnPointerBarrierEvent(PointerBarrierWrapper* owner, BarrierEvent::Ptr const& event);
71- void BarrierPush(PointerBarrierWrapper* owner, BarrierEvent::Ptr const& event);
72- void BarrierRelease(PointerBarrierWrapper* owner, int event);
73+ void OnPointerBarrierEvent(PointerBarrierWrapper::Ptr const& owner, BarrierEvent::Ptr const& event);
74+ void BarrierPush(PointerBarrierWrapper::Ptr const& owner, BarrierEvent::Ptr const& event);
75+ void BarrierRelease(PointerBarrierWrapper::Ptr const& owner, int event);
76 void BarrierReset();
77
78 bool EventIsInsideYBreakZone(BarrierEvent::Ptr const& event);
79
80=== modified file 'launcher/Launcher.cpp'
81--- launcher/Launcher.cpp 2014-09-04 22:11:33 +0000
82+++ launcher/Launcher.cpp 2015-01-14 02:47:10 +0000
83@@ -2224,7 +2224,7 @@
84
85 #ifdef USE_X11
86
87-ui::EdgeBarrierSubscriber::Result Launcher::HandleBarrierEvent(ui::PointerBarrierWrapper* owner, ui::BarrierEvent::Ptr event)
88+ui::EdgeBarrierSubscriber::Result Launcher::HandleBarrierEvent(ui::PointerBarrierWrapper::Ptr const& owner, ui::BarrierEvent::Ptr event)
89 {
90 if (hide_machine_.GetQuirk(LauncherHideMachine::EXTERNAL_DND_ACTIVE))
91 {
92
93=== modified file 'launcher/Launcher.h'
94--- launcher/Launcher.h 2014-03-17 20:58:25 +0000
95+++ launcher/Launcher.h 2015-01-14 02:47:10 +0000
96@@ -200,7 +200,7 @@
97 #endif
98
99 #ifdef USE_X11
100- ui::EdgeBarrierSubscriber::Result HandleBarrierEvent(ui::PointerBarrierWrapper* owner, ui::BarrierEvent::Ptr event);
101+ ui::EdgeBarrierSubscriber::Result HandleBarrierEvent(ui::PointerBarrierWrapper::Ptr const& owner, ui::BarrierEvent::Ptr event);
102 #endif
103
104 void OnExpoChanged();
105
106=== modified file 'launcher/PointerBarrier.cpp'
107--- launcher/PointerBarrier.cpp 2013-08-07 18:50:10 +0000
108+++ launcher/PointerBarrier.cpp 2015-01-14 02:47:10 +0000
109@@ -101,7 +101,7 @@
110 {
111 auto event = std::make_shared<BarrierEvent>(x, y, velocity, event_id);
112
113- barrier_event.emit(this, event);
114+ barrier_event.emit(shared_from_this(), event);
115 }
116
117 bool PointerBarrierWrapper::IsFirstEvent() const
118
119=== modified file 'launcher/PointerBarrier.h'
120--- launcher/PointerBarrier.h 2013-08-08 14:43:50 +0000
121+++ launcher/PointerBarrier.h 2015-01-14 02:47:10 +0000
122@@ -62,7 +62,7 @@
123 HORIZONTAL
124 };
125
126-class PointerBarrierWrapper : public sigc::trackable
127+class PointerBarrierWrapper : public sigc::trackable, public std::enable_shared_from_this<PointerBarrierWrapper>
128 {
129 public:
130 typedef std::shared_ptr<PointerBarrierWrapper> Ptr;
131@@ -94,7 +94,7 @@
132 virtual void DestroyBarrier();
133 virtual void ReleaseBarrier(int event_id);
134
135- sigc::signal<void, PointerBarrierWrapper*, BarrierEvent::Ptr> barrier_event;
136+ sigc::signal<void, PointerBarrierWrapper::Ptr const&, BarrierEvent::Ptr> barrier_event;
137
138 bool IsFirstEvent() const;
139
140
141=== modified file 'panel/PanelView.cpp'
142--- panel/PanelView.cpp 2014-07-30 00:49:35 +0000
143+++ panel/PanelView.cpp 2015-01-14 02:47:10 +0000
144@@ -811,7 +811,7 @@
145 return stored_dash_width_;
146 }
147
148-ui::EdgeBarrierSubscriber::Result PanelView::HandleBarrierEvent(ui::PointerBarrierWrapper* owner, ui::BarrierEvent::Ptr event)
149+ui::EdgeBarrierSubscriber::Result PanelView::HandleBarrierEvent(ui::PointerBarrierWrapper::Ptr const& owner, ui::BarrierEvent::Ptr event)
150 {
151 if (WindowManager::Default().IsAnyWindowMoving())
152 return ui::EdgeBarrierSubscriber::Result::IGNORED;
153
154=== modified file 'panel/PanelView.h'
155--- panel/PanelView.h 2014-03-06 16:26:34 +0000
156+++ panel/PanelView.h 2015-01-14 02:47:10 +0000
157@@ -73,7 +73,7 @@
158
159 bool IsMouseInsideIndicator(nux::Point const& mouse_position) const;
160
161- ui::EdgeBarrierSubscriber::Result HandleBarrierEvent(ui::PointerBarrierWrapper* owner, ui::BarrierEvent::Ptr event) override;
162+ ui::EdgeBarrierSubscriber::Result HandleBarrierEvent(ui::PointerBarrierWrapper::Ptr const& owner, ui::BarrierEvent::Ptr event) override;
163
164 protected:
165 void Draw(nux::GraphicsEngine& GfxContext, bool force_draw);
166
167=== modified file 'tests/test_edge_barrier_controller.cpp'
168--- tests/test_edge_barrier_controller.cpp 2013-11-06 11:21:43 +0000
169+++ tests/test_edge_barrier_controller.cpp 2015-01-14 02:47:10 +0000
170@@ -56,7 +56,7 @@
171 : handle_result_(result)
172 {}
173
174- EdgeBarrierSubscriber::Result HandleBarrierEvent(PointerBarrierWrapper* owner, BarrierEvent::Ptr event)
175+ EdgeBarrierSubscriber::Result HandleBarrierEvent(PointerBarrierWrapper::Ptr const& owner, BarrierEvent::Ptr event)
176 {
177 return handle_result_;
178 }
179@@ -89,7 +89,7 @@
180 }
181 }
182
183- void ProcessBarrierEvent(PointerBarrierWrapper* owner, BarrierEvent::Ptr event)
184+ void ProcessBarrierEvent(PointerBarrierWrapper::Ptr const& owner, BarrierEvent::Ptr event)
185 {
186 GetPrivateImpl()->OnPointerBarrierEvent(owner, event);
187 }
188@@ -203,11 +203,11 @@
189 TestBarrierSubscriber handling_subscriber(EdgeBarrierSubscriber::Result::HANDLED);
190 bc.AddVerticalSubscriber(&handling_subscriber, monitor);
191
192- MockPointerBarrierWrapper owner(monitor, false, VERTICAL);
193+ auto owner = std::make_shared<MockPointerBarrierWrapper>(monitor, false, VERTICAL);
194 auto breaking_barrier_event = MakeBarrierEvent(0, true);
195
196- EXPECT_CALL(owner, ReleaseBarrier(_)).Times(0);
197- ProcessBarrierEvent(&owner, breaking_barrier_event);
198+ EXPECT_CALL(*owner, ReleaseBarrier(_)).Times(0);
199+ ProcessBarrierEvent(owner, breaking_barrier_event);
200 EXPECT_EQ(GetPrivateImpl()->decaymulator_.value(), 0);
201 }
202
203@@ -218,11 +218,11 @@
204 TestBarrierSubscriber handling_subscriber(EdgeBarrierSubscriber::Result::HANDLED);
205 bc.AddHorizontalSubscriber(&handling_subscriber, monitor);
206
207- MockPointerBarrierWrapper owner(monitor, false, HORIZONTAL);
208+ auto owner = std::make_shared<MockPointerBarrierWrapper>(monitor, false, HORIZONTAL);
209 auto breaking_barrier_event = MakeBarrierEvent(0, true);
210
211- EXPECT_CALL(owner, ReleaseBarrier(_)).Times(0);
212- ProcessBarrierEvent(&owner, breaking_barrier_event);
213+ EXPECT_CALL(*owner, ReleaseBarrier(_)).Times(0);
214+ ProcessBarrierEvent(owner, breaking_barrier_event);
215 EXPECT_EQ(GetPrivateImpl()->decaymulator_.value(), 0);
216 }
217
218@@ -233,11 +233,11 @@
219 TestBarrierSubscriber handling_subscriber(EdgeBarrierSubscriber::Result::HANDLED);
220 bc.AddVerticalSubscriber(&handling_subscriber, monitor);
221
222- MockPointerBarrierWrapper owner(monitor, true, VERTICAL);
223+ auto owner = std::make_shared<MockPointerBarrierWrapper>(monitor, true, VERTICAL);
224 auto breaking_barrier_event = MakeBarrierEvent(5, true);
225
226- EXPECT_CALL(owner, ReleaseBarrier(5)).Times(1);
227- ProcessBarrierEvent(&owner, breaking_barrier_event);
228+ EXPECT_CALL(*owner, ReleaseBarrier(5)).Times(1);
229+ ProcessBarrierEvent(owner, breaking_barrier_event);
230 }
231
232 TEST_F(TestEdgeBarrierController, ProcessHandledEventOnReleasedBarrierForHorizontalSubscriber)
233@@ -247,118 +247,118 @@
234 TestBarrierSubscriber handling_subscriber(EdgeBarrierSubscriber::Result::HANDLED);
235 bc.AddHorizontalSubscriber(&handling_subscriber, monitor);
236
237- MockPointerBarrierWrapper owner(monitor, true, HORIZONTAL);
238+ auto owner = std::make_shared<MockPointerBarrierWrapper>(monitor, true, HORIZONTAL);
239 auto breaking_barrier_event = MakeBarrierEvent(5, true);
240
241- EXPECT_CALL(owner, ReleaseBarrier(5)).Times(1);
242- ProcessBarrierEvent(&owner, breaking_barrier_event);
243+ EXPECT_CALL(*owner, ReleaseBarrier(5)).Times(1);
244+ ProcessBarrierEvent(owner, breaking_barrier_event);
245 }
246
247 TEST_F(TestEdgeBarrierController, ProcessUnHandledEventBreakingBarrierForVerticalSubscriber)
248 {
249 int monitor = 1;
250
251- MockPointerBarrierWrapper owner(monitor, false, VERTICAL);
252+ auto owner = std::make_shared<MockPointerBarrierWrapper>(monitor, false, VERTICAL);
253 int breaking_id = 12345;
254 auto breaking_barrier_event = MakeBarrierEvent(breaking_id, true);
255
256- EXPECT_CALL(owner, ReleaseBarrier(breaking_id));
257- ProcessBarrierEvent(&owner, breaking_barrier_event);
258+ EXPECT_CALL(*owner, ReleaseBarrier(breaking_id));
259+ ProcessBarrierEvent(owner, breaking_barrier_event);
260 }
261
262 TEST_F(TestEdgeBarrierController, ProcessUnHandledEventBreakingBarrierForHorizontalSubscriber)
263 {
264 int monitor = 1;
265
266- MockPointerBarrierWrapper owner(monitor, false, HORIZONTAL);
267+ auto owner = std::make_shared<MockPointerBarrierWrapper>(monitor, false, HORIZONTAL);
268 int breaking_id = 12345;
269 auto breaking_barrier_event = MakeBarrierEvent(breaking_id, true);
270
271- EXPECT_CALL(owner, ReleaseBarrier(breaking_id));
272- ProcessBarrierEvent(&owner, breaking_barrier_event);
273+ EXPECT_CALL(*owner, ReleaseBarrier(breaking_id));
274+ ProcessBarrierEvent(owner, breaking_barrier_event);
275 }
276
277 TEST_F(TestEdgeBarrierController, ProcessUnHandledEventBreakingBarrierOnMaxMonitorForVerticalSubscriber)
278 {
279 int monitor = monitors::MAX;
280
281- MockPointerBarrierWrapper owner(monitor, false, VERTICAL);
282+ auto owner = std::make_shared<MockPointerBarrierWrapper>(monitor, false, VERTICAL);
283 auto breaking_barrier_event = MakeBarrierEvent(0, true);
284
285- EXPECT_CALL(owner, ReleaseBarrier(_));
286- ProcessBarrierEvent(&owner, breaking_barrier_event);
287+ EXPECT_CALL(*owner, ReleaseBarrier(_));
288+ ProcessBarrierEvent(owner, breaking_barrier_event);
289 }
290
291 TEST_F(TestEdgeBarrierController, ProcessUnHandledEventBreakingBarrierOnMaxMonitorForHorizontalSubscriber)
292 {
293 int monitor = monitors::MAX;
294
295- MockPointerBarrierWrapper owner(monitor, false, HORIZONTAL);
296+ auto owner = std::make_shared<MockPointerBarrierWrapper>(monitor, false, HORIZONTAL);
297 auto breaking_barrier_event = MakeBarrierEvent(0, true);
298
299- EXPECT_CALL(owner, ReleaseBarrier(_));
300- ProcessBarrierEvent(&owner, breaking_barrier_event);
301+ EXPECT_CALL(*owner, ReleaseBarrier(_));
302+ ProcessBarrierEvent(owner, breaking_barrier_event);
303 }
304
305 TEST_F(TestEdgeBarrierController, ProcessUnHandledEventNotBreakingBarrierForVerticalSubscriber)
306 {
307 int monitor = 2;
308
309- MockPointerBarrierWrapper owner(monitor, false, VERTICAL);
310+ auto owner = std::make_shared<MockPointerBarrierWrapper>(monitor, false, VERTICAL);
311 int not_breaking_id = 54321;
312 auto not_breaking_barrier_event = MakeBarrierEvent(not_breaking_id, false);
313
314- EXPECT_CALL(owner, ReleaseBarrier(not_breaking_id)).Times(0);
315- ProcessBarrierEvent(&owner, not_breaking_barrier_event);
316+ EXPECT_CALL(*owner, ReleaseBarrier(not_breaking_id)).Times(0);
317+ ProcessBarrierEvent(owner, not_breaking_barrier_event);
318 }
319
320 TEST_F(TestEdgeBarrierController, ProcessUnHandledEventNotBreakingBarrierForHorizontalSubscriber)
321 {
322 int monitor = 2;
323
324- MockPointerBarrierWrapper owner(monitor, false, HORIZONTAL);
325+ auto owner = std::make_shared<MockPointerBarrierWrapper>(monitor, false, HORIZONTAL);
326 int not_breaking_id = 54321;
327 auto not_breaking_barrier_event = MakeBarrierEvent(not_breaking_id, false);
328
329- EXPECT_CALL(owner, ReleaseBarrier(not_breaking_id)).Times(0);
330- ProcessBarrierEvent(&owner, not_breaking_barrier_event);
331+ EXPECT_CALL(*owner, ReleaseBarrier(not_breaking_id)).Times(0);
332+ ProcessBarrierEvent(owner, not_breaking_barrier_event);
333 }
334
335 TEST_F(TestEdgeBarrierController, ProcessUnHandledEventOnReleasedBarrierForVerticalSubscriber)
336 {
337 int monitor = 2;
338
339- MockPointerBarrierWrapper owner(monitor, true, VERTICAL);
340+ auto owner = std::make_shared<MockPointerBarrierWrapper>(monitor, true, VERTICAL);
341 int not_breaking_id = 345678;
342 auto not_breaking_barrier_event = MakeBarrierEvent(not_breaking_id, false);
343
344- EXPECT_CALL(owner, ReleaseBarrier(not_breaking_id));
345- ProcessBarrierEvent(&owner, not_breaking_barrier_event);
346+ EXPECT_CALL(*owner, ReleaseBarrier(not_breaking_id));
347+ ProcessBarrierEvent(owner, not_breaking_barrier_event);
348 }
349
350 TEST_F(TestEdgeBarrierController, ProcessUnHandledEventOnReleasedBarrierForHorizontalSubscriber)
351 {
352 int monitor = 2;
353
354- MockPointerBarrierWrapper owner(monitor, true, HORIZONTAL);
355+ auto owner = std::make_shared<MockPointerBarrierWrapper>(monitor, true, HORIZONTAL);
356 int not_breaking_id = 345678;
357 auto not_breaking_barrier_event = MakeBarrierEvent(not_breaking_id, false);
358
359- EXPECT_CALL(owner, ReleaseBarrier(not_breaking_id));
360- ProcessBarrierEvent(&owner, not_breaking_barrier_event);
361+ EXPECT_CALL(*owner, ReleaseBarrier(not_breaking_id));
362+ ProcessBarrierEvent(owner, not_breaking_barrier_event);
363 }
364
365 TEST_F(TestEdgeBarrierController, ProcessAlreadyHandledEventForVerticalSubscriber)
366 {
367 int monitor = g_random_int_range(0, monitors::MAX);
368
369- MockPointerBarrierWrapper owner(monitor, false, VERTICAL);
370+ auto owner = std::make_shared<MockPointerBarrierWrapper>(monitor, false, VERTICAL);
371 vertical_subscribers_[monitor].handle_result_ = EdgeBarrierSubscriber::Result::ALREADY_HANDLED;
372
373 auto event = MakeBarrierEvent(g_random_int(), false);
374
375- EXPECT_CALL(owner, ReleaseBarrier(_)).Times(0);
376- ProcessBarrierEvent(&owner, event);
377+ EXPECT_CALL(*owner, ReleaseBarrier(_)).Times(0);
378+ ProcessBarrierEvent(owner, event);
379 EXPECT_EQ(GetPrivateImpl()->decaymulator_.value(), event->velocity);
380 }
381
382@@ -366,13 +366,13 @@
383 {
384 int monitor = g_random_int_range(0, monitors::MAX);
385
386- MockPointerBarrierWrapper owner(monitor, false, HORIZONTAL);
387+ auto owner = std::make_shared<MockPointerBarrierWrapper>(monitor, false, HORIZONTAL);
388 horizontal_subscribers_[monitor].handle_result_ = EdgeBarrierSubscriber::Result::ALREADY_HANDLED;
389
390 auto event = MakeBarrierEvent(g_random_int(), false);
391
392- EXPECT_CALL(owner, ReleaseBarrier(_)).Times(0);
393- ProcessBarrierEvent(&owner, event);
394+ EXPECT_CALL(*owner, ReleaseBarrier(_)).Times(0);
395+ ProcessBarrierEvent(owner, event);
396 EXPECT_EQ(GetPrivateImpl()->decaymulator_.value(), event->velocity);
397 }
398
399@@ -381,15 +381,15 @@
400 int monitor = g_random_int_range(0, monitors::MAX);
401
402 bc.sticky_edges = true;
403- MockPointerBarrierWrapper owner(monitor, false, VERTICAL);
404+ auto owner = std::make_shared<MockPointerBarrierWrapper>(monitor, false, VERTICAL);
405 vertical_subscribers_[monitor].handle_result_ = EdgeBarrierSubscriber::Result::IGNORED;
406
407 auto event = MakeBarrierEvent(g_random_int(), false);
408
409- EXPECT_CALL(owner, ReleaseBarrier(_)).Times(0);
410- ProcessBarrierEvent(&owner, event);
411- EXPECT_FALSE(owner.released());
412- EXPECT_FALSE(owner.release_once());
413+ EXPECT_CALL(*owner, ReleaseBarrier(_)).Times(0);
414+ ProcessBarrierEvent(owner, event);
415+ EXPECT_FALSE(owner->released());
416+ EXPECT_FALSE(owner->release_once());
417 EXPECT_EQ(GetPrivateImpl()->decaymulator_.value(), event->velocity);
418 }
419
420@@ -398,15 +398,15 @@
421 int monitor = g_random_int_range(0, monitors::MAX);
422
423 bc.sticky_edges = true;
424- MockPointerBarrierWrapper owner(monitor, false, HORIZONTAL);
425+ auto owner = std::make_shared<MockPointerBarrierWrapper>(monitor, false, HORIZONTAL);
426 horizontal_subscribers_[monitor].handle_result_ = EdgeBarrierSubscriber::Result::IGNORED;
427
428 auto event = MakeBarrierEvent(g_random_int(), false);
429
430- EXPECT_CALL(owner, ReleaseBarrier(_)).Times(0);
431- ProcessBarrierEvent(&owner, event);
432- EXPECT_FALSE(owner.released());
433- EXPECT_FALSE(owner.release_once());
434+ EXPECT_CALL(*owner, ReleaseBarrier(_)).Times(0);
435+ ProcessBarrierEvent(owner, event);
436+ EXPECT_FALSE(owner->released());
437+ EXPECT_FALSE(owner->release_once());
438 EXPECT_EQ(GetPrivateImpl()->decaymulator_.value(), event->velocity);
439 }
440
441@@ -415,15 +415,15 @@
442 int monitor = g_random_int_range(0, monitors::MAX);
443
444 bc.sticky_edges = false;
445- MockPointerBarrierWrapper owner(monitor, false, VERTICAL);
446+ auto owner = std::make_shared<MockPointerBarrierWrapper>(monitor, false, VERTICAL);
447 vertical_subscribers_[monitor].handle_result_ = EdgeBarrierSubscriber::Result::IGNORED;
448
449 auto event = MakeBarrierEvent(g_random_int(), false);
450
451- EXPECT_CALL(owner, ReleaseBarrier(event->event_id));
452- ProcessBarrierEvent(&owner, event);
453- EXPECT_TRUE(owner.released());
454- EXPECT_TRUE(owner.release_once());
455+ EXPECT_CALL(*owner, ReleaseBarrier(event->event_id));
456+ ProcessBarrierEvent(owner, event);
457+ EXPECT_TRUE(owner->released());
458+ EXPECT_TRUE(owner->release_once());
459 EXPECT_EQ(GetPrivateImpl()->decaymulator_.value(), 0);
460 }
461
462@@ -432,15 +432,15 @@
463 int monitor = g_random_int_range(0, monitors::MAX);
464
465 bc.sticky_edges = false;
466- MockPointerBarrierWrapper owner(monitor, false, HORIZONTAL);
467+ auto owner = std::make_shared<MockPointerBarrierWrapper>(monitor, false, HORIZONTAL);
468 horizontal_subscribers_[monitor].handle_result_ = EdgeBarrierSubscriber::Result::IGNORED;
469
470 auto event = MakeBarrierEvent(g_random_int(), false);
471
472- EXPECT_CALL(owner, ReleaseBarrier(event->event_id));
473- ProcessBarrierEvent(&owner, event);
474- EXPECT_TRUE(owner.released());
475- EXPECT_TRUE(owner.release_once());
476+ EXPECT_CALL(*owner, ReleaseBarrier(event->event_id));
477+ ProcessBarrierEvent(owner, event);
478+ EXPECT_TRUE(owner->released());
479+ EXPECT_TRUE(owner->release_once());
480 EXPECT_EQ(GetPrivateImpl()->decaymulator_.value(), 0);
481 }
482
483@@ -448,13 +448,13 @@
484 {
485 int monitor = g_random_int_range(0, monitors::MAX);
486
487- MockPointerBarrierWrapper owner(monitor, false, VERTICAL);
488+ auto owner = std::make_shared<MockPointerBarrierWrapper>(monitor, false, VERTICAL);
489 vertical_subscribers_[monitor].handle_result_ = EdgeBarrierSubscriber::Result::NEEDS_RELEASE;
490
491 auto event = MakeBarrierEvent(g_random_int(), false);
492
493- EXPECT_CALL(owner, ReleaseBarrier(event->event_id));
494- ProcessBarrierEvent(&owner, event);
495+ EXPECT_CALL(*owner, ReleaseBarrier(event->event_id));
496+ ProcessBarrierEvent(owner, event);
497 EXPECT_EQ(GetPrivateImpl()->decaymulator_.value(), 0);
498 }
499
500@@ -462,100 +462,100 @@
501 {
502 int monitor = g_random_int_range(0, monitors::MAX);
503
504- MockPointerBarrierWrapper owner(monitor, false, HORIZONTAL);
505+ auto owner = std::make_shared<MockPointerBarrierWrapper>(monitor, false, HORIZONTAL);
506 horizontal_subscribers_[monitor].handle_result_ = EdgeBarrierSubscriber::Result::NEEDS_RELEASE;
507
508 auto event = MakeBarrierEvent(g_random_int(), false);
509
510- EXPECT_CALL(owner, ReleaseBarrier(event->event_id));
511- ProcessBarrierEvent(&owner, event);
512+ EXPECT_CALL(*owner, ReleaseBarrier(event->event_id));
513+ ProcessBarrierEvent(owner, event);
514 EXPECT_EQ(GetPrivateImpl()->decaymulator_.value(), 0);
515 }
516
517 TEST_F(TestEdgeBarrierController, BreakingEdgeTemporaryReleasesBarrierForVerticalSubscriber)
518 {
519 int monitor = g_random_int_range(0, monitors::MAX);
520- MockPointerBarrierWrapper owner(monitor, false, VERTICAL);
521+ auto owner = std::make_shared<MockPointerBarrierWrapper>(monitor, false, VERTICAL);
522
523- EXPECT_CALL(owner, ReleaseBarrier(1));
524- ProcessBarrierEvent(&owner, MakeBarrierEvent(1, true));
525- ASSERT_TRUE(owner.released());
526+ EXPECT_CALL(*owner, ReleaseBarrier(1));
527+ ProcessBarrierEvent(owner, MakeBarrierEvent(1, true));
528+ ASSERT_TRUE(owner->released());
529
530 Utils::WaitForTimeoutMSec(bc.options()->edge_passed_disabled_ms);
531- EXPECT_FALSE(owner.released());
532+ EXPECT_FALSE(owner->released());
533 }
534
535 TEST_F(TestEdgeBarrierController, BreakingEdgeTemporaryReleasesBarrierForHoriziontalSubscriber)
536 {
537 int monitor = g_random_int_range(0, monitors::MAX);
538- MockPointerBarrierWrapper owner(monitor, false, HORIZONTAL);
539+ auto owner = std::make_shared<MockPointerBarrierWrapper>(monitor, false, HORIZONTAL);
540
541- EXPECT_CALL(owner, ReleaseBarrier(1));
542- ProcessBarrierEvent(&owner, MakeBarrierEvent(1, true));
543- ASSERT_TRUE(owner.released());
544+ EXPECT_CALL(*owner, ReleaseBarrier(1));
545+ ProcessBarrierEvent(owner, MakeBarrierEvent(1, true));
546+ ASSERT_TRUE(owner->released());
547
548 Utils::WaitForTimeoutMSec(bc.options()->edge_passed_disabled_ms);
549- EXPECT_FALSE(owner.released());
550+ EXPECT_FALSE(owner->released());
551 }
552
553 TEST_F(TestEdgeBarrierController, BreakingEdgeTemporaryReleasesBarrierForNotHandledEventsForVerticalSubscriber)
554 {
555 int monitor = 0;
556- MockPointerBarrierWrapper owner(monitor, false, VERTICAL);
557- vertical_subscribers_[monitor].handle_result_ = EdgeBarrierSubscriber::Result::IGNORED;
558-
559- EXPECT_CALL(owner, ReleaseBarrier(5));
560- ProcessBarrierEvent(&owner, MakeBarrierEvent(5, true));
561- ASSERT_TRUE(owner.released());
562-
563- vertical_subscribers_[monitor].handle_result_ = EdgeBarrierSubscriber::Result::IGNORED;
564- EXPECT_CALL(owner, ReleaseBarrier(6));
565- ProcessBarrierEvent(&owner, MakeBarrierEvent(6, false));
566+ auto owner = std::make_shared<MockPointerBarrierWrapper>(monitor, false, VERTICAL);
567+ vertical_subscribers_[monitor].handle_result_ = EdgeBarrierSubscriber::Result::IGNORED;
568+
569+ EXPECT_CALL(*owner, ReleaseBarrier(5));
570+ ProcessBarrierEvent(owner, MakeBarrierEvent(5, true));
571+ ASSERT_TRUE(owner->released());
572+
573+ vertical_subscribers_[monitor].handle_result_ = EdgeBarrierSubscriber::Result::IGNORED;
574+ EXPECT_CALL(*owner, ReleaseBarrier(6));
575+ ProcessBarrierEvent(owner, MakeBarrierEvent(6, false));
576 }
577
578 TEST_F(TestEdgeBarrierController, BreakingEdgeTemporaryReleasesBarrierForNotHandledEventsForHorizontalSubscriber)
579 {
580 int monitor = 0;
581- MockPointerBarrierWrapper owner(monitor, false, HORIZONTAL);
582- horizontal_subscribers_[monitor].handle_result_ = EdgeBarrierSubscriber::Result::IGNORED;
583-
584- EXPECT_CALL(owner, ReleaseBarrier(5));
585- ProcessBarrierEvent(&owner, MakeBarrierEvent(5, true));
586- ASSERT_TRUE(owner.released());
587-
588- horizontal_subscribers_[monitor].handle_result_ = EdgeBarrierSubscriber::Result::IGNORED;
589- EXPECT_CALL(owner, ReleaseBarrier(6));
590- ProcessBarrierEvent(&owner, MakeBarrierEvent(6, false));
591+ auto owner = std::make_shared<MockPointerBarrierWrapper>(monitor, false, HORIZONTAL);
592+ horizontal_subscribers_[monitor].handle_result_ = EdgeBarrierSubscriber::Result::IGNORED;
593+
594+ EXPECT_CALL(*owner, ReleaseBarrier(5));
595+ ProcessBarrierEvent(owner, MakeBarrierEvent(5, true));
596+ ASSERT_TRUE(owner->released());
597+
598+ horizontal_subscribers_[monitor].handle_result_ = EdgeBarrierSubscriber::Result::IGNORED;
599+ EXPECT_CALL(*owner, ReleaseBarrier(6));
600+ ProcessBarrierEvent(owner, MakeBarrierEvent(6, false));
601 }
602
603 TEST_F(TestEdgeBarrierController, BreakingEdgeTemporaryReleasesBarrierForHandledEventsForVerticalSubscriber)
604 {
605 int monitor = 0;
606- MockPointerBarrierWrapper owner(monitor, false, VERTICAL);
607+ auto owner = std::make_shared<MockPointerBarrierWrapper>(monitor, false, VERTICAL);
608 vertical_subscribers_[monitor].handle_result_ = EdgeBarrierSubscriber::Result::IGNORED;
609
610- EXPECT_CALL(owner, ReleaseBarrier(5));
611- ProcessBarrierEvent(&owner, MakeBarrierEvent(5, true));
612- ASSERT_TRUE(owner.released());
613+ EXPECT_CALL(*owner, ReleaseBarrier(5));
614+ ProcessBarrierEvent(owner, MakeBarrierEvent(5, true));
615+ ASSERT_TRUE(owner->released());
616
617 vertical_subscribers_[monitor].handle_result_ = EdgeBarrierSubscriber::Result::HANDLED;
618- EXPECT_CALL(owner, ReleaseBarrier(6)).Times(1);
619- ProcessBarrierEvent(&owner, MakeBarrierEvent(6, true));
620+ EXPECT_CALL(*owner, ReleaseBarrier(6)).Times(1);
621+ ProcessBarrierEvent(owner, MakeBarrierEvent(6, true));
622 }
623
624 TEST_F(TestEdgeBarrierController, BreakingEdgeTemporaryReleasesBarrierForHandledEventsForHoriziontalSubscriber)
625 {
626 int monitor = 0;
627- MockPointerBarrierWrapper owner(monitor, false, HORIZONTAL);
628+ auto owner = std::make_shared<MockPointerBarrierWrapper>(monitor, false, HORIZONTAL);
629 horizontal_subscribers_[monitor].handle_result_ = EdgeBarrierSubscriber::Result::IGNORED;
630
631- EXPECT_CALL(owner, ReleaseBarrier(5));
632- ProcessBarrierEvent(&owner, MakeBarrierEvent(5, true));
633- ASSERT_TRUE(owner.released());
634+ EXPECT_CALL(*owner, ReleaseBarrier(5));
635+ ProcessBarrierEvent(owner, MakeBarrierEvent(5, true));
636+ ASSERT_TRUE(owner->released());
637
638 horizontal_subscribers_[monitor].handle_result_ = EdgeBarrierSubscriber::Result::HANDLED;
639- EXPECT_CALL(owner, ReleaseBarrier(6)).Times(1);
640- ProcessBarrierEvent(&owner, MakeBarrierEvent(6, true));
641+ EXPECT_CALL(*owner, ReleaseBarrier(6)).Times(1);
642+ ProcessBarrierEvent(owner, MakeBarrierEvent(6, true));
643 }
644
645 TEST_F(TestEdgeBarrierController, StickyEdgePropertyProxiesLauncherOption)
646@@ -587,70 +587,70 @@
647
648 TEST_F(TestEdgeBarrierController, VerticalBarrierDoesNotBreakIfYEventToFarApart)
649 {
650- MockPointerBarrierWrapper owner(0, false, VERTICAL);
651+ auto owner = std::make_shared<MockPointerBarrierWrapper>(0, false, VERTICAL);
652
653 int velocity = bc.options()->edge_overcome_pressure() * bc.options()->edge_responsiveness();
654 auto firstEvent = std::make_shared<BarrierEvent>(0, 50, velocity, 10);
655 auto secondEvent = std::make_shared<BarrierEvent>(0, 150, velocity, 11);
656
657- EXPECT_CALL(owner, ReleaseBarrier(_)).Times(0);
658- ProcessBarrierEvent(&owner, firstEvent);
659- ProcessBarrierEvent(&owner, secondEvent);
660+ EXPECT_CALL(*owner, ReleaseBarrier(_)).Times(0);
661+ ProcessBarrierEvent(owner, firstEvent);
662+ ProcessBarrierEvent(owner, secondEvent);
663 }
664
665 TEST_F(TestEdgeBarrierController, HorizontalBarrierDoesNotBreakIfXEventToFarApart)
666 {
667- MockPointerBarrierWrapper owner(0, false, HORIZONTAL);
668+ auto owner = std::make_shared<MockPointerBarrierWrapper>(0, false, HORIZONTAL);
669
670 int velocity = bc.options()->edge_overcome_pressure() * bc.options()->edge_responsiveness();
671 auto firstEvent = std::make_shared<BarrierEvent>(50, 0, velocity, 10);
672 auto secondEvent = std::make_shared<BarrierEvent>(150, 0, velocity, 11);
673
674- EXPECT_CALL(owner, ReleaseBarrier(_)).Times(0);
675- ProcessBarrierEvent(&owner, firstEvent);
676- ProcessBarrierEvent(&owner, secondEvent);
677+ EXPECT_CALL(*owner, ReleaseBarrier(_)).Times(0);
678+ ProcessBarrierEvent(owner, firstEvent);
679+ ProcessBarrierEvent(owner, secondEvent);
680 }
681
682 TEST_F(TestEdgeBarrierController, VerticalBarrierBreaksInYBreakZone)
683 {
684- MockPointerBarrierWrapper owner(0, false, VERTICAL);
685+ auto owner = std::make_shared<MockPointerBarrierWrapper>(0, false, VERTICAL);
686
687 int velocity = bc.options()->edge_overcome_pressure() * bc.options()->edge_responsiveness();
688 auto firstEvent = std::make_shared<BarrierEvent>(0, 50, velocity, 10);
689
690- EXPECT_CALL(owner, ReleaseBarrier(_)).Times(1);
691- ProcessBarrierEvent(&owner, firstEvent);
692- ProcessBarrierEvent(&owner, firstEvent);
693+ EXPECT_CALL(*owner, ReleaseBarrier(_)).Times(1);
694+ ProcessBarrierEvent(owner, firstEvent);
695+ ProcessBarrierEvent(owner, firstEvent);
696 }
697
698 TEST_F(TestEdgeBarrierController, HorizontalBarrierBreaksInXBreakZone)
699 {
700- MockPointerBarrierWrapper owner(0, false, HORIZONTAL);
701+ auto owner = std::make_shared<MockPointerBarrierWrapper>(0, false, HORIZONTAL);
702
703 int velocity = bc.options()->edge_overcome_pressure() * bc.options()->edge_responsiveness();
704 auto firstEvent = std::make_shared<BarrierEvent>(50, 0, velocity, 10);
705
706- EXPECT_CALL(owner, ReleaseBarrier(_)).Times(1);
707- ProcessBarrierEvent(&owner, firstEvent);
708- ProcessBarrierEvent(&owner, firstEvent);
709+ EXPECT_CALL(*owner, ReleaseBarrier(_)).Times(1);
710+ ProcessBarrierEvent(owner, firstEvent);
711+ ProcessBarrierEvent(owner, firstEvent);
712 }
713
714 TEST_F(TestEdgeBarrierController, VerticalBarrierReleaseIfNoSubscriberForMonitor)
715 {
716- MockPointerBarrierWrapper owner(monitors::MAX, false, VERTICAL);
717+ auto owner = std::make_shared<MockPointerBarrierWrapper>(monitors::MAX, false, VERTICAL);
718 auto firstEvent = std::make_shared<BarrierEvent>(0, 50, 1, 10);
719
720- EXPECT_CALL(owner, ReleaseBarrier(_)).Times(1);
721- ProcessBarrierEvent(&owner, firstEvent);
722+ EXPECT_CALL(*owner, ReleaseBarrier(_)).Times(1);
723+ ProcessBarrierEvent(owner, firstEvent);
724 }
725
726 TEST_F(TestEdgeBarrierController, HorizontalBarrierReleaseIfNoSubscriberForMonitor)
727 {
728- MockPointerBarrierWrapper owner(monitors::MAX, false, HORIZONTAL);
729+ auto owner = std::make_shared<MockPointerBarrierWrapper>(monitors::MAX, false, HORIZONTAL);
730 auto firstEvent = std::make_shared<BarrierEvent>(50, 0, 1, 10);
731
732- EXPECT_CALL(owner, ReleaseBarrier(_)).Times(1);
733- ProcessBarrierEvent(&owner, firstEvent);
734+ EXPECT_CALL(*owner, ReleaseBarrier(_)).Times(1);
735+ ProcessBarrierEvent(owner, firstEvent);
736 }
737
738 }
739
740=== modified file 'tests/test_launcher.cpp'
741--- tests/test_launcher.cpp 2014-03-21 04:40:12 +0000
742+++ tests/test_launcher.cpp 2015-01-14 02:47:10 +0000
743@@ -502,7 +502,7 @@
744
745 launcher_->DndStarted("");
746
747- EXPECT_EQ(launcher_->HandleBarrierEvent(barrier.get(), event),
748+ EXPECT_EQ(launcher_->HandleBarrierEvent(barrier, event),
749 ui::EdgeBarrierSubscriber::Result::NEEDS_RELEASE);
750 }
751
752@@ -515,24 +515,24 @@
753
754 event->x = launcher_geo.x-1;
755 event->y = launcher_geo.y;
756- EXPECT_EQ(launcher_->HandleBarrierEvent(barrier.get(), event),
757+ EXPECT_EQ(launcher_->HandleBarrierEvent(barrier, event),
758 ui::EdgeBarrierSubscriber::Result::IGNORED);
759
760 event->x = launcher_geo.x+launcher_geo.width+1;
761 event->y = launcher_geo.y;
762- EXPECT_EQ(launcher_->HandleBarrierEvent(barrier.get(), event),
763+ EXPECT_EQ(launcher_->HandleBarrierEvent(barrier, event),
764 ui::EdgeBarrierSubscriber::Result::IGNORED);
765
766 options_->reveal_trigger = RevealTrigger::EDGE;
767 event->x = launcher_geo.x+launcher_geo.width/2;
768 event->y = launcher_geo.y - 1;
769- EXPECT_EQ(launcher_->HandleBarrierEvent(barrier.get(), event),
770+ EXPECT_EQ(launcher_->HandleBarrierEvent(barrier, event),
771 ui::EdgeBarrierSubscriber::Result::IGNORED);
772
773 options_->reveal_trigger = RevealTrigger::CORNER;
774 event->x = launcher_geo.x+launcher_geo.width/2;
775 event->y = launcher_geo.y;
776- EXPECT_EQ(launcher_->HandleBarrierEvent(barrier.get(), event),
777+ EXPECT_EQ(launcher_->HandleBarrierEvent(barrier, event),
778 ui::EdgeBarrierSubscriber::Result::IGNORED);
779 }
780
781@@ -551,7 +551,7 @@
782 {
783 event->x = x;
784 event->y = y;
785- ASSERT_EQ(launcher_->HandleBarrierEvent(barrier.get(), event),
786+ ASSERT_EQ(launcher_->HandleBarrierEvent(barrier, event),
787 ui::EdgeBarrierSubscriber::Result::HANDLED);
788 }
789 }
790@@ -564,7 +564,7 @@
791 {
792 event->x = x;
793 event->y = y;
794- ASSERT_EQ(launcher_->HandleBarrierEvent(barrier.get(), event),
795+ ASSERT_EQ(launcher_->HandleBarrierEvent(barrier, event),
796 ui::EdgeBarrierSubscriber::Result::HANDLED);
797 }
798 }
799
800=== modified file 'tests/test_panel_view.cpp'
801--- tests/test_panel_view.cpp 2014-03-21 04:40:12 +0000
802+++ tests/test_panel_view.cpp 2015-01-14 02:47:10 +0000
803@@ -80,11 +80,11 @@
804 auto event = std::make_shared<ui::BarrierEvent>(0, 0, 0, 100);
805
806 WM->SetIsAnyWindowMoving(false);
807- EXPECT_EQ(panel_view_->HandleBarrierEvent(barrier.get(), event),
808+ EXPECT_EQ(panel_view_->HandleBarrierEvent(barrier, event),
809 ui::EdgeBarrierSubscriber::Result::NEEDS_RELEASE);
810
811 WM->SetIsAnyWindowMoving(true);
812- EXPECT_EQ(panel_view_->HandleBarrierEvent(barrier.get(), event),
813+ EXPECT_EQ(panel_view_->HandleBarrierEvent(barrier, event),
814 ui::EdgeBarrierSubscriber::Result::IGNORED);
815 }
816
817
818=== modified file 'tests/test_pointer_barrier.cpp'
819--- tests/test_pointer_barrier.cpp 2013-07-09 23:18:29 +0000
820+++ tests/test_pointer_barrier.cpp 2015-01-14 02:47:10 +0000
821@@ -79,79 +79,79 @@
822
823 TEST(TestPointerBarrier, HandleHitNotifyEvents)
824 {
825- MockPointerBarrier pb;
826- pb.threshold = 1000;
827+ auto pb = std::make_shared<MockPointerBarrier>();
828+ pb->threshold = 1000;
829 XIBarrierEvent ev = GetGenericEvent(0xdeadbeef);
830
831 bool got_event = false;
832
833- pb.barrier_event.connect([&] (PointerBarrierWrapper* pbw, BarrierEvent::Ptr bev) {
834+ pb->barrier_event.connect([&] (PointerBarrierWrapper::Ptr const& pbw, BarrierEvent::Ptr bev) {
835 if (!pbw->IsFirstEvent())
836 {
837 got_event = true;
838
839- EXPECT_EQ(pbw, &pb);
840+ EXPECT_EQ(pbw.get(), pb.get());
841 EXPECT_EQ(bev->x, ev.root_x);
842 EXPECT_EQ(bev->y, ev.root_y);
843- EXPECT_EQ(bev->velocity, 600 * pb.max_velocity_multiplier);
844+ EXPECT_EQ(bev->velocity, 600 * pb->max_velocity_multiplier);
845 EXPECT_EQ(bev->event_id, ev.eventid);
846 }
847 });
848
849- EXPECT_TRUE(pb.HandleBarrierEvent(&ev));
850+ EXPECT_TRUE(pb->HandleBarrierEvent(&ev));
851 EXPECT_FALSE(got_event);
852
853- Utils::WaitForTimeoutMSec(pb.smoothing());
854+ Utils::WaitForTimeoutMSec(pb->smoothing());
855
856 EXPECT_TRUE(got_event);
857 }
858
859 TEST(TestPointerBarrier, HandleHitNotifyReleasedEvents)
860 {
861- MockPointerBarrier pb;
862- pb.threshold = 1000;
863+ auto pb = std::make_shared<MockPointerBarrier>();
864+ pb->threshold = 1000;
865 XIBarrierEvent ev = GetGenericEvent(0xabba);
866 bool got_event = false;
867
868- pb.barrier_event.connect([&] (PointerBarrierWrapper* pbw, BarrierEvent::Ptr bev) {
869+ pb->barrier_event.connect([&] (PointerBarrierWrapper::Ptr const& pbw, BarrierEvent::Ptr bev) {
870 got_event = true;
871
872- EXPECT_EQ(pbw, &pb);
873+ EXPECT_EQ(pbw.get(), pb.get());
874 EXPECT_EQ(bev->x, ev.root_x);
875 EXPECT_EQ(bev->y, ev.root_y);
876 EXPECT_GT(bev->velocity, 0);
877 EXPECT_EQ(bev->event_id, ev.eventid);
878 });
879
880- pb.released = true;
881- EXPECT_TRUE(pb.HandleBarrierEvent(&ev));
882+ pb->released = true;
883+ EXPECT_TRUE(pb->HandleBarrierEvent(&ev));
884 EXPECT_TRUE(got_event);
885 }
886
887 TEST(TestPointerBarrier, ReciveFirstEvent)
888 {
889- MockPointerBarrier pb;
890- pb.threshold = 1000;
891+ auto pb = std::make_shared<MockPointerBarrier>();
892+ pb->threshold = 1000;
893 XIBarrierEvent ev = GetGenericEvent(0xabba);
894
895 bool first_is_true = false;
896
897- pb.barrier_event.connect([&] (PointerBarrierWrapper* pbw, BarrierEvent::Ptr bev) {
898+ pb->barrier_event.connect([&] (PointerBarrierWrapper::Ptr const& pbw, BarrierEvent::Ptr bev) {
899 first_is_true = true;
900 });
901
902- EXPECT_TRUE(pb.HandleBarrierEvent(&ev));
903+ EXPECT_TRUE(pb->HandleBarrierEvent(&ev));
904 EXPECT_TRUE(first_is_true);
905 }
906
907 TEST(TestPointerBarrier, ReciveSecondEventFirstFalse)
908 {
909- MockPointerBarrier pb;
910- pb.threshold = 1000;
911+ auto pb = std::make_shared<MockPointerBarrier>();
912+ pb->threshold = 1000;
913 XIBarrierEvent ev = GetGenericEvent(0xabba);
914 int events_recived = 0;
915
916- pb.barrier_event.connect([&] (PointerBarrierWrapper* pbw, BarrierEvent::Ptr bev) {
917+ pb->barrier_event.connect([&] (PointerBarrierWrapper::Ptr const& pbw, BarrierEvent::Ptr bev) {
918 events_recived++;
919
920 if (events_recived == 1)
921@@ -160,44 +160,44 @@
922 EXPECT_FALSE(pbw->IsFirstEvent());
923 });
924
925- EXPECT_TRUE(pb.HandleBarrierEvent(&ev));
926+ EXPECT_TRUE(pb->HandleBarrierEvent(&ev));
927
928- Utils::WaitForTimeoutMSec(pb.smoothing());
929+ Utils::WaitForTimeoutMSec(pb->smoothing());
930
931 EXPECT_EQ(events_recived, 2);
932 }
933
934 TEST(TestPointerBarrier, DontReleaseBarrierOnEmptyDTime)
935 {
936- MockPointerBarrier pb;
937- pb.threshold = 1000;
938+ auto pb = std::make_shared<MockPointerBarrier>();
939+ pb->threshold = 1000;
940 XIBarrierEvent ev = GetGenericEvent(0xabba);
941 ev.dtime = 0;
942
943 {
944 InSequence sequence;
945- EXPECT_CALL(pb, ReleaseBarrier(0xabba)).Times(0);
946+ EXPECT_CALL(*pb, ReleaseBarrier(0xabba)).Times(0);
947 }
948
949- EXPECT_TRUE(pb.HandleBarrierEvent(&ev));
950+ EXPECT_TRUE(pb->HandleBarrierEvent(&ev));
951
952- Utils::WaitForTimeoutMSec(pb.smoothing());
953+ Utils::WaitForTimeoutMSec(pb->smoothing());
954 }
955
956 TEST(TestPointerBarrier, ReleaseBarrierIfOverThreshold)
957 {
958- MockPointerBarrier pb;
959- pb.threshold = 500;
960+ auto pb = std::make_shared<MockPointerBarrier>();
961+ pb->threshold = 500;
962 XIBarrierEvent ev = GetGenericEvent(0xabba);
963
964 {
965 InSequence sequence;
966- EXPECT_CALL(pb, ReleaseBarrier(0xabba)).Times(1);
967+ EXPECT_CALL(*pb, ReleaseBarrier(0xabba)).Times(1);
968 }
969
970- EXPECT_TRUE(pb.HandleBarrierEvent(&ev));
971+ EXPECT_TRUE(pb->HandleBarrierEvent(&ev));
972
973- Utils::WaitForTimeoutMSec(pb.smoothing());
974+ Utils::WaitForTimeoutMSec(pb->smoothing());
975 }
976
977 }