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

[Andrea Azzarone]

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

[PS Jenkins bot (ps-jenkins)]

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)

[PS Jenkins bot (ps-jenkins)]

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)

[Marco Trevisan (Treviño) (3v1n0)]

Looks very nice, check my comments.

[Andrea Azzarone (azzar1)]

Done

[PS Jenkins bot (ps-jenkins)]

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)

[PS Jenkins bot (ps-jenkins)]

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)

[Stephen M. Webb (bregma)]

OK.

review: Approve

[Marco Trevisan (Treviño) (3v1n0)]

review: Approve

=== modified file 'launcher/EdgeBarrierController.cpp'
--- launcher/EdgeBarrierController.cpp	2014-02-27 05:30:25 +0000
+++ launcher/EdgeBarrierController.cpp	2015-01-14 02:47:10 +0000
@@ -318,7 +318,7 @@
   decaymulator_.value = 0;
 }
 
-void EdgeBarrierController::Impl::BarrierPush(PointerBarrierWrapper* owner, BarrierEvent::Ptr const& event)
+void EdgeBarrierController::Impl::BarrierPush(PointerBarrierWrapper::Ptr const& owner, BarrierEvent::Ptr const& event)
 {
   if ((owner->orientation == VERTICAL and EventIsInsideYBreakZone(event)) or
       (owner->orientation == HORIZONTAL and EventIsInsideXBreakZone(event)))
@@ -368,7 +368,7 @@
   return false;
 }
 
-void EdgeBarrierController::Impl::OnPointerBarrierEvent(PointerBarrierWrapper* owner, BarrierEvent::Ptr const& event)
+void EdgeBarrierController::Impl::OnPointerBarrierEvent(PointerBarrierWrapper::Ptr const& owner, BarrierEvent::Ptr const& event)
 {
   if (owner->released)
   {
@@ -418,7 +418,7 @@
   }
 }
 
-void EdgeBarrierController::Impl::BarrierRelease(PointerBarrierWrapper* owner, int event)
+void EdgeBarrierController::Impl::BarrierRelease(PointerBarrierWrapper::Ptr const& owner, int event)
 {
   owner->ReleaseBarrier(event);
   owner->released = true;
@@ -428,9 +428,14 @@
       (owner->release_once() && (!release_timeout_ || !release_timeout_->IsRunning())))
   {
     unsigned duration = parent_->options()->edge_passed_disabled_ms;
-    release_timeout_.reset(new glib::Timeout(duration, [owner] {
-      owner->released = false;
-      owner->release_once = false;
+
+    std::weak_ptr<PointerBarrierWrapper> owner_weak(owner);
+    release_timeout_.reset(new glib::Timeout(duration, [owner_weak] {
+      if (PointerBarrierWrapper::Ptr const& owner = owner_weak.lock())
+      {
+        owner->released = false;
+        owner->release_once = false;
+      }
       return false;
     }));
   }
 
=== modified file 'launcher/EdgeBarrierController.h'
--- launcher/EdgeBarrierController.h	2013-11-06 11:21:43 +0000
+++ launcher/EdgeBarrierController.h	2015-01-14 02:47:10 +0000
@@ -37,7 +37,7 @@
   };
 
   virtual ~EdgeBarrierSubscriber() {}
-  virtual Result HandleBarrierEvent(PointerBarrierWrapper* owner, BarrierEvent::Ptr event) = 0;
+  virtual Result HandleBarrierEvent(PointerBarrierWrapper::Ptr const& owner, BarrierEvent::Ptr event) = 0;
 };
 
 class EdgeBarrierController : public sigc::trackable
 
=== modified file 'launcher/EdgeBarrierControllerPrivate.h'
--- launcher/EdgeBarrierControllerPrivate.h	2014-02-27 05:30:25 +0000
+++ launcher/EdgeBarrierControllerPrivate.h	2015-01-14 02:47:10 +0000
@@ -44,9 +44,9 @@
   void OnUScreenChanged(int primary, std::vector<nux::Geometry> const& layout);
   void OnOptionsChanged();
 
-  void OnPointerBarrierEvent(PointerBarrierWrapper* owner, BarrierEvent::Ptr const& event);
-  void BarrierPush(PointerBarrierWrapper* owner, BarrierEvent::Ptr const& event);
-  void BarrierRelease(PointerBarrierWrapper* owner, int event);
+  void OnPointerBarrierEvent(PointerBarrierWrapper::Ptr const& owner, BarrierEvent::Ptr const& event);
+  void BarrierPush(PointerBarrierWrapper::Ptr const& owner, BarrierEvent::Ptr const& event);
+  void BarrierRelease(PointerBarrierWrapper::Ptr const& owner, int event);
   void BarrierReset();
 
   bool EventIsInsideYBreakZone(BarrierEvent::Ptr const& event);
 
=== modified file 'launcher/Launcher.cpp'
--- launcher/Launcher.cpp	2014-09-04 22:11:33 +0000
+++ launcher/Launcher.cpp	2015-01-14 02:47:10 +0000
@@ -2224,7 +2224,7 @@
 
 #ifdef USE_X11
 
-ui::EdgeBarrierSubscriber::Result Launcher::HandleBarrierEvent(ui::PointerBarrierWrapper* owner, ui::BarrierEvent::Ptr event)
+ui::EdgeBarrierSubscriber::Result Launcher::HandleBarrierEvent(ui::PointerBarrierWrapper::Ptr const& owner, ui::BarrierEvent::Ptr event)
 {
   if (hide_machine_.GetQuirk(LauncherHideMachine::EXTERNAL_DND_ACTIVE))
   {
 
=== modified file 'launcher/Launcher.h'
--- launcher/Launcher.h	2014-03-17 20:58:25 +0000
+++ launcher/Launcher.h	2015-01-14 02:47:10 +0000
@@ -200,7 +200,7 @@
 #endif
 
 #ifdef USE_X11
-  ui::EdgeBarrierSubscriber::Result HandleBarrierEvent(ui::PointerBarrierWrapper* owner, ui::BarrierEvent::Ptr event);
+  ui::EdgeBarrierSubscriber::Result HandleBarrierEvent(ui::PointerBarrierWrapper::Ptr const& owner, ui::BarrierEvent::Ptr event);
 #endif
 
   void OnExpoChanged();
 
=== modified file 'launcher/PointerBarrier.cpp'
--- launcher/PointerBarrier.cpp	2013-08-07 18:50:10 +0000
+++ launcher/PointerBarrier.cpp	2015-01-14 02:47:10 +0000
@@ -101,7 +101,7 @@
 {
   auto event = std::make_shared<BarrierEvent>(x, y, velocity, event_id);
 
-  barrier_event.emit(this, event);
+  barrier_event.emit(shared_from_this(), event);
 }
 
 bool PointerBarrierWrapper::IsFirstEvent() const
 
=== modified file 'launcher/PointerBarrier.h'
--- launcher/PointerBarrier.h	2013-08-08 14:43:50 +0000
+++ launcher/PointerBarrier.h	2015-01-14 02:47:10 +0000
@@ -62,7 +62,7 @@
   HORIZONTAL
 };
 
-class PointerBarrierWrapper : public sigc::trackable
+class PointerBarrierWrapper : public sigc::trackable, public std::enable_shared_from_this<PointerBarrierWrapper>
 {
 public:
   typedef std::shared_ptr<PointerBarrierWrapper> Ptr;
@@ -94,7 +94,7 @@
   virtual void DestroyBarrier();
   virtual void ReleaseBarrier(int event_id);
 
-  sigc::signal<void, PointerBarrierWrapper*, BarrierEvent::Ptr> barrier_event;
+  sigc::signal<void, PointerBarrierWrapper::Ptr const&, BarrierEvent::Ptr> barrier_event;
 
   bool IsFirstEvent() const;
 
 
=== modified file 'panel/PanelView.cpp'
--- panel/PanelView.cpp	2014-07-30 00:49:35 +0000
+++ panel/PanelView.cpp	2015-01-14 02:47:10 +0000
@@ -811,7 +811,7 @@
   return stored_dash_width_;
 }
 
-ui::EdgeBarrierSubscriber::Result PanelView::HandleBarrierEvent(ui::PointerBarrierWrapper* owner, ui::BarrierEvent::Ptr event)
+ui::EdgeBarrierSubscriber::Result PanelView::HandleBarrierEvent(ui::PointerBarrierWrapper::Ptr const& owner, ui::BarrierEvent::Ptr event)
 {
   if (WindowManager::Default().IsAnyWindowMoving())
     return ui::EdgeBarrierSubscriber::Result::IGNORED;
 
=== modified file 'panel/PanelView.h'
--- panel/PanelView.h	2014-03-06 16:26:34 +0000
+++ panel/PanelView.h	2015-01-14 02:47:10 +0000
@@ -73,7 +73,7 @@
 
   bool IsMouseInsideIndicator(nux::Point const& mouse_position) const;
 
-  ui::EdgeBarrierSubscriber::Result HandleBarrierEvent(ui::PointerBarrierWrapper* owner, ui::BarrierEvent::Ptr event) override;
+  ui::EdgeBarrierSubscriber::Result HandleBarrierEvent(ui::PointerBarrierWrapper::Ptr const& owner, ui::BarrierEvent::Ptr event) override;
 
 protected:
   void Draw(nux::GraphicsEngine& GfxContext, bool force_draw);
 
=== modified file 'tests/test_edge_barrier_controller.cpp'
--- tests/test_edge_barrier_controller.cpp	2013-11-06 11:21:43 +0000
+++ tests/test_edge_barrier_controller.cpp	2015-01-14 02:47:10 +0000
@@ -56,7 +56,7 @@
     : handle_result_(result)
   {}
 
-  EdgeBarrierSubscriber::Result HandleBarrierEvent(PointerBarrierWrapper* owner, BarrierEvent::Ptr event)
+  EdgeBarrierSubscriber::Result HandleBarrierEvent(PointerBarrierWrapper::Ptr const& owner, BarrierEvent::Ptr event)
   {
     return handle_result_;
   }
@@ -89,7 +89,7 @@
     }
   }
 
-  void ProcessBarrierEvent(PointerBarrierWrapper* owner, BarrierEvent::Ptr event)
+  void ProcessBarrierEvent(PointerBarrierWrapper::Ptr const& owner, BarrierEvent::Ptr event)
   {
     GetPrivateImpl()->OnPointerBarrierEvent(owner, event);
   }
@@ -203,11 +203,11 @@
   TestBarrierSubscriber handling_subscriber(EdgeBarrierSubscriber::Result::HANDLED);
   bc.AddVerticalSubscriber(&handling_subscriber, monitor);
 
-  MockPointerBarrierWrapper owner(monitor, false, VERTICAL);
+  auto owner = std::make_shared<MockPointerBarrierWrapper>(monitor, false, VERTICAL);
   auto breaking_barrier_event = MakeBarrierEvent(0, true);
 
-  EXPECT_CALL(owner, ReleaseBarrier(_)).Times(0);
-  ProcessBarrierEvent(&owner, breaking_barrier_event);
+  EXPECT_CALL(*owner, ReleaseBarrier(_)).Times(0);
+  ProcessBarrierEvent(owner, breaking_barrier_event);
   EXPECT_EQ(GetPrivateImpl()->decaymulator_.value(), 0);
 }
 
