Merge lp:~unity-team/unity/edge-barrier-autohide-fix into lp:unity

[Marco Trevisan (Treviño)]

EdgeBarrierController: add multiple types of subscriber results, fix edges on autohide

Now when sticky keys are disabled, and the launcher is set to autohide, the mouse will hit both sides of the screen (instead of just the left side of the barrier); at that point we'll release the events coming from the launcher-less side of the monitor, but we'll use them to temporary keep the barrier "broken".

=== Problem ===
When sticky keys are set to off only the left side of the barrier blocks the mouse. This means when moving the mouse from the LEFT screen to the RIGHT screen it will skip the barrier.

=== Fix ===
Just use direction::BOTH for both cases.
So we'll release the events coming from the launcher-less side of the monitor, but we'll use them to temporary keep the barrier "broken".

Initially based on lp:~brandontschaefer/unity/lp.1064945-fix

=== Test ===
Added new unit tests, updated old ones.

[Brandon Schaefer (brandontschaefer)]

Awesome, looks good, and works well :).

review: Approve

[PS Jenkins bot (ps-jenkins)]

FAILED: Autolanding.
Approved revid is not set in launchpad (maybe a permission problem?).
http://jenkins.qa.ubuntu.com/job/unity-mbs-autolanding/411/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-mbs-autolanding/./build=pbuilder,distribution=raring,flavor=amd64/411/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-mbs-autolanding/./build=pbuilder,distribution=raring,flavor=i386/411/console

review: Needs Fixing (continuous-integration)

[Brandon Schaefer (brandontschaefer)]

review: Approve

=== modified file 'launcher/EdgeBarrierController.cpp'
--- launcher/EdgeBarrierController.cpp	2012-12-11 23:38:30 +0000
+++ launcher/EdgeBarrierController.cpp	2013-02-08 01:02:23 +0000
@@ -19,6 +19,7 @@
  */
 
 #include "EdgeBarrierController.h"
+#include "EdgeBarrierControllerPrivate.h"
 #include "Decaymulator.h"
 #include "unity-shared/UScreen.h"
 #include "UnityCore/GLibSource.h"
@@ -26,23 +27,6 @@
 namespace unity {
 namespace ui {
 
-struct EdgeBarrierController::Impl
-{
-  Impl(EdgeBarrierController *parent);
-
-  void ResizeBarrierList(std::vector<nux::Geometry> const& layout);
-  void SetupBarriers(std::vector<nux::Geometry> const& layout);
-
-  void OnPointerBarrierEvent(PointerBarrierWrapper* owner, BarrierEvent::Ptr event);
-  void BarrierRelease(PointerBarrierWrapper* owner, int event);
-
-  std::vector<PointerBarrierWrapper::Ptr> barriers_;
-  std::vector<EdgeBarrierSubscriber*> subscribers_;
-  Decaymulator decaymulator_;
-  glib::Source::UniquePtr release_timeout_;
-  float edge_overcome_pressure_;
-  EdgeBarrierController* parent_;
-};
 
 EdgeBarrierController::Impl::Impl(EdgeBarrierController *parent)
   : edge_overcome_pressure_(0)
@@ -106,7 +90,7 @@
 
     barrier->DestroyBarrier();
 
-    if (!edge_resist && (subscribers_[i] == nullptr || parent_->options()->hide_mode() == launcher::LauncherHideMode::LAUNCHER_HIDE_NEVER))
+    if (!edge_resist && parent_->options()->hide_mode() == launcher::LauncherHideMode::LAUNCHER_HIDE_NEVER)
       continue;
 
     barrier->x1 = monitor.x;
@@ -118,11 +102,6 @@
     barrier->threshold = parent_->options()->edge_stop_velocity();
     barrier->max_velocity_multiplier = parent_->options()->edge_responsiveness();
 
-    if (edge_resist)
-      barrier->direction = BarrierDirection::BOTH;
-    else
-      barrier->direction = BarrierDirection::LEFT;
-
     barrier->ConstructBarrier();
   }
 
@@ -133,7 +112,22 @@
   edge_overcome_pressure_ = parent_->options()->edge_overcome_pressure() * overcome_responsiveness_mult;
 }
 
