Merge lp:~mhr3/libunity/invalidation-propagation into lp:libunity

[Michal Hruby]

Correctly propagate the results_invalidated signal from scopes to master scopes and eventually to home scope.

Correctly propagate the results_invalidated signal from scopes to master scopes and eventually to home scope.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:268
http://jenkins.qa.ubuntu.com/job/libunity-ci/79/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/libunity-saucy-amd64-ci/64
    SUCCESS: http://jenkins.qa.ubuntu.com/job/libunity-saucy-armhf-ci/64
    SUCCESS: http://jenkins.qa.ubuntu.com/job/libunity-saucy-i386-ci/64

Click here to trigger a rebuild:
http://s-jenkins:8080/job/libunity-ci/79/rebuild

review: Approve (continuous-integration)

[James Henstridge (jamesh)]

It looks like AggregatorScopeimpl.queue_search_for_type is unused, so can probably go. (from what I can see, its one previous use now emits the results_invalidated signal instead)

In the tests, the conversion of ChildScope to a Unity.SimpleScope looks like a good cleanup, but it seems that the dbus_path property you add is unused if I'm not mistaken (it duplicates the SimpleScope.unique_name one, which does seem to be used).

Other than that, the changes look good.

review: Needs Fixing

[lp:~mhr3/libunity/invalidation-propagation]

269. By Michal Hruby on 2013-07-24

Remove unused property

270. By Michal Hruby on 2013-07-24

Emit results_invalidated when necessary

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:270
http://jenkins.qa.ubuntu.com/job/libunity-ci/80/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/libunity-saucy-amd64-ci/65
    SUCCESS: http://jenkins.qa.ubuntu.com/job/libunity-saucy-armhf-ci/65
    SUCCESS: http://jenkins.qa.ubuntu.com/job/libunity-saucy-i386-ci/65

Click here to trigger a rebuild:
http://s-jenkins:8080/job/libunity-ci/80/rebuild

review: Approve (continuous-integration)

[lp:~mhr3/libunity/invalidation-propagation]

271. By Michal Hruby on 2013-07-24

Don't automatically cancel current search when using results_invalidated

[James Henstridge (jamesh)]

Looks good.

review: Approve

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:271
http://jenkins.qa.ubuntu.com/job/libunity-ci/81/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/libunity-saucy-amd64-ci/66
    SUCCESS: http://jenkins.qa.ubuntu.com/job/libunity-saucy-armhf-ci/66
    SUCCESS: http://jenkins.qa.ubuntu.com/job/libunity-saucy-i386-ci/66

Click here to trigger a rebuild:
http://s-jenkins:8080/job/libunity-ci/81/rebuild

review: Approve (continuous-integration)

=== modified file 'protocol/protocol-icon.vala'
--- protocol/protocol-icon.vala	2012-09-24 13:53:47 +0000
+++ protocol/protocol-icon.vala	2013-07-24 13:18:24 +0000
@@ -157,6 +157,13 @@
     tokens.add (dict.print (true));
     return true;
   }
+
+  /* Added to GIcon interface in 2.37 */
+  private Variant serialize ()
+  {
+    Variant? ret = null;
+    return ret;
+  }
 }
 
 

=== modified file 'src/Makefile.am'
--- src/Makefile.am	2013-07-03 23:14:43 +0000
+++ src/Makefile.am	2013-07-24 13:18:24 +0000
@@ -119,6 +119,7 @@
   unity-master-scope.vala \
   unity-simple-scope.vala \
   unity-scope-loader.vala \
+  unity-scope-tracker.vala \
   unity-sound-menu.vala \
   unity-sound-menu-mpris.vala \
   unity-utils.vala \