@@ -218,11 +218,11 @@
   TestBarrierSubscriber handling_subscriber(EdgeBarrierSubscriber::Result::HANDLED);
   bc.AddHorizontalSubscriber(&handling_subscriber, monitor);
 
-  MockPointerBarrierWrapper owner(monitor, false, HORIZONTAL);
+  auto owner = std::make_shared<MockPointerBarrierWrapper>(monitor, false, HORIZONTAL);
   auto breaking_barrier_event = MakeBarrierEvent(0, true);
 
-  EXPECT_CALL(owner, ReleaseBarrier(_)).Times(0);
-  ProcessBarrierEvent(&owner, breaking_barrier_event);
+  EXPECT_CALL(*owner, ReleaseBarrier(_)).Times(0);
+  ProcessBarrierEvent(owner, breaking_barrier_event);
   EXPECT_EQ(GetPrivateImpl()->decaymulator_.value(), 0);
 }
 
@@ -233,11 +233,11 @@
   TestBarrierSubscriber handling_subscriber(EdgeBarrierSubscriber::Result::HANDLED);
   bc.AddVerticalSubscriber(&handling_subscriber, monitor);
 
-  MockPointerBarrierWrapper owner(monitor, true, VERTICAL);
+  auto owner = std::make_shared<MockPointerBarrierWrapper>(monitor, true, VERTICAL);
   auto breaking_barrier_event = MakeBarrierEvent(5, true);
 
-  EXPECT_CALL(owner, ReleaseBarrier(5)).Times(1);
-  ProcessBarrierEvent(&owner, breaking_barrier_event);
+  EXPECT_CALL(*owner, ReleaseBarrier(5)).Times(1);
+  ProcessBarrierEvent(owner, breaking_barrier_event);
 }
 
 TEST_F(TestEdgeBarrierController, ProcessHandledEventOnReleasedBarrierForHorizontalSubscriber)