-void EdgeBarrierController::Impl::OnPointerBarrierEvent(PointerBarrierWrapper* owner, BarrierEvent::Ptr event)
+void EdgeBarrierController::Impl::BarrierReset()
+{
+  decaymulator_.value = 0;
+}
+
+void EdgeBarrierController::Impl::BarrierPush(PointerBarrierWrapper* owner, BarrierEvent::Ptr const& event)
+{
+  decaymulator_.value = decaymulator_.value + event->velocity;
+
+  if (decaymulator_.value > edge_overcome_pressure_)
+  {
+    BarrierRelease(owner, event->event_id);
+  }
+}
+
+void EdgeBarrierController::Impl::OnPointerBarrierEvent(PointerBarrierWrapper* owner, BarrierEvent::Ptr const& event)
 {
   if (owner->released)
   {
@@ -142,28 +136,41 @@
   }
 
   unsigned int monitor = owner->index;
-  bool process = true;
+  auto result = EdgeBarrierSubscriber::Result::IGNORED;
 
   if (monitor < subscribers_.size())
   {
     auto subscriber = subscribers_[monitor];
 
-    if (subscriber && subscriber->HandleBarrierEvent(owner, event))
-      process = false;
+    if (subscriber)
+      result = subscriber->HandleBarrierEvent(owner, event);
   }
 
-  if (process && owner->x1 > 0)
+  switch (result)
   {
-    decaymulator_.value = decaymulator_.value + event->velocity;
-
-    if (decaymulator_.value > edge_overcome_pressure_ || (!parent_->sticky_edges() && !subscribers_[monitor]))
-    {
+    case EdgeBarrierSubscriber::Result::HANDLED:
+      BarrierReset();
+      break;
+
+    case EdgeBarrierSubscriber::Result::ALREADY_HANDLED:
+      BarrierPush(owner, event);
+      break;
+
+    case EdgeBarrierSubscriber::Result::IGNORED:
+      if (parent_->sticky_edges())
+      {
+        BarrierPush(owner, event);
+      }
+      else
+      {
+        owner->release_once = true;
+        BarrierRelease(owner, event->event_id);
+      }
+      break;
+
+    case EdgeBarrierSubscriber::Result::NEEDS_RELEASE:
       BarrierRelease(owner, event->event_id);
-    }
-  }
-  else
-  {
-    decaymulator_.value = 0;
+      break;
   }
 }
 
@@ -171,13 +178,18 @@
 {
   owner->ReleaseBarrier(event);
   owner->released = true;
-  decaymulator_.value = 0;
+  BarrierReset();
 
-  unsigned duration = parent_->options()->edge_passed_disabled_ms;
-  release_timeout_.reset(new glib::Timeout(duration, [owner] {
-    owner->released = false;
-    return false;
-  }));
+  if (!owner->release_once() ||
+      (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;
+      return false;
+    }));
+  }
 }
 
 EdgeBarrierController::EdgeBarrierController()
@@ -217,10 +229,5 @@
   return pimpl->subscribers_[monitor];
 }
 
-void EdgeBarrierController::ProcessBarrierEvent(PointerBarrierWrapper* owner, BarrierEvent::Ptr event)
-{
-  pimpl->OnPointerBarrierEvent(owner, event);
-}
-
 }
 }
 
=== modified file 'launcher/EdgeBarrierController.h'
--- launcher/EdgeBarrierController.h	2012-11-23 02:11:30 +0000
+++ launcher/EdgeBarrierController.h	2013-02-08 01:02:23 +0000
@@ -28,7 +28,15 @@
 
 struct EdgeBarrierSubscriber
 {
-  virtual bool HandleBarrierEvent(PointerBarrierWrapper* owner, BarrierEvent::Ptr event) = 0;
+  enum class Result
+  {
+    IGNORED,
+    HANDLED,
+    ALREADY_HANDLED,
+    NEEDS_RELEASE
+  };
+
+  virtual Result HandleBarrierEvent(PointerBarrierWrapper* owner, BarrierEvent::Ptr event) = 0;
 };
 
 class EdgeBarrierController : public sigc::trackable
@@ -44,12 +52,10 @@
   void Unsubscribe(EdgeBarrierSubscriber* subscriber, unsigned int monitor);
   EdgeBarrierSubscriber* GetSubscriber(unsigned int monitor);
 
-protected:
-  void ProcessBarrierEvent(PointerBarrierWrapper* owner, BarrierEvent::Ptr event);
-
 private:
   struct Impl;
   std::unique_ptr<Impl> pimpl;
+  friend class TestEdgeBarrierController;
 };
 
 }
 