=== modified file 'src/unity-aggregator-scope-private.vala'
--- src/unity-aggregator-scope-private.vala	2013-07-22 12:11:04 +0000
+++ src/unity-aggregator-scope-private.vala	2013-07-24 13:18:24 +0000
@@ -30,548 +30,6 @@
                                     DeprecatedScopeDBusImpl, MergeStrategy
 {
   const int DEFAULT_TIMEOUT_INTERVAL_MS = 16;
-  const int MODEL_UPDATE_TIMEOUT_SECS = 30;
-  private static Quark dedup_model_quark = Quark.from_string ("unity-dedup-model");
-
-  private class ScopeTracker : Object
-  {
-    private GenericArray<ScopeProxy> scope_proxy_arr;
-    // scope_id -> ScopeProxy
-    private HashTable<string, Utils.AsyncOnce<ScopeProxy>> scope_proxies;
-    // channel_key (proxy + master_channel_id) -> scope channel_id
-    private HashTable<string, Utils.AsyncOnce<string>> scope_channel_ids;
-    // channel_key (proxy + master_channel_id) -> Dee.Model
-    private HashTable<string, Dee.SerializableModel> scope_models;
-    // master_channel_id -> ResultsSynchronizer
-    private HashTable<string, ResultsSynchronizer> synchronizers;
-    // scope_id -> ScopeMetadata
-    private HashTable<string, ScopeRegistry.ScopeMetadata> scope_metadata;
-    // binary name -> present on the system
-    private HashTable<string, bool> binary_present;
-
-    public ScopeTracker ()
-    {
-      scope_proxy_arr = new GenericArray<ScopeProxy> ();
-      scope_proxies = new HashTable<string, Utils.AsyncOnce<ScopeProxy>> (str_hash, str_equal);
-      scope_channel_ids = new HashTable<string, Utils.AsyncOnce<string>> (str_hash, str_equal);
-      scope_models = new HashTable<string, Dee.SerializableModel> (str_hash, str_equal);
-      synchronizers = new HashTable<string, ResultsSynchronizer> (str_hash, str_equal);
-      scope_metadata = new HashTable<string, ScopeRegistry.ScopeMetadata> (str_hash, str_equal);
-      binary_present = new HashTable<string, bool> (str_hash, str_equal);
-    }
-
-    public List<weak string> scope_ids_for_proxies ()
-    {
-      return scope_proxies.get_keys ();
-    }
-
-    public unowned ScopeProxy? get_proxy_for_scope_id (string scope_id)
-    {
-      var proxy_once = get_proxy_once (scope_id);
-      if (!proxy_once.is_initialized ())
-      {
-        return null;
-      }
-
-      return proxy_once.get_data ();
-    }
-
-    public unowned ResultsSynchronizer? get_synchronizer (string channel_id)
-    {
-      return synchronizers.lookup (channel_id);
-    }
-
-    private bool content_enabled (ScopeRegistry.ScopeMetadata metadata)
-    {
-      var pref_man = PreferencesManager.get_default ();
-      if (metadata.remote_content && pref_man.remote_content_search == PreferencesManager.RemoteContent.NONE)
-      {
-        return false;
-      }
-      return true;
-    }
-
-    private void perform_checks (ScopeRegistry.ScopeMetadata metadata,
-                                 ChannelType requested_channel_type)
-      throws ScopeError
-    {
-      // check remote content vs user preference
-      if (!content_enabled (metadata))
-      {
-        throw new ScopeError.DISABLED_CONTENT ("Requested content disabled");
-      }
-      // check global search flag
-      if (!metadata.global_searches && requested_channel_type == ChannelType.GLOBAL)
-      {
-        throw new ScopeError.DISABLED_CONTENT ("Global search is disabled");
-      }
-      // check if the required binary is installed
-      if (metadata.query_binary != null && metadata.query_binary != "")
-      {
-        if (!(metadata.query_binary in binary_present))
-        {
-          binary_present[metadata.query_binary] = Environment.find_program_in_path (metadata.query_binary) != null;
-        }
-        if (!binary_present[metadata.query_binary])
-        {
-          throw new ScopeError.DISABLED_CONTENT ("Required application isn't installed");
-        }
-      }
-    }
-
-    public async ScopeProxy? create_proxy (ScopeRegistry.ScopeMetadata metadata)
-      throws Error
-    {
-      var proxy = yield ScopeProxy.new_from_metadata (metadata);
-      dynamic ScopeProxy remote_proxy = proxy;
-      remote_proxy.auto_reconnect = false;
-      // check that the proxy props match the metadata,
-      // will throw an error if it doesn't
-      check_proxy_vs_metadata (proxy, metadata);
-
-      scope_proxy_arr.add (proxy);
-
-      proxy.channels_invalidated.connect (channels_invalidated);
-      proxy.results_invalidated.connect (on_results_invalidated);
-      return proxy;
-    }
-
-    private void channels_invalidated (ScopeProxy proxy)
-    {
-      // we're not removing the results that were associated with this proxy
-      // and are still living in the associated ResultsSynchronizer,
-      // cause scope quitting after a while is an excepted part of scope
-      // lifecycle, plus activating a result will try to respawn the scope
-
-      // invalidate all associated containers
-      string[] invalid_keys = {};
-      string prefix = "%p::".printf (proxy);
-      
-      debug ("Invalidating channels for %s", prefix);
-
-      foreach (unowned string channel_key in scope_channel_ids.get_keys ())
-      {
-        if (channel_key.has_prefix (prefix)) invalid_keys += channel_key;
-      }
-
-      foreach (unowned string channel_key in invalid_keys)
-      {
-        scope_channel_ids.remove (channel_key);
-        scope_models.remove (channel_key);
-      }
-    }
-
-    public signal void results_invalidated (ChannelType channel_type);
-
-    private void on_results_invalidated (ScopeProxy proxy,
-                                         ChannelType channel_type)
-    {
-      this.results_invalidated (channel_type);
-    }
-
-    private void check_proxy_vs_metadata (
-        ScopeProxy proxy,
-        ScopeRegistry.ScopeMetadata metadata) throws Error
-    {
-      if (proxy.is_master != metadata.is_master)
-        throw new ScopeError.DATA_MISMATCH ("Scope file info for '%s' doesn't match on IsMaster key".printf (metadata.id));
-
-      if (metadata.required_metadata != null)
-      {
-        var dict = metadata.required_metadata.as_hash_table ();
-        unowned string field_name;
-        unowned string schema;
-        var iter = HashTableIter<string, string> (dict);
-        while (iter.next (out field_name, out schema))
-        {
-          if (proxy.metadata[field_name] != schema)
-            throw new ScopeError.DATA_MISMATCH ("Scope file info for '%s' doesn't match on RequiredMetadata key".printf (metadata.id));
-        }
-      }
-    }
-
-    private string get_channel_key (string master_channel_id, ScopeProxy proxy)
-    {
-      return "%p::%s".printf (proxy, master_channel_id);
-    }
-
-    public void register_channel (string master_channel_id,
-                                  Dee.SerializableModel model,
-                                  MergeStrategy merge_strategy)
-    {
-      // create new synchronizer for this channel
-      var synchronizer = new ResultsSynchronizer (model);
-      synchronizer.merge_strategy = merge_strategy;
-      synchronizers[master_channel_id] = synchronizer;
-    }
-
-    public void unregister_channel (string master_channel_id)
-    {
-      var synchronizer = synchronizers[master_channel_id];
-      if (synchronizer != null)
-      {
-        // break the circular reference
-        synchronizer.receiver.set_qdata<Dee.Model?> (dedup_model_quark, null);
-        synchronizers.remove (master_channel_id);
-      }
-      // FIXME: close child scopes' channels
-    }
-    
-    private async void wait_for_seqnum (Dee.SharedModel model, uint64 seqnum)
-      throws Error
-    {
-      if (model.get_seqnum () >= seqnum) return;
-
-      var update_sig_id = model.end_transaction.connect ((m, begin_seqnum, end_seqnum) =>
-      {
-        if (end_seqnum < seqnum) return;
-
-        wait_for_seqnum.callback ();
-      });
-
-      // make sure we don't wait indefinitely
-      uint src_id = 0;
-      src_id = Timeout.add_seconds (MODEL_UPDATE_TIMEOUT_SECS, () =>
-      {
-        src_id = 0;
-        wait_for_seqnum.callback ();
-        return false;
-      });
-
-      yield;
-
-      SignalHandler.disconnect (model, update_sig_id);
-      if (src_id != 0)
-      {
-        Source.remove (src_id);
-      }
-      else
-      {
-        // timeout was reached
-        throw new DBusError.TIMEOUT ("Timed out waiting for model update");
-      }
-    }
-
-    private Utils.AsyncOnce<ScopeProxy> get_proxy_once (string scope_id)
-    {
-      var proxy_once = scope_proxies[scope_id];
-      if (proxy_once == null)
-      {
-        proxy_once = new Utils.AsyncOnce<ScopeProxy> ();
-        scope_proxies[scope_id] = proxy_once;
-      }
-
-      return proxy_once;
-    }
-
-    private Utils.AsyncOnce<string> get_channel_id_once (string channel_key)
-    {
-      var channel_id_once = scope_channel_ids[channel_key];
-      if (channel_id_once == null)
-      {
-        channel_id_once = new Utils.AsyncOnce<string> ();
-        scope_channel_ids[channel_key] = channel_id_once;
-      }
-
-      return channel_id_once;
-    }
-
-    private unowned string? get_channel_id (string master_channel_id,
-                                            string scope_id,
-                                            out ScopeProxy? proxy) throws Error
-    {
-      var proxy_once = get_proxy_once (scope_id);
-      if (!proxy_once.is_initialized ())
-      {
-        proxy = null;
-        return null;
-      }
-
-      if (proxy_once.get_data () == null)
-        throw new ScopeError.REQUEST_FAILED ("Unable to create proxy");
-
-      proxy = proxy_once.get_data ();
-
-      var channel_key = get_channel_key (master_channel_id, proxy);
-      var channel_id_once = get_channel_id_once (channel_key);
-      if (!channel_id_once.is_initialized ()) return null;
-      return channel_id_once.get_data ();
-    }
-
-    private async unowned string init_channel (string master_channel_id,
-                                               string scope_id,
-                                               ChannelType channel_type,
-                                               out ScopeProxy proxy)
-      throws Error
-    {
-      // init ScopeProxy
-      var proxy_once = get_proxy_once (scope_id);
-      Error? failure = null;
-
-      // short-circuit evaluation
-      if (scope_id in scope_metadata)
-      {
-        // will throw if checks fail
-        perform_checks (scope_metadata[scope_id], channel_type);
-      }
-
-      if (!proxy_once.is_initialized ())
-      {
-        if (yield proxy_once.enter ())
-        {
-          ScopeProxy? actual_proxy = null;
-          try
-          {
-            if (!(scope_id in scope_metadata))
-            {
-              scope_metadata[scope_id] = ScopeRegistry.ScopeMetadata.for_id (scope_id);
-            }
-            var metadata = scope_metadata[scope_id];
-            // don't even create the proxy if one of the checks fail
-            perform_checks (metadata, channel_type);
-            actual_proxy = yield create_proxy (metadata);
-          }
-          catch (Error e)
-          {
-            failure = e;
-          }
-          finally
-          {
-            proxy_once.leave (actual_proxy);
-          }
-        }
-      }
-
-      proxy = proxy_once.get_data ();
-      if (proxy == null)
-      {
-        if (failure != null && failure is ScopeError.DISABLED_CONTENT)
-        {
-          // retry next time
-          proxy_once.reset ();
-          throw failure;
-        }
-        var msg = "Unable to create scope proxy for \"%s\": %s".printf (
-          scope_id, failure != null ? failure.message : "(unknown)");
-        throw new ScopeError.REQUEST_FAILED (msg);
-      }
-
-      // open a channel
-      var channel_key = get_channel_key (master_channel_id, proxy);
-      var channel_id_once = get_channel_id_once (channel_key);
-
-      if (!channel_id_once.is_initialized ())
-      {
-        if (yield channel_id_once.enter ())
-        {
-          Dee.SerializableModel model;
-          string? chan_id = null;
-          try
-          {
-            chan_id = yield proxy.open_channel (channel_type,
-                                                ChannelFlags.PRIVATE,
-                                                null,
-                                                out model);
-            scope_models[channel_key] = model;
-            // register as receiver
-            var synchronizer = synchronizers[master_channel_id];
-            if (synchronizer != null)
-            {
-              synchronizer.add_provider (model, scope_id);
-            }
-            else
-            {
-              warning ("Unable to find ResultsSynchronizer for channel %s",
-                       master_channel_id);
-            }
-          }
-          finally
-          {
-            channel_id_once.leave (chan_id);
-          }
-          // emit a signal
-          scope_channel_opened (master_channel_id, proxy, model);
-        }
-      }
-
-      unowned string scope_channel_id = channel_id_once.get_data ();
-      if (scope_channel_id == null)
-      {
-        // uh oh, couldn't open a channel, try again next time
-        channel_id_once.reset ();
-      }
-      return scope_channel_id;
-    }
-
-    public async ActivationReplyRaw activate_wrapper (
-        string master_channel_id,
-        string scope_id,
-        ChannelType channel_type,
-        owned Variant[] result_arr,
-        uint action_type,
-        HashTable<string, Variant> hints,
-        GLib.Cancellable? cancellable) throws Error
-    {
-      ScopeProxy proxy;
-      unowned string scope_channel_id;
-      scope_channel_id = get_channel_id (master_channel_id, scope_id, out proxy);
-      if (scope_channel_id == null)
-        scope_channel_id = yield init_channel (master_channel_id, scope_id,
-                                               channel_type, out proxy);
-
-      cancellable.set_error_if_cancelled ();
-
-      var action = (Unity.Protocol.ActionType) action_type;
-      return yield proxy.activate (scope_channel_id, result_arr,
-                                   action, hints, cancellable);
-    }
-
-    public async HashTable<string, Variant> search_wrapper (
-        string master_channel_id,
-        ChannelType channel_type,
-        string search_string,
-        HashTable<string, Variant> hints,
-        string scope_id,
-        CategoryMerger category_merger,
-        GLib.Cancellable? cancellable) throws Error
-    {
-      ScopeProxy proxy;
-      unowned string scope_channel_id;
-      scope_channel_id = get_channel_id (master_channel_id, scope_id, out proxy);
-      if (scope_channel_id == null)
-        scope_channel_id = yield init_channel (master_channel_id, scope_id,
-                                               channel_type, out proxy);
-
-      cancellable.set_error_if_cancelled ();
-
-      var reply_hints = new HashTable<string, Variant> (str_hash, str_equal);
-
-      if (!content_enabled (scope_metadata[scope_id])
-          || scope_channel_id == null)
-      {
-        return reply_hints;
-      }
-
-      if (category_merger is CategoryMergerByField)
-      {
-        (category_merger as CategoryMergerByField).map_subscope_categories (scope_id, proxy.categories_model);
-      }
-
-      var channel_key = get_channel_key (master_channel_id, proxy);
-      var last_seq_num = scope_models[channel_key].get_seqnum ();
-
-      var sync = synchronizers[master_channel_id];
-      sync.enable_provider (scope_id);
-
-      var reply_dict = yield proxy.search (scope_channel_id, search_string,
-                                           hints, cancellable);
-
-      var iter = HashTableIter<string, Variant> (reply_dict);
-      unowned string key;
-      unowned Variant variant;
-
-      while (iter.next (out key, out variant))
-      {
-        if (key == SEARCH_SEQNUM_HINT)
-        {
-          uint64 seqnum = variant.get_uint64 ();
-          var model = scope_models[channel_key];
-          if (model.get_seqnum () < seqnum)
-            yield wait_for_seqnum (model as Dee.SharedModel, seqnum);
-
-          // if the proxy was disconnected and its channels invalidated, this
-          // model is no longer merged, check if that's the case
-          if (scope_models[channel_key] != model)
-            return reply_hints;
-
-          if (seqnum == last_seq_num)
-          {
-            debug ("Model seqnum for channel key %s not changed, copying", channel_key);
-            var synchronizer = get_synchronizer (master_channel_id);
-            if (synchronizer != null)
-              synchronizer.copy_model (model);
-            else
-              warning ("No synchronizer for master channel %s", master_channel_id);
-          }
-        }
-        else if (key == SEARCH_TIME_HINT)
-        {
-          reply_hints["%s:%s".printf (SEARCH_TIME_HINT, scope_id)] = variant;
-        }
-        else
-        {
-          reply_hints[key] = variant; // pass up
-        }
-      }
-
-      cancellable.set_error_if_cancelled ();
-      // don't disable the provider if this search got cancelled, new search
-      // might expect it to be enabled
-      sync.disable_provider (scope_id);
-
-      return reply_hints;
-    }
-
-    public async void push_wrapper (
-        string parent_channel_id,
-        string search_string,
-        ChannelType channel_type,
-        string master_scope_id,
-        string scope_id,
-        Dee.SerializableModel results_model,
-        owned string[] categories,
-        GLib.Cancellable? cancellable) throws Error
-    {
-      ScopeProxy proxy;
-      unowned string scope_channel_id;
-      scope_channel_id = get_channel_id (parent_channel_id, master_scope_id, out proxy);
-      if (scope_channel_id == null)
-        scope_channel_id = yield init_channel (parent_channel_id,
-                                               master_scope_id,
-                                               channel_type, out proxy);
-
-      if (scope_channel_id == null)
-      {
-        return; // shouldn't be reached really
-      }
-
-      cancellable.set_error_if_cancelled ();
-
-      var channel_key = get_channel_key (parent_channel_id, proxy);
-      var sync = synchronizers[parent_channel_id];
-      sync.enable_provider (master_scope_id);
-
-      var reply_dict = yield proxy.push_results (scope_channel_id,
-                                                 search_string,
-                                                 scope_id,
-                                                 results_model,
-                                                 categories, cancellable);
-
-      var iter = HashTableIter<string, Variant> (reply_dict);
-      unowned string key;
-      unowned Variant variant;
-
-      while (iter.next (out key, out variant))
-      {
-        if (key == SEARCH_SEQNUM_HINT)
-        {
-          uint64 seqnum = variant.get_uint64 ();
-          var model = scope_models[channel_key];
-          if (model.get_seqnum () < seqnum)
-            yield wait_for_seqnum (model as Dee.SharedModel, seqnum);
-        }
-      }
-
-      cancellable.set_error_if_cancelled ();
-      // don't disable the provider if this search got cancelled, new search
-      // might expect it to be enabled
-      sync.disable_provider (master_scope_id);
-    }
-
-    public signal void scope_channel_opened (string master_channel_id,
-                                             ScopeProxy scope_proxy,
-                                             Dee.SerializableModel model);
-  }
 
   private abstract class CategoryMerger : Object
   {
@@ -806,7 +264,8 @@
     _rand = new Rand ();
     _channels = new HashTable<string, ScopeChannel> (str_hash, str_equal);
     _scopes = new ScopeTracker ();
-    _scopes.results_invalidated.connect (on_proxy_results_invalidated);
+    _scopes.results_invalidated.connect (on_results_invalidated);
+    _scopes.proxy_category_model_changed.connect (on_proxy_categories_changed);
     merge_strategy = this;
     create_models ();
   }
@@ -978,22 +437,50 @@
     }
   }
 