@@ -247,118 +247,118 @@
   TestBarrierSubscriber handling_subscriber(EdgeBarrierSubscriber::Result::HANDLED);
   bc.AddHorizontalSubscriber(&handling_subscriber, monitor);
 
-  MockPointerBarrierWrapper owner(monitor, true, HORIZONTAL);
+  auto owner = std::make_shared<MockPointerBarrierWrapper>(monitor, true, HORIZONTAL);
   auto breaking_barrier_event = MakeBarrierEvent(5, true);
 
-  EXPECT_CALL(owner, ReleaseBarrier(5)).Times(1);
-  ProcessBarrierEvent(&owner, breaking_barrier_event);
+  EXPECT_CALL(*owner, ReleaseBarrier(5)).Times(1);
+  ProcessBarrierEvent(owner, breaking_barrier_event);
 }
 
 TEST_F(TestEdgeBarrierController, ProcessUnHandledEventBreakingBarrierForVerticalSubscriber)
 {
   int monitor = 1;
 
-  MockPointerBarrierWrapper owner(monitor, false, VERTICAL);
+  auto owner = std::make_shared<MockPointerBarrierWrapper>(monitor, false, VERTICAL);
   int breaking_id = 12345;
   auto breaking_barrier_event = MakeBarrierEvent(breaking_id, true);
 
-  EXPECT_CALL(owner, ReleaseBarrier(breaking_id));
-  ProcessBarrierEvent(&owner, breaking_barrier_event);
+  EXPECT_CALL(*owner, ReleaseBarrier(breaking_id));
+  ProcessBarrierEvent(owner, breaking_barrier_event);
 }
 
 TEST_F(TestEdgeBarrierController, ProcessUnHandledEventBreakingBarrierForHorizontalSubscriber)
 {
   int monitor = 1;
 
-  MockPointerBarrierWrapper owner(monitor, false, HORIZONTAL);
+  auto owner = std::make_shared<MockPointerBarrierWrapper>(monitor, false, HORIZONTAL);
   int breaking_id = 12345;
   auto breaking_barrier_event = MakeBarrierEvent(breaking_id, true);
 
-  EXPECT_CALL(owner, ReleaseBarrier(breaking_id));
-  ProcessBarrierEvent(&owner, breaking_barrier_event);
+  EXPECT_CALL(*owner, ReleaseBarrier(breaking_id));
+  ProcessBarrierEvent(owner, breaking_barrier_event);
 }
 
 TEST_F(TestEdgeBarrierController, ProcessUnHandledEventBreakingBarrierOnMaxMonitorForVerticalSubscriber)
 {
   int monitor = monitors::MAX;
 
-  MockPointerBarrierWrapper owner(monitor, false, VERTICAL);
+  auto owner = std::make_shared<MockPointerBarrierWrapper>(monitor, false, VERTICAL);
   auto breaking_barrier_event = MakeBarrierEvent(0, true);
 
-  EXPECT_CALL(owner, ReleaseBarrier(_));
-  ProcessBarrierEvent(&owner, breaking_barrier_event);
+  EXPECT_CALL(*owner, ReleaseBarrier(_));
+  ProcessBarrierEvent(owner, breaking_barrier_event);
 }
 
 TEST_F(TestEdgeBarrierController, ProcessUnHandledEventBreakingBarrierOnMaxMonitorForHorizontalSubscriber)
 {
   int monitor = monitors::MAX;
 
-  MockPointerBarrierWrapper owner(monitor, false, HORIZONTAL);
+  auto owner = std::make_shared<MockPointerBarrierWrapper>(monitor, false, HORIZONTAL);
   auto breaking_barrier_event = MakeBarrierEvent(0, true);
 
-  EXPECT_CALL(owner, ReleaseBarrier(_));
-  ProcessBarrierEvent(&owner, breaking_barrier_event);
+  EXPECT_CALL(*owner, ReleaseBarrier(_));
+  ProcessBarrierEvent(owner, breaking_barrier_event);
 }
 
 TEST_F(TestEdgeBarrierController, ProcessUnHandledEventNotBreakingBarrierForVerticalSubscriber)
 {
   int monitor = 2;
 
-  MockPointerBarrierWrapper owner(monitor, false, VERTICAL);
+  auto owner = std::make_shared<MockPointerBarrierWrapper>(monitor, false, VERTICAL);
   int not_breaking_id = 54321;
   auto not_breaking_barrier_event = MakeBarrierEvent(not_breaking_id, false);
 
-  EXPECT_CALL(owner, ReleaseBarrier(not_breaking_id)).Times(0);
-  ProcessBarrierEvent(&owner, not_breaking_barrier_event);
+  EXPECT_CALL(*owner, ReleaseBarrier(not_breaking_id)).Times(0);
+  ProcessBarrierEvent(owner, not_breaking_barrier_event);
 }
 
 TEST_F(TestEdgeBarrierController, ProcessUnHandledEventNotBreakingBarrierForHorizontalSubscriber)
 {
   int monitor = 2;
 
-  MockPointerBarrierWrapper owner(monitor, false, HORIZONTAL);
+  auto owner =  std::make_shared<MockPointerBarrierWrapper>(monitor, false, HORIZONTAL);
   int not_breaking_id = 54321;
   auto not_breaking_barrier_event = MakeBarrierEvent(not_breaking_id, false);
 
-  EXPECT_CALL(owner, ReleaseBarrier(not_breaking_id)).Times(0);
-  ProcessBarrierEvent(&owner, not_breaking_barrier_event);
+  EXPECT_CALL(*owner, ReleaseBarrier(not_breaking_id)).Times(0);
+  ProcessBarrierEvent(owner, not_breaking_barrier_event);
 }
 
 TEST_F(TestEdgeBarrierController, ProcessUnHandledEventOnReleasedBarrierForVerticalSubscriber)
 {
   int monitor = 2;
 
-  MockPointerBarrierWrapper owner(monitor, true, VERTICAL);
+  auto owner = std::make_shared<MockPointerBarrierWrapper>(monitor, true, VERTICAL);
   int not_breaking_id = 345678;
   auto not_breaking_barrier_event = MakeBarrierEvent(not_breaking_id, false);
 
-  EXPECT_CALL(owner, ReleaseBarrier(not_breaking_id));
-  ProcessBarrierEvent(&owner, not_breaking_barrier_event);
+  EXPECT_CALL(*owner, ReleaseBarrier(not_breaking_id));
+  ProcessBarrierEvent(owner, not_breaking_barrier_event);
 }
 
 TEST_F(TestEdgeBarrierController, ProcessUnHandledEventOnReleasedBarrierForHorizontalSubscriber)
 {
   int monitor = 2;
 
-  MockPointerBarrierWrapper owner(monitor, true, HORIZONTAL);
+  auto owner = std::make_shared<MockPointerBarrierWrapper>(monitor, true, HORIZONTAL);
   int not_breaking_id = 345678;
   auto not_breaking_barrier_event = MakeBarrierEvent(not_breaking_id, false);
 
-  EXPECT_CALL(owner, ReleaseBarrier(not_breaking_id));
-  ProcessBarrierEvent(&owner, not_breaking_barrier_event);
+  EXPECT_CALL(*owner, ReleaseBarrier(not_breaking_id));
+  ProcessBarrierEvent(owner, not_breaking_barrier_event);
 }
 
 TEST_F(TestEdgeBarrierController, ProcessAlreadyHandledEventForVerticalSubscriber)
 {
   int monitor = g_random_int_range(0, monitors::MAX);
 
-  MockPointerBarrierWrapper owner(monitor, false, VERTICAL);
+  auto owner = std::make_shared<MockPointerBarrierWrapper>(monitor, false, VERTICAL);
   vertical_subscribers_[monitor].handle_result_ = EdgeBarrierSubscriber::Result::ALREADY_HANDLED;
 
   auto event = MakeBarrierEvent(g_random_int(), false);
 
-  EXPECT_CALL(owner, ReleaseBarrier(_)).Times(0);
-  ProcessBarrierEvent(&owner, event);
+  EXPECT_CALL(*owner, ReleaseBarrier(_)).Times(0);
+  ProcessBarrierEvent(owner, event);
   EXPECT_EQ(GetPrivateImpl()->decaymulator_.value(), event->velocity);
 }
 
