Merge lp:~3v1n0/nautilus/recent-files-patches-update into lp:~ubuntu-desktop/nautilus/ubuntu

[Marco Trevisan (Treviño)]

debian/patches: readd missing locate search and update unity and recent files ones

gbp pq generated branch at https://gitlab.gnome.org/3v1n0/nautilus/commits/ubuntu-3-26

[Jeremy Bícha (jbicha)]

Thank you!

Uploading to bionic. Because of the archive freeze, the upload will need to be manually approved by the Ubuntu Release Team.

review: Approve

=== modified file 'debian/changelog'
--- debian/changelog	2018-03-24 20:07:05 +0000
+++ debian/changelog	2018-04-12 23:13:34 +0000
@@ -1,3 +1,16 @@
+nautilus (1:3.26.3-0ubuntu2) UNRELEASED; urgency=medium
+
+  * Readded wrongly removed patches:
+    - 0015-tracker-search-engine-don-t-start-it-if-not-availabl.patch
+    - 0018-search-engine-add-locate-based-search-engine.patch
+  * debian/patches/12_unity_launcher_support.patch:
+    - Fix not to break builds when --enable-unity is not set
+  * Updated patches as per upstream reviews:
+    - 0016-search-engine-add-a-recent-search-engine-listing-Gtk.patch
+    - 0017-recent-add-function-to-update-manager-on-file-rename.patch
+
+ -- Marco Trevisan (Treviño) <[e-mail]>  Thu, 12 Apr 2018 19:00:28 -0400
+
 nautilus (1:3.26.3-0ubuntu1) bionic; urgency=medium
 
   * New upstream release