-  private void on_proxy_results_invalidated (ChannelType channel_type)
-  {
-    queue_search_for_type ((SearchType) channel_type);
-  }
-
-  public void queue_search_for_type (SearchType search_type)
-  {
-    var channel_type = search_type == SearchType.GLOBAL ?
-      ChannelType.GLOBAL : ChannelType.DEFAULT;
+  private void on_results_invalidated (ChannelUpdateFlags flags)
+  {
+    // results of a subscope got invalidated, propagate the change if necesary
+    if (ChannelUpdateFlags.DEFAULT in flags)
+    {
+      var channel_type = ChannelType.DEFAULT;
+      if (invalidate_last_search_for_channel (channel_type))
+        this.results_invalidated (channel_type);
+    }
+    if (ChannelUpdateFlags.GLOBAL in flags)
+    {
+      var channel_type = ChannelType.GLOBAL;
+      if (invalidate_last_search_for_channel (channel_type))
+        this.results_invalidated (channel_type);
+    }
+  }
+
+  private void on_proxy_categories_changed (string scope_id, ScopeProxy proxy)
+  {
+    if (category_merger is CategoryMergerByField)
+    {
+      (category_merger as CategoryMergerByField).map_subscope_categories (scope_id, proxy.categories_model);
+    }
+  }
+
+  private bool invalidate_last_search_for_channel (ChannelType channel_type)
+  {
+    bool any_invalidated = false;
     foreach (var channel in _channels.get_values ())
     {
       if (channel.channel_type == channel_type)
       {
         channel.last_search = null;
+        any_invalidated = true;
       }
     }
+    return any_invalidated;
+  }
+
+  public void queue_search_for_type (SearchType search_type)
+  {
+    var flags = search_type == SearchType.GLOBAL ?
+      ChannelUpdateFlags.GLOBAL : ChannelUpdateFlags.DEFAULT;
+    on_results_invalidated (flags);
   }
 
   public void invalidate_search (SearchType search_type)
@@ -1219,7 +706,7 @@
     {
       /* the lookups need to be fast, so keeping a FilterModel on top
        * of the real model that's sorted according to the de-dup fields */
-      var dedup_model = target.get_qdata<Dee.Model> (dedup_model_quark);
+      var dedup_model = target.get_qdata<Dee.Model> (ScopeTracker.DEDUP_MODEL_QUARK);
       if (dedup_model == null)
       {
         warn_if_fail (target.get_n_rows () == 0);
@@ -1238,7 +725,7 @@
         });
         dedup_model = new Dee.FilterModel (target, filter);
         // eek, circular reference
-        target.set_qdata (dedup_model_quark, dedup_model);
+        target.set_qdata (ScopeTracker.DEDUP_MODEL_QUARK, dedup_model);
       }
       bool found;
       bool fell_through = false;