=== added file 'launcher/EdgeBarrierControllerPrivate.h'
--- launcher/EdgeBarrierControllerPrivate.h	1970-01-01 00:00:00 +0000
+++ launcher/EdgeBarrierControllerPrivate.h	2013-02-08 01:02:23 +0000
@@ -0,0 +1,57 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+ * Copyright (C) 2012-2013 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Jason Smith <[e-mail]>
+ *              Marco Trevisan <[e-mail]>
+ */
+
+#ifndef EDGE_BARRIER_CONTROLLER_IMPL_PRIVATE
+#define EDGE_BARRIER_CONTROLLER_IMPL_PRIVATE
+
+#include "Decaymulator.h"
+#include "UnityCore/GLibSource.h"
+
+namespace unity
+{
+namespace ui
+{
+
+// NOTE: This private header is not part of the public interface
+struct EdgeBarrierController::Impl
+{
+  Impl(EdgeBarrierController *parent);
+
+  void ResizeBarrierList(std::vector<nux::Geometry> const& layout);
+  void SetupBarriers(std::vector<nux::Geometry> const& layout);
+
+  void OnPointerBarrierEvent(PointerBarrierWrapper* owner, BarrierEvent::Ptr const& event);
+  void BarrierPush(PointerBarrierWrapper* owner, BarrierEvent::Ptr const& event);
+  void BarrierRelease(PointerBarrierWrapper* owner, int event);
+  void BarrierReset();
+
+  std::vector<PointerBarrierWrapper::Ptr> barriers_;
+  std::vector<EdgeBarrierSubscriber*> subscribers_;
+  Decaymulator decaymulator_;
+  glib::Source::UniquePtr release_timeout_;
+  float edge_overcome_pressure_;
+  EdgeBarrierController* parent_;
+};
+
+} //namespace ui
+} //namespace unity
+
+
+#endif // EDGE_BARRIER_CONTROLLER_IMPL_PRIVATE
 
=== modified file 'launcher/Launcher.cpp'
--- launcher/Launcher.cpp	2013-02-01 22:53:42 +0000
+++ launcher/Launcher.cpp	2013-02-08 01:02:23 +0000
@@ -2252,19 +2252,21 @@
 
 #ifdef USE_X11
 
-bool Launcher::HandleBarrierEvent(ui::PointerBarrierWrapper* owner, ui::BarrierEvent::Ptr event)
+ui::EdgeBarrierSubscriber::Result Launcher::HandleBarrierEvent(ui::PointerBarrierWrapper* owner, ui::BarrierEvent::Ptr event)
 {
   if (_hide_machine.GetQuirk(LauncherHideMachine::EXTERNAL_DND_ACTIVE))
   {
-    owner->ReleaseBarrier(event->event_id);
-    return true;
+    return ui::EdgeBarrierSubscriber::Result::NEEDS_RELEASE;
   }
 
   nux::Geometry const& abs_geo = GetAbsoluteGeometry();
 
   bool apply_to_reveal = false;
-  if (_hidden && event->x >= abs_geo.x && event->x <= abs_geo.x + abs_geo.width)
+  if (event->x >= abs_geo.x && event->x <= abs_geo.x + abs_geo.width)
   {
+    if (!_hidden)
+      return ui::EdgeBarrierSubscriber::Result::ALREADY_HANDLED;
+
     if (options()->reveal_trigger == RevealTrigger::EDGE)
     {
       if (event->y >= abs_geo.y)
@@ -2288,15 +2290,15 @@
                        &root_y_return, &win_x_return, &win_y_return, &mask_return))
     {
       if (mask_return & (Button1Mask | Button3Mask))
-        apply_to_reveal = false;
+        return ui::EdgeBarrierSubscriber::Result::NEEDS_RELEASE;
     }
   }
 
   if (!apply_to_reveal)
-    return false;
+    return ui::EdgeBarrierSubscriber::Result::IGNORED;
 
   _hide_machine.AddRevealPressure(event->velocity);
-  return true;
+  return ui::EdgeBarrierSubscriber::Result::HANDLED;
 }
 
 #endif
 
=== modified file 'launcher/Launcher.h'
--- launcher/Launcher.h	2013-02-01 22:53:42 +0000
+++ launcher/Launcher.h	2013-02-08 01:02:23 +0000
@@ -210,7 +210,7 @@
 #endif
 
 #ifdef USE_X11