@@ -366,13 +366,13 @@
 {
   int monitor = g_random_int_range(0, monitors::MAX);
 
-  MockPointerBarrierWrapper owner(monitor, false, HORIZONTAL);
+  auto owner = std::make_shared<MockPointerBarrierWrapper>(monitor, false, HORIZONTAL);
   horizontal_subscribers_[monitor].handle_result_ = EdgeBarrierSubscriber::Result::ALREADY_HANDLED;
 
   auto event = MakeBarrierEvent(g_random_int(), false);
 
-  EXPECT_CALL(owner, ReleaseBarrier(_)).Times(0);
-  ProcessBarrierEvent(&owner, event);
+  EXPECT_CALL(*owner, ReleaseBarrier(_)).Times(0);
+  ProcessBarrierEvent(owner, event);
   EXPECT_EQ(GetPrivateImpl()->decaymulator_.value(), event->velocity);
 }
 
@@ -381,15 +381,15 @@
   int monitor = g_random_int_range(0, monitors::MAX);
 
   bc.sticky_edges = true;
-  MockPointerBarrierWrapper owner(monitor, false, VERTICAL);
+  auto owner = std::make_shared<MockPointerBarrierWrapper>(monitor, false, VERTICAL);
   vertical_subscribers_[monitor].handle_result_ = EdgeBarrierSubscriber::Result::IGNORED;
 
   auto event = MakeBarrierEvent(g_random_int(), false);
 
-  EXPECT_CALL(owner, ReleaseBarrier(_)).Times(0);
-  ProcessBarrierEvent(&owner, event);
-  EXPECT_FALSE(owner.released());
-  EXPECT_FALSE(owner.release_once());
+  EXPECT_CALL(*owner, ReleaseBarrier(_)).Times(0);
+  ProcessBarrierEvent(owner, event);
+  EXPECT_FALSE(owner->released());
+  EXPECT_FALSE(owner->release_once());
   EXPECT_EQ(GetPrivateImpl()->decaymulator_.value(), event->velocity);
 }
 
@@ -398,15 +398,15 @@
   int monitor = g_random_int_range(0, monitors::MAX);
 
   bc.sticky_edges = true;
-  MockPointerBarrierWrapper owner(monitor, false, HORIZONTAL);
+  auto owner = std::make_shared<MockPointerBarrierWrapper>(monitor, false, HORIZONTAL);
   horizontal_subscribers_[monitor].handle_result_ = EdgeBarrierSubscriber::Result::IGNORED;
 
   auto event = MakeBarrierEvent(g_random_int(), false);
 
-  EXPECT_CALL(owner, ReleaseBarrier(_)).Times(0);
-  ProcessBarrierEvent(&owner, event);
-  EXPECT_FALSE(owner.released());
-  EXPECT_FALSE(owner.release_once());
+  EXPECT_CALL(*owner, ReleaseBarrier(_)).Times(0);
+  ProcessBarrierEvent(owner, event);
+  EXPECT_FALSE(owner->released());
+  EXPECT_FALSE(owner->release_once());
   EXPECT_EQ(GetPrivateImpl()->decaymulator_.value(), event->velocity);
 }
 
@@ -415,15 +415,15 @@
   int monitor = g_random_int_range(0, monitors::MAX);
 
   bc.sticky_edges = false;
-  MockPointerBarrierWrapper owner(monitor, false, VERTICAL);
+  auto owner = std::make_shared<MockPointerBarrierWrapper>(monitor, false, VERTICAL);
   vertical_subscribers_[monitor].handle_result_ = EdgeBarrierSubscriber::Result::IGNORED;
 
   auto event = MakeBarrierEvent(g_random_int(), false);
 
-  EXPECT_CALL(owner, ReleaseBarrier(event->event_id));
-  ProcessBarrierEvent(&owner, event);
-  EXPECT_TRUE(owner.released());
-  EXPECT_TRUE(owner.release_once());
+  EXPECT_CALL(*owner, ReleaseBarrier(event->event_id));
+  ProcessBarrierEvent(owner, event);
+  EXPECT_TRUE(owner->released());
+  EXPECT_TRUE(owner->release_once());
   EXPECT_EQ(GetPrivateImpl()->decaymulator_.value(), 0);
 }
 
@@ -432,15 +432,15 @@
   int monitor = g_random_int_range(0, monitors::MAX);
 
   bc.sticky_edges = false;
-  MockPointerBarrierWrapper owner(monitor, false, HORIZONTAL);
+  auto owner = std::make_shared<MockPointerBarrierWrapper>(monitor, false, HORIZONTAL);
   horizontal_subscribers_[monitor].handle_result_ = EdgeBarrierSubscriber::Result::IGNORED;
 
   auto event = MakeBarrierEvent(g_random_int(), false);
 