@@ -1359,8 +846,7 @@
     /* proxy the request by default */
     try
     {
-      return yield _scopes.activate_wrapper (channel_id, scope_id,
-                                             channel.channel_type,
+      return yield _scopes.activate_wrapper (channel, scope_id,
                                              (owned) result_arr_cpy,
                                              action_type, hints, cancellable);
     }
@@ -1666,11 +1152,12 @@
 
     var channel_type = search_type == SearchType.DEFAULT ?
       ChannelType.DEFAULT : ChannelType.GLOBAL;
-    var res = yield _scopes.search_wrapper (search.channel_id,
+    var channel = get_channel_by_id (search.channel_id);
+    var res = yield _scopes.search_wrapper (channel,
                                             channel_type,
                                             search_string,
-                                            combined_hints != null ? combined_hints : search.hints, scope_id,
-                                            category_merger,
+                                            combined_hints != null ? combined_hints : search.hints,
+                                            scope_id,
                                             cancellable);
     res.foreach ((key, variant) =>
     {
@@ -1707,7 +1194,8 @@
     if (category_merger is CategoryMergerByScope)
       (category_merger as CategoryMergerByScope).add_scope_mapping (owner, master_scope_id);
 
-    yield _scopes.push_wrapper (channel_id, search_string, ChannelType.GLOBAL,
+    var channel = get_channel_by_id (channel_id);
+    yield _scopes.push_wrapper (channel, search_string, ChannelType.GLOBAL,
                                 master_scope_id, scope_id,
                                 results_model, category_ids, cancellable);
   }

=== modified file 'src/unity-deprecated-scope-impl.vala'
--- src/unity-deprecated-scope-impl.vala	2013-07-17 15:18:49 +0000
+++ src/unity-deprecated-scope-impl.vala	2013-07-24 13:18:24 +0000
@@ -384,10 +384,7 @@
     {
       if (channel.channel_type == channel_type)
       {
-        ScopeSearchBase? search = channel.last_search;
-        if (search != null) search.search_context.cancellable.cancel ();
         channel.last_search = null;
-        // FIXME: queue new search
       }
     }
 

=== modified file 'src/unity-scope-dbus-impl.vala'
--- src/unity-scope-dbus-impl.vala	2013-07-22 10:35:06 +0000
+++ src/unity-scope-dbus-impl.vala	2013-07-24 13:18:24 +0000
@@ -28,7 +28,6 @@
 {
   public abstract void export () throws Error;
   public abstract void unexport ();
-  public abstract void queue_search_for_type (SearchType search_type);
 
   public abstract void queue_property_notification (string prop_name,
                                                     Variant prop_value);
@@ -302,10 +301,7 @@
     {
       if (channel.channel_type == channel_type)
       {
-        var search = channel.last_search;
-        if (search != null) search.search_context.cancellable.cancel ();
         channel.last_search = null;
-        // FIXME: queue new search
       }
     }
     this.results_invalidated (channel_type);
@@ -433,24 +429,6 @@
     return reply;
   }
 
-  public void queue_search_for_type (SearchType search_type)
-    requires (search_type < SearchType.N_TYPES)
-  {
-    ChannelType channel_type = search_type == SearchType.DEFAULT ?
-      ChannelType.DEFAULT : ChannelType.GLOBAL;
-
-    foreach (var channel in _channels.get_values ())
-    {
-      if (channel.channel_type == channel_type)
-      {
-        ScopeSearchBase? search = channel.last_search;
-        if (search != null) search.search_context.cancellable.cancel ();
-        channel.last_search = null;
-        // FIXME: queue new search
-      }
-    }
-  }
-
   private async HashTable<string, Variant> search_internal (
       string search_string, HashTable<string, Variant> hints,
       ScopeChannel channel) throws ScopeError

=== added file 'src/unity-scope-tracker.vala'
--- src/unity-scope-tracker.vala	1970-01-01 00:00:00 +0000
+++ src/unity-scope-tracker.vala	2013-07-24 13:18:24 +0000
@@ -0,0 +1,616 @@
+/*
+ * Copyright (C) 2011-2012 Canonical, Ltd.
+ *
+ * This library is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License
+ * version 3.0 as published by the Free Software Foundation.
+ *
+ * This library 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 Lesser General Public License version 3.0 for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see
+ * <http://www.gnu.org/licenses/>.
+ *
+ * Authored by Neil Jagdish Patel <[e-mail]>
+ *             Michal Hruby <[e-mail]>
+ *
+ */
+
+using GLib;
+using Dee;
+using Unity;
+using Unity.Protocol;
+
+namespace Unity.Internal {
+
+[Flags]
+private enum ChannelUpdateFlags
+{
+  NONE = 0,
+  DEFAULT,
+  GLOBAL
+}
+
+private class ScopeTracker : Object
+{
+  public static Quark DEDUP_MODEL_QUARK = Quark.from_string ("unity-dedup-model");
+  const int MODEL_UPDATE_TIMEOUT_SECS = 30;
+
+  private GenericArray<ScopeProxy> scope_proxy_arr;
+  // scope_id -> ScopeProxy
+  private HashTable<string, Utils.AsyncOnce<ScopeProxy>> scope_proxies;
+  // channel_key (proxy + master_channel_id) -> scope channel_id
+  private HashTable<string, Utils.AsyncOnce<string>> scope_channel_ids;
+  // channel_key (proxy + master_channel_id) -> Dee.Model
+  private HashTable<string, Dee.SerializableModel> scope_models;
+  // master_channel_id -> ResultsSynchronizer
+  private HashTable<string, ResultsSynchronizer> synchronizers;
+  // update_key (proxy + channel_type) -> ChannelUpdateFlags
+  private HashTable<string, ChannelUpdateFlags> master_update_flags;
+  // scope_id -> ScopeMetadata
+  private HashTable<string, ScopeRegistry.ScopeMetadata> scope_metadata;
+  // binary name -> present on the system
+  private HashTable<string, bool> binary_present;
+
+  public ScopeTracker ()
+  {
+    scope_proxy_arr = new GenericArray<ScopeProxy> ();
+    scope_proxies = new HashTable<string, Utils.AsyncOnce<ScopeProxy>> (str_hash, str_equal);
+    scope_channel_ids = new HashTable<string, Utils.AsyncOnce<string>> (str_hash, str_equal);
+    scope_models = new HashTable<string, Dee.SerializableModel> (str_hash, str_equal);
+    synchronizers = new HashTable<string, ResultsSynchronizer> (str_hash, str_equal);
+    master_update_flags = new HashTable<string, ChannelUpdateFlags> (str_hash, str_equal);
+    scope_metadata = new HashTable<string, ScopeRegistry.ScopeMetadata> (str_hash, str_equal);
+    binary_present = new HashTable<string, bool> (str_hash, str_equal);
+  }
+
+  public List<weak string> scope_ids_for_proxies ()
+  {
+    return scope_proxies.get_keys ();
+  }
+
+  public unowned ScopeProxy? get_proxy_for_scope_id (string scope_id)
+  {
+    var proxy_once = get_proxy_once (scope_id);
+    if (!proxy_once.is_initialized ())
+    {
+      return null;
+    }
+
+    return proxy_once.get_data ();
+  }
+
+  /* Careful, this could be expensive... O(n) */
+  public string? get_scope_id_for_proxy (ScopeProxy proxy)
+  {
+    var iter = HashTableIter<string, Utils.AsyncOnce<ScopeProxy>> (scope_proxies);
+    unowned string scope_id;
+    unowned Utils.AsyncOnce<ScopeProxy> val;
+    while (iter.next (out scope_id, out val))
+    {
+      if (val.get_data () == proxy) return scope_id;
+    }
+
+    return null;
+  }
+
+  public unowned ResultsSynchronizer? get_synchronizer (string channel_id)
+  {
+    return synchronizers.lookup (channel_id);
+  }
+
+  private bool content_enabled (ScopeRegistry.ScopeMetadata metadata)
+  {
+    var pref_man = PreferencesManager.get_default ();
+    if (metadata.remote_content && pref_man.remote_content_search == PreferencesManager.RemoteContent.NONE)
+    {
+      return false;
+    }
+    return true;
+  }
+
+  private void perform_checks (ScopeRegistry.ScopeMetadata metadata,
+                               ChannelType requested_channel_type)
+    throws ScopeError
+  {
+    // check remote content vs user preference
+    if (!content_enabled (metadata))
+    {
+      throw new ScopeError.DISABLED_CONTENT ("Requested content disabled");
+    }
+    // check global search flag
+    if (!metadata.global_searches && requested_channel_type == ChannelType.GLOBAL)
+    {
+      throw new ScopeError.DISABLED_CONTENT ("Global search is disabled");
+    }
+    // check if the required binary is installed
+    if (metadata.query_binary != null && metadata.query_binary != "")
+    {
+      if (!(metadata.query_binary in binary_present))
+      {
+        binary_present[metadata.query_binary] = Environment.find_program_in_path (metadata.query_binary) != null;
+      }
+      if (!binary_present[metadata.query_binary])
+      {
+        throw new ScopeError.DISABLED_CONTENT ("Required application isn't installed");
+      }
+    }
+  }
+
+  public async ScopeProxy? create_proxy (ScopeRegistry.ScopeMetadata metadata)
+    throws Error
+  {
+    var proxy = yield ScopeProxy.new_from_metadata (metadata);
+    dynamic ScopeProxy remote_proxy = proxy;
+    remote_proxy.auto_reconnect = false;
+    // check that the proxy props match the metadata,
+    // will throw an error if it doesn't
+    check_proxy_vs_metadata (proxy, metadata);
+
+    scope_proxy_arr.add (proxy);
+
+    proxy.channels_invalidated.connect (channels_invalidated);
+    proxy.results_invalidated.connect (on_results_invalidated);
+
+    return proxy;
+  }
+
+  private void channels_invalidated (ScopeProxy proxy)
+  {
+    // we're not removing the results that were associated with this proxy
+    // and are still living in the associated ResultsSynchronizer,
+    // cause scope quitting after a while is an excepted part of scope
+    // lifecycle, plus activating a result will try to respawn the scope
+
+    // invalidate all associated containers
+    string[] invalid_keys = {};
+    string prefix = "%p::".printf (proxy);
+    
+    debug ("Invalidating channels for %s", prefix);
+
+    foreach (unowned string channel_key in scope_channel_ids.get_keys ())
+    {
+      if (channel_key.has_prefix (prefix)) invalid_keys += channel_key;
+    }
+
+    foreach (unowned string channel_key in invalid_keys)
+    {
+      scope_channel_ids.remove (channel_key);
+      scope_models.remove (channel_key);
+    }
+  }
+
+  public signal void results_invalidated (ChannelUpdateFlags update_flags);
+
+  private void on_results_invalidated (ScopeProxy proxy,
+                                       ChannelType channel_type)
+  {
+    var flags = master_update_flags[get_update_key (proxy, channel_type)];
+    if (flags == ChannelUpdateFlags.NONE) return;
+    this.results_invalidated (flags);
+  }
+
+  private void check_proxy_vs_metadata (
+      ScopeProxy proxy,
+      ScopeRegistry.ScopeMetadata metadata) throws Error
+  {
+    if (proxy.is_master != metadata.is_master)
+      throw new ScopeError.DATA_MISMATCH ("Scope file info for '%s' doesn't match on IsMaster key".printf (metadata.id));
+
+    if (metadata.required_metadata != null)
+    {
+      var dict = metadata.required_metadata.as_hash_table ();
+      unowned string field_name;
+      unowned string schema;
+      var iter = HashTableIter<string, string> (dict);
+      while (iter.next (out field_name, out schema))
+      {
+        if (proxy.metadata[field_name] != schema)
+          throw new ScopeError.DATA_MISMATCH ("Scope file info for '%s' doesn't match on RequiredMetadata key".printf (metadata.id));
+      }
+    }
+  }
+
+  private string get_channel_key (string master_channel_id, ScopeProxy proxy)
+  {
+    return "%p::%s".printf (proxy, master_channel_id);
+  }
+
+  private string get_update_key (ScopeProxy proxy, ChannelType channel_type)
+  {
+    return "%p::%d".printf (proxy, (int) channel_type);
+  }
+
+  public void register_channel (string master_channel_id,
+                                Dee.SerializableModel model,
+                                MergeStrategy merge_strategy)
+  {
+    // create new synchronizer for this channel
+    var synchronizer = new ResultsSynchronizer (model);
+    synchronizer.merge_strategy = merge_strategy;
+    synchronizers[master_channel_id] = synchronizer;
+  }
+
+  public void unregister_channel (string master_channel_id)
+  {
+    var synchronizer = synchronizers[master_channel_id];
+    if (synchronizer != null)
+    {
+      // break the circular reference
+      synchronizer.receiver.set_qdata<Dee.Model?> (DEDUP_MODEL_QUARK, null);
+      synchronizers.remove (master_channel_id);
+    }
+    // FIXME: close child scopes' channels
+  }
+  
+  private async void wait_for_seqnum (Dee.SharedModel model, uint64 seqnum)
+    throws Error
+  {
+    if (model.get_seqnum () >= seqnum) return;
+
+    var update_sig_id = model.end_transaction.connect ((m, begin_seqnum, end_seqnum) =>
+    {
+      if (end_seqnum < seqnum) return;
+
+      wait_for_seqnum.callback ();
+    });
+
+    // make sure we don't wait indefinitely
+    uint src_id = 0;
+    src_id = Timeout.add_seconds (MODEL_UPDATE_TIMEOUT_SECS, () =>
+    {
+      src_id = 0;
+      wait_for_seqnum.callback ();
+      return false;
+    });
+
+    yield;
+
+    SignalHandler.disconnect (model, update_sig_id);
+    if (src_id != 0)
+    {
+      Source.remove (src_id);
+    }
+    else
+    {
+      // timeout was reached
+      throw new DBusError.TIMEOUT ("Timed out waiting for model update");
+    }
+  }
+
+  private Utils.AsyncOnce<ScopeProxy> get_proxy_once (string scope_id)
+  {
+    var proxy_once = scope_proxies[scope_id];
+    if (proxy_once == null)
+    {
+      proxy_once = new Utils.AsyncOnce<ScopeProxy> ();
+      scope_proxies[scope_id] = proxy_once;
+    }
+
+    return proxy_once;
+  }
+
+  private Utils.AsyncOnce<string> get_channel_id_once (string channel_key)
+  {
+    var channel_id_once = scope_channel_ids[channel_key];
+    if (channel_id_once == null)
+    {
+      channel_id_once = new Utils.AsyncOnce<string> ();
+      scope_channel_ids[channel_key] = channel_id_once;
+    }
+
+    return channel_id_once;
+  }
+
+  private unowned string? get_channel_id (string master_channel_id,
+                                          string scope_id,
+                                          out ScopeProxy? proxy) throws Error
+  {
+    var proxy_once = get_proxy_once (scope_id);
+    if (!proxy_once.is_initialized ())
+    {
+      proxy = null;
+      return null;
+    }
+
+    if (proxy_once.get_data () == null)
+      throw new ScopeError.REQUEST_FAILED ("Unable to create proxy");
+
+    proxy = proxy_once.get_data ();
+
+    var channel_key = get_channel_key (master_channel_id, proxy);
+    var channel_id_once = get_channel_id_once (channel_key);
+    if (!channel_id_once.is_initialized ()) return null;
+    return channel_id_once.get_data ();
+  }
+
+  private async unowned string init_channel (ScopeChannel master_channel,
+                                             string scope_id,
+                                             ChannelType channel_type,
+                                             out ScopeProxy proxy)
+    throws Error
+  {
+    // init ScopeProxy
+    var proxy_once = get_proxy_once (scope_id);
+    Error? failure = null;
+
+    // short-circuit evaluation
+    if (scope_id in scope_metadata)
+    {
+      // will throw if checks fail
+      perform_checks (scope_metadata[scope_id], channel_type);
+    }
+
+    if (!proxy_once.is_initialized ())
+    {
+      if (yield proxy_once.enter ())
+      {
+        ScopeProxy? actual_proxy = null;
+        try
+        {
+          if (!(scope_id in scope_metadata))
+          {
+            scope_metadata[scope_id] = ScopeRegistry.ScopeMetadata.for_id (scope_id);
+          }
+          var metadata = scope_metadata[scope_id];
+          // don't even create the proxy if one of the checks fail
+          perform_checks (metadata, channel_type);
+          actual_proxy = yield create_proxy (metadata);
+
+          if (actual_proxy.categories_model != null)
+          {
+            proxy_category_model_changed (scope_id, actual_proxy);
+          }
+          actual_proxy.notify["categories-model"].connect ((obj, pspec) =>
+          {
+            ScopeProxy the_proxy = obj as ScopeProxy;
+            string? id = get_scope_id_for_proxy (the_proxy);
+            if (id != null)
+            {
+              proxy_category_model_changed (id, the_proxy);
+            }
+          });
+        }
+        catch (Error e)
+        {
+          failure = e;
+        }
+        finally
+        {
+          proxy_once.leave (actual_proxy);
+        }
+      }
+    }
+
+    proxy = proxy_once.get_data ();
+    if (proxy == null)
+    {
+      if (failure != null && failure is ScopeError.DISABLED_CONTENT)
+      {
+        // retry next time
+        proxy_once.reset ();
+        throw failure;
+      }
+      var msg = "Unable to create scope proxy for \"%s\": %s".printf (
+        scope_id, failure != null ? failure.message : "(unknown)");
+      throw new ScopeError.REQUEST_FAILED (msg);
+    }
+
+    // open a channel
+    var channel_key = get_channel_key (master_channel.id, proxy);
+    var channel_id_once = get_channel_id_once (channel_key);
+
+    if (!channel_id_once.is_initialized ())
+    {
+      if (yield channel_id_once.enter ())
+      {
+        Dee.SerializableModel model;
+        string? chan_id = null;
+        try
+        {
+          chan_id = yield proxy.open_channel (channel_type,
+                                              ChannelFlags.PRIVATE,
+                                              null,
+                                              out model);
+          scope_models[channel_key] = model;
+          // register as receiver
+          var synchronizer = synchronizers[master_channel.id];
+          if (synchronizer != null)
+          {
+            synchronizer.add_provider (model, scope_id);
+          }
+          else
+          {
+            warning ("Unable to find ResultsSynchronizer for channel %s",
+                     master_channel.id);
+          }
+          // a mapping for on_results_invalidated
+          var flag = master_channel.channel_type == ChannelType.DEFAULT ?
+            ChannelUpdateFlags.DEFAULT : ChannelUpdateFlags.GLOBAL;
+          // note that the hash table key contains the channel_type of the just
+          // opened channel, while the flag depends on master channel type
+          master_update_flags[get_update_key (proxy, channel_type)] |= flag;
+        }
+        finally
+        {
+          channel_id_once.leave (chan_id);
+        }
+      }
+    }
+
+    unowned string scope_channel_id = channel_id_once.get_data ();
+    if (scope_channel_id == null)
+    {
+      // uh oh, couldn't open a channel, try again next time
+      channel_id_once.reset ();
+    }
+    return scope_channel_id;
+  }
+
+  public async ActivationReplyRaw activate_wrapper (
+      ScopeChannel master_channel,
+      string scope_id,
+      owned Variant[] result_arr,
+      uint action_type,
+      HashTable<string, Variant> hints,
+      GLib.Cancellable? cancellable) throws Error
+  {
+    ScopeProxy proxy;
+    unowned string scope_channel_id;
+    scope_channel_id = get_channel_id (master_channel.id, scope_id, out proxy);
+    if (scope_channel_id == null)
+      scope_channel_id = yield init_channel (master_channel, scope_id,
+                                             master_channel.channel_type,
+                                             out proxy);
+
+    cancellable.set_error_if_cancelled ();
+
+    var action = (Unity.Protocol.ActionType) action_type;
+    return yield proxy.activate (scope_channel_id, result_arr,
+                                 action, hints, cancellable);
+  }
+
+  public async HashTable<string, Variant> search_wrapper (
+      ScopeChannel master_channel,
+      ChannelType channel_type,
+      string search_string,
+      HashTable<string, Variant> hints,
+      string scope_id,
+      GLib.Cancellable? cancellable) throws Error
+  {
+    ScopeProxy proxy;
+    unowned string scope_channel_id;
+    scope_channel_id = get_channel_id (master_channel.id, scope_id, out proxy);
+    if (scope_channel_id == null)
+      scope_channel_id = yield init_channel (master_channel, scope_id,
+                                             channel_type, out proxy);
+
+    cancellable.set_error_if_cancelled ();
+
+    var reply_hints = new HashTable<string, Variant> (str_hash, str_equal);
+
+    if (!content_enabled (scope_metadata[scope_id])
+        || scope_channel_id == null)
+    {
+      return reply_hints;
+    }
+
+    var channel_key = get_channel_key (master_channel.id, proxy);
+    var last_seq_num = scope_models[channel_key].get_seqnum ();
+
+    var sync = synchronizers[master_channel.id];
+    sync.enable_provider (scope_id);
+
+    var reply_dict = yield proxy.search (scope_channel_id, search_string,
+                                         hints, cancellable);
+
+    var iter = HashTableIter<string, Variant> (reply_dict);
+    unowned string key;
+    unowned Variant variant;
+
+    while (iter.next (out key, out variant))
+    {
+      if (key == SEARCH_SEQNUM_HINT)
+      {
+        uint64 seqnum = variant.get_uint64 ();
+        var model = scope_models[channel_key];
+        if (model.get_seqnum () < seqnum)
+          yield wait_for_seqnum (model as Dee.SharedModel, seqnum);
+
+        // if the proxy was disconnected and its channels invalidated, this
+        // model is no longer merged, check if that's the case
+        if (scope_models[channel_key] != model)
+          return reply_hints;
+
+        if (seqnum == last_seq_num)
+        {
+          debug ("Model seqnum for channel key %s not changed, copying", channel_key);
+          var synchronizer = get_synchronizer (master_channel.id);
+          if (synchronizer != null)
+            synchronizer.copy_model (model);
+          else
+            warning ("No synchronizer for master channel %s", master_channel.id);
+        }
+      }
+      else if (key == SEARCH_TIME_HINT)
+      {
+        reply_hints["%s:%s".printf (SEARCH_TIME_HINT, scope_id)] = variant;
+      }
+      else
+      {
+        reply_hints[key] = variant; // pass up
+      }
+    }
+
+    cancellable.set_error_if_cancelled ();
+    // don't disable the provider if this search got cancelled, new search
+    // might expect it to be enabled
+    sync.disable_provider (scope_id);
+
+    return reply_hints;
+  }
+
+  public async void push_wrapper (
+      ScopeChannel parent_channel,
+      string search_string,
+      ChannelType channel_type,
+      string master_scope_id,
+      string scope_id,
+      Dee.SerializableModel results_model,
+      owned string[] categories,
+      GLib.Cancellable? cancellable) throws Error
+  {
+    ScopeProxy proxy;
+    unowned string scope_channel_id;
+    scope_channel_id = get_channel_id (parent_channel.id, master_scope_id, out proxy);
+    if (scope_channel_id == null)
+      scope_channel_id = yield init_channel (parent_channel,
+                                             master_scope_id,
+                                             channel_type, out proxy);
+
+    if (scope_channel_id == null)
+    {
+      return; // shouldn't be reached really
+    }
+
+    cancellable.set_error_if_cancelled ();
+
+    var channel_key = get_channel_key (parent_channel.id, proxy);
+    var sync = synchronizers[parent_channel.id];
+    sync.enable_provider (master_scope_id);
+
+    var reply_dict = yield proxy.push_results (scope_channel_id,
+                                               search_string,
+                                               scope_id,
+                                               results_model,
+                                               categories, cancellable);
+
+    var iter = HashTableIter<string, Variant> (reply_dict);
+    unowned string key;
+    unowned Variant variant;
+
+    while (iter.next (out key, out variant))
+    {
+      if (key == SEARCH_SEQNUM_HINT)
+      {
+        uint64 seqnum = variant.get_uint64 ();
+        var model = scope_models[channel_key];
+        if (model.get_seqnum () < seqnum)
+          yield wait_for_seqnum (model as Dee.SharedModel, seqnum);
+      }
+    }
+
+    cancellable.set_error_if_cancelled ();
+    // don't disable the provider if this search got cancelled, new search
+    // might expect it to be enabled
+    sync.disable_provider (master_scope_id);
+  }
+
+  public signal void proxy_category_model_changed (string scope_id,
+                                                   ScopeProxy scope_proxy);
+}
+
+} /* namespace Unity.Internal */

=== modified file 'test/vala/test-scope-base.vala'
--- test/vala/test-scope-base.vala	2013-07-22 14:02:29 +0000
+++ test/vala/test-scope-base.vala	2013-07-24 13:18:24 +0000
@@ -32,20 +32,6 @@
         Fixture.create<AbstractScopeTester> (AbstractScopeTester.test_add_variant_result));
       GLib.Test.add_data_func ("/Unit/Cancellable/GetGCancellable",
         Fixture.create<CancellableTester> (CancellableTester.test_get_gcancellable));
-      /* disabled for now
-      GLib.Test.add_data_func ("/Unit/Scope/Signal/NoSearchChanged",
-                               test_no_search_changed);
-      GLib.Test.add_data_func ("/Unit/Scope/Signal/SearchChanged",
-                               test_search_changed);
-      GLib.Test.add_data_func ("/Unit/Scope/Signal/SearchKey",
-                               test_search_key);
-      GLib.Test.add_data_func ("/Unit/Scope/Signal/SearchKeyDetails",
-                               test_search_key_details);
-      GLib.Test.add_data_func ("/Unit/Scope/Signals/MultipleQueueCalls",
-                               test_multiple_queue_calls);
-      GLib.Test.add_data_func ("/Unit/Scope/Signals/Cancellable",
-                               test_cancellable);
-      */
     }
 
     class AbstractScopeTester: Object, Fixture
@@ -219,191 +205,5 @@
         assert (cancellable.get_gcancellable () is GLib.Cancellable);
       }
     }