-  bool HandleBarrierEvent(ui::PointerBarrierWrapper* owner, ui::BarrierEvent::Ptr event);
+  ui::EdgeBarrierSubscriber::Result HandleBarrierEvent(ui::PointerBarrierWrapper* owner, ui::BarrierEvent::Ptr event);
 #endif
 
   void OnPluginStateChanged();
 
=== modified file 'launcher/PointerBarrier.cpp'
--- launcher/PointerBarrier.cpp	2012-07-19 01:22:13 +0000
+++ launcher/PointerBarrier.cpp	2013-02-08 01:02:23 +0000
@@ -38,6 +38,7 @@
 PointerBarrierWrapper::PointerBarrierWrapper()
   : active(false)
   , released(false)
+  , release_once(false)
   , smoothing(75)
   , max_velocity_multiplier(1.0f)
   , direction(BOTH)
 
=== modified file 'launcher/PointerBarrier.h'
--- launcher/PointerBarrier.h	2012-07-19 01:22:13 +0000
+++ launcher/PointerBarrier.h	2013-02-08 01:02:23 +0000
@@ -70,6 +70,7 @@
 
   nux::Property<bool> active;
   nux::Property<bool> released;
+  nux::Property<bool> release_once;
 
   nux::Property<int> smoothing;
 
 
=== modified file 'tests/test_edge_barrier_controller.cpp'
--- tests/test_edge_barrier_controller.cpp	2012-09-13 10:56:42 +0000
+++ tests/test_edge_barrier_controller.cpp	2013-02-08 01:02:23 +0000
@@ -23,6 +23,7 @@
 #include "test_uscreen_mock.h"
 
 #include "EdgeBarrierController.h"
+#include "EdgeBarrierControllerPrivate.h"
 
 using namespace unity;
 using namespace unity::ui;
@@ -46,35 +47,25 @@
   MOCK_METHOD1(ReleaseBarrier, void(int));
 };
 
-class MockEdgeBarrierController : public EdgeBarrierController
-{
-public:
-  void ProcessBarrierEvent(PointerBarrierWrapper* owner, BarrierEvent::Ptr event)
-  {
-    EdgeBarrierController::ProcessBarrierEvent(owner, event);
-  }
-
-  EdgeBarrierSubscriber* GetSubscriber(unsigned int monitor)
-  {
-    return EdgeBarrierController::GetSubscriber(monitor);
-  }
-};
-
 class TestBarrierSubscriber : public EdgeBarrierSubscriber
 {
 public:
-  TestBarrierSubscriber(bool handles = false)
-    : handles_(handles)
+  TestBarrierSubscriber(EdgeBarrierSubscriber::Result result = EdgeBarrierSubscriber::Result::IGNORED)
+    : handle_result_(result)
   {}
 
-  bool HandleBarrierEvent(PointerBarrierWrapper* owner, BarrierEvent::Ptr event)
+  EdgeBarrierSubscriber::Result HandleBarrierEvent(PointerBarrierWrapper* owner, BarrierEvent::Ptr event)
   {
-    return handles_;
+    return handle_result_;
   }
 
-  bool handles_;
+  EdgeBarrierSubscriber::Result handle_result_;
 };
 
+} // namespace
+
+namespace unity {
+namespace ui {
 class TestEdgeBarrierController : public Test
 {
 public:
@@ -93,16 +84,32 @@
     }
   }
 
+  void ProcessBarrierEvent(PointerBarrierWrapper* owner, BarrierEvent::Ptr event)
+  {
+    GetPrivateImpl()->OnPointerBarrierEvent(owner, event);
+  }
+
+  EdgeBarrierController::Impl* GetPrivateImpl() const
+  {
+    return bc.pimpl.get();
+  }
+
   BarrierEvent::Ptr MakeBarrierEvent(int id, bool breaker)
   {
     int velocity = breaker ? std::numeric_limits<int>::max() : bc.options()->edge_overcome_pressure() - 1;
     return std::make_shared<BarrierEvent>(0, 1, velocity, id);
   }
 
+
   TestBarrierSubscriber subscribers_[max_num_monitors];
   MockUScreen uscreen;
-  MockEdgeBarrierController bc;
+  EdgeBarrierController bc;
 };
