Merge lp:~gordallott/unity/fix-hud-not-emitting-signal into lp:unity

[Gord Allott]

Fixes issue with hud not emitting a signal when results change

Fixes issue with hud not emitting when results change

== The Problem ==
Hud was listening the to the QueryUpdated signal but wasn't emitting a signal

== The Solution ==
Emit the signal

== Testing ==
About a billion lines in comparison, adds the signal check to our hud test suite

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

Looks good. ;)

review: Approve

[Unity Merger (unity-merger)]

No commit message specified.

=== modified file 'UnityCore/Hud.cpp'
--- UnityCore/Hud.cpp	2012-02-02 14:47:15 +0000
+++ UnityCore/Hud.cpp	2012-03-16 13:18:21 +0000
@@ -150,6 +150,7 @@
     GVariant* queries = g_variant_get_child_value(query, 1);
     BuildQueries(queries);
     g_variant_unref(queries);
+    parent_->queries_updated.emit(queries_);
   }
 }
 

=== modified file 'tests/test_hud.cpp'
--- tests/test_hud.cpp	2012-03-05 16:56:48 +0000
+++ tests/test_hud.cpp	2012-03-16 13:18:21 +0000
@@ -2,6 +2,7 @@
 #include <glib-object.h>
 #include <UnityCore/GLibWrapper.h>
 #include <UnityCore/Hud.h>
+#include <sigc++/connection.h>
 
 using namespace std;
 
@@ -22,6 +23,7 @@
   unity::hud::Hud::Queries queries;
   bool query_return_result;
   bool connected_result;
+  int number_signals_found;
 };
 
 TEST_F(TestHud, TestConstruction)
@@ -85,7 +87,7 @@
     return FALSE;
   };
    
-  hud->queries_updated.connect(query_connection);
+  sigc::connection connection = hud->queries_updated.connect(query_connection);
  
   guint source_id = g_timeout_add(10000, timeout_bailout, this);
  
@@ -98,7 +100,43 @@
 
   // finally close the connection - Nothing to check for here
   hud->CloseQuery();
-}
-
+  connection.disconnect();
+}
+
+TEST_F(TestHud, TestSigEmission)
+{
+  // checks that the signal emission from Hud is working correctly
+  // the service is setup to emit the same signal every 1000ms
+  // using the same query key as its StarQuery method
+  // so calling StartQuery and listening we expect > 1 
+  // signal emission
+  number_signals_found = 0;
+
+  // make sure we receive the queries
+  auto query_connection = [this](unity::hud::Hud::Queries queries_) 
+  { 
+    number_signals_found += 1;
+  };
+
+  auto timeout_bailout = [] (gpointer data) -> gboolean
+  {
+    g_main_loop_quit(loop_);
+    return FALSE;
+  };
+   
+  sigc::connection connection = hud->queries_updated.connect(query_connection);
+ 
+  hud->RequestQuery("Request30Queries");
+  guint source_id = g_timeout_add(10000, timeout_bailout, this);
+ 
+  g_main_loop_run(loop_);
+  EXPECT_GT(number_signals_found, 1);
+  g_source_remove(source_id);
+
+  // finally close the connection - Nothing to check for here
+  hud->CloseQuery();
+  connection.disconnect();
+  
+}
 
 }

=== modified file 'tests/test_service_hud.c'
--- tests/test_service_hud.c	2012-01-12 11:45:05 +0000
+++ tests/test_service_hud.c	2012-03-16 13:18:21 +0000
@@ -51,6 +51,10 @@
                                 GDBusMethodInvocation *invocation,
                                 gpointer user_data);
 
+static gboolean                 do_emit_signal(gpointer data);
+static void                     emit_signal(GDBusConnection *connection);
+
+
 G_DEFINE_TYPE(ServiceHud, service_hud, G_TYPE_OBJECT);
 static GDBusNodeInfo * node_info = NULL;
 static GDBusInterfaceInfo * iface_info = NULL;
@@ -60,12 +64,12 @@
   set_property: NULL,
 };
 
-
 struct _ServiceHudPrivate
 {
   GDBusConnection * bus;
   GCancellable * bus_lookup;
   guint bus_registration;
+  guint sig_emission_handle;
 };
 
 static void
@@ -88,6 +92,11 @@
     self->priv->bus = NULL;
   }
 
+  if (self->priv->sig_emission_handle) {
+    g_source_remove(self->priv->sig_emission_handle);
+    self->priv->sig_emission_handle = 0;
+  }
+
 }
 
 static void