-
-/* disabled for now
-    static void test_no_search_changed ()
-    {
-      MainLoop ml = new MainLoop ();
-      var scope = new Unity.Scope ("com/canonical/Scope/Test", "test_scope");
-      assert (scope != null);
-
-      bool got_signal = false;
-      scope.search_changed.connect (() =>
-      {
-        got_signal = true;
-        ml.quit ();
-      });
-
-      // queue_search_changed shouldn't emit the search_changed signal if
-      // appropriate view isn't active
-      scope.queue_search_changed (SearchType.DEFAULT);
-
-      uint tid = Timeout.add (500, () => { ml.quit (); return false; });
-
-      ml.run ();
-      assert (got_signal == false);
-      Source.remove (tid);
-    }
-
-    static void test_search_changed ()
-    {
-      MainLoop ml = new MainLoop ();
-      var scope = new Unity.Scope ("com/canonical/Scope/Test", "test_scope");
-      assert (scope != null);
-      scope.set_view_type_internal (ViewType.LENS_VIEW);
-
-      bool got_signal = false;
-      scope.search_changed.connect (() =>
-      {
-        got_signal = true;
-        ml.quit ();
-      });
-
-      scope.queue_search_changed (SearchType.DEFAULT);
-
-      // we don't want to wait indefinitely
-      uint tid = Timeout.add (500, () => { assert_not_reached (); });
-
-      ml.run ();
-      assert (got_signal == true);
-      Source.remove (tid);
-    }
-
-    static void test_search_key ()
-    {
-      MainLoop ml = new MainLoop ();
-      var scope = new Unity.Scope ("com/canonical/Scope/Test", "test_scope");
-      assert (scope != null);
-      scope.set_view_type_internal (ViewType.LENS_VIEW);
-
-      bool got_changed_signal = false;
-      scope.search_changed.connect ((lens_search, search_type, cancellable) =>
-      {
-        got_changed_signal = true;
-        ml.quit ();
-      });
-
-      bool got_gen_signal = false;
-      scope.generate_search_key.connect ((lens_search) =>
-      {
-        got_gen_signal = true;
-        return "foo";
-      });
-
-      scope.queue_search_changed (SearchType.DEFAULT);
-
-      // we don't want to wait indefinitely
-      uint tid = Timeout.add (500, () => { assert_not_reached (); });
-
-      ml.run ();
-      assert (got_changed_signal == true);
-      assert (got_gen_signal == true);
-
-      Source.remove (tid);
-    }
-    
-    static void test_search_key_details ()
-    {
-      MainLoop ml = new MainLoop ();
-      var scope = new Unity.Scope ("com/canonical/Scope/Test", "test_scope");
-      assert (scope != null);
-      scope.set_view_type_internal (ViewType.LENS_VIEW);
-
-      int num_changed_signals = 0;
-      int num_gen_signals = 0;
-      scope.search_changed.connect ((lens_search, search_type, cancellable) =>
-      {
-        num_changed_signals++;
-
-        if (num_changed_signals == 1)
-          scope.set_view_type_internal (ViewType.HOME_VIEW);
-        else if (num_changed_signals >= 2) ml.quit ();
-      });
-
-      scope.generate_search_key["default"].connect ((lens_search) =>
-      {
-        num_gen_signals++;
-        return "foo";
-      });
-
-      scope.queue_search_changed (SearchType.DEFAULT);
-      scope.queue_search_changed (SearchType.GLOBAL);
-
-      // we don't want to wait indefinitely
-      uint tid = Timeout.add (500, () => { assert_not_reached (); });
-
-      ml.run ();
-      assert (num_changed_signals == 2);
-      assert (num_gen_signals == 1);
-
-      Source.remove (tid);
-    }
-    
-    static void test_multiple_queue_calls ()
-    {
-      MainLoop ml = new MainLoop ();
-      var scope = new Unity.Scope ("com/canonical/Scope/Test", "test_scope");
-      assert (scope != null);
-      scope.set_view_type_internal (ViewType.LENS_VIEW);
-
-      int num_changed = 0;
-      scope.search_changed.connect (() =>
-      {
-        num_changed++;
-      });
-
-      scope.queue_search_changed (SearchType.DEFAULT);
-      scope.queue_search_changed (SearchType.GLOBAL);
-      scope.queue_search_changed (SearchType.DEFAULT);
-      scope.queue_search_changed (SearchType.GLOBAL);
-      scope.queue_search_changed (SearchType.DEFAULT);
-      scope.queue_search_changed (SearchType.GLOBAL);
-      scope.queue_search_changed (SearchType.DEFAULT);
-      scope.queue_search_changed (SearchType.DEFAULT);
-      scope.queue_search_changed (SearchType.GLOBAL);
-      scope.queue_search_changed (SearchType.GLOBAL);
-
-      // we don't want to wait indefinitely
-      Timeout.add (500, () => { ml.quit (); return false; });
-
-      ml.run ();
-      // we expect just one signal (for SearchType.DEFAULT, LENS_VIEW is active)
-      assert (num_changed == 1);
-    }
-
-    static void test_cancellable ()
-    {
-      MainLoop ml = new MainLoop ();
-      var scope = new Unity.Scope ("com/canonical/Scope/Test", "test_scope");
-      assert (scope != null);
-      scope.set_view_type_internal (ViewType.LENS_VIEW);
-
-      Cancellable? canc = null;
-      scope.search_changed.connect ((lens_search, search_type, cancellable) =>
-      {
-        if (canc == null)
-        {
-          canc = cancellable;
-          scope.queue_search_changed (SearchType.DEFAULT);
-        }
-        else
-        {
-          assert (cancellable.is_cancelled () == false);
-          ml.quit ();
-        }
-      });
-
-      scope.queue_search_changed (SearchType.DEFAULT);
-
-      // we don't want to wait indefinitely
-      uint tid = Timeout.add (500, () => { assert_not_reached (); });
-
-      ml.run ();
-      assert (canc != null);
-      assert (canc.is_cancelled () == true);
-
-      Source.remove (tid);
-    }
-*/
   }
 }