-  EXPECT_CALL(owner, ReleaseBarrier(event->event_id));
-  ProcessBarrierEvent(&owner, event);
-  EXPECT_TRUE(owner.released());
-  EXPECT_TRUE(owner.release_once());
+  EXPECT_CALL(*owner, ReleaseBarrier(event->event_id));
+  ProcessBarrierEvent(owner, event);
+  EXPECT_TRUE(owner->released());
+  EXPECT_TRUE(owner->release_once());
   EXPECT_EQ(GetPrivateImpl()->decaymulator_.value(), 0);
 }
 
@@ -448,13 +448,13 @@
 {
   int monitor = g_random_int_range(0, monitors::MAX);
 
-  MockPointerBarrierWrapper owner(monitor, false, VERTICAL);
+  auto owner = std::make_shared<MockPointerBarrierWrapper>(monitor, false, VERTICAL);
   vertical_subscribers_[monitor].handle_result_ = EdgeBarrierSubscriber::Result::NEEDS_RELEASE;
 
   auto event = MakeBarrierEvent(g_random_int(), false);
 
-  EXPECT_CALL(owner, ReleaseBarrier(event->event_id));
-  ProcessBarrierEvent(&owner, event);
+  EXPECT_CALL(*owner, ReleaseBarrier(event->event_id));
+  ProcessBarrierEvent(owner, event);
   EXPECT_EQ(GetPrivateImpl()->decaymulator_.value(), 0);
 }
 
@@ -462,100 +462,100 @@
 {
   int monitor = g_random_int_range(0, monitors::MAX);
 
-  MockPointerBarrierWrapper owner(monitor, false, HORIZONTAL);
+  auto owner = std::make_shared<MockPointerBarrierWrapper>(monitor, false, HORIZONTAL);
   horizontal_subscribers_[monitor].handle_result_ = EdgeBarrierSubscriber::Result::NEEDS_RELEASE;
 
   auto event = MakeBarrierEvent(g_random_int(), false);
 
-  EXPECT_CALL(owner, ReleaseBarrier(event->event_id));
-  ProcessBarrierEvent(&owner, event);
+  EXPECT_CALL(*owner, ReleaseBarrier(event->event_id));
+  ProcessBarrierEvent(owner, event);
   EXPECT_EQ(GetPrivateImpl()->decaymulator_.value(), 0);
 }
 
 TEST_F(TestEdgeBarrierController, BreakingEdgeTemporaryReleasesBarrierForVerticalSubscriber)
 {
   int monitor = g_random_int_range(0, monitors::MAX);
-  MockPointerBarrierWrapper owner(monitor, false, VERTICAL);
+  auto owner = std::make_shared<MockPointerBarrierWrapper>(monitor, false, VERTICAL);
 
-  EXPECT_CALL(owner, ReleaseBarrier(1));
-  ProcessBarrierEvent(&owner, MakeBarrierEvent(1, true));
-  ASSERT_TRUE(owner.released());
+  EXPECT_CALL(*owner, ReleaseBarrier(1));
+  ProcessBarrierEvent(owner, MakeBarrierEvent(1, true));
+  ASSERT_TRUE(owner->released());
 
   Utils::WaitForTimeoutMSec(bc.options()->edge_passed_disabled_ms);
-  EXPECT_FALSE(owner.released());
+  EXPECT_FALSE(owner->released());
 }
 
 TEST_F(TestEdgeBarrierController, BreakingEdgeTemporaryReleasesBarrierForHoriziontalSubscriber)
 {
   int monitor = g_random_int_range(0, monitors::MAX);
-  MockPointerBarrierWrapper owner(monitor, false, HORIZONTAL);
+  auto owner = std::make_shared<MockPointerBarrierWrapper>(monitor, false, HORIZONTAL);
 
-  EXPECT_CALL(owner, ReleaseBarrier(1));
-  ProcessBarrierEvent(&owner, MakeBarrierEvent(1, true));
-  ASSERT_TRUE(owner.released());
+  EXPECT_CALL(*owner, ReleaseBarrier(1));
+  ProcessBarrierEvent(owner, MakeBarrierEvent(1, true));
+  ASSERT_TRUE(owner->released());
 
   Utils::WaitForTimeoutMSec(bc.options()->edge_passed_disabled_ms);
-  EXPECT_FALSE(owner.released());
+  EXPECT_FALSE(owner->released());
 }
 
 TEST_F(TestEdgeBarrierController, BreakingEdgeTemporaryReleasesBarrierForNotHandledEventsForVerticalSubscriber)
 {
   int monitor = 0;
-  MockPointerBarrierWrapper owner(monitor, false, VERTICAL);
-  vertical_subscribers_[monitor].handle_result_ = EdgeBarrierSubscriber::Result::IGNORED;
-
-  EXPECT_CALL(owner, ReleaseBarrier(5));
-  ProcessBarrierEvent(&owner, MakeBarrierEvent(5, true));
-  ASSERT_TRUE(owner.released());
-
-  vertical_subscribers_[monitor].handle_result_ = EdgeBarrierSubscriber::Result::IGNORED;
-  EXPECT_CALL(owner, ReleaseBarrier(6));
-  ProcessBarrierEvent(&owner, MakeBarrierEvent(6, false));
+  auto owner = std::make_shared<MockPointerBarrierWrapper>(monitor, false, VERTICAL);
+  vertical_subscribers_[monitor].handle_result_ = EdgeBarrierSubscriber::Result::IGNORED;
+
+  EXPECT_CALL(*owner, ReleaseBarrier(5));
+  ProcessBarrierEvent(owner, MakeBarrierEvent(5, true));
+  ASSERT_TRUE(owner->released());
+
+  vertical_subscribers_[monitor].handle_result_ = EdgeBarrierSubscriber::Result::IGNORED;
+  EXPECT_CALL(*owner, ReleaseBarrier(6));
+  ProcessBarrierEvent(owner, MakeBarrierEvent(6, false));
 }
 
 TEST_F(TestEdgeBarrierController, BreakingEdgeTemporaryReleasesBarrierForNotHandledEventsForHorizontalSubscriber)
 {
   int monitor = 0;
-  MockPointerBarrierWrapper owner(monitor, false, HORIZONTAL);
-  horizontal_subscribers_[monitor].handle_result_ = EdgeBarrierSubscriber::Result::IGNORED;
-
-  EXPECT_CALL(owner, ReleaseBarrier(5));
-  ProcessBarrierEvent(&owner, MakeBarrierEvent(5, true));
-  ASSERT_TRUE(owner.released());
-
-  horizontal_subscribers_[monitor].handle_result_ = EdgeBarrierSubscriber::Result::IGNORED;
-  EXPECT_CALL(owner, ReleaseBarrier(6));
-  ProcessBarrierEvent(&owner, MakeBarrierEvent(6, false));
+  auto owner = std::make_shared<MockPointerBarrierWrapper>(monitor, false, HORIZONTAL);
+  horizontal_subscribers_[monitor].handle_result_ = EdgeBarrierSubscriber::Result::IGNORED;
+
+  EXPECT_CALL(*owner, ReleaseBarrier(5));
+  ProcessBarrierEvent(owner, MakeBarrierEvent(5, true));
+  ASSERT_TRUE(owner->released());
+
+  horizontal_subscribers_[monitor].handle_result_ = EdgeBarrierSubscriber::Result::IGNORED;
+  EXPECT_CALL(*owner, ReleaseBarrier(6));
+  ProcessBarrierEvent(owner, MakeBarrierEvent(6, false));
 }
 
 TEST_F(TestEdgeBarrierController, BreakingEdgeTemporaryReleasesBarrierForHandledEventsForVerticalSubscriber)
 {
   int monitor = 0;
-  MockPointerBarrierWrapper owner(monitor, false, VERTICAL);
+  auto owner = std::make_shared<MockPointerBarrierWrapper>(monitor, false, VERTICAL);
   vertical_subscribers_[monitor].handle_result_ = EdgeBarrierSubscriber::Result::IGNORED;
 
-  EXPECT_CALL(owner, ReleaseBarrier(5));
-  ProcessBarrierEvent(&owner, MakeBarrierEvent(5, true));
-  ASSERT_TRUE(owner.released());
+  EXPECT_CALL(*owner, ReleaseBarrier(5));
+  ProcessBarrierEvent(owner, MakeBarrierEvent(5, true));
+  ASSERT_TRUE(owner->released());
 
   vertical_subscribers_[monitor].handle_result_ = EdgeBarrierSubscriber::Result::HANDLED;
-  EXPECT_CALL(owner, ReleaseBarrier(6)).Times(1);
-  ProcessBarrierEvent(&owner, MakeBarrierEvent(6, true));
+  EXPECT_CALL(*owner, ReleaseBarrier(6)).Times(1);
+  ProcessBarrierEvent(owner, MakeBarrierEvent(6, true));
 }
 
 TEST_F(TestEdgeBarrierController, BreakingEdgeTemporaryReleasesBarrierForHandledEventsForHoriziontalSubscriber)
 {
   int monitor = 0;
-  MockPointerBarrierWrapper owner(monitor, false, HORIZONTAL);
+  auto owner = std::make_shared<MockPointerBarrierWrapper>(monitor, false, HORIZONTAL);
   horizontal_subscribers_[monitor].handle_result_ = EdgeBarrierSubscriber::Result::IGNORED;
 
-  EXPECT_CALL(owner, ReleaseBarrier(5));
-  ProcessBarrierEvent(&owner, MakeBarrierEvent(5, true));
-  ASSERT_TRUE(owner.released());
+  EXPECT_CALL(*owner, ReleaseBarrier(5));
+  ProcessBarrierEvent(owner, MakeBarrierEvent(5, true));
+  ASSERT_TRUE(owner->released());
 
   horizontal_subscribers_[monitor].handle_result_ = EdgeBarrierSubscriber::Result::HANDLED;
-  EXPECT_CALL(owner, ReleaseBarrier(6)).Times(1);
-  ProcessBarrierEvent(&owner, MakeBarrierEvent(6, true));
+  EXPECT_CALL(*owner, ReleaseBarrier(6)).Times(1);
+  ProcessBarrierEvent(owner, MakeBarrierEvent(6, true));
 }
 
 TEST_F(TestEdgeBarrierController, StickyEdgePropertyProxiesLauncherOption)