@@ -129,7 +138,6 @@
   
   self->priv->bus_lookup = g_cancellable_new();
   g_bus_get(G_BUS_TYPE_SESSION, self->priv->bus_lookup, bus_got_cb, self);
-  
 }
 
 ServiceHud*
@@ -168,10 +176,94 @@
     g_error_free(error);
     return;
   }
+  else
+  {
+    self->priv->sig_emission_handle = g_timeout_add(1000, do_emit_signal, bus);
+  }
   
   return;
 }
 
+static gboolean
+do_emit_signal(gpointer data)
+{
+  emit_signal(G_DBUS_CONNECTION(data));
+  return TRUE;
+}
+
+static void
+emit_signal(GDBusConnection *connection)
+{
+  GVariant *query;
+  int num_entries = 5;
+
+  /* Build into into a variant */
+  GVariantBuilder ret_builder;
+  g_variant_builder_init(&ret_builder, G_VARIANT_TYPE_TUPLE);
+  g_variant_builder_add_value(&ret_builder, g_variant_new_string("target"));
+  GVariantBuilder builder;
+  
+  g_variant_builder_init(&builder, G_VARIANT_TYPE_ARRAY);
+   
+  int i = 0;
+  for (i = 0; i < num_entries; i++) 
+  {
+    gchar* target = g_strdup_printf("test-%i", i);
+    gchar* icon = g_strdup_printf("icon-%i", i);
+    gchar* future_icon = g_strdup(icon);
+    gchar* completion_text = g_strdup_printf("completion-%i", i);
+    gchar* accelerator = g_strdup_printf("<alt>+whatever");
+
+    GVariantBuilder tuple;
+    g_variant_builder_init(&tuple, G_VARIANT_TYPE_TUPLE);
+    g_variant_builder_add_value(&tuple, g_variant_new_string(target));
+    g_variant_builder_add_value(&tuple, g_variant_new_string(icon));
+    g_variant_builder_add_value(&tuple, g_variant_new_string(future_icon));
+    g_variant_builder_add_value(&tuple, g_variant_new_string(completion_text));
+    g_variant_builder_add_value(&tuple, g_variant_new_string(accelerator));
+    // build a fake key
+    GVariant* key;
+    {
+      GVariantBuilder keybuilder;
+      g_variant_builder_init(&keybuilder, G_VARIANT_TYPE_TUPLE);
+      g_variant_builder_add_value(&keybuilder, g_variant_new_string("dummy string"));
+      g_variant_builder_add_value(&keybuilder, g_variant_new_string("dummy string"));
+      g_variant_builder_add_value(&keybuilder, g_variant_new_string("dummy string"));
+      g_variant_builder_add_value(&keybuilder, g_variant_new_int32(1986));
+
+      key = g_variant_new_variant(g_variant_builder_end(&keybuilder));
+    }
+    g_variant_ref_sink(key);
+    g_variant_builder_add_value(&tuple, key);
+    g_variant_builder_add_value(&builder, g_variant_builder_end(&tuple));
+    g_free(target);
+    g_free(icon);
+    g_free(future_icon);
+    g_free(completion_text);
+  }
+  g_variant_builder_add_value(&ret_builder, g_variant_builder_end(&builder));
+ 
+  GVariant* query_key;
+  {
+    GVariantBuilder keybuilder;
+    g_variant_builder_init(&keybuilder, G_VARIANT_TYPE_TUPLE);
+    g_variant_builder_add_value(&keybuilder, g_variant_new_string("dummy string"));
+    g_variant_builder_add_value(&keybuilder, g_variant_new_string("dummy string"));
+    g_variant_builder_add_value(&keybuilder, g_variant_new_string("dummy string"));
+    g_variant_builder_add_value(&keybuilder, g_variant_new_int32(1986));
+
+    query_key = g_variant_new_variant(g_variant_builder_end(&keybuilder));
+  }
+  g_variant_ref_sink(query_key);
+  g_variant_builder_add_value(&ret_builder, query_key);
+  
+  query = g_variant_builder_end(&ret_builder);
+  
+  g_dbus_connection_emit_signal (connection, NULL, "/com/canonical/hud",
+                                 "com.canonical.hud", "UpdatedQuery",
+                                 query, NULL);
+}
+
 static void
 bus_method (GDBusConnection *connection, const gchar *sender, const gchar *object_path, const gchar *interface_name, const gchar *method_name, GVariant *parameters, GDBusMethodInvocation *invocation, gpointer user_data)
 {