=== modified file 'test/vala/test-scope.vala'
--- test/vala/test-scope.vala	2013-07-22 14:02:29 +0000
+++ test/vala/test-scope.vala	2013-07-24 13:18:24 +0000
@@ -108,6 +108,8 @@
         Fixture.create<MasterScopeTester> (MasterScopeTester.test_master_multiple_channels));
     Test.add_data_func ("/Unit/MasterScope/NoContentHint",
         Fixture.create<MasterScopeTester> (MasterScopeTester.test_master_no_content));
+    Test.add_data_func ("/Unit/MasterScope/ResultsInvalidated",
+        Fixture.create<MasterScopeTester> (MasterScopeTester.test_master_results_invalidated));
     Test.add_data_func ("/Unit/MasterScope/Activation",
         Fixture.create<MasterScopeTester> (MasterScopeTester.test_master_activation));
     Test.add_data_func ("/Unit/MasterScope/Sorting/Ascending",
@@ -1292,11 +1294,13 @@
 
   class MasterScopeTester: Object, Fixture
   {
-    class ChildScope: Unity.DeprecatedScope
+    class ChildScope: Unity.SimpleScope
     {
+      public string scope_id { get; construct set; }
+
       public ChildScope (string dbus_path, string id)
       {
-        Object (dbus_path: dbus_path, id: id);
+        Object (unique_name: dbus_path, scope_id: id, group_name: DBUS_NAME);
       }
 
       protected override void constructed ()
@@ -1312,14 +1316,24 @@
         var cats = new Unity.CategorySet ();
         cats.add (new Unity.Category ("1211", "A Category", new GLib.ThemedIcon ("text")));
         cats.add (new Unity.Category ("1991", "Unused category", new GLib.ThemedIcon ("text")));
-        categories = cats;
+        this.category_set = cats;
+
+        this.set_search_async_func ((search, cb) =>
+        {
+          perform_search (search.search_context);
+          // simulate a bit of asynchronicity
+          Idle.add (() => { cb (search); return false; });
+        });
       }
+
+      public signal void perform_search (Unity.SearchContext? search);
     }
 
     private uint owning_id;
     private Unity.MasterScope master_scope;
     private ScopeProxy proxy;
-    private Unity.DeprecatedScope[] child_scopes = {};
+    private ChildScope[] child_scopes = {};
+    private Unity.ScopeDBusConnector[] connectors = {};
     private Rand random = new Rand ();
     private uint results_per_scope = 1;
     private int random_range_end = 1000000000;
@@ -1335,14 +1349,12 @@
     }
     private string[] active_filters = {};
 