+} // namespace ui
+} // namespace unity
+
+namespace
+{
 
 TEST_F(TestEdgeBarrierController, Construction)
 {
@@ -129,7 +136,7 @@
 
 TEST_F(TestEdgeBarrierController, SubscriberReplace)
 {
-  TestBarrierSubscriber handling_subscriber(true);
+  TestBarrierSubscriber handling_subscriber(EdgeBarrierSubscriber::Result::HANDLED);
   bc.Subscribe(&handling_subscriber, 0);
   EXPECT_EQ(bc.GetSubscriber(0), &handling_subscriber);
 }
@@ -138,28 +145,29 @@
 {
   int monitor = 0;
 
-  TestBarrierSubscriber handling_subscriber(true);
+  TestBarrierSubscriber handling_subscriber(EdgeBarrierSubscriber::Result::HANDLED);
   bc.Subscribe(&handling_subscriber, monitor);
 
   MockPointerBarrier owner(monitor);
   auto breaking_barrier_event = MakeBarrierEvent(0, true);
 
   EXPECT_CALL(owner, ReleaseBarrier(_)).Times(0);
-  bc.ProcessBarrierEvent(&owner, breaking_barrier_event);
+  ProcessBarrierEvent(&owner, breaking_barrier_event);
+  EXPECT_EQ(GetPrivateImpl()->decaymulator_.value(), 0);
 }
 
 TEST_F(TestEdgeBarrierController, ProcessHandledEventOnReleasedBarrier)
 {
   int monitor = max_num_monitors-1;
 
-  TestBarrierSubscriber handling_subscriber(true);
+  TestBarrierSubscriber handling_subscriber(EdgeBarrierSubscriber::Result::HANDLED);
   bc.Subscribe(&handling_subscriber, monitor);
 
   MockPointerBarrier owner(monitor, true);
   auto breaking_barrier_event = MakeBarrierEvent(5, true);
 
   EXPECT_CALL(owner, ReleaseBarrier(5)).Times(1);
-  bc.ProcessBarrierEvent(&owner, breaking_barrier_event);
+  ProcessBarrierEvent(&owner, breaking_barrier_event);
 }
 
 TEST_F(TestEdgeBarrierController, ProcessUnHandledEventBreakingBarrier)
@@ -171,7 +179,7 @@
   auto breaking_barrier_event = MakeBarrierEvent(breaking_id, true);
 
   EXPECT_CALL(owner, ReleaseBarrier(breaking_id));
-  bc.ProcessBarrierEvent(&owner, breaking_barrier_event);
+  ProcessBarrierEvent(&owner, breaking_barrier_event);
 }
 
 TEST_F(TestEdgeBarrierController, ProcessUnHandledEventBreakingBarrierOnMaxMonitor)
@@ -181,11 +189,8 @@
   MockPointerBarrier owner(monitor);
   auto breaking_barrier_event = MakeBarrierEvent(0, true);
 
-  // This was leading to a crash, see bug #1020075
-  // you can reproduce this repeating this test multiple times using the
-  // --gtest_repeat=X command line
   EXPECT_CALL(owner, ReleaseBarrier(_));
-  bc.ProcessBarrierEvent(&owner, breaking_barrier_event);
+  ProcessBarrierEvent(&owner, breaking_barrier_event);
 }
 
 TEST_F(TestEdgeBarrierController, ProcessUnHandledEventNotBreakingBarrier)
@@ -197,7 +202,7 @@
   auto not_breaking_barrier_event = MakeBarrierEvent(not_breaking_id, false);
 
   EXPECT_CALL(owner, ReleaseBarrier(not_breaking_id)).Times(0);
-  bc.ProcessBarrierEvent(&owner, not_breaking_barrier_event);
+  ProcessBarrierEvent(&owner, not_breaking_barrier_event);
 }
 
 TEST_F(TestEdgeBarrierController, ProcessUnHandledEventOnReleasedBarrier)
@@ -209,7 +214,69 @@
   auto not_breaking_barrier_event = MakeBarrierEvent(not_breaking_id, false);
 
   EXPECT_CALL(owner, ReleaseBarrier(not_breaking_id));