=== added file 'debian/patches/0015-tracker-search-engine-don-t-start-it-if-not-availabl.patch'
--- debian/patches/0015-tracker-search-engine-don-t-start-it-if-not-availabl.patch	1970-01-01 00:00:00 +0000
+++ debian/patches/0015-tracker-search-engine-don-t-start-it-if-not-availabl.patch	2018-04-12 23:13:34 +0000
@@ -0,0 +1,72 @@
+From: =?utf-8?b?Ik1hcmNvIFRyZXZpc2FuIChUcmV2acOxbyki?= <[e-mail]>
+Date: Thu, 1 Mar 2018 08:14:04 +0100
+Subject: tracker-search-engine: don't start it if not available on system
+
+---
+ src/nautilus-search-engine-tracker.c | 24 ++++++++++++++++++++----
+ 1 file changed, 20 insertions(+), 4 deletions(-)
+
+diff --git a/src/nautilus-search-engine-tracker.c b/src/nautilus-search-engine-tracker.c
+index 4c917dd..8218ea3 100644
+--- a/src/nautilus-search-engine-tracker.c
++++ b/src/nautilus-search-engine-tracker.c
+@@ -42,6 +42,7 @@ struct _NautilusSearchEngineTracker
+     gboolean query_pending;
+     GQueue *hits_pending;
+ 
++    gboolean available;
+     gboolean recursive;
+     gboolean fts_enabled;
+ 
+@@ -305,8 +306,15 @@ nautilus_search_engine_tracker_start (NautilusSearchProvider *provider)
+         return;
+     }
+ 
+-    DEBUG ("Tracker engine start");
+     g_object_ref (tracker);
++
++    if (!tracker->available)
++    {
++        g_idle_add (search_finished_idle, provider);
++        return;
++    }
++
++    DEBUG ("Tracker engine start");
+     tracker->query_pending = TRUE;
+ 
+     g_object_notify (G_OBJECT (provider), "running");
+@@ -472,6 +480,9 @@ nautilus_search_engine_tracker_set_query (NautilusSearchProvider *provider,
+ 
+     tracker = NAUTILUS_SEARCH_ENGINE_TRACKER (provider);
+ 
++    if (!tracker->available)
++        return;
++
+     g_object_ref (query);
+     g_clear_object (&tracker->query);
+     tracker->query = query;
+@@ -539,16 +550,21 @@ static void
+ nautilus_search_engine_tracker_init (NautilusSearchEngineTracker *engine)
+ {
+     GError *error = NULL;
++    static gboolean tracker_available = TRUE;
+ 
+-    engine->hits_pending = g_queue_new ();
+-
+-    engine->connection = tracker_sparql_connection_get (NULL, &error);
++    if (!tracker_available)
++        engine->connection = tracker_sparql_connection_get (NULL, &error);
+ 
+     if (error)
+     {
++        tracker_available = FALSE;
+         g_warning ("Could not establish a connection to Tracker: %s", error->message);
+         g_error_free (error);
++        return;
+     }
++
++    engine->available = TRUE;
++    engine->hits_pending = g_queue_new ();
+ }
+ 
+ 

=== added file 'debian/patches/0016-search-engine-add-a-recent-search-engine-listing-Gtk.patch'
--- debian/patches/0016-search-engine-add-a-recent-search-engine-listing-Gtk.patch	1970-01-01 00:00:00 +0000
+++ debian/patches/0016-search-engine-add-a-recent-search-engine-listing-Gtk.patch	2018-04-12 23:13:34 +0000
@@ -0,0 +1,538 @@
+From: =?utf-8?b?Ik1hcmNvIFRyZXZpc2FuIChUcmV2acOxbyki?= <[e-mail]>
+Date: Wed, 21 Feb 2018 17:05:51 +0100
+Subject: search-engine: add a recent-search-engine listing GtkRecentManager
+ stuff
+
+Using GtkRecent items as search engine source in nautilus
+---
+ src/meson.build                     |   2 +
+ src/nautilus-file.h                 |   1 +
+ src/nautilus-search-engine-recent.c | 385 ++++++++++++++++++++++++++++++++++++
+ src/nautilus-search-engine-recent.h |  36 ++++
+ src/nautilus-search-engine.c        |  11 ++
+ 5 files changed, 435 insertions(+)
+ create mode 100644 src/nautilus-search-engine-recent.c
+ create mode 100644 src/nautilus-search-engine-recent.h
+
+diff --git a/src/meson.build b/src/meson.build
+index a771d12..0ea9165 100644
+--- a/src/meson.build
++++ b/src/meson.build
+@@ -228,6 +228,8 @@ libnautilus_sources = [
+     'nautilus-search-engine.h',
+     'nautilus-search-engine-model.c',
+     'nautilus-search-engine-model.h',
++    'nautilus-search-engine-recent.c',
++    'nautilus-search-engine-recent.h',
+     'nautilus-search-engine-simple.c',
+     'nautilus-search-engine-simple.h',
+     'nautilus-search-hit.c',
+diff --git a/src/nautilus-file.h b/src/nautilus-file.h
+index 3a83bd4..fd72d7a 100644
+--- a/src/nautilus-file.h
++++ b/src/nautilus-file.h
+@@ -49,6 +49,7 @@ typedef struct NautilusFile NautilusFile;
+   (G_TYPE_CHECK_CLASS_TYPE ((klass), NAUTILUS_TYPE_FILE))
+ #define NAUTILUS_FILE_GET_CLASS(obj) \
+   (G_TYPE_INSTANCE_GET_CLASS ((obj), NAUTILUS_TYPE_FILE, NautilusFileClass))
++G_DEFINE_AUTOPTR_CLEANUP_FUNC (NautilusFile, g_object_unref)
+ 
+ typedef enum {
+ 	NAUTILUS_FILE_SORT_NONE,
+diff --git a/src/nautilus-search-engine-recent.c b/src/nautilus-search-engine-recent.c
+new file mode 100644
+index 0000000..f052e8f
+--- /dev/null
++++ b/src/nautilus-search-engine-recent.c
+@@ -0,0 +1,385 @@
++/*
++ * Copyright (C) 2018 Canonical Ltd
++ *
++ * Nautilus is free software; you can redistribute it and/or
++ * modify it under the terms of the GNU General Public License as
++ * published by the Free Software Foundation; either version 3 of the
++ * License, or (at your option) any later version.
++ *
++ * Nautilus is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
++ * General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public
++ * License along with this program; see the file COPYING.  If not,
++ * see <http://www.gnu.org/licenses/>.
++ *
++ * Author: Marco Trevisan <[e-mail]>
++ */
++
++#include <config.h>
++#include "nautilus-search-hit.h"
++#include "nautilus-search-provider.h"
++#include "nautilus-search-engine-recent.h"
++#include "nautilus-ui-utilities.h"
++#define DEBUG_FLAG NAUTILUS_DEBUG_SEARCH
++#include "nautilus-debug.h"
++
++#include <string.h>
++#include <glib.h>
++#include <gio/gio.h>
++
++#define FILE_ATTRIBS G_FILE_ATTRIBUTE_STANDARD_IS_HIDDEN "," \
++                     G_FILE_ATTRIBUTE_STANDARD_IS_BACKUP "," \
++                     G_FILE_ATTRIBUTE_ACCESS_CAN_READ ","
++
++struct _NautilusSearchEngineRecent
++{
++    GObject parent_instance;
++
++    NautilusQuery *query;
++    GCancellable *cancellable;
++    GtkRecentManager *recent_manager;
++};
++
++static void nautilus_search_provider_init (NautilusSearchProviderInterface *iface);
++
++G_DEFINE_TYPE_WITH_CODE (NautilusSearchEngineRecent,
++                         nautilus_search_engine_recent,
++                         G_TYPE_OBJECT,
++                         G_IMPLEMENT_INTERFACE (NAUTILUS_TYPE_SEARCH_PROVIDER,
++                                                nautilus_search_provider_init))
++
++enum
++{
++  PROP_0,
++  PROP_RUNNING,
++  LAST_PROP
++};
++
++
++NautilusSearchEngineRecent *
++nautilus_search_engine_recent_new (void)
++{
++    return g_object_new (NAUTILUS_TYPE_SEARCH_ENGINE_RECENT, NULL);
++}
++
++static void
++nautilus_search_engine_recent_finalize (GObject *object)
++{
++    NautilusSearchEngineRecent *self = NAUTILUS_SEARCH_ENGINE_RECENT (object);
++
++    if (self->cancellable)
++    {
++        g_cancellable_cancel (self->cancellable);
++    }
++
++    g_clear_object (&self->query);
++    g_clear_object (&self->cancellable);
++
++    G_OBJECT_CLASS (nautilus_search_engine_recent_parent_class)->finalize (object);
++}
++
++typedef struct
++{
++    NautilusSearchEngineRecent *recent;
++    GList *hits;
++} SearchHitsData;
++
++
++static gboolean
++search_thread_add_hits_idle (gpointer user_data)
++{
++    SearchHitsData *search_hits = user_data;
++    NautilusSearchEngineRecent *self = search_hits->recent;
++    NautilusSearchProvider *provider = NAUTILUS_SEARCH_PROVIDER (self);
++
++    if (!g_cancellable_is_cancelled (self->cancellable))
++    {
++        nautilus_search_provider_hits_added (provider, search_hits->hits);
++        DEBUG ("Recent engine add hits");
++    }
++
++    g_list_free_full (search_hits->hits, g_object_unref);
++    g_object_unref (self->query);
++    g_clear_object (&self->cancellable);
++    g_object_unref (self);
++    g_free (search_hits);
++
++    nautilus_search_provider_finished (provider,
++                                       NAUTILUS_SEARCH_PROVIDER_STATUS_NORMAL);
++    g_object_notify (G_OBJECT (provider), "running");
++
++    return FALSE;
++}
++
++static gpointer
++recent_thread_func (gpointer user_data)
++{
++    NautilusSearchEngineRecent *self = NAUTILUS_SEARCH_ENGINE_RECENT (user_data);
++    g_autoptr (GPtrArray) date_range = NULL;
++    g_autoptr (GFile) query_location = NULL;
++    SearchHitsData *search_hits;
++    GList *recent_items;
++    GList *mime_types;
++    GList *hits;
++    GList *l;
++
++    g_return_val_if_fail (self->query, NULL);
++
++    hits = NULL;
++    recent_items = gtk_recent_manager_get_items (self->recent_manager);
++    mime_types = nautilus_query_get_mime_types (self->query);
++    date_range = nautilus_query_get_date_range (self->query);
++    query_location = nautilus_query_get_location (self->query);
++
++    for (l = recent_items; l != NULL; l = l->next)
++    {
++        GtkRecentInfo *info = l->data;
++        g_autoptr (GFile) file = NULL;
++        const gchar *uri;
++        const gchar *name;
++        gdouble rank;
++
++        uri = gtk_recent_info_get_uri (info);
++        file = g_file_new_for_uri (uri);
++
++        if (!g_file_has_prefix (file, query_location))
++        {
++            continue;
++        }
++
++        if (gtk_recent_info_is_local (info))
++        {
++            g_autofree gchar *path = NULL;
++            g_autoptr (GFileInfo) file_info = NULL;
++            g_autoptr (GError) error = NULL;
++
++            file_info = g_file_query_info (file, FILE_ATTRIBS,
++                                           G_FILE_QUERY_INFO_NONE,
++                                           self->cancellable, &error);
++            if (error != NULL)
++            {
++                if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
++                {
++                    break;
++                }
++
++                if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_EXISTS))
++                {
++                    g_debug("Impossible to read locate file info: %s",
++                            error->message);
++                }
++
++                continue;
++            }
++
++            if (!g_file_info_get_attribute_boolean (file_info,
++                                                    G_FILE_ATTRIBUTE_ACCESS_CAN_READ))
++            {
++                continue;
++            }
++
++            path = g_file_get_path (file);
++
++            if (!nautilus_query_get_show_hidden_files (self->query) &&
++                (g_file_info_get_is_hidden (file_info) ||
++                 g_file_info_get_is_backup (file_info) ||
++                 g_strrstr (path, G_DIR_SEPARATOR_S ".") != NULL))
++            {
++                continue;
++            }
++        }
++
++        if (g_cancellable_is_cancelled (self->cancellable))
++        {
++            break;
++        }
++
++        name = gtk_recent_info_get_display_name (info);
++        rank = nautilus_query_matches_string (self->query, name);
++
++        if (rank <= 0)
++        {
++            name = gtk_recent_info_get_short_name (info);
++            rank = nautilus_query_matches_string (self->query, name);
++        }
++
++        if (rank > 0)
++        {
++            NautilusSearchHit *hit;
++            time_t modified, visited;
++            g_autoptr (GDateTime) gmodified = NULL;
++            g_autoptr (GDateTime) gvisited = NULL;
++
++            if (mime_types)
++            {
++                GList *ml;
++                const gchar *mime_type = gtk_recent_info_get_mime_type (info);
++                gboolean found = FALSE;
++
++                for (ml = mime_types; mime_type != NULL && ml != NULL;
++                     ml = ml->next)
++                {
++                    if (g_content_type_is_a (mime_type, ml->data))
++                    {
++                        found = TRUE;
++                        break;
++                    }
++                }
++
++                if (!found)
++                {
++                    continue;
++                }
++            }
++
++            modified = gtk_recent_info_get_modified (info);
++            visited = gtk_recent_info_get_visited (info);
++
++            gmodified = g_date_time_new_from_unix_local (modified);
++            gvisited = g_date_time_new_from_unix_local (visited);
++
++            if (date_range != NULL)
++            {
++                NautilusQuerySearchType type;
++                guint64 target_time;
++                GDateTime *initial_date;
++                GDateTime *end_date;
++
++                initial_date = g_ptr_array_index (date_range, 0);
++                end_date = g_ptr_array_index (date_range, 1);
++                type = nautilus_query_get_search_type (self->query);
++                target_time = (type == NAUTILUS_QUERY_SEARCH_TYPE_LAST_ACCESS) ?
++                               visited : modified;
++
++                if (!nautilus_file_date_in_between (target_time,
++                                                    initial_date, end_date))
++                {
++                    continue;
++                }
++            }
++
++            hit = nautilus_search_hit_new (uri);
++            nautilus_search_hit_set_fts_rank (hit, rank);
++            nautilus_search_hit_set_modification_time (hit, gmodified);
++            nautilus_search_hit_set_access_time (hit, gvisited);
++
++            hits = g_list_prepend (hits, hit);
++        }
++    }
++
++    search_hits = g_new0 (SearchHitsData, 1);
++    search_hits->recent = self;
++    search_hits->hits = hits;
++
++    g_idle_add (search_thread_add_hits_idle, search_hits);
++
++    g_list_free_full (recent_items, (GDestroyNotify) gtk_recent_info_unref);
++    g_list_free_full (mime_types, g_free);
++
++    return NULL;
++}
++
++static void
++nautilus_search_engine_recent_start (NautilusSearchProvider *provider)
++{
++    NautilusSearchEngineRecent *self = NAUTILUS_SEARCH_ENGINE_RECENT (provider);
++    GThread *thread;
++
++    g_return_if_fail (self->query);
++    g_return_if_fail (self->cancellable == NULL);
++
++    g_object_ref (self);
++    g_object_ref (self->query);
++    self->cancellable = g_cancellable_new ();
++
++    thread = g_thread_new ("nautilus-search-recent", recent_thread_func, self);
++    g_object_notify (G_OBJECT (provider), "running");
++
++    g_thread_unref (thread);
++}
++
++static void
++nautilus_search_engine_recent_stop (NautilusSearchProvider *provider)
++{
++    NautilusSearchEngineRecent *self = NAUTILUS_SEARCH_ENGINE_RECENT (provider);
++
++    if (self->cancellable != NULL)
++    {
++        DEBUG ("Recent engine stop");
++        g_cancellable_cancel (self->cancellable);
++        g_clear_object (&self->cancellable);
++
++        g_object_notify (G_OBJECT (provider), "running");
++    }
++}
++
++static void
++nautilus_search_engine_recent_set_query (NautilusSearchProvider *provider,
++                                         NautilusQuery          *query)
++{
++    NautilusSearchEngineRecent *self = NAUTILUS_SEARCH_ENGINE_RECENT (provider);
++
++    g_clear_object (&self->query);
++    self->query = g_object_ref (query);
++}
++
++static gboolean
++nautilus_search_engine_recent_is_running (NautilusSearchProvider *provider)
++{
++    NautilusSearchEngineRecent *self = NAUTILUS_SEARCH_ENGINE_RECENT (provider);
++
++    return self->cancellable != NULL &&
++           !g_cancellable_is_cancelled (self->cancellable);
++}
++
++static void
++nautilus_search_engine_recent_get_property (GObject    *object,
++                                            guint       prop_id,
++                                            GValue     *value,
++                                            GParamSpec *pspec)
++{
++    NautilusSearchProvider *provider = NAUTILUS_SEARCH_PROVIDER (object);
++
++    switch (prop_id)
++    {
++        case PROP_RUNNING:
++        {
++            gboolean running;
++            running = nautilus_search_engine_recent_is_running (provider);
++            g_value_set_boolean (value, running);
++        }
++        break;
++
++        default:
++            G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
++    }
++}
++
++static void
++nautilus_search_provider_init (NautilusSearchProviderInterface *iface)
++{
++    iface->set_query = nautilus_search_engine_recent_set_query;
++    iface->start = nautilus_search_engine_recent_start;
++    iface->stop = nautilus_search_engine_recent_stop;
++    iface->is_running = nautilus_search_engine_recent_is_running;
++}
++
++static void
++nautilus_search_engine_recent_class_init (NautilusSearchEngineRecentClass *klass)
++{
++    GObjectClass *object_class = G_OBJECT_CLASS (klass);
++
++    object_class->finalize = nautilus_search_engine_recent_finalize;
++    object_class->get_property = nautilus_search_engine_recent_get_property;
++
++    g_object_class_override_property (object_class, PROP_RUNNING, "running");
++}
++
++static void
++nautilus_search_engine_recent_init (NautilusSearchEngineRecent *self)
++{
++    self->recent_manager = gtk_recent_manager_get_default ();
++}
+diff --git a/src/nautilus-search-engine-recent.h b/src/nautilus-search-engine-recent.h
+new file mode 100644
+index 0000000..bcd73b9
+--- /dev/null
++++ b/src/nautilus-search-engine-recent.h
+@@ -0,0 +1,36 @@
++/*
++ * Copyright (C) 2018 Canonical Ltd
++ *
++ * Nautilus is free software; you can redistribute it and/or
++ * modify it under the terms of the GNU General Public License as
++ * published by the Free Software Foundation; either version 3 of the
++ * License, or (at your option) any later version.
++ *
++ * Nautilus is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
++ * General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public
++ * License along with this program; see the file COPYING.  If not,
++ * see <http://www.gnu.org/licenses/>.
++ *
++ * Author: Marco Trevisan <[e-mail]>
++ */
++
++#ifndef __NAUTILUS_SEARCH_ENGINE_RECENT_H__
++#define __NAUTILUS_SEARCH_ENGINE_RECENT_H__
++
++#include <glib-object.h>
++
++G_BEGIN_DECLS
++
++#define NAUTILUS_TYPE_SEARCH_ENGINE_RECENT (nautilus_search_engine_recent_get_type ())
++
++G_DECLARE_FINAL_TYPE (NautilusSearchEngineRecent, nautilus_search_engine_recent, NAUTILUS, SEARCH_ENGINE_RECENT, GObject);
++
++NautilusSearchEngineRecent *nautilus_search_engine_recent_new (void);
++
++G_END_DECLS
++
++#endif /* __NAUTILUS_SEARCH_ENGINE_RECENT_H__ */
+diff --git a/src/nautilus-search-engine.c b/src/nautilus-search-engine.c
+index 209bd4f..aef91b7 100644
+--- a/src/nautilus-search-engine.c
++++ b/src/nautilus-search-engine.c
+@@ -24,6 +24,7 @@
+ #include <glib/gi18n.h>
+ #include "nautilus-search-provider.h"
+ #include "nautilus-search-engine.h"
++#include "nautilus-search-engine-recent.h"
+ #include "nautilus-search-engine-simple.h"
+ #include "nautilus-search-engine-model.h"
+ #define DEBUG_FLAG NAUTILUS_DEBUG_SEARCH
+@@ -33,6 +34,7 @@
+ typedef struct
+ {
+     NautilusSearchEngineTracker *tracker;
++    NautilusSearchEngineRecent *recent;
+     NautilusSearchEngineSimple *simple;
+     NautilusSearchEngineModel *model;
+ 
+@@ -74,6 +76,7 @@ nautilus_search_engine_set_query (NautilusSearchProvider *provider,
+     priv = nautilus_search_engine_get_instance_private (engine);
+ 
+     nautilus_search_provider_set_query (NAUTILUS_SEARCH_PROVIDER (priv->tracker), query);
++    nautilus_search_provider_set_query (NAUTILUS_SEARCH_PROVIDER (priv->recent), query);
+     nautilus_search_provider_set_query (NAUTILUS_SEARCH_PROVIDER (priv->model), query);
+     nautilus_search_provider_set_query (NAUTILUS_SEARCH_PROVIDER (priv->simple), query);
+ }
+@@ -98,6 +101,9 @@ search_engine_start_real (NautilusSearchEngine *engine)
+     nautilus_search_provider_start (NAUTILUS_SEARCH_PROVIDER (priv->tracker));
+     priv->providers_running++;
+ 
++    priv->providers_running++;
++    nautilus_search_provider_start (NAUTILUS_SEARCH_PROVIDER (priv->recent));
++
+     if (nautilus_search_engine_model_get_model (priv->model))
+     {
+         nautilus_search_provider_start (NAUTILUS_SEARCH_PROVIDER (priv->model));
+@@ -159,6 +165,7 @@ nautilus_search_engine_stop (NautilusSearchProvider *provider)
+     DEBUG ("Search engine stop");
+ 
+     nautilus_search_provider_stop (NAUTILUS_SEARCH_PROVIDER (priv->tracker));
++    nautilus_search_provider_stop (NAUTILUS_SEARCH_PROVIDER (priv->recent));
+     nautilus_search_provider_stop (NAUTILUS_SEARCH_PROVIDER (priv->model));
+     nautilus_search_provider_stop (NAUTILUS_SEARCH_PROVIDER (priv->simple));
+ 
+@@ -334,6 +341,7 @@ nautilus_search_engine_finalize (GObject *object)
+     g_hash_table_destroy (priv->uris);
+ 
+     g_clear_object (&priv->tracker);
++    g_clear_object (&priv->recent);
+     g_clear_object (&priv->model);
+     g_clear_object (&priv->simple);
+ 
+@@ -395,6 +403,9 @@ nautilus_search_engine_init (NautilusSearchEngine *engine)
+ 
+     priv->simple = nautilus_search_engine_simple_new ();
+     connect_provider_signals (engine, NAUTILUS_SEARCH_PROVIDER (priv->simple));
++
++    priv->recent = nautilus_search_engine_recent_new ();
++    connect_provider_signals (engine, NAUTILUS_SEARCH_PROVIDER (priv->recent));
+ }
+ 
+ NautilusSearchEngine *

=== added file 'debian/patches/0017-recent-add-function-to-update-manager-on-file-rename.patch'
--- debian/patches/0017-recent-add-function-to-update-manager-on-file-rename.patch	1970-01-01 00:00:00 +0000
+++ debian/patches/0017-recent-add-function-to-update-manager-on-file-rename.patch	2018-04-12 23:13:34 +0000
@@ -0,0 +1,294 @@
+From: =?utf-8?b?Ik1hcmNvIFRyZXZpc2FuIChUcmV2acOxbyki?= <[e-mail]>
+Date: Wed, 11 Apr 2018 18:51:34 -0400
+Subject: recent: add function to update manager on file rename or move
+
+When files have been moved or renamed nautilus should inform
+recent manager about this change for the files that
+are listed there.
+---
+ src/nautilus-directory.c |   8 +++
+ src/nautilus-file.c      |  25 +++++-----
+ src/nautilus-recent.c    | 126 +++++++++++++++++++++++++++++++++++++++++++++++
+ src/nautilus-recent.h    |   8 ++-
+ 4 files changed, 152 insertions(+), 15 deletions(-)
+
+diff --git a/src/nautilus-directory.c b/src/nautilus-directory.c
+index ad3bb03..f1a3bf8 100644
+--- a/src/nautilus-directory.c
++++ b/src/nautilus-directory.c
+@@ -33,6 +33,7 @@
+ #include "nautilus-lib-self-check-functions.h"
+ #include "nautilus-metadata.h"
+ #include "nautilus-profile.h"
++#include "nautilus-recent.h"
+ #include "nautilus-vfs-directory.h"
+ #include <eel/eel-glib-extensions.h>
+ #include <eel/eel-string.h>
+@@ -1546,9 +1547,14 @@ nautilus_directory_notify_files_moved (GList *file_pairs)
+ 
+     for (p = file_pairs; p != NULL; p = p->next)
+     {
++        g_autofree char *from_uri = NULL;
++        g_autofree char *to_uri = NULL;
++
+         pair = p->data;
+         from_location = pair->from;
+         to_location = pair->to;
++        from_uri = g_file_get_uri (from_location);
++        to_uri = g_file_get_uri (to_location);
+ 
+         /* Handle overwriting a file. */
+         file = nautilus_file_get_existing (to_location);
+@@ -1626,6 +1632,8 @@ nautilus_directory_notify_files_moved (GList *file_pairs)
+             /* Unref each file once to balance out nautilus_file_get_by_uri. */
+             unref_list = g_list_prepend (unref_list, file);
+         }
++
++        nautilus_recent_update_file_moved (from_uri, to_uri, NULL, NULL);
+     }
+ 
+     /* Now send out the changed and added signals for existing file objects. */
+diff --git a/src/nautilus-file.c b/src/nautilus-file.c
+index 2135801..15e5d05 100644
+--- a/src/nautilus-file.c
++++ b/src/nautilus-file.c
+@@ -34,6 +34,7 @@
+ #include "nautilus-link.h"
+ #include "nautilus-metadata.h"
+ #include "nautilus-module.h"
++#include "nautilus-recent.h"
+ #include "nautilus-thumbnails.h"
+ #include "nautilus-ui-utilities.h"
+ #include "nautilus-video-mime-types.h"
+@@ -1952,14 +1953,12 @@ rename_get_info_callback (GObject      *source_object,
+                           GAsyncResult *res,
+                           gpointer      callback_data)
+ {
++    g_autoptr (GFileInfo) new_info = NULL;
++    g_autoptr (GError) error = NULL;
+     NautilusFileOperation *op;
+     NautilusDirectory *directory;
+     NautilusFile *existing_file;
+-    char *old_uri;
+-    char *new_uri;
+     const char *new_name;
+-    GFileInfo *new_info;
+-    GError *error;
+ 
+     op = callback_data;
+ 
+@@ -1967,8 +1966,12 @@ rename_get_info_callback (GObject      *source_object,
+     new_info = g_file_query_info_finish (G_FILE (source_object), res, &error);
+     if (new_info != NULL)
+     {
+-        directory = op->file->details->directory;
++        g_autofree char *old_uri = NULL;
++        g_autofree char *new_uri = NULL;
++        g_autofree char *new_display_name = NULL;
++        g_autofree char *old_display_name = NULL;
+ 
++        directory = op->file->details->directory;
+         new_name = g_file_info_get_name (new_info);
+ 
+         /* If there was another file by the same name in this
+@@ -1983,6 +1986,7 @@ rename_get_info_callback (GObject      *source_object,
+         }
+ 
+         old_uri = nautilus_file_get_uri (op->file);
++        old_display_name = nautilus_file_get_display_name (op->file);
+ 
+         update_info_and_name (op->file, new_info);
+ 
+@@ -2010,9 +2014,10 @@ rename_get_info_callback (GObject      *source_object,
+         g_object_unref (subject);
+         g_free (origin);
+ 
++        new_display_name = nautilus_file_get_display_name (op->file);
+         nautilus_directory_moved (old_uri, new_uri);
+-        g_free (new_uri);
+-        g_free (old_uri);
++        nautilus_recent_update_file_moved (old_uri, new_uri,
++                                           old_display_name, new_display_name);
+ 
+         /* the rename could have affected the display name if e.g.
+          * we're in a vfolder where the name comes from a desktop file
+@@ -2024,14 +2029,8 @@ rename_get_info_callback (GObject      *source_object,
+                                                  NAUTILUS_FILE_ATTRIBUTE_INFO |
+                                                  NAUTILUS_FILE_ATTRIBUTE_LINK_INFO);
+         }
+-
+-        g_object_unref (new_info);
+     }
+     nautilus_file_operation_complete (op, NULL, error);
+-    if (error)
+-    {
+-        g_error_free (error);
+-    }
+ }
+ 
+ static void
+diff --git a/src/nautilus-recent.c b/src/nautilus-recent.c
+index ab50fef..c69a3a7 100644
+--- a/src/nautilus-recent.c
++++ b/src/nautilus-recent.c
+@@ -1,5 +1,6 @@
+ /*
+  * Copyright (C) 2002 James Willcox
++ * Copyright (C) 2018 Canonical Ltd
+  *
+  * This program is free software; you can redistribute it and/or modify
+  * it under the terms of the GNU General Public License as published by
+@@ -17,6 +18,7 @@
+ 
+ #include "config.h"
+ #include "nautilus-recent.h"
++#include "nautilus-file-private.h"
+ 
+ #include <eel/eel-vfs-extensions.h>
+ 
+@@ -85,3 +87,127 @@ nautilus_recent_add_file (NautilusFile *file,
+ 
+     g_free (uri);
+ }
++
++void
++nautilus_recent_update_file_moved (const gchar   *old_uri,
++                                   const gchar   *new_uri,
++                                   const gchar   *old_display_name,
++                                   const gchar   *new_display_name)
++{
++    GtkRecentManager *recent_manager = nautilus_recent_get_manager ();
++    g_autoptr (NautilusFile) file = NULL;
++    NautilusFile *existing_file;
++
++    if (new_uri == NULL || old_uri == NULL)
++    {
++        return;
++    }
++
++    existing_file = nautilus_file_get_existing_by_uri (new_uri);
++
++    if (existing_file)
++    {
++        file = g_object_ref (existing_file);
++    }
++    else
++    {
++        g_autoptr (GFile) location = g_file_new_for_uri (new_uri);
++        g_autoptr (GFileInfo) file_info = NULL;
++
++        file_info = g_file_query_info (location,
++                                       NAUTILUS_FILE_DEFAULT_ATTRIBUTES,
++                                       0, NULL, NULL);
++        if (file_info == NULL)
++        {
++            return;
++        }
++
++        file = nautilus_file_get (location);
++        nautilus_file_update_info (file, file_info);
++    }
++
++    if (nautilus_file_is_directory (file))
++    {
++        GList *recent_items;
++        GList *l;
++
++        recent_items = gtk_recent_manager_get_items (recent_manager);
++
++        for (l = recent_items; l; l = l->next)
++        {
++            GtkRecentInfo *info = l->data;
++            const gchar *item_uri = gtk_recent_info_get_uri (info);
++
++            if (g_str_has_prefix (item_uri, old_uri))
++            {
++                const gchar *relative_path = item_uri + strlen (old_uri);
++                g_autofree gchar *new_item_uri = NULL;
++
++                new_item_uri = g_build_filename (new_uri, relative_path, NULL);
++
++                gtk_recent_manager_move_item (recent_manager,
++                                              item_uri, new_item_uri, NULL);
++            }
++        }
++
++        g_list_free_full (recent_items, (GDestroyNotify) gtk_recent_info_unref);
++    }
++    else
++    {
++        GtkRecentInfo *old_recent;
++
++        old_recent = gtk_recent_manager_lookup_item (recent_manager,
++                                                     old_uri, NULL);
++        if (old_recent)
++        {
++            gboolean recreated = FALSE;
++
++            if ((new_display_name != NULL && old_display_name == NULL) ||
++                (g_strcmp0 (old_display_name, new_display_name) != 0 &&
++                 g_strcmp0 (old_display_name,
++                            gtk_recent_info_get_display_name (old_recent)) == 0))
++            {
++                /* If old display name, matches the one in the recent file
++                 * We can't just move it, but we need to recreate the
++                 * GtkRecentInfo
++                 */
++                GtkRecentData recent_data =
++                {
++                    .display_name = (gchar *) new_display_name,
++                    .description = (gchar *) gtk_recent_info_get_description (old_recent),
++                    .mime_type = (gchar *) gtk_recent_info_get_mime_type (old_recent),
++                    .app_name = gtk_recent_info_last_application (old_recent),
++                    .groups = gtk_recent_info_get_groups (old_recent, NULL),
++                    .is_private = gtk_recent_info_get_private_hint (old_recent),
++                };
++
++                if (recent_data.app_name)
++                {
++                    gtk_recent_info_get_application_info (old_recent,
++                                                          recent_data.app_name,
++                                                          (const gchar **) &(recent_data.app_exec),
++                                                          NULL, NULL);
++                }
++
++                if (gtk_recent_manager_add_full (recent_manager,
++                                                 new_uri,
++                                                 &recent_data))
++                {
++                    recreated = gtk_recent_manager_remove_item (recent_manager,
++                                                                old_uri,
++                                                                NULL);
++                }
++            }
++
++            if (!recreated)
++            {
++                gtk_recent_manager_move_item (recent_manager,
++                                              old_uri, new_uri, NULL);
++            }
++        }
++        else
++        {
++            gtk_recent_manager_remove_item (recent_manager, old_uri, NULL);
++        }
++    }
++}
+diff --git a/src/nautilus-recent.h b/src/nautilus-recent.h
+index 5c64f6c..841854e 100644
+--- a/src/nautilus-recent.h
++++ b/src/nautilus-recent.h
+@@ -7,7 +7,11 @@
+ #include "nautilus-file.h"
+ #include <gio/gio.h>
+ 
+-void nautilus_recent_add_file (NautilusFile *file,
+-			       GAppInfo *application);
++void nautilus_recent_add_file          (NautilusFile *file,
++                                        GAppInfo *application);
++void nautilus_recent_update_file_moved (const char *old_uri,
++                                        const char *new_uri,
++                                        const char *old_display_name,
++                                        const char *new_dispaly_name);
+ 
+ #endif