-    private void child_search_handler (Unity.DeprecatedScope scope,
-                                       Unity.DeprecatedScopeSearch search,
-                                       Unity.SearchType search_type,
-                                       Cancellable canc)
+    private void child_search_handler (ChildScope scope,
+                                       Unity.SearchContext? search)
     {
-      child_searches += scope.id;
+      child_searches += scope.scope_id;
 
-      var filter = search.get_filter ("check-options");
+      var filter = search.filter_state.get_filter_by_id ("check-options");
       if (filter != null)
       {
           foreach (var opt in (filter as Unity.CheckOptionFilter).options)
@@ -1352,48 +1364,44 @@
           }
       }
 
-      // simulate async search
-      Idle.add (() => { search.finished (); return false; });
-
-      var model = search.results_model;
-      var uri = "file:///" + scope.id;
+      var uri = "file:///" + scope.scope_id;
       for (uint i = 0; i < results_per_scope; i++)
       {
-        Variant[] row_data;
         uint category_index = 0;
         if (randomize_categories) category_index = random.boolean () ? 1 : 0;
         var rand_int = random.int_range (0, random_range_end);
+        Unity.ScopeResult result = Unity.ScopeResult ();
         if (random.boolean ())
         {
-          row_data = model.build_named_row (null,
-                                            "uri", uri,
-                                            "icon_hint", "",
-                                            "category", category_index,
-                                            "result_type", 0,
-                                            "mimetype", "inode/folder",
-                                            "title", "Title",
-                                            "comment", scope.id,
-                                            "dnd_uri", "file:///",
-                                            "required_int", rand_int,
-                                            "required_string", "qoo");
+          result.uri = uri;
+          result.icon_hint = "";
+          result.category = category_index;
+          result.result_type = Unity.ResultType.DEFAULT;
+          result.mimetype = "inode/folder";
+          result.title = "Title";
+          result.comment = scope.scope_id;
+          result.dnd_uri = "file:///";
+          result.metadata = new HashTable<string, Variant> (str_hash, str_equal);
+          result.metadata["required_int"] = rand_int;
+          result.metadata["required_string"] = "qoo";
         }
         else
         {
           var opt_field = random.next_int ().to_string ();
-          row_data = model.build_named_row (null,
-                                            "uri", uri,
-                                            "icon_hint", "",
-                                            "category", category_index,
-                                            "result_type", 0,
-                                            "mimetype", "inode/folder",
-                                            "title", "Title",
-                                            "comment", scope.id,
-                                            "dnd_uri", "file:///",
-                                            "required_int", rand_int,
-                                            "required_string", "qoo",
-                                            "optional_string", opt_field);
+          result.uri = uri;
+          result.icon_hint = "";
+          result.category = category_index;
+          result.result_type = Unity.ResultType.DEFAULT;
+          result.mimetype = "inode/folder";
+          result.title = "Title";
+          result.comment = scope.scope_id;
+          result.dnd_uri = "file:///";
+          result.metadata = new HashTable<string, Variant> (str_hash, str_equal);
+          result.metadata["required_int"] = rand_int;
+          result.metadata["required_string"] = "qoo";
+          result.metadata["optional_string"] = opt_field;
         }
-        model.append_row (row_data);
+        search.result_set.add_result (result);
       }
     }
 