-  bc.ProcessBarrierEvent(&owner, not_breaking_barrier_event);
+  ProcessBarrierEvent(&owner, not_breaking_barrier_event);
+}
+
+TEST_F(TestEdgeBarrierController, ProcessAlreadyHandledEvent)
+{
+  int monitor = g_random_int_range(0, max_num_monitors);
+
+  MockPointerBarrier owner(monitor);
+  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_EQ(GetPrivateImpl()->decaymulator_.value(), event->velocity);
+}
+
+TEST_F(TestEdgeBarrierController, ProcessIgnoredEventWithStickyEdges)
+{
+  int monitor = g_random_int_range(0, max_num_monitors);
+
+  bc.sticky_edges = true;
+  MockPointerBarrier owner(monitor);
+  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_EQ(GetPrivateImpl()->decaymulator_.value(), event->velocity);
+}
+
+TEST_F(TestEdgeBarrierController, ProcessIgnoredEventWithOutStickyEdges)
+{
+  int monitor = g_random_int_range(0, max_num_monitors);
+
+  bc.sticky_edges = false;
+  MockPointerBarrier owner(monitor);
+  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_EQ(GetPrivateImpl()->decaymulator_.value(), 0);
+}
+
+TEST_F(TestEdgeBarrierController, ProcessNeedsReleaseEvent)
+{
+  int monitor = g_random_int_range(0, max_num_monitors);
+
+  MockPointerBarrier owner(monitor);
+  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_EQ(GetPrivateImpl()->decaymulator_.value(), 0);
 }
 
 TEST_F(TestEdgeBarrierController, BreakingEdgeTemporaryReleasesBarrier)
@@ -217,7 +284,7 @@
   MockPointerBarrier owner;
 
   EXPECT_CALL(owner, ReleaseBarrier(1));
-  bc.ProcessBarrierEvent(&owner, MakeBarrierEvent(1, true));
+  ProcessBarrierEvent(&owner, MakeBarrierEvent(1, true));
   ASSERT_TRUE(owner.released());
 
   Utils::WaitForTimeoutMSec(bc.options()->edge_passed_disabled_ms);
@@ -228,30 +295,30 @@
 {
   MockPointerBarrier owner;
   int monitor = 0;
-  subscribers_[monitor].handles_ = false;
+  subscribers_[monitor].handle_result_ = EdgeBarrierSubscriber::Result::IGNORED;
 
   EXPECT_CALL(owner, ReleaseBarrier(5));
-  bc.ProcessBarrierEvent(&owner, MakeBarrierEvent(5, true));
+  ProcessBarrierEvent(&owner, MakeBarrierEvent(5, true));
   ASSERT_TRUE(owner.released());
 
-  subscribers_[monitor].handles_ = false;
+  subscribers_[monitor].handle_result_ = EdgeBarrierSubscriber::Result::IGNORED;
   EXPECT_CALL(owner, ReleaseBarrier(6));
-  bc.ProcessBarrierEvent(&owner, MakeBarrierEvent(6, false));
+  ProcessBarrierEvent(&owner, MakeBarrierEvent(6, false));
 }
 
 TEST_F(TestEdgeBarrierController, BreakingEdgeTemporaryReleasesBarrierForHandledEvents)
 {
   MockPointerBarrier owner;
   int monitor = 0;
-  subscribers_[monitor].handles_ = false;
+  subscribers_[monitor].handle_result_ = EdgeBarrierSubscriber::Result::IGNORED;
 
   EXPECT_CALL(owner, ReleaseBarrier(5));
-  bc.ProcessBarrierEvent(&owner, MakeBarrierEvent(5, true));
+  ProcessBarrierEvent(&owner, MakeBarrierEvent(5, true));
   ASSERT_TRUE(owner.released());
 
-  subscribers_[monitor].handles_ = true;
+  subscribers_[monitor].handle_result_ = EdgeBarrierSubscriber::Result::HANDLED;
   EXPECT_CALL(owner, ReleaseBarrier(6)).Times(1);
-  bc.ProcessBarrierEvent(&owner, MakeBarrierEvent(6, true));
+  ProcessBarrierEvent(&owner, MakeBarrierEvent(6, true));
 }
 
 TEST_F(TestEdgeBarrierController, StickyEdgePropertyProxiesLauncherOption)
@@ -269,4 +336,10 @@
   EXPECT_TRUE(bc.options()->edge_resist());
 }
 
+TEST_F(TestEdgeBarrierController, TestTheDirectionIsAlawysSetToBothSides)
+{
+  for (auto barrier : GetPrivateImpl()->barriers_)
+    ASSERT_EQ(barrier->direction, BarrierDirection::BOTH);
+}
+
 }
 
=== modified file 'tests/test_launcher.cpp'
--- tests/test_launcher.cpp	2013-02-01 22:53:42 +0000
+++ tests/test_launcher.cpp	2013-02-08 01:02:23 +0000
@@ -54,11 +54,6 @@
   MOCK_METHOD1(Stick, void(bool));
 };
 
