Merge lp:~3v1n0/unity/fix-load-icon-crash-926658 into lp:unity

[Marco Trevisan (Treviño)]

ResultRendererTile: fix a crash if row.renderer<TextureContainer*>() is null

In ResultRendererTile::LoadIcon we assumed that row.renderer<TextureContainer*>() is always not null; even if this should not happen because it has already just set into ResultRendererTile::Preload it looks like that there are cases that when doing row.set_renderer(new TextureContainer()); in the subsequent row.renderer<TextureContainer*>() returns null.
The implementation of that depends on dee_model_{set,get}_tag (it's basically like doing dee_model_set_tag and dee_model_get_tag), so it seems like that is failing. I've not been able to get a failure in stress tests, btw.

So, at this point, even if it would not the best solution, it's better to add a safety check to prevent crashes.

=== modified file 'UnityCore/GLibSource.cpp'
--- UnityCore/GLibSource.cpp	2012-07-16 11:03:32 +0000
+++ UnityCore/GLibSource.cpp	2012-07-20 23:00:30 +0000
@@ -18,7 +18,6 @@
 */
 
 #include "GLibSource.h"
-#include <boost/lexical_cast.hpp>
 
 namespace unity
 {
@@ -225,7 +224,7 @@
   if (source_nick.empty())
   {
     /* If we don't have a nick, we use the source pointer string as nick. */
-    source_nick = boost::lexical_cast<std::string>(source.get());
+    source_nick = std::to_string(reinterpret_cast<uintptr_t>(source.get()));
   }
 
   auto old_source_it = sources_.find(source_nick);

=== modified file 'dash/ResultRendererTile.cpp'
--- dash/ResultRendererTile.cpp	2012-06-18 02:57:23 +0000
+++ dash/ResultRendererTile.cpp	2012-07-20 23:00:30 +0000
@@ -21,14 +21,10 @@
  */
 
 
-#include <sstream>     // for ostringstream
 #include "ResultRendererTile.h"
 
-#include <boost/algorithm/string.hpp>
-
 #include <pango/pango.h>
 #include <pango/pangocairo.h>
-#include <gdk/gdk.h>
 #include <gtk/gtk.h>
 
 #include <NuxCore/Logger.h>
@@ -51,6 +47,7 @@
 namespace
 {
 nux::logging::Logger logger("unity.dash.results");
+const std::string DEFAULT_GICON = ". GThemedIcon text-x-preview";
 
 const int FONT_SIZE = 10;
 }
@@ -230,7 +227,7 @@
 
 void ResultRendererTile::Preload(Result& row)
 {
-  if (row.renderer<TextureContainer*>() == nullptr)
+  if (!row.renderer<TextureContainer*>())
   {
     row.set_renderer(new TextureContainer());
     LoadIcon(row);
@@ -240,17 +237,25 @@
 
 void ResultRendererTile::Unload(Result& row)
 {
-  TextureContainer *container = row.renderer<TextureContainer*>();
-  delete container;
+  delete row.renderer<TextureContainer*>();
   row.set_renderer<TextureContainer*>(nullptr);
 }
 
 void ResultRendererTile::LoadIcon(Result& row)
 {
+  auto container = row.renderer<TextureContainer*>();
+
+  if (!container)
+  {
+    LOG_ERROR(logger) << "No valid container for Result " << row.name() << " with URI "
+                      << row.uri();
+    return;
+  }
+
   Style& style = Style::Instance();
   std::string const& icon_hint = row.icon_hint;
-#define DEFAULT_GICON ". GThemedIcon text-x-preview"
   std::string icon_name;
+
   if (G_UNLIKELY(neko))
   {
     int tmp1 = style.GetTileIconSize() + (rand() % 16) - 8;
@@ -266,26 +271,25 @@
     icon_name = !icon_hint.empty() ? icon_hint : DEFAULT_GICON;
   }
 
-  GIcon*  icon = g_icon_new_for_string(icon_name.c_str(), NULL);
-  TextureContainer* container = row.renderer<TextureContainer*>();
-
-  IconLoader::IconLoaderCallback slot = sigc::bind(sigc::mem_fun(this, &ResultRendererTile::IconLoaded), icon_hint, row);
-
-  if (g_strrstr(icon_name.c_str(), "://"))
+  auto slot = sigc::bind(sigc::mem_fun(this, &ResultRendererTile::IconLoaded), icon_hint, row);
+
+  if (icon_name.find("://") != std::string::npos)
   {
     container->slot_handle = IconLoader::GetDefault().LoadFromURI(icon_name, style.GetTileIconSize(), slot);
   }
-  else if (G_IS_ICON(icon))
-  {
-    container->slot_handle = IconLoader::GetDefault().LoadFromGIconString(icon_name, style.GetTileIconSize(), slot);
-  }
   else
   {
-    container->slot_handle = IconLoader::GetDefault().LoadFromIconName(icon_name, style.GetTileIconSize(), slot);
+    glib::Object<GIcon> icon(g_icon_new_for_string(icon_name.c_str(), nullptr));
+
+    if (icon.IsType(G_TYPE_ICON))
+    {
+      container->slot_handle = IconLoader::GetDefault().LoadFromGIconString(icon_name, style.GetTileIconSize(), slot);
+    }
+    else
+    {
+      container->slot_handle = IconLoader::GetDefault().LoadFromIconName(icon_name, style.GetTileIconSize(), slot);
+    }
   }
-
-  if (icon != NULL)
-    g_object_unref(icon);
 }
 
 nux::BaseTexture* ResultRendererTile::CreateTextureCallback(std::string const& texid,

=== modified file 'launcher/Decaymulator.h'
--- launcher/Decaymulator.h	2012-06-18 02:57:23 +0000
+++ launcher/Decaymulator.h	2012-07-20 23:00:30 +0000
@@ -31,13 +31,11 @@
 class Decaymulator
 {
 public:
-  typedef std::shared_ptr<Decaymulator> Ptr;
+  Decaymulator();
 
   nux::Property<int> rate_of_decay;
   nux::Property<int> value;
 
-  Decaymulator();
-
 private:
   void OnValueChanged(int value);
   bool OnDecayTimeout();

=== modified file 'launcher/EdgeBarrierController.cpp'
--- launcher/EdgeBarrierController.cpp	2012-06-28 17:21:44 +0000
+++ launcher/EdgeBarrierController.cpp	2012-07-20 23:00:30 +0000
@@ -20,6 +20,7 @@
 #include "EdgeBarrierController.h"
 #include "Decaymulator.h"
 #include "unity-shared/UScreen.h"
+#include "UnityCore/GLibSource.h"
 
 namespace unity {
 namespace ui {
@@ -27,23 +28,38 @@
 struct EdgeBarrierController::Impl
 {
   Impl(EdgeBarrierController *parent);
-  ~Impl();
 
   void ResizeBarrierList(std::vector<nux::Geometry> const& layout);
   void SetupBarriers(std::vector<nux::Geometry> const& layout);
 
-  void OnPointerBarrierEvent(ui::PointerBarrierWrapper* owner, ui::BarrierEvent::Ptr event);
+  void OnPointerBarrierEvent(PointerBarrierWrapper* owner, BarrierEvent::Ptr event);
+  void BarrierRelease(PointerBarrierWrapper* owner, int event);
+
+  bool StickyEdgeSetter(bool const& new_val)
+  {
+    if (parent_->options() && new_val != parent_->options()->edge_resist())
+    {
+      parent_->options()->edge_resist = new_val;
+      return true;
+    }
+    return false;
+  }
+
+  bool StickyEdgeGetter()
+  {
+    return parent_->options() ? parent_->options()->edge_resist() : false;
+  }
 
   std::vector<PointerBarrierWrapper::Ptr> barriers_;
-  Decaymulator::Ptr decaymulator_;
+  std::vector<EdgeBarrierSubscriber*> subscribers_;
+  Decaymulator decaymulator_;
+  glib::Source::UniquePtr release_timeout_;
   float edge_overcome_pressure_;
   EdgeBarrierController* parent_;
-  std::vector<EdgeBarrierSubscriber*> subscribers_;
 };
 
 EdgeBarrierController::Impl::Impl(EdgeBarrierController *parent)
-  : decaymulator_(Decaymulator::Ptr(new Decaymulator()))
-  , edge_overcome_pressure_(0)
+  : edge_overcome_pressure_(0)
   , parent_(parent)
 {
   UScreen *uscreen = UScreen::GetDefault();
@@ -56,9 +72,23 @@
     SetupBarriers(layout);
   });
 
-  parent_->sticky_edges.changed.connect([&](bool value) {
-    SetupBarriers(UScreen::GetDefault()->GetMonitors());
-  });
+  parent_->sticky_edges.SetGetterFunction(sigc::mem_fun(this, &Impl::StickyEdgeGetter));
+  parent_->sticky_edges.SetSetterFunction(sigc::mem_fun(this, &Impl::StickyEdgeSetter));
+
+/* Set this back, once lp:~3v1n0/nux/use-std-function is merged
+  parent_->sticky_edges.SetGetterFunction([parent_] {
+    return parent_->options() ? parent_->options()->edge_resist() : false;
+  });
+
+  parent_->sticky_edges.SetSetterFunction([parent_] (bool const& new_val) {
+    if (parent_->options() && new_val != parent_->options()->edge_resist())
+    {
+      parent_->options()->edge_resist = new_val;
+      return true;
+    }
+    return false;
+  });
+  */
 
   parent_->options.changed.connect([&](launcher::Options::Ptr options) {
     options->option_changed.connect([&]() {
@@ -68,14 +98,9 @@
   });
 }
 
-EdgeBarrierController::Impl::~Impl()
-{
-
-}
-
 void EdgeBarrierController::Impl::ResizeBarrierList(std::vector<nux::Geometry> const& layout)
 {
-  size_t num_monitors = layout.size();
+  auto num_monitors = layout.size();
   if (barriers_.size() > num_monitors)
   {
     barriers_.resize(num_monitors);
@@ -83,7 +108,7 @@
 
   while (barriers_.size() < num_monitors)
   {
-    auto barrier = PointerBarrierWrapper::Ptr(new PointerBarrierWrapper());
+    auto barrier = std::make_shared<PointerBarrierWrapper>();
     barrier->barrier_event.connect(sigc::mem_fun(this, &EdgeBarrierController::Impl::OnPointerBarrierEvent));
     barriers_.push_back(barrier);
   }
@@ -91,10 +116,9 @@
 
 void EdgeBarrierController::Impl::SetupBarriers(std::vector<nux::Geometry> const& layout)
 {
-  bool edge_resist = parent_->options()->edge_resist();
+  bool edge_resist = parent_->sticky_edges();
 
-  size_t size = layout.size();
-  for (size_t i = 0; i < size; i++)
+  for (unsigned i = 0; i < layout.size(); i++)
   {
     auto barrier = barriers_[i];
     auto monitor = layout[i];
@@ -122,68 +146,86 @@
   }
 
   float decay_responsiveness_mult = ((parent_->options()->edge_responsiveness() - 1) * .3f) + 1;
-  decaymulator_->rate_of_decay = parent_->options()->edge_decay_rate() * decay_responsiveness_mult;
-  
+  decaymulator_.rate_of_decay = parent_->options()->edge_decay_rate() * decay_responsiveness_mult;
+
   float overcome_responsiveness_mult = ((parent_->options()->edge_responsiveness() - 1) * 1.0f) + 1;
   edge_overcome_pressure_ = parent_->options()->edge_overcome_pressure() * overcome_responsiveness_mult;
 }
 
-void EdgeBarrierController::Impl::OnPointerBarrierEvent(ui::PointerBarrierWrapper* owner, ui::BarrierEvent::Ptr event)
+void EdgeBarrierController::Impl::OnPointerBarrierEvent(PointerBarrierWrapper* owner, BarrierEvent::Ptr event)
 {
-  int monitor = owner->index;
+  unsigned int monitor = owner->index;
   bool process = true;
 
-  if ((size_t)monitor <= subscribers_.size())
+  if (monitor <= subscribers_.size())
   {
     auto subscriber = subscribers_[monitor];
+
     if (subscriber && subscriber->HandleBarrierEvent(owner, event))
       process = false;
   }
 
-  if (process && owner->x1 > 0)
-  {
-    decaymulator_->value = decaymulator_->value + event->velocity;
-    if (decaymulator_->value > edge_overcome_pressure_ || (!parent_->options()->edge_resist() && !subscribers_[monitor]))
+  if (process && owner->released)
+  {
+    BarrierRelease(owner, event->event_id);
+  }
+  else if (process && owner->x1 > 0)
+  {
+    decaymulator_.value = decaymulator_.value + event->velocity;
+
+    if (decaymulator_.value > edge_overcome_pressure_ || (!parent_->sticky_edges() && !subscribers_[monitor]))
     {
-      owner->ReleaseBarrier(event->event_id);
-      decaymulator_->value = 0;
+      BarrierRelease(owner, event->event_id);
     }
   }
   else
   {
-    decaymulator_->value = 0;
+    decaymulator_.value = 0;
   }
 }
 
+void EdgeBarrierController::Impl::BarrierRelease(PointerBarrierWrapper* owner, int event)
+{
+  owner->ReleaseBarrier(event);
+  owner->released = true;
+  decaymulator_.value = 0;
+
+  unsigned duration = parent_->options()->edge_passed_disabled_ms;
+  release_timeout_.reset(new glib::Timeout(duration, [owner] {
+    owner->released = false;
+    return false;
+  }));
+}
+
 EdgeBarrierController::EdgeBarrierController()
-  : sticky_edges(false)
-  , pimpl(new Impl(this))
-{
-}
+  : pimpl(new Impl(this))
+{}
 
 EdgeBarrierController::~EdgeBarrierController()
-{
-
-}
-
-void EdgeBarrierController::Subscribe(EdgeBarrierSubscriber* subscriber, int monitor)
-{
-  if (pimpl->subscribers_.size() <= (size_t)monitor)
+{}
+
+void EdgeBarrierController::Subscribe(EdgeBarrierSubscriber* subscriber, unsigned int monitor)
+{
+  if (pimpl->subscribers_.size() <= monitor)
     pimpl->subscribers_.resize(monitor + 1);
+
   pimpl->subscribers_[monitor] = subscriber;
-
   pimpl->SetupBarriers(UScreen::GetDefault()->GetMonitors());
 }
 
-void EdgeBarrierController::Unsubscribe(EdgeBarrierSubscriber* subscriber, int monitor)
+void EdgeBarrierController::Unsubscribe(EdgeBarrierSubscriber* subscriber, unsigned int monitor)
 {
-  if (pimpl->subscribers_.size() < (size_t)monitor || pimpl->subscribers_[monitor] != subscriber)
+  if (pimpl->subscribers_.size() < monitor || pimpl->subscribers_[monitor] != subscriber)
     return;
+
   pimpl->subscribers_[monitor] = nullptr;
-
   pimpl->SetupBarriers(UScreen::GetDefault()->GetMonitors());
 }
 
+void EdgeBarrierController::ProcessBarrierEvent(PointerBarrierWrapper* owner, BarrierEvent::Ptr event)
+{
+  pimpl->OnPointerBarrierEvent(owner, event);
+}
 
 }
 }

=== modified file 'launcher/EdgeBarrierController.h'
--- launcher/EdgeBarrierController.h	2012-05-07 19:52:54 +0000
+++ launcher/EdgeBarrierController.h	2012-07-20 23:00:30 +0000
@@ -29,26 +29,27 @@
 class EdgeBarrierSubscriber
 {
 public:
-  virtual bool HandleBarrierEvent(PointerBarrierWrapper* owner, BarrierEvent::Ptr event) { return false; };
+  virtual bool HandleBarrierEvent(PointerBarrierWrapper* owner, BarrierEvent::Ptr event) = 0;
 };
 
 class EdgeBarrierController : public sigc::trackable
 {
 public:
-  typedef std::shared_ptr<EdgeBarrierController> Ptr;
-
   EdgeBarrierController();
   ~EdgeBarrierController();
 
-  nux::Property<bool> sticky_edges;
+  nux::RWProperty<bool> sticky_edges;
   nux::Property<launcher::Options::Ptr> options;
 
-  void Subscribe(EdgeBarrierSubscriber* subscriber, int monitor);
-  void Unsubscribe(EdgeBarrierSubscriber* subscriber, int monitor);
+  void Subscribe(EdgeBarrierSubscriber* subscriber, unsigned int monitor);
+  void Unsubscribe(EdgeBarrierSubscriber* subscriber, unsigned int monitor);
+
+protected:
+  void ProcessBarrierEvent(PointerBarrierWrapper* owner, BarrierEvent::Ptr event);
 
 private:
   struct Impl;
-  Impl* pimpl;
+  std::unique_ptr<Impl> pimpl;
 };
 
 }

=== modified file 'launcher/LauncherController.cpp'
--- launcher/LauncherController.cpp	2012-07-18 17:51:56 +0000
+++ launcher/LauncherController.cpp	2012-07-20 23:00:30 +0000
@@ -194,7 +194,7 @@
   int                    launcher_key_press_time_;
   unsigned int           dbus_owner_;
 
-  ui::EdgeBarrierController::Ptr edge_barriers_;
+  ui::EdgeBarrierController edge_barriers_;
 
   LauncherList launchers;
 
@@ -219,10 +219,9 @@
   , device_section_(volume_monitor_)
   , show_desktop_icon_(false)
   , display_(display)
-  , edge_barriers_(new ui::EdgeBarrierController())
   , matcher_(bamf_matcher_get_default())
 {
-  edge_barriers_->options = parent_->options();
+  edge_barriers_.options = parent_->options();
 
   UScreen* uscreen = UScreen::GetDefault();
   auto monitors = uscreen->GetMonitors();
@@ -355,7 +354,7 @@
     {
       parent_->RemoveChild(launcher.GetPointer());
       launcher->GetParent()->UnReference();
-      edge_barriers_->Unsubscribe(launcher.GetPointer(), launcher->monitor);
+      edge_barriers_.Unsubscribe(launcher.GetPointer(), launcher->monitor);
     }
   }
 
@@ -363,7 +362,7 @@
 
   for (size_t i = 0; i < launchers.size(); ++i)
   {
-    edge_barriers_->Subscribe(launchers[i].GetPointer(), launchers[i]->monitor);
+    edge_barriers_.Subscribe(launchers[i].GetPointer(), launchers[i]->monitor);
   }
 }
 

=== modified file 'launcher/LauncherHideMachine.cpp'
--- launcher/LauncherHideMachine.cpp	2012-06-18 02:57:23 +0000
+++ launcher/LauncherHideMachine.cpp	2012-07-20 23:00:30 +0000
@@ -19,7 +19,6 @@
 
 #include "LauncherHideMachine.h"
 
-#include <boost/lexical_cast.hpp>
 #include <NuxCore/Logger.h>
 
 namespace unity
@@ -35,30 +34,29 @@
 
 LauncherHideMachine::LauncherHideMachine()
   : reveal_progress(0)
-  , decaymulator_(new ui::Decaymulator())
   , _mode(HIDE_NEVER)
   , _quirks(DEFAULT)
   , _should_hide(false)
   , _latest_emit_should_hide(false)
 {
-  decaymulator_->value.changed.connect([&](int value) { reveal_progress = value / static_cast<float>(reveal_pressure); });
+  decaymulator_.value.changed.connect([&](int value) { reveal_progress = value / static_cast<float>(reveal_pressure); });
   edge_decay_rate.changed.connect(sigc::mem_fun (this, &LauncherHideMachine::OnDecayRateChanged));
 }
 
 void LauncherHideMachine::OnDecayRateChanged(int value)
 {
-  decaymulator_->rate_of_decay = value;  
+  decaymulator_.rate_of_decay = value;
 }
 
 void LauncherHideMachine::AddRevealPressure(int pressure)
 {
-  decaymulator_->value = decaymulator_->value + pressure;
+  decaymulator_.value = decaymulator_.value + pressure;
 
-  if (decaymulator_->value > reveal_pressure)
+  if (decaymulator_.value > reveal_pressure)
   {
     SetQuirk(REVEAL_PRESSURE_PASS, true);
     SetQuirk(MOUSE_MOVE_POST_REVEAL, true);
-    decaymulator_->value = 0;
+    decaymulator_.value = 0;
   }
 }
 
@@ -240,7 +238,7 @@
 {
   // Although I do wonder why we are returning a string representation
   // of the enum value as an integer anyway.
-  return boost::lexical_cast<std::string>(_quirks);
+  return std::to_string(_quirks);
 }
 
 } // namespace launcher

=== modified file 'launcher/LauncherHideMachine.h'
--- launcher/LauncherHideMachine.h	2012-06-18 02:57:23 +0000
+++ launcher/LauncherHideMachine.h	2012-07-20 23:00:30 +0000
@@ -93,7 +93,7 @@
 
   void OnDecayRateChanged (int value);
 
-  ui::Decaymulator::Ptr decaymulator_;
+  ui::Decaymulator decaymulator_;
   HideMode  _mode;
   HideQuirk _quirks;
   bool      _should_hide;

=== modified file 'launcher/LauncherHoverMachine.cpp'
--- launcher/LauncherHoverMachine.cpp	2012-06-18 02:57:23 +0000
+++ launcher/LauncherHoverMachine.cpp	2012-07-20 23:00:30 +0000
@@ -16,7 +16,6 @@
  *
  * Authored by: Didier Roche <[e-mail]>
  */
-#include <boost/lexical_cast.hpp>
 
 #include "LauncherHoverMachine.h"
 
@@ -110,7 +109,7 @@
 {
   // Although I do wonder why we are returning a string representation
   // of the enum value as an integer anyway.
-  return boost::lexical_cast<std::string>(_quirks);
+  return std::to_string(_quirks);
 }
 
 } //unity namespace

=== modified file 'launcher/LauncherOptions.cpp'
--- launcher/LauncherOptions.cpp	2012-05-07 19:52:54 +0000
+++ launcher/LauncherOptions.cpp	2012-07-20 23:00:30 +0000
@@ -26,42 +26,42 @@
 {
 
 Options::Options()
+    // defaults from XML file
+  : hide_mode(LAUNCHER_HIDE_NEVER)
+  , launch_animation(LAUNCH_ANIMATION_PULSE)
+  , urgent_animation(URGENT_ANIMATION_WIGGLE)
+  , auto_hide_animation(FADE_AND_SLIDE)
+  , backlight_mode(BACKLIGHT_ALWAYS_ON)
+  , reveal_trigger(RevealTrigger::EDGE)
+  , icon_size(48)
+  , tile_size(54)
+  , background_alpha(0.6667)
+  , edge_decay_rate(1500)
+  , edge_overcome_pressure(2000)
+  , edge_stop_velocity(6500)
+  , edge_reveal_pressure(2000)
+  , edge_responsiveness(2.0f)
+  , edge_passed_disabled_ms(1000)
+  , edge_resist(true)
+  , show_for_all(false)
 {
-  // defaults from XML file
-  auto_hide_animation = FADE_AND_SLIDE;
-  background_alpha = 0.6667;
-  backlight_mode = BACKLIGHT_ALWAYS_ON;
-  edge_decay_rate = 1500;
-  edge_overcome_pressure = 2000;
-  edge_responsiveness = 2.0f;
-  edge_reveal_pressure = 2000;
-  edge_stop_velocity = 6500;
-  hide_mode = LAUNCHER_HIDE_NEVER;
-  icon_size = 48;
-  launch_animation = LAUNCH_ANIMATION_PULSE;
-  reveal_trigger = RevealTrigger::EDGE;
-  tile_size = 54;
-  urgent_animation = URGENT_ANIMATION_WIGGLE;
-  edge_resist = true;
-  show_for_all = false;
-
-  auto_hide_animation.changed.connect   ([&] (AutoHideAnimation value)-> void { option_changed.emit(); });
-  background_alpha.changed.connect      ([&] (float value)            -> void { option_changed.emit(); });
-  backlight_mode.changed.connect        ([&] (BacklightMode value)    -> void { option_changed.emit(); });
-  edge_decay_rate.changed.connect       ([&] (int value)              -> void { option_changed.emit(); });
-  edge_overcome_pressure.changed.connect([&] (int value)              -> void { option_changed.emit(); });
-  edge_responsiveness.changed.connect   ([&] (float value)            -> void { option_changed.emit(); });
-  edge_reveal_pressure.changed.connect  ([&] (int value)              -> void { option_changed.emit(); });
-  edge_stop_velocity.changed.connect    ([&] (int value)              -> void { option_changed.emit(); });
-  hide_mode.changed.connect             ([&] (LauncherHideMode value) -> void { option_changed.emit(); });
-  icon_size.changed.connect             ([&] (int value)              -> void { option_changed.emit(); });
-  launch_animation.changed.connect      ([&] (LaunchAnimation value)  -> void { option_changed.emit(); });
-  reveal_trigger.changed.connect        ([&] (RevealTrigger vallue)   -> void { option_changed.emit(); });
-  tile_size.changed.connect             ([&] (int value)              -> void { option_changed.emit(); });
-  urgent_animation.changed.connect      ([&] (UrgentAnimation value)  -> void { option_changed.emit(); });
-  edge_resist.changed.connect           ([&] (bool value)             -> void { option_changed.emit(); });
+  auto_hide_animation.changed.connect    ([this] (AutoHideAnimation value) { option_changed.emit(); });
+  background_alpha.changed.connect       ([this] (float value)             { option_changed.emit(); });
+  backlight_mode.changed.connect         ([this] (BacklightMode value)     { option_changed.emit(); });
+  edge_decay_rate.changed.connect        ([this] (int value)               { option_changed.emit(); });
+  edge_overcome_pressure.changed.connect ([this] (int value)               { option_changed.emit(); });
+  edge_responsiveness.changed.connect    ([this] (float value)             { option_changed.emit(); });
+  edge_reveal_pressure.changed.connect   ([this] (int value)               { option_changed.emit(); });
+  edge_stop_velocity.changed.connect     ([this] (int value)               { option_changed.emit(); });
+  edge_passed_disabled_ms.changed.connect([this] (unsigned value)          { option_changed.emit(); });
+  hide_mode.changed.connect              ([this] (LauncherHideMode value)  { option_changed.emit(); });
+  icon_size.changed.connect              ([this] (int value)               { option_changed.emit(); });
+  launch_animation.changed.connect       ([this] (LaunchAnimation value)   { option_changed.emit(); });
+  reveal_trigger.changed.connect         ([this] (RevealTrigger vallue)    { option_changed.emit(); });
+  tile_size.changed.connect              ([this] (int value)               { option_changed.emit(); });
+  urgent_animation.changed.connect       ([this] (UrgentAnimation value)   { option_changed.emit(); });
+  edge_resist.changed.connect            ([this] (bool value)              { option_changed.emit(); });
 }
-
 
 }
 }

=== modified file 'launcher/LauncherOptions.h'
--- launcher/LauncherOptions.h	2012-05-07 19:52:54 +0000
+++ launcher/LauncherOptions.h	2012-07-20 23:00:30 +0000
@@ -97,6 +97,7 @@
   nux::Property<int> edge_stop_velocity;
   nux::Property<int> edge_reveal_pressure;
   nux::Property<float> edge_responsiveness;
+  nux::Property<unsigned> edge_passed_disabled_ms;
   nux::Property<bool> edge_resist;
   nux::Property<bool> show_for_all;
 

=== modified file 'launcher/PointerBarrier.cpp'
--- launcher/PointerBarrier.cpp	2012-06-18 02:57:23 +0000
+++ launcher/PointerBarrier.cpp	2012-07-20 23:00:30 +0000
@@ -37,12 +37,12 @@
 
 PointerBarrierWrapper::PointerBarrierWrapper()
   : active(false)
+  , released(false)
   , smoothing(75)
   , max_velocity_multiplier(1.0f)
   , direction(BOTH)
-  , last_event_(0)
-  , last_x_(0)
-  , last_y_(0)
+  , event_base_(0)
+  , barrier(0)
   , smoothing_count_(0)
   , smoothing_accum_(0)
 {}
@@ -59,7 +59,8 @@
 
   Display *dpy = nux::GetGraphicsDisplay()->GetX11Display();
 
-  XFixesQueryExtension(dpy, &event_base_, &error_base_);
+  int error_base;
+  XFixesQueryExtension(dpy, &event_base_, &error_base);
 
   int maj,min;
   XFixesQueryVersion(dpy, &maj, &min);
@@ -68,7 +69,7 @@
                                                DefaultRootWindow(dpy),
                                                x1, y1,
                                                x2, y2,
-                                               (int) direction,
+                                               static_cast<int>(direction),
                                                threshold,
                                                0,
                                                NULL);
@@ -103,19 +104,16 @@
 
 void PointerBarrierWrapper::ReleaseBarrier(int event_id)
 {
-  XFixesBarrierReleasePointer (nux::GetGraphicsDisplay()->GetX11Display(), barrier, event_id);
+  XFixesBarrierReleasePointer(nux::GetGraphicsDisplay()->GetX11Display(), barrier, event_id);
 }
 
-void PointerBarrierWrapper::EmitCurrentData()
+void PointerBarrierWrapper::EmitCurrentData(int event_id, int x, int y)
 {
   if (smoothing_count_ <= 0)
     return;
 
-  BarrierEvent::Ptr event (new BarrierEvent());
-  event->x = last_x_;
-  event->y = last_y_;
-  event->velocity = std::min<int> (600 * max_velocity_multiplier, smoothing_accum_ / smoothing_count_);
-  event->event_id = last_event_;
+  int velocity = std::min<int>(600 * max_velocity_multiplier, smoothing_accum_ / smoothing_count_);
+  auto event = std::make_shared<BarrierEvent>(x, y, velocity, event_id);
 
   barrier_event.emit(this, event);
 
@@ -125,31 +123,40 @@
 
 bool PointerBarrierWrapper::HandleEvent(XEvent xevent)
 {
-  if(xevent.type - event_base_ == XFixesBarrierNotify)
+  if (xevent.type - event_base_ == XFixesBarrierNotify)
   {
-    XFixesBarrierNotifyEvent *notify_event = (XFixesBarrierNotifyEvent *)&xevent;
+    auto notify_event = reinterpret_cast<XFixesBarrierNotifyEvent*>(&xevent);
 
     if (notify_event->barrier == barrier && notify_event->subtype == XFixesBarrierHitNotify)
     {
-      last_x_ = notify_event->x;
-      last_y_ = notify_event->y;
-      last_event_ = notify_event->event_id;
       smoothing_accum_ += notify_event->velocity;
       smoothing_count_++;
 
-      if (!smoothing_timeout_)
-      {
-        auto smoothing_cb = [&] ()
+      if (released)
+      {
+        /* If the barrier is released, just emit the current event without
+         * waiting, so there won't be any delay on releasing the barrier. */
+        smoothing_timeout_.reset();
+        auto event = std::make_shared<BarrierEvent>(notify_event->x, notify_event->y,
+                                                    notify_event->velocity, notify_event->event_id);
+        barrier_event.emit(this, event);
+      }
+      else if (!smoothing_timeout_)
+      {
+        int x = notify_event->x;
+        int y = notify_event->y;
+        int event = notify_event->event_id;
+
+        auto smoothing_cb = [&, event, x, y] ()
         {
-          EmitCurrentData();
+          EmitCurrentData(event, x, y);
 
           smoothing_timeout_.reset();
           return false;
         };
 
-        smoothing_timeout_.reset(new glib::Timeout(smoothing(), smoothing_cb));
+        smoothing_timeout_.reset(new glib::Timeout(smoothing, smoothing_cb));
       }
-
     }
 
     return notify_event->barrier == barrier;

=== modified file 'launcher/PointerBarrier.h'
--- launcher/PointerBarrier.h	2012-06-18 02:57:23 +0000
+++ launcher/PointerBarrier.h	2012-07-20 23:00:30 +0000
@@ -30,11 +30,14 @@
 namespace ui
 {
 
-class BarrierEvent
+struct BarrierEvent
 {
-public:
   typedef std::shared_ptr<BarrierEvent> Ptr;
 
+  BarrierEvent(int x_, int y_, int velocity_, int event_id_)
+    : x(x_), y(y_), velocity(velocity_), event_id(event_id_)
+  {}
+
   int x;
   int y;
   int velocity;
@@ -55,6 +58,9 @@
 public:
   typedef std::shared_ptr<PointerBarrierWrapper> Ptr;
 
+  PointerBarrierWrapper();
+  virtual ~PointerBarrierWrapper();
+
   nux::Property<int> x1;
   nux::Property<int> x2;
   nux::Property<int> y1;
@@ -63,6 +69,7 @@
   nux::Property<int> threshold;
 
   nux::Property<bool> active;
+  nux::Property<bool> released;
 
   nux::Property<int> smoothing;
 
@@ -72,28 +79,22 @@
 
   nux::Property<BarrierDirection> direction;
 
-  PointerBarrierWrapper();
-  ~PointerBarrierWrapper();
-
-  void ConstructBarrier();
-  void DestroyBarrier();
-  void ReleaseBarrier(int event_id);
+  virtual void ConstructBarrier();
+  virtual void DestroyBarrier();
+  virtual void ReleaseBarrier(int event_id);
 
   sigc::signal<void, PointerBarrierWrapper*, BarrierEvent::Ptr> barrier_event;
 
+protected:
+  void EmitCurrentData(int event_id, int x, int y);
+  bool HandleEvent(XEvent event);
+
 private:
-  void EmitCurrentData();
-  bool HandleEvent (XEvent event);
   static bool HandleEventWrapper(XEvent event, void* data);
 
-  int last_event_;
-  int last_x_;
-  int last_y_;
-
   int event_base_;
-  int error_base_;
   PointerBarrier barrier;
-  
+
   int smoothing_count_;
   int smoothing_accum_;
   glib::Source::UniquePtr smoothing_timeout_;

=== modified file 'plugins/unityshell/src/unityshell.cpp'
--- plugins/unityshell/src/unityshell.cpp	2012-07-16 11:28:24 +0000
+++ plugins/unityshell/src/unityshell.cpp	2012-07-20 23:00:30 +0000
@@ -337,6 +337,7 @@
      optionSetOvercomePressureNotify(boost::bind(&UnityScreen::optionChanged, this, _1, _2));
      optionSetDecayRateNotify(boost::bind(&UnityScreen::optionChanged, this, _1, _2));
      optionSetShowMinimizedWindowsNotify(boost::bind(&UnityScreen::optionChanged, this, _1, _2));
+     optionSetEdgePassedDisabledMsNotify(boost::bind(&UnityScreen::optionChanged, this, _1, _2));
 
      optionSetNumLaunchersNotify(boost::bind(&UnityScreen::optionChanged, this, _1, _2));
      optionSetLauncherCaptureMouseNotify(boost::bind(&UnityScreen::optionChanged, this, _1, _2));
@@ -2894,9 +2895,13 @@
       break;
     case UnityshellOptions::RevealPressure:
       launcher_options->edge_reveal_pressure = optionGetRevealPressure() * 100;
+      break;
     case UnityshellOptions::EdgeResponsiveness:
       launcher_options->edge_responsiveness = optionGetEdgeResponsiveness();
       break;
+    case UnityshellOptions::EdgePassedDisabledMs:
+      launcher_options->edge_passed_disabled_ms = optionGetEdgePassedDisabledMs();
+      break;
     default:
       break;
   }

=== modified file 'plugins/unityshell/unityshell.xml.in'
--- plugins/unityshell/unityshell.xml.in	2012-03-23 15:30:56 +0000
+++ plugins/unityshell/unityshell.xml.in	2012-07-20 23:00:30 +0000
@@ -329,6 +329,14 @@
                     <max>1000</max>
                     <precision>1</precision>
                 </option>
+                <option name="edge_passed_disabled_ms" type="int">
+                    <_short>Duration of Sticky Edge Release after Break</_short>
+                    <_long>Sticky edges deactivated for number of milliseconds after the user breaks the barrier</_long>
+                    <default>1000</default>
+                    <min>0</min>
+                    <max>5000</max>
+                    <precision>1</precision>
+                </option>
                 <option name="autohide_animation" type="int">
                     <_short>Hide Animation</_short>
                     <_long>Animation played when the launcher is showing or hiding</_long>

=== modified file 'tests/CMakeLists.txt'
--- tests/CMakeLists.txt	2012-07-18 23:54:43 +0000
+++ tests/CMakeLists.txt	2012-07-20 23:00:30 +0000
@@ -124,6 +124,7 @@
 
 # The actual test executable (xless) - do not put anything that requires X in here
   add_executable(test-gtest-xless
+                 test_main_xless.cpp
                  test_animator.cpp
                  test_launcher_model.cpp
                  test_glib_object.cpp
@@ -134,25 +135,25 @@
                  test_glib_signals_utils.h
                  test_glib_source.cpp
                  test_glib_variant.cpp
+                 test_grabhandle.cpp
                  test_desktop_utilities.cpp
-                 ${CMAKE_CURRENT_BINARY_DIR}/test_glib_signals_utils_marshal.cpp
+                 test_hud_private.cpp
                  test_indicator.cpp
                  test_indicator_appmenu.cpp
                  test_indicator_entry.cpp
                  test_indicators.cpp
+                 test_introspection.cpp
                  test_favorite_store_gsettings.cpp
                  test_favorite_store_private.cpp
                  test_home_lens.cpp
                  test_launcher_entry_remote.cpp
+                 test_pointer_barrier.cpp
                  test_previews.cpp
                  test_shortcut_model.cpp
                  test_shortcut_private.cpp
-                 test_introspection.cpp
-                 test_main_xless.cpp
-                 test_grabhandle.cpp
+                 test_showdesktop_handler.cpp
                  test_unityshell_private.cpp
-                 test_showdesktop_handler.cpp
-                 test_hud_private.cpp
+                 ${CMAKE_CURRENT_BINARY_DIR}/test_glib_signals_utils_marshal.cpp
                  ${CMAKE_SOURCE_DIR}/launcher/AbstractLauncherIcon.cpp
                  ${CMAKE_SOURCE_DIR}/unity-shared/Animator.cpp
                  ${UNITY_SRC}/DebugDBusInterface.cpp
@@ -164,6 +165,7 @@
                  ${CMAKE_SOURCE_DIR}/launcher/LauncherEntryRemote.cpp
                  ${CMAKE_SOURCE_DIR}/launcher/MockLauncherIcon.cpp
                  ${CMAKE_SOURCE_DIR}/launcher/FavoriteStorePrivate.cpp
+                 ${CMAKE_SOURCE_DIR}/launcher/PointerBarrier.cpp
                  ${CMAKE_SOURCE_DIR}/shortcuts/ShortcutModel.cpp
                  ${CMAKE_SOURCE_DIR}/shortcuts/ShortcutHintPrivate.cpp
                  ${CMAKE_SOURCE_DIR}/unity-shared/Introspectable.cpp
@@ -203,23 +205,24 @@
 
 # Tests that require X
   add_executable(test-gtest
+                 test_main.cpp
                  test_bamflaunchericon.cpp
-                 test_hud_button.cpp
-                 test_hud_controller.cpp
                  test_dashview_impl.cpp
-                 test_texture_cache.cpp
-                 test_main.cpp
+                 test_edge_barrier_controller.cpp
                  test_launcher.cpp
                  test_device_launcher_section.cpp
                  test_lensview_impl.cpp
+                 test_hud_button.cpp
+                 test_hud_controller.cpp
+                 test_hud_view.cpp
                  test_icon_loader.cpp
                  test_im_text_entry.cpp
-                 test_hud_view.cpp
                  test_keyboard_util.cpp
                  test_resultviewgrid.cpp
                  test_single_monitor_launcher_icon.cpp
                  test_switcher_controller.cpp
                  test_switcher_model.cpp
+                 test_texture_cache.cpp
                  gmockvolume.c
                  ${CMAKE_SOURCE_DIR}/dash/AbstractPlacesGroup.cpp
                  ${CMAKE_SOURCE_DIR}/dash/DashViewPrivate.cpp
@@ -243,6 +246,7 @@
                  ${CMAKE_SOURCE_DIR}/launcher/DeviceLauncherSection.cpp
                  ${CMAKE_SOURCE_DIR}/launcher/DevicesSettings.cpp
                  ${CMAKE_SOURCE_DIR}/launcher/DndData.cpp
+                 ${CMAKE_SOURCE_DIR}/launcher/EdgeBarrierController.cpp
                  ${CMAKE_SOURCE_DIR}/launcher/FavoriteStore.cpp
                  ${CMAKE_SOURCE_DIR}/launcher/FavoriteStoreGSettings.cpp
                  ${CMAKE_SOURCE_DIR}/launcher/FavoriteStorePrivate.cpp
@@ -254,6 +258,7 @@
                  ${CMAKE_SOURCE_DIR}/launcher/LauncherHoverMachine.cpp
                  ${CMAKE_SOURCE_DIR}/launcher/LauncherIcon.cpp
                  ${CMAKE_SOURCE_DIR}/launcher/LauncherModel.cpp
+                 ${CMAKE_SOURCE_DIR}/launcher/LauncherOptions.cpp
                  ${CMAKE_SOURCE_DIR}/launcher/LayoutSystem.cpp
                  ${CMAKE_SOURCE_DIR}/launcher/MockLauncherIcon.cpp
                  ${CMAKE_SOURCE_DIR}/launcher/PointerBarrier.cpp

=== added file 'tests/test_edge_barrier_controller.cpp'
--- tests/test_edge_barrier_controller.cpp	1970-01-01 00:00:00 +0000
+++ tests/test_edge_barrier_controller.cpp	2012-07-20 23:00:30 +0000
@@ -0,0 +1,225 @@
+/*
+ * Copyright 2012 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 warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY 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
+ * version 3 along with this program.  If not, see
+ * <http://www.gnu.org/licenses/>
+ *
+ * Authored by: Marco Trevisan (Treviño) <[e-mail]>
+ *
+ */
+
+#include <gmock/gmock.h>
+#include "test_utils.h"
+
+#include "EdgeBarrierController.h"
+#include "MultiMonitor.h"
+
+using namespace unity;
+using namespace unity::ui;
+using namespace testing;
+
+namespace
+{
+
+class MockPointerBarrier : public PointerBarrierWrapper
+{
+public:
+  MockPointerBarrier(int monitor = 0, bool released_ = false)
+  {
+    index = monitor;
+    x1 = 1;
+    released = released_;
+  }
+
+  MOCK_METHOD0(ConstructBarrier, void());
+  MOCK_METHOD0(DestroyBarrier, void());
+  MOCK_METHOD1(ReleaseBarrier, void(int));
+};
+
+class MockEdgeBarrierController : public EdgeBarrierController
+{
+public:
+  void ProcessBarrierEvent(PointerBarrierWrapper* owner, BarrierEvent::Ptr event)
+  {
+    EdgeBarrierController::ProcessBarrierEvent(owner, event);
+  }
+};
+
+class TestBarrierSubscriber : public EdgeBarrierSubscriber
+{
+public:
+  TestBarrierSubscriber(bool handles = false)
+    : handles_(handles)
+  {}
+
+  bool HandleBarrierEvent(PointerBarrierWrapper* owner, BarrierEvent::Ptr event)
+  {
+    return handles_;
+  }
+
+  bool handles_;
+};
+
+class TestEdgeBarrierController : public Test
+{
+public:
+  virtual void SetUp()
+  {
+    bc.options = std::make_shared<launcher::Options>();
+    bc.options()->edge_resist = true;
+    bc.options()->edge_passed_disabled_ms = 150;
+
+    for (int i = 0; i < max_num_monitors; ++i)
+    {
+      // By default we assume that no subscriber handles the events!!!
+      bc.Subscribe(&subscribers_[i], i);
+    }
+  }
+
+  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];
+  MockEdgeBarrierController bc;
+};
+
+TEST_F(TestEdgeBarrierController, Construction)
+{
+  EXPECT_TRUE(bc.sticky_edges);
+}
+
+TEST_F(TestEdgeBarrierController, ProcessHandledEvent)
+{
+  int monitor = 0;
+
+  TestBarrierSubscriber handling_subscriber(true);
+  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);
+}
+
+TEST_F(TestEdgeBarrierController, ProcessHandledEventOnReleasedBarrier)
+{
+  int monitor = max_num_monitors-1;
+
+  TestBarrierSubscriber handling_subscriber(true);
+  bc.Subscribe(&handling_subscriber, monitor);
+
+  MockPointerBarrier owner(monitor, true);
+  auto breaking_barrier_event = MakeBarrierEvent(0, true);
+
+  EXPECT_CALL(owner, ReleaseBarrier(_)).Times(0);
+  bc.ProcessBarrierEvent(&owner, breaking_barrier_event);
+}
+
+TEST_F(TestEdgeBarrierController, ProcessUnHandledEventBreakingBarrier)
+{
+  int monitor = 1;
+
+  MockPointerBarrier owner(monitor);
+  int breaking_id = 12345;
+  auto breaking_barrier_event = MakeBarrierEvent(breaking_id, true);
+
+  EXPECT_CALL(owner, ReleaseBarrier(breaking_id));
+  bc.ProcessBarrierEvent(&owner, breaking_barrier_event);
+}
+
+TEST_F(TestEdgeBarrierController, ProcessUnHandledEventNotBreakingBarrier)
+{
+  int monitor = 2;
+
+  MockPointerBarrier owner(monitor);
+  int not_breaking_id = 54321;
+  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);
+}
+
+TEST_F(TestEdgeBarrierController, ProcessUnHandledEventOnReleasedBarrier)
+{
+  int monitor = 2;
+
+  MockPointerBarrier owner(monitor, true);
+  int not_breaking_id = 345678;
+  auto not_breaking_barrier_event = MakeBarrierEvent(not_breaking_id, false);
+
+  EXPECT_CALL(owner, ReleaseBarrier(not_breaking_id));
+  bc.ProcessBarrierEvent(&owner, not_breaking_barrier_event);
+}
+
+TEST_F(TestEdgeBarrierController, BreakingEdgeTemporaryReleasesBarrier)
+{
+  MockPointerBarrier owner;
+
+  EXPECT_CALL(owner, ReleaseBarrier(1));
+  bc.ProcessBarrierEvent(&owner, MakeBarrierEvent(1, true));
+  ASSERT_TRUE(owner.released());
+
+  Utils::WaitForTimeoutMSec(bc.options()->edge_passed_disabled_ms);
+  EXPECT_FALSE(owner.released());
+}
+
+TEST_F(TestEdgeBarrierController, BreakingEdgeTemporaryReleasesBarrierForNotHandledEvents)
+{
+  MockPointerBarrier owner;
+  int monitor = 0;
+  subscribers_[monitor].handles_ = false;
+
+  EXPECT_CALL(owner, ReleaseBarrier(5));
+  bc.ProcessBarrierEvent(&owner, MakeBarrierEvent(5, true));
+  ASSERT_TRUE(owner.released());
+
+  subscribers_[monitor].handles_ = false;
+  EXPECT_CALL(owner, ReleaseBarrier(6));
+  bc.ProcessBarrierEvent(&owner, MakeBarrierEvent(6, false));
+}
+
+TEST_F(TestEdgeBarrierController, BreakingEdgeDontReleasesBarrierForHandledEvents)
+{
+  MockPointerBarrier owner;
+  int monitor = 0;
+  subscribers_[monitor].handles_ = false;
+
+  EXPECT_CALL(owner, ReleaseBarrier(5));
+  bc.ProcessBarrierEvent(&owner, MakeBarrierEvent(5, true));
+  ASSERT_TRUE(owner.released());
+
+  subscribers_[monitor].handles_ = true;
+  EXPECT_CALL(owner, ReleaseBarrier(_)).Times(0);
+  bc.ProcessBarrierEvent(&owner, MakeBarrierEvent(6, true));
+}
+
+TEST_F(TestEdgeBarrierController, StickyEdgePropertyProxiesLauncherOption)
+{
+  bc.options()->edge_resist = false;
+  EXPECT_FALSE(bc.sticky_edges());
+
+  bc.options()->edge_resist = true;
+  EXPECT_TRUE(bc.sticky_edges());
+
+  bc.sticky_edges = false;
+  EXPECT_FALSE(bc.options()->edge_resist());
+
+  bc.sticky_edges = true;
+  EXPECT_TRUE(bc.options()->edge_resist());
+}
+
+}

=== added file 'tests/test_pointer_barrier.cpp'
--- tests/test_pointer_barrier.cpp	1970-01-01 00:00:00 +0000
+++ tests/test_pointer_barrier.cpp	2012-07-20 23:00:30 +0000
@@ -0,0 +1,141 @@
+/*
+ * Copyright 2012 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 warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY 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
+ * version 3 along with this program.  If not, see
+ * <http://www.gnu.org/licenses/>
+ *
+ * Authored by: Marco Trevisan (Treviño) <[e-mail]>
+ *
+ */
+
+#include <gtest/gtest.h>
+#include <limits>
+
+#include "test_utils.h"
+#include "PointerBarrier.h"
+
+using namespace unity::ui;
+
+namespace
+{
+
+class MockPointerBarrier : public PointerBarrierWrapper
+{
+public:
+  bool HandleEvent(XEvent ev) { return PointerBarrierWrapper::HandleEvent(ev); }
+};
+
+TEST(TestPointerBarrier, Construction)
+{
+  PointerBarrierWrapper pb;
+
+  EXPECT_EQ(pb.active, false);
+  EXPECT_EQ(pb.released, false);
+  EXPECT_EQ(pb.smoothing, 75);
+  EXPECT_EQ(pb.max_velocity_multiplier, 1.0f);
+  EXPECT_EQ(pb.direction, BOTH);
+}
+
+TEST(TestPointerBarrier, EventConstruction)
+{
+  BarrierEvent bev(1, 2, 3, 4);
+  EXPECT_EQ(bev.x, 1);
+  EXPECT_EQ(bev.y, 2);
+  EXPECT_EQ(bev.velocity, 3);
+  EXPECT_EQ(bev.event_id, 4);
+}
+
+TEST(TestPointerBarrier, HandleInvalidEvents)
+{
+  MockPointerBarrier pb;
+  XFixesBarrierNotifyEvent ev;
+  auto xev = reinterpret_cast<XEvent*>(&ev);
+
+  ev.type = XFixesBarrierNotify + 1;
+  EXPECT_FALSE(pb.HandleEvent(*xev));
+
+  ev.type = XFixesBarrierNotify;
+  ev.subtype = XFixesBarrierHitNotify + 1;
+  ev.barrier = 1;
+  EXPECT_FALSE(pb.HandleEvent(*xev));
+
+  ev.barrier = 0;
+  EXPECT_TRUE(pb.HandleEvent(*xev));
+}
+
+TEST(TestPointerBarrier, HandleHitNotifyEvents)
+{
+  MockPointerBarrier pb;
+  XFixesBarrierNotifyEvent ev;
+  auto xev = reinterpret_cast<XEvent*>(&ev);
+
+  ev.type = XFixesBarrierNotify;
+  ev.subtype = XFixesBarrierHitNotify;
+  ev.barrier = 0;
+  ev.event_id = 0xdeadbeef;
+  ev.x = 555;
+  ev.y = 333;
+  ev.velocity = std::numeric_limits<int>::max();
+
+  bool got_event = false;
+
+  pb.barrier_event.connect([&] (PointerBarrierWrapper* pbw, BarrierEvent::Ptr bev) {
+    got_event = true;
+
+    EXPECT_EQ(pbw, &pb);
+    EXPECT_EQ(bev->x, ev.x);
+    EXPECT_EQ(bev->y, ev.y);
+    EXPECT_EQ(bev->velocity, 600 * pb.max_velocity_multiplier);
+    EXPECT_EQ(bev->event_id, ev.event_id);
+  });
+
+  EXPECT_TRUE(pb.HandleEvent(*xev));
+  EXPECT_FALSE(got_event);
+
+  Utils::WaitForTimeoutMSec(pb.smoothing());
+
+  EXPECT_TRUE(got_event);
+}
+
+TEST(TestPointerBarrier, HandleHitNotifyReleasedEvents)
+{
+  MockPointerBarrier pb;
+  XFixesBarrierNotifyEvent ev;
+  auto xev = reinterpret_cast<XEvent*>(&ev);
+
+  ev.type = XFixesBarrierNotify;
+  ev.subtype = XFixesBarrierHitNotify;
+  ev.barrier = 0;
+  ev.event_id = 0xabba;
+  ev.x = 3333;
+  ev.y = 5555;
+  ev.velocity = std::numeric_limits<int>::max();
+
+  bool got_event = false;
+
+  pb.barrier_event.connect([&] (PointerBarrierWrapper* pbw, BarrierEvent::Ptr bev) {
+    got_event = true;
+
+    EXPECT_EQ(pbw, &pb);
+    EXPECT_EQ(bev->x, ev.x);
+    EXPECT_EQ(bev->y, ev.y);
+    EXPECT_EQ(bev->velocity, ev.velocity);
+    EXPECT_EQ(bev->event_id, ev.event_id);
+  });
+
+  pb.released = true;
+  EXPECT_TRUE(pb.HandleEvent(*xev));
+  EXPECT_TRUE(got_event);
+}
+
+}