@@ -1439,22 +1447,25 @@
         ChildScope child_scope;
         child_scope = new ChildScope ("/com/canonical/unity/scope/childscope_1",
                                       "test_masterscope-childscope_1.scope");
-        child_scope.filters = filters; // set filters for one child scope
-        child_scope.search_changed.connect (child_search_handler);
-        child_scope.export ();
+        child_scope.filter_set = filters; // set filters for one child scope
+        child_scope.perform_search.connect (child_search_handler);
+        connectors += new Unity.ScopeDBusConnector (child_scope);
+        connectors[connectors.length-1].export ();
         child_scopes += child_scope;
 
         child_scope = new ChildScope ("/com/canonical/unity/scope/childscope_2",
                                       "test_masterscope-childscope_2.scope");
-        child_scope.search_changed.connect (child_search_handler);
-        child_scope.export ();
+        child_scope.perform_search.connect (child_search_handler);
+        connectors += new Unity.ScopeDBusConnector (child_scope);
+        connectors[connectors.length-1].export ();
         child_scopes += child_scope;
 
         // this one has GlobalSearches=false
         child_scope = new ChildScope ("/com/canonical/unity/scope/childscope_3",
                                       "test_masterscope-childscope_3.scope");
-        child_scope.search_changed.connect (child_search_handler);
-        child_scope.export ();
+        child_scope.perform_search.connect (child_search_handler);
+        connectors += new Unity.ScopeDBusConnector (child_scope);
+        connectors[connectors.length-1].export ();
         child_scopes += child_scope;
       }
       catch (Error err) { assert_not_reached (); }
@@ -1468,7 +1479,8 @@
       ensure_destruction ((owned) proxy);
       master_scope.unexport ();
       ensure_destruction ((owned) master_scope);
-      foreach (var scope in child_scopes) scope.unexport ();
+      foreach (var connector in connectors) connector.unexport ();
+      connectors = {};
       child_scopes = {};
       if (owning_id != 0) Bus.unown_name (owning_id);
     }
@@ -1521,7 +1533,7 @@
 
       assert (search_handler_invocations == child_scopes.length);
 
-      child_scopes[0].queue_search_changed (Unity.SearchType.DEFAULT);
+      child_scopes[0].results_invalidated (Unity.SearchType.DEFAULT);
 
       // and one more time but this time one scope should be queried
       reply_dict = ScopeTester.perform_search (proxy, channel_id, "foo",
@@ -1567,6 +1579,41 @@
       assert (reply_dict[HINT].get_string () == MSG);
     }
 
+    public void test_master_results_invalidated ()
+    {
+      // we need channel first
+      Dee.SerializableModel model;
+      var channel_id = ScopeTester.open_channel (proxy, ChannelType.DEFAULT,
+                                                 out model);
+      assert (channel_id != null);
+
+      var ml = new MainLoop ();
+      bool master_results_invalidated = false;
+      ChannelType channel_type = ChannelType.GLOBAL;
+      proxy.results_invalidated.connect ((type) =>
+      {
+        master_results_invalidated = true;
+        channel_type = type;
+        ml.quit ();
+      });
+
+      var reply_dict = ScopeTester.perform_search (proxy, channel_id, "", null, model);
+      assert (search_handler_invocations == child_scopes.length);
+      assert (reply_dict != null);
+
+      child_scopes[1].results_invalidated (Unity.SearchType.DEFAULT);
+
+      assert (run_with_timeout (ml));
+      assert (master_results_invalidated == true);
+      assert (channel_type == ChannelType.DEFAULT);
+
+      // repeat the search again and see if the scope search is performed
+      // on the invalidated scope
+      reply_dict = ScopeTester.perform_search (proxy, channel_id, "", null, model);
+      assert (search_handler_invocations == child_scopes.length + 1);
+      assert (reply_dict != null);
+    }
+
     public void test_master_multiple_channels ()
     {
       // we need channel first
@@ -1619,22 +1666,25 @@
 
       string[] activated_scopes = {};
 
-      child_scopes[0].activate_uri.connect ((scope, uri) =>
+      child_scopes[0].set_activate_func ((result, metadata, action_id) =>
       {
+        var uri = result.uri;
         assert (uri.has_prefix ("file:///") && "childscope_1" in uri);
         activated_scopes += "childscope_1";
         return new Unity.ActivationResponse (Unity.HandledType.NOT_HANDLED);
       });
 
-      child_scopes[1].activate_uri.connect ((scope, uri) =>
+      child_scopes[1].set_activate_func ((result, metadata, action_id) =>
       {
+        var uri = result.uri;
         assert (uri.has_prefix ("file:///") && "childscope_2" in uri);
         activated_scopes += "childscope_2";
         return new Unity.ActivationResponse (Unity.HandledType.NOT_HANDLED);
       });
 
-      child_scopes[2].activate_uri.connect ((scope, uri) =>
+      child_scopes[2].set_activate_func ((result, metadata, action_id) =>
       {
+        var uri = result.uri;
         assert (uri.has_prefix ("file:///") && "childscope_3" in uri);
         activated_scopes += "childscope_3";
         return new Unity.ActivationResponse (Unity.HandledType.NOT_HANDLED);
@@ -2102,7 +2152,7 @@
     public override List<Unity.AbstractScope> get_scopes (string module, string? module_type) throws Error
     {
       requested_modules.append(module);
-      return null;
+      return new List<Unity.AbstractScope> ();
     }
   }
 
@@ -2111,7 +2161,11 @@
     public void test_load_scope ()
     {
       var loader = new TestScopeLoader ();
-      loader.load_scope ("test_masterscope/childscope_1.scope");
+      try
+      {
+        loader.load_scope ("test_masterscope/childscope_1.scope");
+      }
+      catch (Error err) { assert_not_reached (); }
       assert (loader.requested_modules != null);
       assert (loader.requested_modules.data == "childscope_1.so");
     }
@@ -2120,7 +2174,11 @@
     {
       var loader = new TestScopeLoader ();
       var file_name = Config.TESTDIR + "/data/test-group.group";
-      loader.load_group (file_name);
+      try
+      {
+        loader.load_group (file_name);
+      }
+      catch (Error err) { assert_not_reached (); }
 
       assert (loader.requested_modules.data == "childscope_1.so");
       assert (loader.requested_modules.next.data == "childscope_2.so");
@@ -2130,7 +2188,11 @@
     public void test_load_module ()
     {
       var loader = new TestScopeLoader ();
-      loader.load_module ("foo.so", "type");
+      try
+      {
+        loader.load_module ("foo.so", "type");
+      }
+      catch (Error err) { assert_not_reached (); }
       assert (loader.requested_modules != null);
       assert (loader.requested_modules.data == "foo.so");
     }