@@ -587,70 +587,70 @@
 
 TEST_F(TestEdgeBarrierController, VerticalBarrierDoesNotBreakIfYEventToFarApart)
 {
-  MockPointerBarrierWrapper owner(0, false, VERTICAL);
+  auto owner = std::make_shared<MockPointerBarrierWrapper>(0, false, VERTICAL);
 
   int velocity = bc.options()->edge_overcome_pressure() * bc.options()->edge_responsiveness();
   auto firstEvent = std::make_shared<BarrierEvent>(0, 50, velocity, 10);
   auto secondEvent = std::make_shared<BarrierEvent>(0, 150, velocity, 11);
 
-  EXPECT_CALL(owner, ReleaseBarrier(_)).Times(0);
-  ProcessBarrierEvent(&owner, firstEvent);
-  ProcessBarrierEvent(&owner, secondEvent);
+  EXPECT_CALL(*owner, ReleaseBarrier(_)).Times(0);
+  ProcessBarrierEvent(owner, firstEvent);
+  ProcessBarrierEvent(owner, secondEvent);
 }
 
 TEST_F(TestEdgeBarrierController, HorizontalBarrierDoesNotBreakIfXEventToFarApart)
 {
-  MockPointerBarrierWrapper owner(0, false, HORIZONTAL);
+  auto owner = std::make_shared<MockPointerBarrierWrapper>(0, false, HORIZONTAL);
 
   int velocity = bc.options()->edge_overcome_pressure() * bc.options()->edge_responsiveness();
   auto firstEvent = std::make_shared<BarrierEvent>(50, 0, velocity, 10);
   auto secondEvent = std::make_shared<BarrierEvent>(150, 0, velocity, 11);
 
-  EXPECT_CALL(owner, ReleaseBarrier(_)).Times(0);
-  ProcessBarrierEvent(&owner, firstEvent);
-  ProcessBarrierEvent(&owner, secondEvent);
+  EXPECT_CALL(*owner, ReleaseBarrier(_)).Times(0);
+  ProcessBarrierEvent(owner, firstEvent);
+  ProcessBarrierEvent(owner, secondEvent);
 }
 
 TEST_F(TestEdgeBarrierController, VerticalBarrierBreaksInYBreakZone)
 {
-  MockPointerBarrierWrapper owner(0, false, VERTICAL);
+  auto owner = std::make_shared<MockPointerBarrierWrapper>(0, false, VERTICAL);
 
   int velocity = bc.options()->edge_overcome_pressure() * bc.options()->edge_responsiveness();
   auto firstEvent = std::make_shared<BarrierEvent>(0, 50, velocity, 10);
 
-  EXPECT_CALL(owner, ReleaseBarrier(_)).Times(1);
-  ProcessBarrierEvent(&owner, firstEvent);
-  ProcessBarrierEvent(&owner, firstEvent);
+  EXPECT_CALL(*owner, ReleaseBarrier(_)).Times(1);
+  ProcessBarrierEvent(owner, firstEvent);
+  ProcessBarrierEvent(owner, firstEvent);
 }
 
 TEST_F(TestEdgeBarrierController, HorizontalBarrierBreaksInXBreakZone)
 {
-  MockPointerBarrierWrapper owner(0, false, HORIZONTAL);
+  auto owner = std::make_shared<MockPointerBarrierWrapper>(0, false, HORIZONTAL);
 
   int velocity = bc.options()->edge_overcome_pressure() * bc.options()->edge_responsiveness();
   auto firstEvent = std::make_shared<BarrierEvent>(50, 0, velocity, 10);
 
-  EXPECT_CALL(owner, ReleaseBarrier(_)).Times(1);
-  ProcessBarrierEvent(&owner, firstEvent);
-  ProcessBarrierEvent(&owner, firstEvent);
+  EXPECT_CALL(*owner, ReleaseBarrier(_)).Times(1);
+  ProcessBarrierEvent(owner, firstEvent);
+  ProcessBarrierEvent(owner, firstEvent);
 }
 
 TEST_F(TestEdgeBarrierController, VerticalBarrierReleaseIfNoSubscriberForMonitor)
 {
-  MockPointerBarrierWrapper owner(monitors::MAX, false, VERTICAL);
+  auto owner = std::make_shared<MockPointerBarrierWrapper>(monitors::MAX, false, VERTICAL);
   auto firstEvent = std::make_shared<BarrierEvent>(0, 50, 1, 10);
 
-  EXPECT_CALL(owner, ReleaseBarrier(_)).Times(1);
-  ProcessBarrierEvent(&owner, firstEvent);
+  EXPECT_CALL(*owner, ReleaseBarrier(_)).Times(1);
+  ProcessBarrierEvent(owner, firstEvent);
 }
 
 TEST_F(TestEdgeBarrierController, HorizontalBarrierReleaseIfNoSubscriberForMonitor)
 {
-  MockPointerBarrierWrapper owner(monitors::MAX, false, HORIZONTAL);
+  auto owner = std::make_shared<MockPointerBarrierWrapper>(monitors::MAX, false, HORIZONTAL);
   auto firstEvent = std::make_shared<BarrierEvent>(50, 0, 1, 10);
 
-  EXPECT_CALL(owner, ReleaseBarrier(_)).Times(1);
-  ProcessBarrierEvent(&owner, firstEvent);
+  EXPECT_CALL(*owner, ReleaseBarrier(_)).Times(1);
+  ProcessBarrierEvent(owner, firstEvent);
 }
 
 }
 