-struct MockPointerBarrierWrapper : ui::PointerBarrierWrapper
-{
-  MOCK_METHOD1(ReleaseBarrier, void(int event_id));
-};
-
 }
 
 class TestLauncher : public Test
@@ -96,10 +91,12 @@
     using Launcher::ProcessDndLeave;
     using Launcher::ProcessDndMove;
     using Launcher::ProcessDndDrop;
-    using Launcher::_drag_icon_position;
-
     using Launcher::IconStartingBlinkValue;
     using Launcher::IconStartingPulseValue;
+    using Launcher::HandleBarrierEvent;
+    using Launcher::SetHidden;
+    using Launcher::_drag_icon_position;
+
 
     void FakeProcessDndMove(int x, int y, std::list<std::string> uris)
     {
@@ -119,11 +116,6 @@
 
       _dnd_hovered_icon = MouseIconIntersection(x, y);
     }
-
-    bool HandleBarrierEvent(ui::PointerBarrierWrapper* barrier, ui::BarrierEvent::Ptr event)
-    {
-      return Launcher::HandleBarrierEvent(barrier, event);
-    }
   };
 
   TestLauncher()
@@ -454,15 +446,79 @@
   EXPECT_FALSE(mouse_entered);
 }
 
-TEST_F(TestLauncher, EdgeResistDuringDnd)
+TEST_F(TestLauncher, EdgeReleasesDuringDnd)
 {
-  auto barrier = std::make_shared<MockPointerBarrierWrapper>();
+  auto barrier = std::make_shared<ui::PointerBarrierWrapper>();
   auto event = std::make_shared<ui::BarrierEvent>(0, 0, 0, 100);
 
   launcher_->DndStarted("");
 
-  EXPECT_CALL(*barrier, ReleaseBarrier(100));
-  EXPECT_TRUE(launcher_->HandleBarrierEvent(barrier.get(), event));
+  EXPECT_EQ(launcher_->HandleBarrierEvent(barrier.get(), event),
+            ui::EdgeBarrierSubscriber::Result::NEEDS_RELEASE);
+}
+
+TEST_F(TestLauncher, EdgeBarriersIgnoreEvents)
+{
+  auto const& launcher_geo = launcher_->GetAbsoluteGeometry();
+  auto barrier = std::make_shared<ui::PointerBarrierWrapper>();
+  auto event = std::make_shared<ui::BarrierEvent>(0, 0, 0, 100);
+  launcher_->SetHidden(true);
+
+  event->x = launcher_geo.x-1;
+  event->y = launcher_geo.y;
+  EXPECT_EQ(launcher_->HandleBarrierEvent(barrier.get(), 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),
+            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),
+            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),
+            ui::EdgeBarrierSubscriber::Result::IGNORED);
+}
+
+TEST_F(TestLauncher, EdgeBarriersHandlesEvent)
+{
+  auto const& launcher_geo = launcher_->GetAbsoluteGeometry();
+  auto barrier = std::make_shared<ui::PointerBarrierWrapper>();
+  auto event = std::make_shared<ui::BarrierEvent>(0, 0, 0, 100);
+  launcher_->SetHidden(true);
+
+  options_->reveal_trigger = RevealTrigger::EDGE;
+
+  for (int x = launcher_geo.x; x < launcher_geo.x+launcher_geo.width; ++x)
+  {
+    for (int y = launcher_geo.y; y < launcher_geo.y+launcher_geo.height; ++y)
+    {
+      event->x = x;
+      event->y = y;
+      ASSERT_EQ(launcher_->HandleBarrierEvent(barrier.get(), event),
+                ui::EdgeBarrierSubscriber::Result::HANDLED);
+    }
+  }
+
+  options_->reveal_trigger = RevealTrigger::CORNER;
+
+  for (int x = launcher_geo.x; x < launcher_geo.x+launcher_geo.width; ++x)
+  {
+    for (int y = launcher_geo.y-10; y < launcher_geo.y; ++y)
+    {
+      event->x = x;
+      event->y = y;
+      ASSERT_EQ(launcher_->HandleBarrierEvent(barrier.get(), event),
+                ui::EdgeBarrierSubscriber::Result::HANDLED);
+    }
+  }
 }
 
 TEST_F(TestLauncher, DndIsSpecialRequest)