=== added file 'debian/patches/0018-search-engine-add-locate-based-search-engine.patch'
--- debian/patches/0018-search-engine-add-locate-based-search-engine.patch	1970-01-01 00:00:00 +0000
+++ debian/patches/0018-search-engine-add-locate-based-search-engine.patch	2018-04-12 23:13:34 +0000
@@ -0,0 +1,739 @@
+From: =?utf-8?b?Ik1hcmNvIFRyZXZpc2FuIChUcmV2acOxbyki?= <[e-mail]>
+Date: Thu, 1 Mar 2018 05:37:08 +0100
+Subject: search-engine: add locate based search engine
+
+Look for files in the (m)locate database using
+command line and parsing output to provide more and
+quicker results to the shell and nautilus
+---
+ src/meson.build                     |   2 +
+ src/nautilus-search-engine-locate.c | 597 ++++++++++++++++++++++++++++++++++++
+ src/nautilus-search-engine-locate.h |  37 +++
+ src/nautilus-search-engine.c        |  11 +
+ 4 files changed, 647 insertions(+)
+ create mode 100644 src/nautilus-search-engine-locate.c
+ create mode 100644 src/nautilus-search-engine-locate.h
+
+diff --git a/src/meson.build b/src/meson.build
+index 0ea9165..06e6633 100644
+--- a/src/meson.build
++++ b/src/meson.build
+@@ -228,6 +228,8 @@ libnautilus_sources = [
+     'nautilus-search-engine.h',
+     'nautilus-search-engine-model.c',
+     'nautilus-search-engine-model.h',
++    'nautilus-search-engine-locate.c',
++    'nautilus-search-engine-locate.h',
+     'nautilus-search-engine-recent.c',
+     'nautilus-search-engine-recent.h',
+     'nautilus-search-engine-simple.c',
+diff --git a/src/nautilus-search-engine-locate.c b/src/nautilus-search-engine-locate.c
+new file mode 100644
+index 0000000..16f9f21
+--- /dev/null
++++ b/src/nautilus-search-engine-locate.c
+@@ -0,0 +1,597 @@
++/*
++ * Copyright (C) 2018 Canonical Ltd
++ *
++ * Nautilus is free software; you can redistribute it and/or
++ * modify it under the terms of the GNU General Public License as
++ * published by the Free Software Foundation; either version 2 of the
++ * License, or (at your option) any later version.
++ *
++ * Nautilus is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
++ * General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public
++ * License along with this program; see the file COPYING.  If not,
++ * see <http://www.gnu.org/licenses/>.
++ *
++ * Author: Marco Trevisan <[e-mail]>
++ *
++ */
++
++#include "nautilus-search-hit.h"
++#include "nautilus-search-provider.h"
++#include "nautilus-search-engine-locate.h"
++#include "nautilus-ui-utilities.h"
++#define DEBUG_FLAG NAUTILUS_DEBUG_SEARCH
++#include "nautilus-debug.h"
++
++#include <string.h>
++#include <glib.h>
++#include <gio/gio.h>
++
++#define LOCATE_BINARY "locate"
++#define WORD_SEPARATORS "\t\n !\"#$%&'()*+,-./:;<=>?[\\]^_`{|}~"
++#define BATCH_SIZE 300
++#define FILE_ATTRIBS G_FILE_ATTRIBUTE_STANDARD_IS_HIDDEN "," \
++                     G_FILE_ATTRIBUTE_STANDARD_IS_BACKUP "," \
++                     G_FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME "," \
++                     G_FILE_ATTRIBUTE_ACCESS_CAN_READ "," \
++                     G_FILE_ATTRIBUTE_TIME_MODIFIED "," \
++                     G_FILE_ATTRIBUTE_TIME_ACCESS
++
++enum
++{
++    LOCATE_INSTALLED                  = (1 << 0),
++    LOCATE_SUPPORTS_IGNORE_CASE       = (1 << 1),
++    LOCATE_SUPPORTS_BASENAME_MATCHING = (1 << 2),
++    LOCATE_SUPPORTS_TRANSLITERATION   = (1 << 3),
++    LOCATE_SUPPORTS_IGNORE_SEPARATORS = (1 << 4),
++};
++
++struct _NautilusSearchEngineLocate
++{
++    GObject parent_instance;
++
++    NautilusQuery *query;
++    GCancellable *cancellable;
++    gint locate_features;
++    GSubprocess *locate_process;
++};
++
++typedef struct
++{
++    NautilusSearchEngineLocate *locate;
++    gboolean completed;
++    gsize pending_ops;
++
++    GPtrArray *date_range;
++    GList *mime_types;
++
++    gsize n_processed_paths;
++    GList *hits;
++
++    NautilusQuery *query;
++    gchar *query_path;
++} LocateSearchData;
++
++static void nautilus_search_provider_init (NautilusSearchProviderInterface *iface);
++
++G_DEFINE_TYPE_WITH_CODE (NautilusSearchEngineLocate,
++                         nautilus_search_engine_locate,
++                         G_TYPE_OBJECT,
++                         G_IMPLEMENT_INTERFACE (NAUTILUS_TYPE_SEARCH_PROVIDER,
++                                                nautilus_search_provider_init))
++
++enum
++{
++  PROP_0,
++  PROP_RUNNING,
++  LAST_PROP
++};
++
++NautilusSearchEngineLocate *
++nautilus_search_engine_locate_new (void)
++{
++    return g_object_new (NAUTILUS_TYPE_SEARCH_ENGINE_LOCATE, NULL);
++}
++
++static void
++nautilus_search_engine_locate_finalize (GObject *object)
++{
++    NautilusSearchEngineLocate *self = NAUTILUS_SEARCH_ENGINE_LOCATE (object);
++
++    if (self->cancellable)
++        g_cancellable_cancel (self->cancellable);
++
++    if (self->locate_process)
++        g_subprocess_force_exit(self->locate_process);
++
++    g_clear_object (&self->query);
++    g_clear_object (&self->cancellable);
++    g_clear_object (&self->locate_process);
++
++    G_OBJECT_CLASS (nautilus_search_engine_locate_parent_class)->finalize (object);
++}
++
++typedef struct
++{
++    NautilusSearchEngineLocate *locate;
++    GList *hits;
++} SearchHitsData;
++
++
++static void
++submit_available_hits (LocateSearchData *sdata)
++{
++    NautilusSearchEngineLocate *self = sdata->locate;
++    NautilusSearchProvider *provider = NAUTILUS_SEARCH_PROVIDER (self);
++
++    if (sdata->hits)
++    {
++        nautilus_search_provider_hits_added (provider, sdata->hits);
++        g_list_free_full (sdata->hits, g_object_unref);
++        sdata->hits = NULL;
++    }
++
++    sdata->n_processed_paths = 0;
++}
++
++static void
++submit_results (LocateSearchData *sdata)
++{
++    NautilusSearchEngineLocate *self = sdata->locate;
++
++    if (!g_cancellable_is_cancelled (self->cancellable))
++        submit_available_hits (sdata);
++
++    g_clear_object (&self->cancellable);
++    g_clear_object (&self->locate_process);
++
++    g_object_notify (G_OBJECT (self), "running");
++    nautilus_search_provider_finished (NAUTILUS_SEARCH_PROVIDER (self),
++                                       NAUTILUS_SEARCH_PROVIDER_STATUS_NORMAL);
++    g_object_unref (self);
++
++    g_clear_object (&sdata->query);
++    g_clear_pointer (&sdata->date_range, g_ptr_array_unref);
++    g_list_free_full (sdata->hits, g_object_unref);
++    g_list_free_full (sdata->mime_types, g_free);
++    g_free (sdata->query_path);
++    g_free (sdata);
++}
++
++static void
++maybe_submit_available_hits (LocateSearchData *sdata)
++{
++    if (G_UNLIKELY (sdata->completed && sdata->pending_ops == 0))
++    {
++        submit_results (sdata);
++    }
++    else if (sdata->n_processed_paths > BATCH_SIZE)
++    {
++        submit_available_hits (sdata);
++    }
++}
++
++static void
++maybe_add_search_hit (LocateSearchData *sdata,
++                      GFile            *file,
++                      GFileInfo        *info)
++{
++    guint64 atime;
++    guint64 mtime;
++    gdouble rank;
++    NautilusSearchHit *hit;
++    const gchar *display_name;
++    g_autofree gchar *uri = NULL;
++    g_autoptr (GDateTime) gmodified = NULL;
++    g_autoptr (GDateTime) gaccessed = NULL;
++
++    if (g_file_info_get_is_backup (info) || g_file_info_get_is_hidden (info) ||
++        !g_file_info_get_attribute_boolean (info, G_FILE_ATTRIBUTE_ACCESS_CAN_READ))
++        return;
++
++    atime = g_file_info_get_attribute_uint64 (info, "time::access");
++    mtime = g_file_info_get_attribute_uint64 (info, "time::modified");
++
++    if (sdata->date_range != NULL)
++    {
++        NautilusQuerySearchType type;
++        GDateTime *initial_date;
++        GDateTime *end_date;
++        guint64 file_time;
++
++        initial_date = g_ptr_array_index (sdata->date_range, 0);
++        end_date = g_ptr_array_index (sdata->date_range, 1);
++        type = nautilus_query_get_search_type (sdata->query);
++
++        file_time = (type == NAUTILUS_QUERY_SEARCH_TYPE_LAST_ACCESS) ?
++                     atime : mtime;
++
++        if (!nautilus_file_date_in_between (file_time, initial_date, end_date))
++            return;
++    }
++
++    uri = g_file_get_uri (file);
++    display_name = g_file_info_get_display_name (info);
++    rank = nautilus_query_matches_string (sdata->query, display_name);
++    gaccessed = g_date_time_new_from_unix_local (atime);
++    gmodified = g_date_time_new_from_unix_local (mtime);
++
++    hit = nautilus_search_hit_new (uri);
++    nautilus_search_hit_set_modification_time (hit, gmodified);
++    nautilus_search_hit_set_access_time (hit, gaccessed);
++    nautilus_search_hit_set_fts_rank (hit, rank);
++
++    sdata->hits = g_list_prepend (sdata->hits, hit);
++}
++
++static void
++path_info_callback (GObject      *source_object,
++                    GAsyncResult *res,
++                    gpointer      user_data)
++{
++    LocateSearchData *sdata = user_data;
++    g_autoptr (GFile) file = G_FILE (source_object);
++    g_autoptr (GFileInfo) info = NULL;
++    g_autoptr (GError) error = NULL;
++
++    info = g_file_query_info_finish (file, res, &error);
++    sdata->pending_ops--;
++
++    if (!error)
++    {
++        maybe_add_search_hit (sdata, file, info);
++    }
++    else
++    {
++        if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
++            return;
++
++        if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_EXISTS))
++            g_debug ("Impossible to read locate file info: %s", error->message);
++    }
++
++    maybe_submit_available_hits (sdata);
++}
++
++static void
++check_path (LocateSearchData *sdata,
++            gchar            *path)
++{
++    NautilusSearchEngineLocate *self = sdata->locate;
++
++    sdata->n_processed_paths++;
++
++    if (g_str_has_prefix (path, sdata->query_path) &&
++        g_strrstr (path, G_DIR_SEPARATOR_S ".") == NULL)
++    {
++        GFile *file;
++        const char *file_attribs = FILE_ATTRIBS;
++
++        if (sdata->mime_types)
++            file_attribs = FILE_ATTRIBS "," \
++                           G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE;
++
++        file = g_file_new_for_path (path);
++
++        sdata->pending_ops++;
++        g_file_query_info_async (file, file_attribs, G_FILE_QUERY_INFO_NONE,
++                                 G_PRIORITY_DEFAULT, self->cancellable,
++                                 path_info_callback, sdata);
++    }
++    else
++    {
++        maybe_submit_available_hits (sdata);
++    }
++}
++
++static void
++read_line_callback (GObject *input_stream,
++                    GAsyncResult *res,
++                    gpointer user_data)
++{
++    LocateSearchData *sdata = user_data;
++    NautilusSearchEngineLocate *self = sdata->locate;
++    GDataInputStream *data_input = G_DATA_INPUT_STREAM (input_stream);
++    g_autofree gchar *path = NULL;
++    g_autoptr (GError) error = NULL;
++    gsize length;
++
++    path = g_data_input_stream_read_line_finish_utf8 (data_input, res,
++                                                      &length, &error);
++    sdata->pending_ops--;
++
++    if (path != NULL)
++    {
++        check_path (sdata, path);
++        sdata->pending_ops++;
++        g_data_input_stream_read_line_async (data_input, G_PRIORITY_DEFAULT,
++                                             self->cancellable,
++                                             read_line_callback, sdata);
++    }
++    else
++    {
++        if (error)
++        {
++            if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
++                sdata->pending_ops = 0;
++            else
++                g_warning ("Impossible to read locate output path: %s",
++                           error->message);
++        }
++
++        sdata->completed = TRUE;
++        maybe_submit_available_hits (sdata);
++    }
++}
++
++static void
++search_string_rewrite_with_wildcards (gchar **query)
++{
++    gsize query_len;
++    gsize rewritten_len;
++    gchar *arg;
++    gchar *query_text;
++    gboolean needs_leading;
++    gboolean needs_trailing;
++
++    g_return_if_fail (*query);
++
++    query_text = *query;
++    query_len = strlen (query_text);
++    rewritten_len = query_len;
++    needs_leading = FALSE;
++    needs_trailing = FALSE;
++
++    if (query_text[0] != '*')
++    {
++        needs_leading = TRUE;
++        rewritten_len++;
++    }
++
++    if (query_text[query_len-1] != '*' && (!needs_leading || query_len > 0))
++    {
++        needs_trailing = TRUE;
++        rewritten_len++;
++    }
++
++    if (!needs_leading && !needs_trailing)
++        return;
++
++    arg = g_malloc0 (rewritten_len + 1);
++    *query = arg;
++
++    if (needs_trailing)
++        arg[rewritten_len-1] = '*';
++
++    if (needs_leading)
++    {
++        arg[0] = '*';
++        arg += 1;
++    }
++
++    memcpy (arg, query_text, query_len);
++
++    g_free (query_text);
++}
++
++static void
++search_string_replace_separators (gchar **query)
++{
++    g_auto (GStrv) words = NULL;
++    g_autofree gchar *query_text = *query;
++
++    /* Using generated WORD_SEPARATORS, it uses this rule:
++     * gsize i;
++     * gchar c;
++     * gchar separators[0xff] = {0};
++     * for (c = 0, i = 0; c < sizeof (separators); ++c)
++     * {
++     *     if (g_ascii_isspace (c) || (g_ascii_ispunct (c) && c != '@'))
++     *         separators[i++] = c;
++     * }
++     */
++
++    words = g_strsplit_set (query_text, WORD_SEPARATORS, -1);
++    *query = g_strjoinv ("*", words);
++}
++
++static void
++nautilus_search_engine_locate_start (NautilusSearchProvider *provider)
++{
++    NautilusSearchEngineLocate *self = NAUTILUS_SEARCH_ENGINE_LOCATE (provider);
++    GInputStream *output;
++    GDataInputStream *input;
++    LocateSearchData *sdata;
++    g_autoptr (GError) error = NULL;
++    g_autoptr (GFile) query_location = NULL;
++    g_autoptr (GPtrArray) args = NULL;
++    char *query_text;
++
++    g_return_if_fail (self->query);
++    g_return_if_fail (self->cancellable == NULL ||
++                      !g_cancellable_is_cancelled (self->cancellable));
++
++    sdata = g_new0 (LocateSearchData, 1);
++    sdata->locate = g_object_ref (self);
++
++    if (!(self->locate_features & LOCATE_INSTALLED))
++    {
++        g_idle_add ((GSourceFunc) submit_results, sdata);
++        return;
++    }
++
++    args = g_ptr_array_new_full (3, g_free);
++    g_ptr_array_add (args, g_strdup (LOCATE_BINARY));
++
++    if (self->locate_features & LOCATE_SUPPORTS_IGNORE_CASE)
++        g_ptr_array_add (args, g_strdup ("--ignore-case"));
++
++    if (self->locate_features & LOCATE_SUPPORTS_IGNORE_SEPARATORS)
++        g_ptr_array_add (args, g_strdup ("--ignore-spaces"));
++
++    if (self->locate_features & LOCATE_SUPPORTS_BASENAME_MATCHING)
++        g_ptr_array_add (args, g_strdup ("--basename"));
++
++    if (self->locate_features & LOCATE_SUPPORTS_TRANSLITERATION)
++        g_ptr_array_add (args, g_strdup ("--transliterate"));
++
++    query_text = nautilus_query_get_text (self->query);
++
++    if (!(self->locate_features & LOCATE_SUPPORTS_IGNORE_SEPARATORS))
++        search_string_replace_separators (&query_text);
++
++    search_string_rewrite_with_wildcards (&query_text);
++
++    g_ptr_array_add (args, query_text);
++    g_ptr_array_add (args, NULL);
++
++    g_autoptr (GSubprocess) proc = NULL;
++    proc = g_subprocess_newv ((const gchar * const *) args->pdata,
++                              G_SUBPROCESS_FLAGS_STDOUT_PIPE, &error);
++
++    if (error)
++    {
++        g_warning ("Can't start locate process: %s", error->message);
++        return;
++    }
++
++    query_location = nautilus_query_get_location (self->query);
++
++    sdata->query = g_object_ref (self->query);
++    sdata->date_range = nautilus_query_get_date_range (self->query);
++    sdata->mime_types = nautilus_query_get_mime_types (self->query);
++    sdata->query_path = g_file_get_path (query_location);
++
++    output = g_subprocess_get_stdout_pipe (proc);
++    input = g_data_input_stream_new (output);
++
++    self->locate_process = g_steal_pointer (&proc);
++    self->cancellable = g_cancellable_new ();
++
++    g_object_notify (G_OBJECT (provider), "running");
++
++    g_object_set_data (G_OBJECT (self->locate_process), "search-data", sdata);
++    g_object_set_data_full (G_OBJECT (self->locate_process), "input-stream",
++                            input, g_object_unref);
++
++    sdata->pending_ops++;
++    g_data_input_stream_read_line_async (input, G_PRIORITY_DEFAULT,
++                                         self->cancellable,
++                                         read_line_callback, sdata);
++}
++
++static void
++nautilus_search_engine_locate_stop (NautilusSearchProvider *provider)
++{
++    NautilusSearchEngineLocate *self = NAUTILUS_SEARCH_ENGINE_LOCATE (provider);
++
++    if (self->locate_process != NULL)
++    {
++        DEBUG ("Locate engine stop");
++        g_cancellable_cancel (self->cancellable);
++
++        g_subprocess_force_exit (self->locate_process);
++    }
++}
++
++static void
++nautilus_search_engine_locate_set_query (NautilusSearchProvider *provider,
++                                         NautilusQuery          *query)
++{
++    NautilusSearchEngineLocate *self = NAUTILUS_SEARCH_ENGINE_LOCATE (provider);
++
++    g_clear_object (&self->query);
++    self->query = g_object_ref (query);
++}
++
++static gboolean
++nautilus_search_engine_locate_is_running (NautilusSearchProvider *provider)
++{
++    NautilusSearchEngineLocate *self = NAUTILUS_SEARCH_ENGINE_LOCATE (provider);
++
++    return self->locate_process != NULL;
++}
++
++static void
++check_locate_features (NautilusSearchEngineLocate *self)
++{
++    gint exit_status;
++    g_autofree gchar *output = NULL;
++    g_autoptr (GError) error = NULL;
++
++    g_spawn_command_line_sync (LOCATE_BINARY " -h", &output, NULL,
++                               &exit_status, &error);
++
++    if (error)
++    {
++        g_warning ("locate can't be properly inspected for supported features: "
++                   "%s", error->message);
++        return;
++    }
++
++    self->locate_features |= LOCATE_INSTALLED;
++
++    if (g_strrstr (output, "--basename"))
++        self->locate_features |= LOCATE_SUPPORTS_BASENAME_MATCHING;
++
++    if (g_strrstr (output, "--transliterate"))
++        self->locate_features |= LOCATE_SUPPORTS_TRANSLITERATION;
++
++    if (g_strrstr (output, "--ignore-case"))
++        self->locate_features |= LOCATE_SUPPORTS_IGNORE_CASE;
++
++    if (g_strrstr (output, "--ignore-spaces"))
++        self->locate_features |= LOCATE_SUPPORTS_IGNORE_SEPARATORS;
++}
++
++static void
++nautilus_search_engine_locate_get_property (GObject    *object,
++                                            guint       prop_id,
++                                            GValue     *value,
++                                            GParamSpec *pspec)
++{
++    NautilusSearchProvider *provider = NAUTILUS_SEARCH_PROVIDER (object);
++
++    switch (prop_id)
++    {
++        case PROP_RUNNING:
++        {
++            gboolean running;
++            running = nautilus_search_engine_locate_is_running (provider);
++            g_value_set_boolean (value, running);
++        }
++        break;
++
++        default:
++            G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
++    }
++}
++
++static void
++nautilus_search_provider_init (NautilusSearchProviderInterface *iface)
++{
++    iface->set_query = nautilus_search_engine_locate_set_query;
++    iface->start = nautilus_search_engine_locate_start;
++    iface->stop = nautilus_search_engine_locate_stop;
++    iface->is_running = nautilus_search_engine_locate_is_running;
++}
++
++static void
++nautilus_search_engine_locate_class_init (NautilusSearchEngineLocateClass *klass)
++{
++    GObjectClass *object_class = G_OBJECT_CLASS (klass);
++
++    object_class->finalize = nautilus_search_engine_locate_finalize;
++    object_class->get_property = nautilus_search_engine_locate_get_property;
++
++    g_object_class_override_property (object_class, PROP_RUNNING, "running");
++}
++
++static void
++nautilus_search_engine_locate_init (NautilusSearchEngineLocate *self)
++{
++    check_locate_features (self);
++}
+diff --git a/src/nautilus-search-engine-locate.h b/src/nautilus-search-engine-locate.h
+new file mode 100644
+index 0000000..ac5e3fc
+--- /dev/null
++++ b/src/nautilus-search-engine-locate.h
+@@ -0,0 +1,37 @@
++/*
++ * Copyright (C) 2018 Canonical Ltd
++ *
++ * Nautilus is free software; you can redistribute it and/or
++ * modify it under the terms of the GNU General Public License as
++ * published by the Free Software Foundation; either version 2 of the
++ * License, or (at your option) any later version.
++ *
++ * Nautilus is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
++ * General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public
++ * License along with this program; see the file COPYING.  If not,
++ * see <http://www.gnu.org/licenses/>.
++ *
++ * Author: Marco Trevisan <[e-mail]>
++ *
++ */
++
++#ifndef __NAUTILUS_SEARCH_ENGINE_LOCATE_H__
++#define __NAUTILUS_SEARCH_ENGINE_LOCATE_H__
++
++#include <glib-object.h>
++
++G_BEGIN_DECLS
++
++#define NAUTILUS_TYPE_SEARCH_ENGINE_LOCATE (nautilus_search_engine_locate_get_type ())
++
++G_DECLARE_FINAL_TYPE (NautilusSearchEngineLocate, nautilus_search_engine_locate, NAUTILUS, SEARCH_ENGINE_LOCATE, GObject);
++
++NautilusSearchEngineLocate *nautilus_search_engine_locate_new (void);
++
++G_END_DECLS
++
++#endif /* __NAUTILUS_SEARCH_ENGINE_LOCATE_H__ */
+diff --git a/src/nautilus-search-engine.c b/src/nautilus-search-engine.c
+index aef91b7..bf0e85d 100644
+--- a/src/nautilus-search-engine.c
++++ b/src/nautilus-search-engine.c
+@@ -25,6 +25,7 @@
+ #include "nautilus-search-provider.h"
+ #include "nautilus-search-engine.h"
+ #include "nautilus-search-engine-recent.h"
++#include "nautilus-search-engine-locate.h"
+ #include "nautilus-search-engine-simple.h"
+ #include "nautilus-search-engine-model.h"
+ #define DEBUG_FLAG NAUTILUS_DEBUG_SEARCH
+@@ -35,6 +36,7 @@ typedef struct
+ {
+     NautilusSearchEngineTracker *tracker;
+     NautilusSearchEngineRecent *recent;
++    NautilusSearchEngineLocate *locate;
+     NautilusSearchEngineSimple *simple;
+     NautilusSearchEngineModel *model;
+ 
+@@ -77,6 +79,7 @@ nautilus_search_engine_set_query (NautilusSearchProvider *provider,
+ 
+     nautilus_search_provider_set_query (NAUTILUS_SEARCH_PROVIDER (priv->tracker), query);
+     nautilus_search_provider_set_query (NAUTILUS_SEARCH_PROVIDER (priv->recent), query);
++    nautilus_search_provider_set_query (NAUTILUS_SEARCH_PROVIDER (priv->locate), query);
+     nautilus_search_provider_set_query (NAUTILUS_SEARCH_PROVIDER (priv->model), query);
+     nautilus_search_provider_set_query (NAUTILUS_SEARCH_PROVIDER (priv->simple), query);
+ }
+@@ -104,6 +107,9 @@ search_engine_start_real (NautilusSearchEngine *engine)
+     priv->providers_running++;
+     nautilus_search_provider_start (NAUTILUS_SEARCH_PROVIDER (priv->recent));
+ 
++    priv->providers_running++;
++    nautilus_search_provider_start (NAUTILUS_SEARCH_PROVIDER (priv->locate));
++
+     if (nautilus_search_engine_model_get_model (priv->model))
+     {
+         nautilus_search_provider_start (NAUTILUS_SEARCH_PROVIDER (priv->model));
+@@ -166,6 +172,7 @@ nautilus_search_engine_stop (NautilusSearchProvider *provider)
+ 
+     nautilus_search_provider_stop (NAUTILUS_SEARCH_PROVIDER (priv->tracker));
+     nautilus_search_provider_stop (NAUTILUS_SEARCH_PROVIDER (priv->recent));
++    nautilus_search_provider_stop (NAUTILUS_SEARCH_PROVIDER (priv->locate));
+     nautilus_search_provider_stop (NAUTILUS_SEARCH_PROVIDER (priv->model));
+     nautilus_search_provider_stop (NAUTILUS_SEARCH_PROVIDER (priv->simple));
+ 
+@@ -342,6 +349,7 @@ nautilus_search_engine_finalize (GObject *object)
+ 
+     g_clear_object (&priv->tracker);
+     g_clear_object (&priv->recent);
++    g_clear_object (&priv->locate);
+     g_clear_object (&priv->model);
+     g_clear_object (&priv->simple);
+ 
+@@ -406,6 +414,9 @@ nautilus_search_engine_init (NautilusSearchEngine *engine)
+ 
+     priv->recent = nautilus_search_engine_recent_new ();
+     connect_provider_signals (engine, NAUTILUS_SEARCH_PROVIDER (priv->recent));
++
++    priv->locate = nautilus_search_engine_locate_new ();
++    connect_provider_signals (engine, NAUTILUS_SEARCH_PROVIDER (priv->locate));
+ }
+ 
+ NautilusSearchEngine *

=== modified file 'debian/patches/12_unity_launcher_support.patch'
--- debian/patches/12_unity_launcher_support.patch	2018-03-24 20:06:53 +0000
+++ debian/patches/12_unity_launcher_support.patch	2018-04-12 23:13:34 +0000
@@ -1,16 +1,26 @@
+From: Ubuntu Developers <[e-mail]>
+Date: Thu, 12 Apr 2018 16:54:13 -0500
+Subject: _unity_launcher_support
+
 ---
- config.h.meson                |    1 
- meson.build                   |    8 ++
- meson_options.txt             |    3 
- src/meson.build               |    8 ++
- src/nautilus-application.c    |    8 ++
- src/nautilus-toolbar.c        |   19 +++++
- src/unity-bookmarks-handler.c |  148 ++++++++++++++++++++++++++++++++++++++++
- src/unity-bookmarks-handler.h |   31 ++++++++
- src/unity-quicklist-handler.c |  154 ++++++++++++++++++++++++++++++++++++++++++
- src/unity-quicklist-handler.h |   72 +++++++++++++++++++
- 10 files changed, 452 insertions(+)
+ config.h.meson                |   1 +
+ meson.build                   |   8 +++
+ meson_options.txt             |   4 ++
+ src/meson.build               |  10 +++
+ src/nautilus-application.c    |   8 +++
+ src/nautilus-toolbar.c        |  21 ++++++
+ src/unity-bookmarks-handler.c | 147 +++++++++++++++++++++++++++++++++++++
+ src/unity-bookmarks-handler.h |  31 ++++++++
+ src/unity-quicklist-handler.c | 163 ++++++++++++++++++++++++++++++++++++++++++
+ src/unity-quicklist-handler.h |  72 +++++++++++++++++++
+ 10 files changed, 465 insertions(+)
+ create mode 100644 src/unity-bookmarks-handler.c
+ create mode 100644 src/unity-bookmarks-handler.h
+ create mode 100644 src/unity-quicklist-handler.c
+ create mode 100644 src/unity-quicklist-handler.h
 
+diff --git a/config.h.meson b/config.h.meson
+index 4f5cb58..9ddb88d 100644
 --- a/config.h.meson
 +++ b/config.h.meson
 @@ -4,6 +4,7 @@
@@ -21,6 +31,8 @@
  #mesondefine ENABLE_DESKTOP
  #mesondefine ENABLE_PACKAGEKIT
  #mesondefine LOCALEDIR
+diff --git a/meson.build b/meson.build
+index 18e645a..495101f 100644
 --- a/meson.build
 +++ b/meson.build
 @@ -30,6 +30,8 @@ exempi_ver = '>=2.1.0'
@@ -45,6 +57,8 @@
  tracker_sparql = dependency ('tracker-sparql-2.0', required: false)
  if not tracker_sparql.found()
      tracker_sparql = dependency ('tracker-sparql-1.0')
+diff --git a/meson_options.txt b/meson_options.txt
+index c934dd8..2e4d0af 100644
 --- a/meson_options.txt
 +++ b/meson_options.txt
 @@ -15,6 +15,10 @@ option ('enable-xmp',
@@ -58,30 +72,29 @@
  option ('enable-desktop',
          type: 'boolean',
          value: true)
+diff --git a/src/meson.build b/src/meson.build
+index cc08345..59703df 100644
 --- a/src/meson.build
 +++ b/src/meson.build
-@@ -254,6 +254,10 @@ libnautilus_sources = [
-     'nautilus-file-undo-operations.h',
-     'nautilus-file-undo-manager.c',
-     'nautilus-file-undo-manager.h',
-+    'unity-quicklist-handler.c',
-+    'unity-quicklist-handler.h',
-+    'unity-bookmarks-handler.c',
-+    'unity-bookmarks-handler.h',
-     'nautilus-batch-rename-dialog.c',
-     'nautilus-batch-rename-dialog.h',
-     'nautilus-batch-rename-utilities.c',
-@@ -284,6 +288,10 @@ if get_option ('enable-selinux')
+@@ -285,6 +285,16 @@ if get_option ('enable-selinux')
      nautilus_deps += selinux
  endif
  
 +if get_option ('enable-unity')
 +    nautilus_deps += [unity, dbusmenu]
++    libnautilus_sources += [
++        'unity-quicklist-handler.c',
++        'unity-quicklist-handler.h',
++        'unity-bookmarks-handler.c',
++        'unity-bookmarks-handler.h'
++    ]
 +endif
 +
  if get_option ('enable-xmp')
      nautilus_deps += exempi
  endif
+diff --git a/src/nautilus-application.c b/src/nautilus-application.c
+index 98e6f35..ae19115 100644
 --- a/src/nautilus-application.c
 +++ b/src/nautilus-application.c
 @@ -54,6 +54,10 @@
@@ -95,7 +108,7 @@
  #include <sys/types.h>
  #include <sys/stat.h>
  #include <fcntl.h>
-@@ -1275,6 +1279,10 @@ nautilus_application_startup (GApplicati
+@@ -1301,6 +1305,10 @@ nautilus_application_startup (GApplication *app)
      nautilus_application_startup_common (self);
  
      nautilus_profile_end (NULL);
@@ -106,6 +119,8 @@
  }
  
  static gboolean
+diff --git a/src/nautilus-toolbar.c b/src/nautilus-toolbar.c
+index a6d01b8..2b47275 100644
 --- a/src/nautilus-toolbar.c
 +++ b/src/nautilus-toolbar.c
 @@ -40,6 +40,10 @@
@@ -119,15 +134,17 @@
  #include <glib/gi18n.h>
  #include <math.h>
  
-@@ -99,6 +103,7 @@ struct _NautilusToolbar
+@@ -100,6 +104,9 @@ struct _NautilusToolbar
      NautilusWindowSlot *active_slot;
      GBinding *icon_binding;
      GBinding *view_widget_binding;
++#if HAVE_UNITY
 +    UnityLauncherEntry *ulauncher;
++#endif
  };
  
  enum
-@@ -388,6 +393,9 @@ on_remove_finished_operations_timeout (N
+@@ -389,6 +396,9 @@ on_remove_finished_operations_timeout (NautilusToolbar *self)
      {
          gtk_revealer_set_reveal_child (GTK_REVEALER (self->operations_revealer),
                                         FALSE);
@@ -137,7 +154,7 @@
      }
      else
      {
-@@ -574,6 +582,10 @@ update_operations (NautilusToolbar *self
+@@ -575,6 +585,10 @@ update_operations (NautilusToolbar *self)
                                         TRUE);
          gtk_widget_queue_draw (self->operations_icon);
  
@@ -148,7 +165,7 @@
          /* Show the popover at start to increase visibility.
           * Check whether the toolbar is visible or not before showing the
           * popover. This can happens if the window has the disables-chrome
-@@ -741,6 +753,10 @@ on_operations_icon_draw (GtkWidget
+@@ -742,6 +756,10 @@ on_operations_icon_draw (GtkWidget       *widget,
      }
  
  
@@ -159,7 +176,7 @@
      width = gtk_widget_get_allocated_width (widget);
      height = gtk_widget_get_allocated_height (widget);
  
-@@ -895,6 +911,9 @@ nautilus_toolbar_init (NautilusToolbar *
+@@ -943,6 +961,9 @@ nautilus_toolbar_init (NautilusToolbar *self)
                         self->location_entry);
  
      self->progress_manager = nautilus_progress_info_manager_dup_singleton ();
@@ -169,6 +186,9 @@
      g_signal_connect (self->progress_manager, "new-progress-info",
                        G_CALLBACK (on_new_progress_info), self);
      g_signal_connect (self->progress_manager, "has-viewers-changed",
+diff --git a/src/unity-bookmarks-handler.c b/src/unity-bookmarks-handler.c
+new file mode 100644
+index 0000000..5c1a234
 --- /dev/null
 +++ b/src/unity-bookmarks-handler.c
 @@ -0,0 +1,147 @@
@@ -319,6 +339,9 @@
 +    g_signal_connect (bookmarks, "changed",
 +                      G_CALLBACK (unity_bookmarks_handler_refresh_bookmarks), 0);
 +}
+diff --git a/src/unity-bookmarks-handler.h b/src/unity-bookmarks-handler.h
+new file mode 100644
+index 0000000..a887648
 --- /dev/null
 +++ b/src/unity-bookmarks-handler.h
 @@ -0,0 +1,31 @@
@@ -353,6 +376,9 @@
 +void unity_bookmarks_handler_initialize (void);
 +
 +#endif /* __UNITY_BOOKMARKS_HANDLER_H__*/
+diff --git a/src/unity-quicklist-handler.c b/src/unity-quicklist-handler.c
+new file mode 100644
+index 0000000..e11da55
 --- /dev/null
 +++ b/src/unity-quicklist-handler.c
 @@ -0,0 +1,163 @@
@@ -519,6 +545,9 @@
 +{
 +    return g_object_new (UNITY_TYPE_QUICKLIST_HANDLER, NULL);
 +}
+diff --git a/src/unity-quicklist-handler.h b/src/unity-quicklist-handler.h
+new file mode 100644
+index 0000000..8ffbb06
 --- /dev/null
 +++ b/src/unity-quicklist-handler.h
 @@ -0,0 +1,72 @@

=== removed file 'debian/patches/directory-update-recent-files-manager-on-rename-or-f.patch'
--- debian/patches/directory-update-recent-files-manager-on-rename-or-f.patch	2018-02-23 15:14:39 +0000
+++ debian/patches/directory-update-recent-files-manager-on-rename-or-f.patch	1970-01-01 00:00:00 +0000
@@ -1,208 +0,0 @@
-From 1a5a391ca1a4e6982e0fd973cb65b9e1275cec73 Mon Sep 17 00:00:00 2001
-From: =?UTF-8?q?Marco=20Trevisan=20=28Trevi=C3=B1o=29?= <[e-mail]>
-Date: Thu, 22 Feb 2018 05:20:36 +0100
-Subject: [PATCH 2/2] directory: update recent files manager on rename or file
- move
-
-When files have been moved or renamed nautilus should inform
-recent manager about this change for the files that
-are listed there.
----
- src/nautilus-directory-private.h |   4 ++
- src/nautilus-directory.c         | 110 +++++++++++++++++++++++++++++++++++++++
- src/nautilus-file.c              |   9 ++++
- 3 files changed, 123 insertions(+)
-
-diff --git a/src/nautilus-directory-private.h b/src/nautilus-directory-private.h
-index dae1b96ce..82283f69e 100644
---- a/src/nautilus-directory-private.h
-+++ b/src/nautilus-directory-private.h
-@@ -217,6 +217,10 @@ void               nautilus_directory_end_file_name_change            (NautilusD
- 								       GList                     *node);
- void               nautilus_directory_moved                           (const char                *from_uri,
- 								       const char                *to_uri);
-+void               nautilus_directory_recent_update                   (const char                *from_uri,
-+								       const char                *to_uri,
-+								       const char                *old_display_name,
-+								       const char                *new_display_name);
- /* Interface to the work queue. */
- 
- void               nautilus_directory_add_file_to_work_queue          (NautilusDirectory *directory,
-diff --git a/src/nautilus-directory.c b/src/nautilus-directory.c
-index ad3bb03db..b2b52752b 100644
---- a/src/nautilus-directory.c
-+++ b/src/nautilus-directory.c
-@@ -1549,6 +1549,8 @@ nautilus_directory_notify_files_moved (GList *file_pairs)
-         pair = p->data;
-         from_location = pair->from;
-         to_location = pair->to;
-+        g_autofree char *from_uri = g_file_get_uri (from_location);
-+        g_autofree char *to_uri = g_file_get_uri (to_location);
- 
-         /* Handle overwriting a file. */
-         file = nautilus_file_get_existing (to_location);
-@@ -1626,6 +1628,8 @@ nautilus_directory_notify_files_moved (GList *file_pairs)
-             /* Unref each file once to balance out nautilus_file_get_by_uri. */
-             unref_list = g_list_prepend (unref_list, file);
-         }
-+
-+        nautilus_directory_recent_update (from_uri, to_uri, NULL, NULL);
-     }
- 
-     /* Now send out the changed and added signals for existing file objects. */
-@@ -1710,6 +1714,112 @@ nautilus_directory_schedule_position_set (GList *position_setting_list)
-     }
- }
- 
-+void
-+nautilus_directory_recent_update (const char   *old_uri,
-+                                  const char   *new_uri,
-+                                  const char   *old_display_name,
-+                                  const char   *new_dispaly_name)
-+{
-+    GtkRecentManager *recent_manager = gtk_recent_manager_get_default ();
-+    NautilusFile *file;
-+    NautilusFile *existing_file;
-+
-+    if (!new_uri || !old_uri)
-+        return;
-+
-+    existing_file = nautilus_file_get_existing_by_uri (new_uri);
-+
-+    if (existing_file)
-+        file = g_object_ref (existing_file);
-+    else
-+        file = nautilus_file_get_by_uri (new_uri);
-+
-+    if (nautilus_file_is_directory (file))
-+    {
-+        GList *recent_items, *l;
-+
-+        recent_items = gtk_recent_manager_get_items (recent_manager);
-+
-+        for (l = recent_items; l; l = l->next)
-+        {
-+            GtkRecentInfo *info = l->data;
-+            const char *item_uri = gtk_recent_info_get_uri (info);
-+
-+            if (g_str_has_prefix (item_uri, old_uri))
-+            {
-+                const char *relative_path = item_uri + strlen (old_uri);
-+                g_autofree char *new_item_uri = NULL;
-+
-+                new_item_uri = g_build_filename (new_uri, relative_path, NULL);
-+
-+                gtk_recent_manager_move_item (recent_manager,
-+                                              item_uri, new_item_uri, NULL);
-+            }
-+        }
-+
-+        g_list_free_full (recent_items, (GDestroyNotify) gtk_recent_info_unref);
-+    }
-+    else
-+    {
-+        GtkRecentInfo *old_recent =
-+            gtk_recent_manager_lookup_item (recent_manager, old_uri, NULL);
-+
-+        if (old_recent)
-+        {
-+            gboolean recreated = FALSE;
-+
-+            if ((new_dispaly_name != NULL && old_display_name == NULL) ||
-+                (g_strcmp0 (old_display_name, new_dispaly_name) != 0 &&
-+                 g_strcmp0 (old_display_name,
-+                            gtk_recent_info_get_display_name (old_recent)) == 0))
-+            {
-+                /* If old display name, matches the one in the recent file
-+                 * We can't just move it, but we need to recreate the
-+                 * GtkRecentInfo
-+                 */
-+                GtkRecentData recent_data = {
-+                    .display_name = (char *) new_dispaly_name,
-+                    .description = (char *) gtk_recent_info_get_description (old_recent),
-+                    .mime_type = (char *) gtk_recent_info_get_mime_type (old_recent),
-+                    .app_name = gtk_recent_info_last_application (old_recent),
-+                    .groups = gtk_recent_info_get_groups (old_recent, NULL),
-+                    .is_private = gtk_recent_info_get_private_hint (old_recent),
-+                };
-+
-+                if (recent_data.app_name)
-+                {
-+                    gtk_recent_info_get_application_info (old_recent,
-+                                                          recent_data.app_name,
-+                                                          (const char **)
-+                                                          &(recent_data.app_exec),
-+                                                          NULL, NULL);
-+                }
-+
-+                if (gtk_recent_manager_add_full (recent_manager,
-+                                                 new_uri,
-+                                                 &recent_data))
-+                {
-+                    recreated = gtk_recent_manager_remove_item (recent_manager,
-+                                                                old_uri,
-+                                                                NULL);
-+                }
-+            }
-+
-+            if (!recreated)
-+            {
-+                gtk_recent_manager_move_item (recent_manager,
-+                                              old_uri, new_uri, NULL);
-+            }
-+        }
-+        else
-+        {
-+            gtk_recent_manager_remove_item (recent_manager, old_uri, NULL);
-+        }
-+    }
-+
-+    g_object_unref (file);
-+}
-+
- gboolean
- nautilus_directory_contains_file (NautilusDirectory *directory,
-                                   NautilusFile      *file)
-diff --git a/src/nautilus-file.c b/src/nautilus-file.c
-index c8f918969..7d4e85ee2 100644
---- a/src/nautilus-file.c
-+++ b/src/nautilus-file.c
-@@ -1957,6 +1957,8 @@ rename_get_info_callback (GObject      *source_object,
-     NautilusFile *existing_file;
-     char *old_uri;
-     char *new_uri;
-+    char *new_display_name;
-+    char *old_display_name;
-     const char *new_name;
-     GFileInfo *new_info;
-     GError *error;
-@@ -1983,10 +1985,12 @@ rename_get_info_callback (GObject      *source_object,
-         }
- 
-         old_uri = nautilus_file_get_uri (op->file);
-+        old_display_name = nautilus_file_get_display_name (op->file);
- 
-         update_info_and_name (op->file, new_info);
- 
-         new_uri = nautilus_file_get_uri (op->file);
-+        new_display_name = nautilus_file_get_display_name (op->file);
- 
-        /* Send event to Zeitgeist */
-        ZeitgeistLog *log = zeitgeist_log_get_default ();
-@@ -2011,8 +2015,13 @@ rename_get_info_callback (GObject      *source_object,
-         g_free (origin);
- 
-         nautilus_directory_moved (old_uri, new_uri);
-+        nautilus_directory_recent_update (old_uri, new_uri,
-+                                          old_display_name, new_display_name);
-+
-         g_free (new_uri);
-         g_free (old_uri);
-+        g_free (new_display_name);
-+        g_free (old_display_name);
- 
-         /* the rename could have affected the display name if e.g.
-          * we're in a vfolder where the name comes from a desktop file
--- 
-2.15.1
-

=== removed file 'debian/patches/search-engine-add-a-recent-search-engine-listing-Gtk.patch'
--- debian/patches/search-engine-add-a-recent-search-engine-listing-Gtk.patch	2018-03-02 17:39:58 +0000
+++ debian/patches/search-engine-add-a-recent-search-engine-listing-Gtk.patch	1970-01-01 00:00:00 +0000
@@ -1,429 +0,0 @@
-From 3f4cb4ada813d115a271138b8ae6c16132732446 Mon Sep 17 00:00:00 2001
-From: =?UTF-8?q?Marco=20Trevisan=20=28Trevi=C3=B1o=29?= <[e-mail]>
-Date: Wed, 21 Feb 2018 17:05:51 +0100
-Subject: [PATCH 1/2] search-engine: add a recent-search-engine listing
- GtkRecentManager stuff
-
-Using GtkRecent items as search engine source in nautilus
----
- src/meson.build                     |   2 +
- src/nautilus-search-engine-recent.c | 283 ++++++++++++++++++++++++++++++++++++
- src/nautilus-search-engine-recent.h |  37 +++++
- src/nautilus-search-engine.c        |  11 ++
- 4 files changed, 333 insertions(+)
- create mode 100644 src/nautilus-search-engine-recent.c
- create mode 100644 src/nautilus-search-engine-recent.h
-
-diff --git a/src/meson.build b/src/meson.build
-index 0c0833ee2..91ad1f704 100644
---- a/src/meson.build
-+++ b/src/meson.build
-@@ -228,6 +228,8 @@ libnautilus_sources = [
-     'nautilus-search-engine.h',
-     'nautilus-search-engine-model.c',
-     'nautilus-search-engine-model.h',
-+    'nautilus-search-engine-recent.c',
-+    'nautilus-search-engine-recent.h',
-     'nautilus-search-engine-simple.c',
-     'nautilus-search-engine-simple.h',
-     'nautilus-search-hit.c',
-diff --git a/src/nautilus-search-engine-recent.c b/src/nautilus-search-engine-recent.c
-new file mode 100644
-index 000000000..517e9b705
---- /dev/null
-+++ b/src/nautilus-search-engine-recent.c
-@@ -0,0 +1,284 @@
-+/*
-+ * Copyright (C) 2018 Canonical Ltd
-+ *
-+ * Nautilus is free software; you can redistribute it and/or
-+ * modify it under the terms of the GNU General Public License as
-+ * published by the Free Software Foundation; either version 2 of the
-+ * License, or (at your option) any later version.
-+ *
-+ * Nautilus is distributed in the hope that it will be useful,
-+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
-+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-+ * General Public License for more details.
-+ *
-+ * You should have received a copy of the GNU General Public
-+ * License along with this program; see the file COPYING.  If not,
-+ * see <http://www.gnu.org/licenses/>.
-+ *
-+ * Author: Marco Trevisan <[e-mail]>
-+ *
-+ */
-+
-+#include <config.h>
-+#include "nautilus-search-hit.h"
-+#include "nautilus-search-provider.h"
-+#include "nautilus-search-engine-recent.h"
-+#include "nautilus-ui-utilities.h"
-+#define DEBUG_FLAG NAUTILUS_DEBUG_SEARCH
-+#include "nautilus-debug.h"
-+
-+#include <string.h>
-+#include <glib.h>
-+#include <gio/gio.h>
-+
-+struct _NautilusSearchEngineRecent
-+{
-+    GObject parent_instance;
-+
-+    NautilusQuery *query;
-+    GCancellable *cancellable;
-+    GtkRecentManager *recent_manager;
-+};
-+
-+static void nautilus_search_provider_init (NautilusSearchProviderInterface *iface);
-+
-+G_DEFINE_TYPE_WITH_CODE (NautilusSearchEngineRecent,
-+                         nautilus_search_engine_recent,
-+                         G_TYPE_OBJECT,
-+                         G_IMPLEMENT_INTERFACE (NAUTILUS_TYPE_SEARCH_PROVIDER,
-+                                                nautilus_search_provider_init))
-+
-+enum
-+{
-+  PROP_0,
-+  PROP_RUNNING,
-+  LAST_PROP
-+};
-+
-+
-+NautilusSearchEngineRecent *
-+nautilus_search_engine_recent_new (void)
-+{
-+    return g_object_new (NAUTILUS_TYPE_SEARCH_ENGINE_RECENT, NULL);
-+}
-+
-+static void
-+nautilus_search_engine_recent_finalize (GObject *object)
-+{
-+    NautilusSearchEngineRecent *self = NAUTILUS_SEARCH_ENGINE_RECENT (object);
-+
-+    if (self->cancellable)
-+        g_cancellable_cancel (self->cancellable);
-+
-+    g_clear_object (&self->query);
-+    g_clear_object (&self->cancellable);
-+
-+    G_OBJECT_CLASS (nautilus_search_engine_recent_parent_class)->finalize (object);
-+}
-+
-+typedef struct
-+{
-+    NautilusSearchEngineRecent *recent;
-+    GList *hits;
-+} SearchHitsData;
-+
-+
-+static gboolean
-+search_thread_add_hits_idle (gpointer user_data)
-+{
-+    SearchHitsData *search_hits = user_data;
-+    NautilusSearchEngineRecent *self = search_hits->recent;
-+    NautilusSearchProvider *provider = NAUTILUS_SEARCH_PROVIDER (self);
-+
-+    if (!g_cancellable_is_cancelled (self->cancellable))
-+    {
-+        nautilus_search_provider_hits_added (provider, search_hits->hits);
-+        DEBUG ("Recent engine add hits");
-+    }
-+
-+    g_list_free_full (search_hits->hits, g_object_unref);
-+    g_object_unref (self->query);
-+    g_clear_object (&self->cancellable);
-+    g_object_unref (self);
-+    g_free (search_hits);
-+
-+    nautilus_search_provider_finished (provider,
-+                                       NAUTILUS_SEARCH_PROVIDER_STATUS_NORMAL);
-+    g_object_notify (G_OBJECT (provider), "running");
-+
-+    return FALSE;
-+}
-+
-+static gpointer
-+recent_thread_func (gpointer user_data)
-+{
-+    NautilusSearchEngineRecent *self = NAUTILUS_SEARCH_ENGINE_RECENT (user_data);
-+    SearchHitsData *search_hits;
-+    GList *recent_items, *hits, *l;
-+
-+    g_return_val_if_fail (self->query, NULL);
-+
-+    hits = NULL;
-+    recent_items = gtk_recent_manager_get_items (self->recent_manager);
-+
-+    for (l = recent_items; l; l = l->next)
-+    {
-+        GtkRecentInfo *info = l->data;
-+        const gchar *uri = gtk_recent_info_get_uri (info);
-+        const gchar *name;
-+        gdouble rank;
-+
-+        if (gtk_recent_info_is_local (info))
-+        {
-+            g_autofree gchar *path = g_filename_from_uri (uri, NULL, NULL);
-+
-+            if (!path || !g_file_test (path, G_FILE_TEST_EXISTS))
-+                continue;
-+        }
-+
-+        if (g_cancellable_is_cancelled (self->cancellable))
-+            break;
-+
-+        name = gtk_recent_info_get_display_name (info);
-+        rank = nautilus_query_matches_string (self->query, name);
-+
-+        if (rank <= 0)
-+        {
-+            name = gtk_recent_info_get_short_name (info);
-+            rank = nautilus_query_matches_string (self->query, name);
-+        }
-+
-+        if (rank > 0)
-+        {
-+            NautilusSearchHit *hit;
-+            time_t modified, visited;
-+            g_autoptr (GDateTime) gmodified = NULL;
-+            g_autoptr (GDateTime) gvisited = NULL;
-+
-+            modified = gtk_recent_info_get_modified (info);
-+            visited = gtk_recent_info_get_visited (info);
-+
-+            gmodified = g_date_time_new_from_unix_local (modified);
-+            gvisited = g_date_time_new_from_unix_local (visited);
-+
-+            hit = nautilus_search_hit_new (uri);
-+            nautilus_search_hit_set_fts_rank (hit, rank);
-+            nautilus_search_hit_set_modification_time (hit, gmodified);
-+            nautilus_search_hit_set_access_time (hit, gvisited);
-+
-+            hits = g_list_prepend (hits, hit);
-+        }
-+    }
-+
-+    search_hits = g_new0 (SearchHitsData, 1);
-+    search_hits->recent = self;
-+    search_hits->hits = hits;
-+
-+    g_idle_add (search_thread_add_hits_idle, search_hits);
-+
-+    g_list_free_full (recent_items, (GDestroyNotify) gtk_recent_info_unref);
-+
-+    return NULL;
-+}
-+
-+static void
-+nautilus_search_engine_recent_start (NautilusSearchProvider *provider)
-+{
-+    NautilusSearchEngineRecent *self = NAUTILUS_SEARCH_ENGINE_RECENT (provider);
-+    GThread *thread;
-+
-+    g_return_if_fail (self->query);
-+    g_return_if_fail (self->cancellable == NULL);
-+
-+    g_object_ref (self);
-+    g_object_ref (self->query);
-+    self->cancellable = g_cancellable_new ();
-+
-+    thread = g_thread_new ("nautilus-search-recent", recent_thread_func, self);
-+    g_object_notify (G_OBJECT (provider), "running");
-+
-+    g_thread_unref (thread);
-+}
-+
-+static void
-+nautilus_search_engine_recent_stop (NautilusSearchProvider *provider)
-+{
-+    NautilusSearchEngineRecent *self = NAUTILUS_SEARCH_ENGINE_RECENT (provider);
-+
-+    if (self->cancellable != NULL)
-+    {
-+        DEBUG ("Recent engine stop");
-+        g_cancellable_cancel (self->cancellable);
-+        g_clear_object (&self->cancellable);
-+
-+        g_object_notify (G_OBJECT (provider), "running");
-+    }
-+}
-+
-+static void
-+nautilus_search_engine_recent_set_query (NautilusSearchProvider *provider,
-+                                         NautilusQuery          *query)
-+{
-+    NautilusSearchEngineRecent *self = NAUTILUS_SEARCH_ENGINE_RECENT (provider);
-+
-+    g_clear_object (&self->query);
-+    self->query = g_object_ref (query);
-+}
-+
-+static gboolean
-+nautilus_search_engine_recent_is_running (NautilusSearchProvider *provider)
-+{
-+    NautilusSearchEngineRecent *self = NAUTILUS_SEARCH_ENGINE_RECENT (provider);
-+
-+    return self->cancellable != NULL &&
-+           !g_cancellable_is_cancelled (self->cancellable);
-+}
-+
-+static void
-+nautilus_search_engine_recent_get_property (GObject    *object,
-+                                            guint       prop_id,
-+                                            GValue     *value,
-+                                            GParamSpec *pspec)
-+{
-+    NautilusSearchProvider *provider = NAUTILUS_SEARCH_PROVIDER (object);
-+
-+    switch (prop_id)
-+    {
-+        case PROP_RUNNING:
-+        {
-+            gboolean running;
-+            running = nautilus_search_engine_recent_is_running (provider);
-+            g_value_set_boolean (value, running);
-+        }
-+        break;
-+
-+        default:
-+            G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
-+    }
-+}
-+
-+static void
-+nautilus_search_provider_init (NautilusSearchProviderInterface *iface)
-+{
-+    iface->set_query = nautilus_search_engine_recent_set_query;
-+    iface->start = nautilus_search_engine_recent_start;
-+    iface->stop = nautilus_search_engine_recent_stop;
-+    iface->is_running = nautilus_search_engine_recent_is_running;
-+}
-+
-+static void
-+nautilus_search_engine_recent_class_init (NautilusSearchEngineRecentClass *klass)
-+{
-+    GObjectClass *object_class = G_OBJECT_CLASS (klass);
-+
-+    object_class->finalize = nautilus_search_engine_recent_finalize;
-+    object_class->get_property = nautilus_search_engine_recent_get_property;
-+
-+    g_object_class_override_property (object_class, PROP_RUNNING, "running");
-+}
-+
-+static void
-+nautilus_search_engine_recent_init (NautilusSearchEngineRecent *self)
-+{
-+    self->recent_manager = gtk_recent_manager_get_default ();
-+}
-diff --git a/src/nautilus-search-engine-recent.h b/src/nautilus-search-engine-recent.h
-new file mode 100644
-index 000000000..fc225f736
---- /dev/null
-+++ b/src/nautilus-search-engine-recent.h
-@@ -0,0 +1,37 @@
-+/*
-+ * Copyright (C) 2018 Canonical Ltd
-+ *
-+ * Nautilus is free software; you can redistribute it and/or
-+ * modify it under the terms of the GNU General Public License as
-+ * published by the Free Software Foundation; either version 2 of the
-+ * License, or (at your option) any later version.
-+ *
-+ * Nautilus is distributed in the hope that it will be useful,
-+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
-+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-+ * General Public License for more details.
-+ *
-+ * You should have received a copy of the GNU General Public
-+ * License along with this program; see the file COPYING.  If not,
-+ * see <http://www.gnu.org/licenses/>.
-+ *
-+ * Author: Marco Trevisan <[e-mail]>
-+ *
-+ */
-+
-+#ifndef __NAUTILUS_SEARCH_ENGINE_RECENT_H__
-+#define __NAUTILUS_SEARCH_ENGINE_RECENT_H__
-+
-+#include <glib-object.h>
-+
-+G_BEGIN_DECLS
-+
-+#define NAUTILUS_TYPE_SEARCH_ENGINE_RECENT (nautilus_search_engine_recent_get_type ())
-+
-+G_DECLARE_FINAL_TYPE (NautilusSearchEngineRecent, nautilus_search_engine_recent, NAUTILUS, SEARCH_ENGINE_RECENT, GObject);
-+
-+NautilusSearchEngineRecent *nautilus_search_engine_recent_new (void);
-+
-+G_END_DECLS
-+
-+#endif /* __NAUTILUS_SEARCH_ENGINE_RECENT_H__ */
-diff --git a/src/nautilus-search-engine.c b/src/nautilus-search-engine.c
-index 209bd4f80..aef91b702 100644
---- a/src/nautilus-search-engine.c
-+++ b/src/nautilus-search-engine.c
-@@ -24,6 +24,7 @@
- #include <glib/gi18n.h>
- #include "nautilus-search-provider.h"
- #include "nautilus-search-engine.h"
-+#include "nautilus-search-engine-recent.h"
- #include "nautilus-search-engine-simple.h"
- #include "nautilus-search-engine-model.h"
- #define DEBUG_FLAG NAUTILUS_DEBUG_SEARCH
-@@ -33,6 +34,7 @@
- typedef struct
- {
-     NautilusSearchEngineTracker *tracker;
-+    NautilusSearchEngineRecent *recent;
-     NautilusSearchEngineSimple *simple;
-     NautilusSearchEngineModel *model;
- 
-@@ -74,6 +76,7 @@ nautilus_search_engine_set_query (NautilusSearchProvider *provider,
-     priv = nautilus_search_engine_get_instance_private (engine);
- 
-     nautilus_search_provider_set_query (NAUTILUS_SEARCH_PROVIDER (priv->tracker), query);
-+    nautilus_search_provider_set_query (NAUTILUS_SEARCH_PROVIDER (priv->recent), query);
-     nautilus_search_provider_set_query (NAUTILUS_SEARCH_PROVIDER (priv->model), query);
-     nautilus_search_provider_set_query (NAUTILUS_SEARCH_PROVIDER (priv->simple), query);
- }
-@@ -98,6 +101,9 @@ search_engine_start_real (NautilusSearchEngine *engine)
-     nautilus_search_provider_start (NAUTILUS_SEARCH_PROVIDER (priv->tracker));
-     priv->providers_running++;
- 
-+    priv->providers_running++;
-+    nautilus_search_provider_start (NAUTILUS_SEARCH_PROVIDER (priv->recent));
-+
-     if (nautilus_search_engine_model_get_model (priv->model))
-     {
-         nautilus_search_provider_start (NAUTILUS_SEARCH_PROVIDER (priv->model));
-@@ -159,6 +165,7 @@ nautilus_search_engine_stop (NautilusSearchProvider *provider)
-     DEBUG ("Search engine stop");
- 
-     nautilus_search_provider_stop (NAUTILUS_SEARCH_PROVIDER (priv->tracker));
-+    nautilus_search_provider_stop (NAUTILUS_SEARCH_PROVIDER (priv->recent));
-     nautilus_search_provider_stop (NAUTILUS_SEARCH_PROVIDER (priv->model));
-     nautilus_search_provider_stop (NAUTILUS_SEARCH_PROVIDER (priv->simple));
- 
-@@ -334,6 +341,7 @@ nautilus_search_engine_finalize (GObject *object)
-     g_hash_table_destroy (priv->uris);
- 
-     g_clear_object (&priv->tracker);
-+    g_clear_object (&priv->recent);
-     g_clear_object (&priv->model);
-     g_clear_object (&priv->simple);
- 
-@@ -395,6 +403,9 @@ nautilus_search_engine_init (NautilusSearchEngine *engine)
- 
-     priv->simple = nautilus_search_engine_simple_new ();
-     connect_provider_signals (engine, NAUTILUS_SEARCH_PROVIDER (priv->simple));
-+
-+    priv->recent = nautilus_search_engine_recent_new ();
-+    connect_provider_signals (engine, NAUTILUS_SEARCH_PROVIDER (priv->recent));
- }
- 
- NautilusSearchEngine *
--- 
-2.15.1
-

=== modified file 'debian/patches/series'
--- debian/patches/series	2018-03-24 20:06:53 +0000
+++ debian/patches/series	2018-04-12 23:13:34 +0000
@@ -14,5 +14,7 @@
 0001-Respect-gtk-dialogs-use-header-for-all-dialogs.patch
 #Needs updating
 #16_unity_new_documents.patch
-search-engine-add-a-recent-search-engine-listing-Gtk.patch
-directory-update-recent-files-manager-on-rename-or-f.patch
+0015-tracker-search-engine-don-t-start-it-if-not-availabl.patch
+0016-search-engine-add-a-recent-search-engine-listing-Gtk.patch
+0017-recent-add-function-to-update-manager-on-file-rename.patch
+0018-search-engine-add-locate-based-search-engine.patch