=== modified file 'tests/test_launcher.cpp'
--- tests/test_launcher.cpp	2014-03-21 04:40:12 +0000
+++ tests/test_launcher.cpp	2015-01-14 02:47:10 +0000
@@ -502,7 +502,7 @@
 
   launcher_->DndStarted("");
 
-  EXPECT_EQ(launcher_->HandleBarrierEvent(barrier.get(), event),
+  EXPECT_EQ(launcher_->HandleBarrierEvent(barrier, event),
             ui::EdgeBarrierSubscriber::Result::NEEDS_RELEASE);
 }
 
@@ -515,24 +515,24 @@
 
   event->x = launcher_geo.x-1;
   event->y = launcher_geo.y;
-  EXPECT_EQ(launcher_->HandleBarrierEvent(barrier.get(), event),
+  EXPECT_EQ(launcher_->HandleBarrierEvent(barrier, event),
             ui::EdgeBarrierSubscriber::Result::IGNORED);
 
   event->x = launcher_geo.x+launcher_geo.width+1;
   event->y = launcher_geo.y;
-  EXPECT_EQ(launcher_->HandleBarrierEvent(barrier.get(), event),
+  EXPECT_EQ(launcher_->HandleBarrierEvent(barrier, event),
             ui::EdgeBarrierSubscriber::Result::IGNORED);
 
   options_->reveal_trigger = RevealTrigger::EDGE;
   event->x = launcher_geo.x+launcher_geo.width/2;
   event->y = launcher_geo.y - 1;
-  EXPECT_EQ(launcher_->HandleBarrierEvent(barrier.get(), event),
+  EXPECT_EQ(launcher_->HandleBarrierEvent(barrier, event),
             ui::EdgeBarrierSubscriber::Result::IGNORED);
 
   options_->reveal_trigger = RevealTrigger::CORNER;
   event->x = launcher_geo.x+launcher_geo.width/2;
   event->y = launcher_geo.y;
-  EXPECT_EQ(launcher_->HandleBarrierEvent(barrier.get(), event),
+  EXPECT_EQ(launcher_->HandleBarrierEvent(barrier, event),
             ui::EdgeBarrierSubscriber::Result::IGNORED);
 }
 
@@ -551,7 +551,7 @@
     {
       event->x = x;
       event->y = y;
-      ASSERT_EQ(launcher_->HandleBarrierEvent(barrier.get(), event),
+      ASSERT_EQ(launcher_->HandleBarrierEvent(barrier, event),
                 ui::EdgeBarrierSubscriber::Result::HANDLED);
     }
   }
@@ -564,7 +564,7 @@
     {
       event->x = x;
       event->y = y;
-      ASSERT_EQ(launcher_->HandleBarrierEvent(barrier.get(), event),
+      ASSERT_EQ(launcher_->HandleBarrierEvent(barrier, event),
                 ui::EdgeBarrierSubscriber::Result::HANDLED);
     }
   }
 
=== modified file 'tests/test_panel_view.cpp'
--- tests/test_panel_view.cpp	2014-03-21 04:40:12 +0000
+++ tests/test_panel_view.cpp	2015-01-14 02:47:10 +0000
@@ -80,11 +80,11 @@
   auto event = std::make_shared<ui::BarrierEvent>(0, 0, 0, 100);
 
   WM->SetIsAnyWindowMoving(false);
-  EXPECT_EQ(panel_view_->HandleBarrierEvent(barrier.get(), event),
+  EXPECT_EQ(panel_view_->HandleBarrierEvent(barrier, event),
             ui::EdgeBarrierSubscriber::Result::NEEDS_RELEASE);
 
   WM->SetIsAnyWindowMoving(true);
-  EXPECT_EQ(panel_view_->HandleBarrierEvent(barrier.get(), event),
+  EXPECT_EQ(panel_view_->HandleBarrierEvent(barrier, event),
             ui::EdgeBarrierSubscriber::Result::IGNORED);
 }
 
 
=== modified file 'tests/test_pointer_barrier.cpp'
--- tests/test_pointer_barrier.cpp	2013-07-09 23:18:29 +0000
+++ tests/test_pointer_barrier.cpp	2015-01-14 02:47:10 +0000
@@ -79,79 +79,79 @@
 
 TEST(TestPointerBarrier, HandleHitNotifyEvents)
 {
-  MockPointerBarrier pb;
-  pb.threshold = 1000;
+  auto pb = std::make_shared<MockPointerBarrier>();
+  pb->threshold = 1000;
   XIBarrierEvent ev = GetGenericEvent(0xdeadbeef);
 
   bool got_event = false;
 
-  pb.barrier_event.connect([&] (PointerBarrierWrapper* pbw, BarrierEvent::Ptr bev) {
+  pb->barrier_event.connect([&] (PointerBarrierWrapper::Ptr const& pbw, BarrierEvent::Ptr bev) {
     if (!pbw->IsFirstEvent())
     {
       got_event = true;
 
-      EXPECT_EQ(pbw, &pb);
+      EXPECT_EQ(pbw.get(), pb.get());
       EXPECT_EQ(bev->x, ev.root_x);
       EXPECT_EQ(bev->y, ev.root_y);
-      EXPECT_EQ(bev->velocity, 600 * pb.max_velocity_multiplier);
+      EXPECT_EQ(bev->velocity, 600 * pb->max_velocity_multiplier);
       EXPECT_EQ(bev->event_id, ev.eventid);
      }
   });
 
-  EXPECT_TRUE(pb.HandleBarrierEvent(&ev));
+  EXPECT_TRUE(pb->HandleBarrierEvent(&ev));
   EXPECT_FALSE(got_event);
 
-  Utils::WaitForTimeoutMSec(pb.smoothing());
+  Utils::WaitForTimeoutMSec(pb->smoothing());
 
   EXPECT_TRUE(got_event);
 }
 
 TEST(TestPointerBarrier, HandleHitNotifyReleasedEvents)
 {
-  MockPointerBarrier pb;
-  pb.threshold = 1000;
+  auto pb = std::make_shared<MockPointerBarrier>();
+  pb->threshold = 1000;
   XIBarrierEvent ev = GetGenericEvent(0xabba);
   bool got_event = false;
 
-  pb.barrier_event.connect([&] (PointerBarrierWrapper* pbw, BarrierEvent::Ptr bev) {
+  pb->barrier_event.connect([&] (PointerBarrierWrapper::Ptr const& pbw, BarrierEvent::Ptr bev) {
     got_event = true;
 
-    EXPECT_EQ(pbw, &pb);
+    EXPECT_EQ(pbw.get(), pb.get());
     EXPECT_EQ(bev->x, ev.root_x);
     EXPECT_EQ(bev->y, ev.root_y);
     EXPECT_GT(bev->velocity, 0);
     EXPECT_EQ(bev->event_id, ev.eventid);
   });
 
-  pb.released = true;
-  EXPECT_TRUE(pb.HandleBarrierEvent(&ev));
+  pb->released = true;
+  EXPECT_TRUE(pb->HandleBarrierEvent(&ev));
   EXPECT_TRUE(got_event);
 }
 
 TEST(TestPointerBarrier, ReciveFirstEvent)
 {
-  MockPointerBarrier pb;
-  pb.threshold = 1000;
+  auto pb = std::make_shared<MockPointerBarrier>();
+  pb->threshold = 1000;
   XIBarrierEvent ev = GetGenericEvent(0xabba);
 
   bool first_is_true = false;
 
-  pb.barrier_event.connect([&] (PointerBarrierWrapper* pbw, BarrierEvent::Ptr bev) {
+  pb->barrier_event.connect([&] (PointerBarrierWrapper::Ptr const& pbw, BarrierEvent::Ptr bev) {
     first_is_true = true;
   });
 
-  EXPECT_TRUE(pb.HandleBarrierEvent(&ev));
+  EXPECT_TRUE(pb->HandleBarrierEvent(&ev));
   EXPECT_TRUE(first_is_true);
 }
 
 TEST(TestPointerBarrier, ReciveSecondEventFirstFalse)
 {
-  MockPointerBarrier pb;
-  pb.threshold = 1000;
+  auto pb = std::make_shared<MockPointerBarrier>();
+  pb->threshold = 1000;
   XIBarrierEvent ev = GetGenericEvent(0xabba);
   int events_recived = 0;
 
-  pb.barrier_event.connect([&] (PointerBarrierWrapper* pbw, BarrierEvent::Ptr bev) {
+  pb->barrier_event.connect([&] (PointerBarrierWrapper::Ptr const& pbw, BarrierEvent::Ptr bev) {
       events_recived++;
 
       if (events_recived == 1)
@@ -160,44 +160,44 @@
         EXPECT_FALSE(pbw->IsFirstEvent());
   });
 
-  EXPECT_TRUE(pb.HandleBarrierEvent(&ev));
+  EXPECT_TRUE(pb->HandleBarrierEvent(&ev));
 
-  Utils::WaitForTimeoutMSec(pb.smoothing());
+  Utils::WaitForTimeoutMSec(pb->smoothing());
 
   EXPECT_EQ(events_recived, 2);
 }
 
 TEST(TestPointerBarrier, DontReleaseBarrierOnEmptyDTime)
 {
-  MockPointerBarrier pb;
-  pb.threshold = 1000;
+  auto pb = std::make_shared<MockPointerBarrier>();
+  pb->threshold = 1000;
   XIBarrierEvent ev = GetGenericEvent(0xabba);
   ev.dtime = 0;
 
   {
     InSequence sequence;
-    EXPECT_CALL(pb, ReleaseBarrier(0xabba)).Times(0);
+    EXPECT_CALL(*pb, ReleaseBarrier(0xabba)).Times(0);
   }
 
-  EXPECT_TRUE(pb.HandleBarrierEvent(&ev));
+  EXPECT_TRUE(pb->HandleBarrierEvent(&ev));
 
-  Utils::WaitForTimeoutMSec(pb.smoothing());
+  Utils::WaitForTimeoutMSec(pb->smoothing());
 }
 
 TEST(TestPointerBarrier, ReleaseBarrierIfOverThreshold)
 {
-  MockPointerBarrier pb;
-  pb.threshold = 500;
+  auto pb = std::make_shared<MockPointerBarrier>();
+  pb->threshold = 500;
   XIBarrierEvent ev = GetGenericEvent(0xabba);
 
   {
     InSequence sequence;
-    EXPECT_CALL(pb, ReleaseBarrier(0xabba)).Times(1);
+    EXPECT_CALL(*pb, ReleaseBarrier(0xabba)).Times(1);
   }
 
-  EXPECT_TRUE(pb.HandleBarrierEvent(&ev));
+  EXPECT_TRUE(pb->HandleBarrierEvent(&ev));
 
-  Utils::WaitForTimeoutMSec(pb.smoothing());
+  Utils::WaitForTimeoutMSec(pb->smoothing());
 }
 
 }