Merge ~3v1n0/ubuntu/+source/gnome-calculator:ubuntu/bionic-xubuntu-cancel-search into ~ubuntu-desktop/ubuntu/+source/gnome-calculator:ubuntu/bionic

[Marco Trevisan (Treviño)]

diff --git a/debian/changelog b/debian/changelog
index 44dd584..9da064b 100644
--- a/debian/changelog
+++ b/debian/changelog
@@ -1,3 +1,31 @@
+gnome-calculator (1:3.28.2-1~ubuntu18.04.3) UNRELEASED; urgency=medium
+
+  * d/p/search-provider-stop-normalizing-the-equation-twice.patch:
+    - Don't normalize multiple times an equation, fixing issues with decimal
+      numbers computations (fixes a regression introduced with previous
+      patch set in order to fix LP: #1756826)
+  * d/p/Use-GLib.List.deep_copy-to-fix-type-argument-mismatch.patch:
+    - Fix a build issue when compiling with vala 0.40.17 (LP: #1857005)
+
+ -- Marco Trevisan (Treviño) <[e-mail]>  Wed, 18 Dec 2019 21:10:54 +0100
+
+gnome-calculator (1:3.28.2-1~ubuntu18.04.2) bionic; urgency=medium
+
+  * d/p/search-provider-Use-async-calls-cancel-search-on-inactivi.patch,
+    d/p/search-provider-renew-inactivity-timeout-at-each-calculat.patch,
+    d/p/search-provider-Use-lower-inactivity-timeout.patch,
+    d/p/search-provider-simplify-solve_subprocess.patch,
+    d/p/search-provider-cache-equations-avoiding-spawning-calcula.patch,
+    d/p/search-provider-cancel-the-current-process-on-new-calcula.patch,
+    d/p/search-provider-cache-only-a-limited-number-of-equations.patch,
+    d/p/search-provider-Handle-errors-gracefully.patch,
+    d/p/ubuntu/search-provider-Cancel-operations-on-XUbuntuCancel.patch:
+    - Make search provider async and support XUbuntuCancel method to
+      stop expensive operations that might lead to an unresponsive
+      process (LP: #1756826)
+ 
+ -- Marco Trevisan (Treviño) <[e-mail]>  Thu, 08 Nov 2018 01:34:07 -0500
+
 gnome-calculator (1:3.28.2-1~ubuntu18.04.1) bionic; urgency=medium
 
   * New upstream stable release (LP: #1790876)
diff --git a/debian/control b/debian/control
index cd4706c..0782192 100644
--- a/debian/control
+++ b/debian/control
@@ -5,7 +5,8 @@
 Source: gnome-calculator
 Section: math
 Priority: optional
-Maintainer: Debian GNOME Maintainers <[e-mail]>
+Maintainer: Ubuntu Developers <[e-mail]>
+XSBC-Original-Maintainer: Debian GNOME Maintainers <[e-mail]>
 Uploaders: Jeremy Bicha <[e-mail]>, Laurent Bigonville <[e-mail]>, Michael Biebl <[e-mail]>
 Build-Depends: appstream-util,
                debhelper (>= 11.1.3),
diff --git a/debian/control.in b/debian/control.in
index b5194ee..d9e0327 100644
--- a/debian/control.in
+++ b/debian/control.in
@@ -1,7 +1,8 @@
 Source: gnome-calculator
 Section: math
 Priority: optional
-Maintainer: Debian GNOME Maintainers <[e-mail]>
+Maintainer: Ubuntu Developers <[e-mail]>
+XSBC-Original-Maintainer: Debian GNOME Maintainers <[e-mail]>
 Uploaders: @GNOME_TEAM@
 Build-Depends: appstream-util,
                debhelper (>= 11.1.3),
diff --git a/debian/patches/Use-GLib.List.deep_copy-to-fix-type-argument-mismatch.patch b/debian/patches/Use-GLib.List.deep_copy-to-fix-type-argument-mismatch.patch
new file mode 100644
index 0000000..0810e88
--- /dev/null
+++ b/debian/patches/Use-GLib.List.deep_copy-to-fix-type-argument-mismatch.patch
@@ -0,0 +1,25 @@
+From: Rico Tzschichholz <[e-mail]>
+Date: Sun, 4 Nov 2018 19:41:23 +0100
+Subject: Use GLib.List.deep_copy() to fix type-argument mismatch
+
+Origin: https://gitlab.gnome.org/GNOME/gnome-calculator/commit/d89466a7
+Bug-Ubuntu: https://bugs.launchpad.net/ubuntu/+source/gnome-calculator/+bug/1857005
+Applied-Upstream: 3.31.2
+
+---
+ lib/equation-parser.vala | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+diff --git a/lib/equation-parser.vala b/lib/equation-parser.vala
+index 668e1cd..d16e5b1 100644
+--- a/lib/equation-parser.vala
++++ b/lib/equation-parser.vala
+@@ -76,7 +76,7 @@ public class ParseNode : Object
+     public ParseNode.WithList (Parser parser, List<LexerToken> token_list, uint precedence, Associativity associativity, string? value = null)
+     {
+         this.parser = parser;
+-        this.token_list = token_list.copy();
++        this.token_list = token_list.copy_deep((CopyFunc) Object.ref);
+         this.precedence = precedence;
+         this.associativity = associativity;
+         this.value = value;
diff --git a/debian/patches/search-provider-Handle-errors-gracefully.patch b/debian/patches/search-provider-Handle-errors-gracefully.patch
new file mode 100644
index 0000000..f78c54b
--- /dev/null
+++ b/debian/patches/search-provider-Handle-errors-gracefully.patch
@@ -0,0 +1,108 @@
+From: =?utf-8?b?Ik1hcmNvIFRyZXZpc2FuIChUcmV2acOxbyki?= <[e-mail]>
+Date: Wed, 5 Sep 2018 17:11:27 +0200
+Subject: search-provider: Handle errors gracefully
+
+Instead of exiting immediately if a spawn error occurred, inform our dbus
+client about it with a proper spawn error.
+
+As bonus, get rid of the compile warning.
+
+Bug-Ubuntu: https://bugs.launchpad.net/ubuntu/+source/gnome-calculator/+bug/1795399
+Forwarded: https://gitlab.gnome.org/GNOME/gnome-calculator/merge_requests/10
+Applied-Upstream: yes, 3.31.1
+---
+ search-provider/search-provider.vala | 24 +++++++++++++-----------
+ 1 file changed, 13 insertions(+), 11 deletions(-)
+
+diff --git a/search-provider/search-provider.vala b/search-provider/search-provider.vala
+index fc72128..a48c440 100644
+--- a/search-provider/search-provider.vala
++++ b/search-provider/search-provider.vala
+@@ -63,7 +63,7 @@ public class SearchProvider : Object
+         }
+         catch (Error e)
+         {
+-            error ("Failed to spawn Calculator: %s", e.message);
++            throw e;
+         }
+ 
+         if (cancellable == null)
+@@ -79,7 +79,7 @@ public class SearchProvider : Object
+         return subprocess;
+     }
+ 
+-    private async bool solve_equation (string equation)
++    private async bool solve_equation (string equation) throws DBusError
+     {
+         string? result;
+ 
+@@ -112,7 +112,8 @@ public class SearchProvider : Object
+         }
+         catch (SpawnError e)
+         {
+-            error ("Failed to spawn Calculator: %s", e.message);
++            critical ("Failed to spawn Calculator: %s", e.message);
++            throw new DBusError.SPAWN_FAILED (e.message);
+         }
+         catch (Error e)
+         {
+@@ -128,7 +129,7 @@ public class SearchProvider : Object
+         return true;
+     }
+ 
+-    private async string[] get_result_identifier (string[] terms)
++    private async string[] get_result_identifier (string[] terms) throws Error
+     {
+         /* We have at most one result: the search terms as one string */
+         var equation = terms_to_equation (terms);
+@@ -138,17 +139,17 @@ public class SearchProvider : Object
+             return new string[0];
+     }
+ 
+-    public async string[] get_initial_result_set (string[] terms)
++    public async string[] get_initial_result_set (string[] terms) throws Error
+     {
+         return yield get_result_identifier (terms);
+     }
+ 
+-    public async string[] get_subsearch_result_set (string[] previous_results, string[] terms)
++    public async string[] get_subsearch_result_set (string[] previous_results, string[] terms) throws Error
+     {
+         return yield get_result_identifier (terms);
+     }
+ 
+-    public async HashTable<string, Variant>[] get_result_metas (string[] results, GLib.BusName sender)
++    public async HashTable<string, Variant>[] get_result_metas (string[] results, GLib.BusName sender) throws Error
+         requires (results.length == 1)
+     {
+         string equation;
+@@ -171,7 +172,7 @@ public class SearchProvider : Object
+         return metadata;
+     }
+ 
+-    private static void spawn_and_display_equation (string[] terms)
++    private static void spawn_and_display_equation (string[] terms) throws Error
+     {
+         try
+         {
+@@ -180,16 +181,17 @@ public class SearchProvider : Object
+         }
+         catch (SpawnError e)
+         {
+-            error ("Failed to spawn Calculator: %s", e.message);
++            critical ("Failed to spawn Calculator: %s", e.message);
++            throw new DBusError.SPAWN_FAILED (e.message);
+         }
+     }
+ 
+-    public void activate_result (string result, string[] terms, uint32 timestamp)
++    public void activate_result (string result, string[] terms, uint32 timestamp) throws Error
+     {
+         spawn_and_display_equation (terms);
+     }
+ 
+-    public void launch_search (string[] terms, uint32 timestamp)
++    public void launch_search (string[] terms, uint32 timestamp) throws Error
+     {
+         spawn_and_display_equation (terms);
+     }
diff --git a/debian/patches/search-provider-Use-async-calls-cancel-search-on-inactivi.patch b/debian/patches/search-provider-Use-async-calls-cancel-search-on-inactivi.patch
new file mode 100644
index 0000000..d8e38be
--- /dev/null
+++ b/debian/patches/search-provider-Use-async-calls-cancel-search-on-inactivi.patch
@@ -0,0 +1,233 @@
+From: =?utf-8?b?Ik1hcmNvIFRyZXZpc2FuIChUcmV2acOxbyki?= <[e-mail]>
+Date: Fri, 24 Aug 2018 06:57:03 +0200
+Subject: search-provider: Use async calls, cancel search on inactivity
+
+Move to async methods everywhere and factorize the `solve` calls to a single
+method that only uses Subprocess and that can be cancelled.
+
+As per this, if the the search-provider is trying to compute some complex
+operation, the daemon won't hang and once the applications' inactivity
+timeout is hit, any running instance of gnome-calculator will be killed and
+the daemon will return accordingly.
+
+This reduces the impact of an issue that can cause gnome-calculator to keep
+running forever if a complex computation is required (10!!!) from the shell,
+and won't ever be killed (see GNOME/gnome-shell#183).
+
+This is also a prerequisite for supporting the search Cancellation that is
+going to be available on next version of the Search provider protocol
+(as per GNOME/gnome-shell#436)
+
+Bug-Ubuntu: https://launchpad.net/bugs/1756826
+Bug-GNOME: https://gitlab.gnome.org/GNOME/gnome-shell/issues/183
+Forwarded: https://gitlab.gnome.org/GNOME/gnome-calculator/merge_requests/10
+Applied-Upstream: yes, 3.31.1
+---
+ search-provider/search-provider.vala | 126 +++++++++++++++++++++++++----------
+ 1 file changed, 89 insertions(+), 37 deletions(-)
+
+diff --git a/search-provider/search-provider.vala b/search-provider/search-provider.vala
+index 26c72af..659f73d 100644
+--- a/search-provider/search-provider.vala
++++ b/search-provider/search-provider.vala
+@@ -1,6 +1,7 @@
+ /* -*- Mode: vala; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+  *
+  * Copyright (C) 2014 Michael Catanzaro
++ * Copyright (C) 2018 Marco Trevisan
+  *
+  * 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 the Free Software
+@@ -12,17 +13,85 @@
+ [DBus (name = "org.gnome.Shell.SearchProvider2")]
+ public class SearchProvider : Object
+ {
++    private Cancellable cancellable = new Cancellable ();
++
++    ~SearchProvider ()
++    {
++        cancel ();
++    }
++
++    [DBus (visible = false)]
++    public void cancel ()
++    {
++        if (cancellable != null)
++        {
++            cancellable.cancel ();
++        }
++    }
++
+     private static string terms_to_equation (string[] terms)
+     {
+         return string.joinv (" ", terms);
+     }
+ 
+-    private static bool can_parse (string[] terms)
++    private async Subprocess solve_subprocess (string equation, bool return_solution = false, out string? solution_buf = null) throws Error
+     {
++        Subprocess subprocess;
++        string[] argv = {"gnome-calculator", "--solve"};
++        argv += equation;
++        argv += null;
++
++        debug (@"Trying to solve $(equation)");
++
+         try
+         {
+-            int exit_status;
++            // Eat output so that it doesn't wind up in the journal. It's
++            // expected that most searches are not valid calculator input.
++            var flags = SubprocessFlags.STDERR_PIPE;
++
++            if (return_solution)
++            {
++                flags |= SubprocessFlags.STDOUT_PIPE;
++            }
++
++            subprocess = new Subprocess.newv (argv, flags);
++        }
++        catch (Error e)
++        {
++            error ("Failed to spawn Calculator: %s", e.message);
++        }
++
++        try
++        {
++            string stderr_buf;
++
++            cancellable = new Cancellable ();
++            cancellable.cancelled.connect (() => {
++                subprocess.force_exit ();
++                cancellable = null;
++            });
++
++            yield subprocess.communicate_utf8_async (null, cancellable, out solution_buf, out stderr_buf);
++        }
++        catch (Error e)
++        {
++            if (e is IOError.CANCELLED)
++            {
++                throw e;
++            }
++            else
++            {
++                error ("Failed reading result: %s", e.message);
++            }
++        }
+ 
++        return subprocess;
++    }
++
++    private async bool can_parse (string[] terms)
++    {
++        try
++        {
+             var tsep_string = Posix.nl_langinfo (Posix.NLItem.THOUSEP);
+             if (tsep_string == null || tsep_string == "")
+                 tsep_string = " ";
+@@ -39,14 +108,8 @@ public class SearchProvider : Object
+                 return false;
+             }
+ 
+-            // Eat output so that it doesn't wind up in the journal. It's
+-            // expected that most searches are not valid calculator input.
+-            string stdout_buf;
+-            string stderr_buf;
+-            Process.spawn_command_line_sync (
+-                "gnome-calculator --solve " + Shell.quote (equation),
+-                out stdout_buf, out stderr_buf, out exit_status);
+-            Process.check_exit_status (exit_status);
++            var subprocess = yield solve_subprocess (equation);
++            yield subprocess.wait_check_async ();
+         }
+         catch (SpawnError e)
+         {
+@@ -60,54 +123,37 @@ public class SearchProvider : Object
+         return true;
+     }
+ 
+-    private static string[] get_result_identifier (string[] terms)
+-        ensures (result.length == 0 || result.length == 1)
++    private async string[] get_result_identifier (string[] terms)
+     {
+         /* We have at most one result: the search terms as one string */
+-        if (can_parse (terms))
++        if (yield can_parse (terms))
+             return { terms_to_equation (terms) };
+         else
+             return new string[0];
+     }
+ 
+-    public string[] get_initial_result_set (string[] terms)
++    public async string[] get_initial_result_set (string[] terms)
+     {
+-        return get_result_identifier (terms);
++        return yield get_result_identifier (terms);
+     }
+ 
+-    public string[] get_subsearch_result_set (string[] previous_results, string[] terms)
++    public async string[] get_subsearch_result_set (string[] previous_results, string[] terms)
+     {
+-        return get_result_identifier (terms);
++        return yield get_result_identifier (terms);
+     }
+ 
+-    public HashTable<string, Variant>[] get_result_metas (string[] results)
++    public async HashTable<string, Variant>[] get_result_metas (string[] results, GLib.BusName sender)
+         requires (results.length == 1)
+-        ensures (result.length == 1)
+     {
+-        Subprocess subprocess;
+         string stdout_buf;
+-        string stderr_buf;
+-
+-        string[] argv = {"gnome-calculator", "--solve"};
+-        argv += results[0];
+-        argv += null;
+-
+-        try
+-        {
+-            subprocess = new Subprocess.newv (argv, SubprocessFlags.STDOUT_PIPE | SubprocessFlags.STDERR_PIPE);
+-        }
+-        catch (Error e)
+-        {
+-            error ("Failed to spawn Calculator: %s", e.message);
+-        }
+ 
+         try
+         {
+-            subprocess.communicate_utf8 (null, null, out stdout_buf, out stderr_buf);
++            yield solve_subprocess (results[0], true, out stdout_buf);
+         }
+         catch (Error e)
+         {
+-            error ("Failed reading result: %s", e.message);
++            return new HashTable<string, Variant>[0];
+         }
+ 
+         var metadata = new HashTable<string, Variant>[1];
+@@ -155,9 +201,11 @@ public class SearchProviderApp : Application
+ 
+     public override bool dbus_register (DBusConnection connection, string object_path)
+     {
++        SearchProvider search_provider = new SearchProvider ();
++
+         try
+         {
+-            connection.register_object (object_path, new SearchProvider ());
++            connection.register_object (object_path, search_provider);
+         }
+         catch (IOError error)
+         {
+@@ -165,6 +213,10 @@ public class SearchProviderApp : Application
+             quit ();
+         }
+ 
++        shutdown.connect (() => {
++            search_provider.cancel ();
++        });
++
+         return true;
+     }
+ }
diff --git a/debian/patches/search-provider-Use-lower-inactivity-timeout.patch b/debian/patches/search-provider-Use-lower-inactivity-timeout.patch
new file mode 100644
index 0000000..5008fe5
--- /dev/null
+++ b/debian/patches/search-provider-Use-lower-inactivity-timeout.patch
@@ -0,0 +1,30 @@
+From: =?utf-8?b?Ik1hcmNvIFRyZXZpc2FuIChUcmV2acOxbyki?= <[e-mail]>
+Date: Fri, 24 Aug 2018 07:12:12 +0200
+Subject: search-provider: Use lower inactivity timeout
+
+Since we're renewing it at every call involving a process call, we can just
+set it to a lower value than the default dbus proxy timeout, so that the provider
+will return invalid values before that the timeout has been hit.
+
+Bug-Ubuntu: https://launchpad.net/bugs/1756826
+Bug-GNOME: https://gitlab.gnome.org/GNOME/gnome-shell/issues/183
+Forwarded: https://gitlab.gnome.org/GNOME/gnome-calculator/merge_requests/10
+Applied-Upstream: yes, 3.31.1
+---
+ search-provider/search-provider.vala | 3 ++-
+ 1 file changed, 2 insertions(+), 1 deletion(-)
+
+diff --git a/search-provider/search-provider.vala b/search-provider/search-provider.vala
+index 7e54fa6..9035c58 100644
+--- a/search-provider/search-provider.vala
++++ b/search-provider/search-provider.vala
+@@ -203,7 +203,8 @@ public class SearchProviderApp : Application
+     {
+         Object (application_id: "org.gnome.Calculator.SearchProvider",
+                 flags: ApplicationFlags.IS_SERVICE,
+-                inactivity_timeout: 60000);
++                inactivity_timeout: 20000);
++    }
+ 
+     public void renew_inactivity_timeout ()
+     {
diff --git a/debian/patches/search-provider-cache-equations-avoiding-spawning-calcula.patch b/debian/patches/search-provider-cache-equations-avoiding-spawning-calcula.patch
new file mode 100644
index 0000000..85d83ce
--- /dev/null
+++ b/debian/patches/search-provider-cache-equations-avoiding-spawning-calcula.patch
@@ -0,0 +1,171 @@
+From: =?utf-8?b?Ik1hcmNvIFRyZXZpc2FuIChUcmV2acOxbyki?= <[e-mail]>
+Date: Mon, 27 Aug 2018 18:45:34 +0200
+Subject: search-provider: cache equations avoiding spawning calculator twice
+
+Currently we spawn the calculator two times for each operation, one to check
+if the search provider is valid for such syntax, the other time to actually
+present the results. But since these results are just available at first
+call, we can just keep them around and return them if the shell requires them.
+
+Since the search provider deamon is kept alive for just few moments, there's
+no real need to cleanup the cache using a queue.
+
+In case of multiple async calls, reuse cancellable instead so that we can
+just kill all the related processes one time at once.
+
+Bug-Ubuntu: https://launchpad.net/bugs/1756826
+Bug-GNOME: https://gitlab.gnome.org/GNOME/gnome-shell/issues/183
+Forwarded: https://gitlab.gnome.org/GNOME/gnome-calculator/merge_requests/10
+Applied-Upstream: yes, 3.31.1
+---
+ search-provider/search-provider.vala | 79 ++++++++++++++++++++----------------
+ 1 file changed, 45 insertions(+), 34 deletions(-)
+
+diff --git a/search-provider/search-provider.vala b/search-provider/search-provider.vala
+index a3c57f7..af2779e 100644
+--- a/search-provider/search-provider.vala
++++ b/search-provider/search-provider.vala
+@@ -14,10 +14,13 @@
+ public class SearchProvider : Object
+ {
+     private unowned SearchProviderApp application;
+-    private Cancellable cancellable = new Cancellable ();
++    private Cancellable cancellable;
++
++    private HashTable<string, string> cached_equations;
+     public SearchProvider (SearchProviderApp app)
+     {
+         application = app;
++        cached_equations = new HashTable<string, string> (str_hash, str_equal);
+     }
+ 
+     ~SearchProvider ()
+@@ -29,9 +32,7 @@ public class SearchProvider : Object
+     public void cancel ()
+     {
+         if (cancellable != null)
+-        {
+             cancellable.cancel ();
+-        }
+     }
+ 
+     private static string terms_to_equation (string[] terms)
+@@ -60,7 +61,9 @@ public class SearchProvider : Object
+             error ("Failed to spawn Calculator: %s", e.message);
+         }
+ 
+-        cancellable = new Cancellable ();
++        if (cancellable == null)
++            cancellable = new Cancellable ();
++
+         cancellable.cancelled.connect (() => {
+             subprocess.force_exit ();
+             cancellable = null;
+@@ -71,29 +74,36 @@ public class SearchProvider : Object
+         return subprocess;
+     }
+ 
+-    private async bool can_parse (string[] terms)
++    private async bool solve_equation (string equation)
+     {
+-        try
+-        {
+-            var tsep_string = Posix.nl_langinfo (Posix.NLItem.THOUSEP);
+-            if (tsep_string == null || tsep_string == "")
+-                tsep_string = " ";
++        string? result;
+ 
+-            var decimal = Posix.nl_langinfo (Posix.NLItem.RADIXCHAR);
+-            if (decimal == null)
+-                decimal = "";
++        cancel();
+ 
+-            // "normalize" input to a format known to double.try_parse
+-            var equation = terms_to_equation (terms).replace (tsep_string, "").replace (decimal, ".");
++        var tsep_string = Posix.nl_langinfo (Posix.NLItem.THOUSEP);
++        if (tsep_string == null || tsep_string == "")
++        tsep_string = " ";
+ 
+-            cancel();
++        var decimal = Posix.nl_langinfo (Posix.NLItem.RADIXCHAR);
++        if (decimal == null)
++        decimal = "";
+ 
+-            // if the search is a plain number, don't process it
+-            if (double.try_parse (equation)) {
+-                return false;
+-            }
++        // "normalize" input to a format known to double.try_parse
++        var normalized_equation = equation.replace (tsep_string, "").replace (decimal, ".");
+ 
+-            (yield solve_subprocess (equation)).wait_check (cancellable);
++        // if the search is a plain number, don't process it
++        if (double.try_parse (normalized_equation)) {
++            return false;
++        }
++
++        if (cached_equations.lookup (equation) != null)
++            return true;
++
++        try
++        {
++            var subprocess = yield solve_subprocess (normalized_equation);
++            yield subprocess.communicate_utf8_async (null, cancellable, out result, null);
++            subprocess.wait_check (cancellable);
+         }
+         catch (SpawnError e)
+         {
+@@ -104,14 +114,17 @@ public class SearchProvider : Object
+             return false;
+         }
+ 
++        cached_equations.insert (equation, result.strip ());
++
+         return true;
+     }
+ 
+     private async string[] get_result_identifier (string[] terms)
+     {
+         /* We have at most one result: the search terms as one string */
+-        if (yield can_parse (terms))
+-            return { terms_to_equation (terms) };
++        var equation = terms_to_equation (terms);
++        if (yield solve_equation (equation))
++            return { equation };
+         else
+             return new string[0];
+     }
+@@ -129,24 +142,22 @@ public class SearchProvider : Object
+     public async HashTable<string, Variant>[] get_result_metas (string[] results, GLib.BusName sender)
+         requires (results.length == 1)
+     {
+-        string stdout_buf;
+-        string stderr_buf;
++        string equation;
++        string result;
+ 
+-        try
+-        {
+-            var subprocess = yield solve_subprocess (results[0]);
+-            yield subprocess.communicate_utf8_async (null, cancellable, out stdout_buf, out stderr_buf);
+-        }
+-        catch (Error e)
+-        {
++        equation = terms_to_equation (results);
++
++        if (!yield solve_equation (equation))
+             return new HashTable<string, Variant>[0];
+-        }
++
++        result = cached_equations.lookup (equation);
++        assert (result != null);
+ 
+         var metadata = new HashTable<string, Variant>[1];
+         metadata[0] = new HashTable<string, Variant>(str_hash, str_equal);
+         metadata[0].insert ("id", results[0]);
+         metadata[0].insert ("name", results[0] );
+-        metadata[0].insert ("description", " = " + stdout_buf.strip ());
++        metadata[0].insert ("description", @" = $result");
+ 
+         return metadata;
+     }
diff --git a/debian/patches/search-provider-cache-only-a-limited-number-of-equations.patch b/debian/patches/search-provider-cache-only-a-limited-number-of-equations.patch
new file mode 100644
index 0000000..651aa28
--- /dev/null
+++ b/debian/patches/search-provider-cache-only-a-limited-number-of-equations.patch
@@ -0,0 +1,45 @@
+From: =?utf-8?b?Ik1hcmNvIFRyZXZpc2FuIChUcmV2acOxbyki?= <[e-mail]>
+Date: Mon, 27 Aug 2018 18:56:09 +0200
+Subject: search-provider: cache only a limited number of equations
+
+Bug-Ubuntu: https://launchpad.net/bugs/1756826
+Bug-GNOME: https://gitlab.gnome.org/GNOME/gnome-shell/issues/183
+Forwarded: https://gitlab.gnome.org/GNOME/gnome-calculator/merge_requests/10
+Applied-Upstream: yes, 3.31.1
+---
+ search-provider/search-provider.vala | 9 +++++++++
+ 1 file changed, 9 insertions(+)
+
+diff --git a/search-provider/search-provider.vala b/search-provider/search-provider.vala
+index af2779e..fc72128 100644
+--- a/search-provider/search-provider.vala
++++ b/search-provider/search-provider.vala
+@@ -16,10 +16,15 @@ public class SearchProvider : Object
+     private unowned SearchProviderApp application;
+     private Cancellable cancellable;
+ 
++    private const int MAX_CACHED_OPERATIONS = 10;
++    private Queue<string> queued_equations;
+     private HashTable<string, string> cached_equations;
++
+     public SearchProvider (SearchProviderApp app)
+     {
+         application = app;
++
++        queued_equations = new Queue<string> ();
+         cached_equations = new HashTable<string, string> (str_hash, str_equal);
+     }
+ 
+@@ -114,8 +119,12 @@ public class SearchProvider : Object
+             return false;
+         }
+ 
++        queued_equations.push_tail (equation);
+         cached_equations.insert (equation, result.strip ());
+ 
++        if (queued_equations.length > MAX_CACHED_OPERATIONS)
++            cached_equations.remove (queued_equations.pop_head ());
++
+         return true;
+     }
+ 
diff --git a/debian/patches/search-provider-cancel-the-current-process-on-new-calcula.patch b/debian/patches/search-provider-cancel-the-current-process-on-new-calcula.patch
new file mode 100644
index 0000000..26435e2
--- /dev/null
+++ b/debian/patches/search-provider-cancel-the-current-process-on-new-calcula.patch
@@ -0,0 +1,30 @@
+From: =?utf-8?b?Ik1hcmNvIFRyZXZpc2FuIChUcmV2acOxbyki?= <[e-mail]>
+Date: Thu, 30 Aug 2018 18:47:16 +0200
+Subject: search-provider: cancel the current process on new calculation
+ request
+
+As there's just one shell running at time, there's no point of supporting
+parallel calls, we can just safely refer to the last equation as the only one
+we need to compute.
+
+Bug-Ubuntu: https://launchpad.net/bugs/1756826
+Bug-GNOME: https://gitlab.gnome.org/GNOME/gnome-shell/issues/183
+Forwarded: https://gitlab.gnome.org/GNOME/gnome-calculator/merge_requests/10
+Applied-Upstream: yes, 3.31.1
+---
+ search-provider/search-provider.vala | 2 ++
+ 1 file changed, 2 insertions(+)
+
+diff --git a/search-provider/search-provider.vala b/search-provider/search-provider.vala
+index df37b86..a3c57f7 100644
+--- a/search-provider/search-provider.vala
++++ b/search-provider/search-provider.vala
+@@ -86,6 +86,8 @@ public class SearchProvider : Object
+             // "normalize" input to a format known to double.try_parse
+             var equation = terms_to_equation (terms).replace (tsep_string, "").replace (decimal, ".");
+ 
++            cancel();
++
+             // if the search is a plain number, don't process it
+             if (double.try_parse (equation)) {
+                 return false;
diff --git a/debian/patches/search-provider-renew-inactivity-timeout-at-each-calculat.patch b/debian/patches/search-provider-renew-inactivity-timeout-at-each-calculat.patch
new file mode 100644
index 0000000..274aae1
--- /dev/null
+++ b/debian/patches/search-provider-renew-inactivity-timeout-at-each-calculat.patch
@@ -0,0 +1,61 @@
+From: =?utf-8?b?Ik1hcmNvIFRyZXZpc2FuIChUcmV2acOxbyki?= <[e-mail]>
+Date: Fri, 24 Aug 2018 07:10:17 +0200
+Subject: search-provider: renew inactivity timeout at each calculator run
+
+As per the async rewrite, now the daemon inactivity timeout might happen
+when another call has just been done, while we don't want this to be the case.
+
+So, everytime we do a subprocess call, let's renew the application timeout.
+
+Bug-Ubuntu: https://launchpad.net/bugs/1756826
+Bug-GNOME: https://gitlab.gnome.org/GNOME/gnome-shell/issues/183
+Forwarded: https://gitlab.gnome.org/GNOME/gnome-calculator/merge_requests/100
+Applied-Upstream: yes, 3.31.1
+---
+ search-provider/search-provider.vala | 14 +++++++++++++-
+ 1 file changed, 13 insertions(+), 1 deletion(-)
+
+diff --git a/search-provider/search-provider.vala b/search-provider/search-provider.vala
+index 659f73d..7e54fa6 100644
+--- a/search-provider/search-provider.vala
++++ b/search-provider/search-provider.vala
+@@ -13,7 +13,12 @@
+ [DBus (name = "org.gnome.Shell.SearchProvider2")]
+ public class SearchProvider : Object
+ {
++    private unowned SearchProviderApp application;
+     private Cancellable cancellable = new Cancellable ();
++    public SearchProvider (SearchProviderApp app)
++    {
++        application = app;
++    }
+ 
+     ~SearchProvider ()
+     {
+@@ -71,6 +76,8 @@ public class SearchProvider : Object
+                 cancellable = null;
+             });
+ 
++            application.renew_inactivity_timeout ();
++
+             yield subprocess.communicate_utf8_async (null, cancellable, out solution_buf, out stderr_buf);
+         }
+         catch (Error e)
+@@ -197,11 +204,16 @@ public class SearchProviderApp : Application
+         Object (application_id: "org.gnome.Calculator.SearchProvider",
+                 flags: ApplicationFlags.IS_SERVICE,
+                 inactivity_timeout: 60000);
++
++    public void renew_inactivity_timeout ()
++    {
++        this.hold ();
++        this.release ();
+     }
+ 
+     public override bool dbus_register (DBusConnection connection, string object_path)
+     {
+-        SearchProvider search_provider = new SearchProvider ();
++        SearchProvider search_provider = new SearchProvider (this);
+ 
+         try
+         {
diff --git a/debian/patches/search-provider-simplify-solve_subprocess.patch b/debian/patches/search-provider-simplify-solve_subprocess.patch
new file mode 100644
index 0000000..4f9cde8
--- /dev/null
+++ b/debian/patches/search-provider-simplify-solve_subprocess.patch
@@ -0,0 +1,114 @@
+From: =?utf-8?b?Ik1hcmNvIFRyZXZpc2FuIChUcmV2acOxbyki?= <[e-mail]>
+Date: Fri, 24 Aug 2018 07:31:37 +0200
+Subject: search-provider: simplify solve_subprocess
+
+Only return a subprocess in solve_subprocess and make the callers deal with
+the actual operation to perform.
+
+Bug-Ubuntu: https://launchpad.net/bugs/1756826
+Bug-GNOME: https://gitlab.gnome.org/GNOME/gnome-shell/issues/183
+Forwarded: https://gitlab.gnome.org/GNOME/gnome-calculator/merge_requests/10
+Applied-Upstream: yes, 3.31.1
+---
+ search-provider/search-provider.vala | 49 ++++++++++--------------------------
+ 1 file changed, 13 insertions(+), 36 deletions(-)
+
+diff --git a/search-provider/search-provider.vala b/search-provider/search-provider.vala
+index 9035c58..df37b86 100644
+--- a/search-provider/search-provider.vala
++++ b/search-provider/search-provider.vala
+@@ -39,7 +39,7 @@ public class SearchProvider : Object
+         return string.joinv (" ", terms);
+     }
+ 
+-    private async Subprocess solve_subprocess (string equation, bool return_solution = false, out string? solution_buf = null) throws Error
++    private async Subprocess solve_subprocess (string equation) throws Error
+     {
+         Subprocess subprocess;
+         string[] argv = {"gnome-calculator", "--solve"};
+@@ -52,13 +52,7 @@ public class SearchProvider : Object
+         {
+             // Eat output so that it doesn't wind up in the journal. It's
+             // expected that most searches are not valid calculator input.
+-            var flags = SubprocessFlags.STDERR_PIPE;
+-
+-            if (return_solution)
+-            {
+-                flags |= SubprocessFlags.STDOUT_PIPE;
+-            }
+-
++            var flags = SubprocessFlags.STDOUT_PIPE | SubprocessFlags.STDERR_PIPE;
+             subprocess = new Subprocess.newv (argv, flags);
+         }
+         catch (Error e)
+@@ -66,31 +60,13 @@ public class SearchProvider : Object
+             error ("Failed to spawn Calculator: %s", e.message);
+         }
+ 
+-        try
+-        {
+-            string stderr_buf;
+-
+-            cancellable = new Cancellable ();
+-            cancellable.cancelled.connect (() => {
+-                subprocess.force_exit ();
+-                cancellable = null;
+-            });
+-
+-            application.renew_inactivity_timeout ();
++        cancellable = new Cancellable ();
++        cancellable.cancelled.connect (() => {
++            subprocess.force_exit ();
++            cancellable = null;
++        });
+ 
+-            yield subprocess.communicate_utf8_async (null, cancellable, out solution_buf, out stderr_buf);
+-        }
+-        catch (Error e)
+-        {
+-            if (e is IOError.CANCELLED)
+-            {
+-                throw e;
+-            }
+-            else
+-            {
+-                error ("Failed reading result: %s", e.message);
+-            }
+-        }
++        application.renew_inactivity_timeout ();
+ 
+         return subprocess;
+     }
+@@ -115,8 +91,7 @@ public class SearchProvider : Object
+                 return false;
+             }
+ 
+-            var subprocess = yield solve_subprocess (equation);
+-            yield subprocess.wait_check_async ();
++            (yield solve_subprocess (equation)).wait_check (cancellable);
+         }
+         catch (SpawnError e)
+         {
+@@ -153,10 +128,12 @@ public class SearchProvider : Object
+         requires (results.length == 1)
+     {
+         string stdout_buf;
++        string stderr_buf;
+ 
+         try
+         {
+-            yield solve_subprocess (results[0], true, out stdout_buf);
++            var subprocess = yield solve_subprocess (results[0]);
++            yield subprocess.communicate_utf8_async (null, cancellable, out stdout_buf, out stderr_buf);
+         }
+         catch (Error e)
+         {
+@@ -167,7 +144,7 @@ public class SearchProvider : Object
+         metadata[0] = new HashTable<string, Variant>(str_hash, str_equal);
+         metadata[0].insert ("id", results[0]);
+         metadata[0].insert ("name", results[0] );
+-        metadata[0].insert ("description", " = " + stdout_buf.strip() );
++        metadata[0].insert ("description", " = " + stdout_buf.strip ());
+ 
+         return metadata;
+     }
diff --git a/debian/patches/search-provider-stop-normalizing-the-equation-twice.patch b/debian/patches/search-provider-stop-normalizing-the-equation-twice.patch
new file mode 100644
index 0000000..6882583
--- /dev/null
+++ b/debian/patches/search-provider-stop-normalizing-the-equation-twice.patch
@@ -0,0 +1,48 @@
+From: Pascal Nowack <[e-mail]>
+Date: Sun, 31 Mar 2019 14:11:16 +0200
+Subject: search-provider: stop normalizing the equation twice
+
+When an equation is given by the g-s overview, g-c
+will solve this equation, where it will be first
+normalized and then solved.
+This is done by running a subprocess, where g-c
+will call g-c in this subprocess with the
+"--solve" argument.
+With this "--solve" argument, the equation will
+also be normalized.
+However, when an equation is given by the g-s
+overview, it will also be normalized in a check,
+that happens before the solve process, to not to
+process single numbers given by the g-s overview.
+This normalized equation will then be used to
+invoke the subprocess to solve the equation,
+leading into normalizing the already normalized
+equation and therefore resulting into wrong
+results when the equation itself contains
+decimal numbers.
+
+Solve this issue, by invoking the subprocess with
+the unnormalized equation, instead of the
+normalized one, to not to normalize the
+equation twice.
+
+Closes: https://gitlab.gnome.org/GNOME/gnome-calculator/issues/104
+
+Bug-GNOME: https://gitlab.gnome.org/GNOME/gnome-shell/issues/104
+---
+ search-provider/search-provider.vala | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+diff --git a/search-provider/search-provider.vala b/search-provider/search-provider.vala
+index 9823ef7..7f9f51e 100644
+--- a/search-provider/search-provider.vala
++++ b/search-provider/search-provider.vala
+@@ -129,7 +129,7 @@ public class SearchProvider : Object
+ 
+         try
+         {
+-            var subprocess = yield solve_subprocess (normalized_equation);
++            var subprocess = yield solve_subprocess (equation);
+             yield subprocess.communicate_utf8_async (null, cancellable, out result, null);
+             subprocess.wait_check (cancellable);
+         }
diff --git a/debian/patches/series b/debian/patches/series
index e69de29..f088177 100644
--- a/debian/patches/series
+++ b/debian/patches/series
@@ -0,0 +1,11 @@
+search-provider-Use-async-calls-cancel-search-on-inactivi.patch
+search-provider-renew-inactivity-timeout-at-each-calculat.patch
+search-provider-Use-lower-inactivity-timeout.patch
+search-provider-simplify-solve_subprocess.patch
+search-provider-cancel-the-current-process-on-new-calcula.patch
+search-provider-cache-equations-avoiding-spawning-calcula.patch
+search-provider-cache-only-a-limited-number-of-equations.patch
+search-provider-Handle-errors-gracefully.patch
+ubuntu/search-provider-Cancel-operations-on-XUbuntuCancel.patch
+search-provider-stop-normalizing-the-equation-twice.patch
+Use-GLib.List.deep_copy-to-fix-type-argument-mismatch.patch
diff --git a/debian/patches/ubuntu/search-provider-Cancel-operations-on-XUbuntuCancel.patch b/debian/patches/ubuntu/search-provider-Cancel-operations-on-XUbuntuCancel.patch
new file mode 100644
index 0000000..edc9419
--- /dev/null
+++ b/debian/patches/ubuntu/search-provider-Cancel-operations-on-XUbuntuCancel.patch
@@ -0,0 +1,118 @@
+From: =?utf-8?b?Ik1hcmNvIFRyZXZpc2FuIChUcmV2acOxbyki?= <[e-mail]>
+Date: Tue, 28 Aug 2018 04:12:20 +0200
+Subject: search-provider: Cancel operations on XUbuntuCancel
+
+Stop process and any computation on XUbuntuCancel method, if the caller
+was the same triggering the last operation.
+
+Fixes LP: #1756826
+
+Bug-Ubuntu: https://launchpad.net/bugs/1756826
+Bug-GNOME: https://gitlab.gnome.org/GNOME/gnome-shell/issues/183
+Forwarded: not-needed
+---
+ search-provider/search-provider.vala | 46 ++++++++++++++++++++++++++++++++----
+ 1 file changed, 41 insertions(+), 5 deletions(-)
+
+diff --git a/search-provider/search-provider.vala b/search-provider/search-provider.vala
+index a48c440..9823ef7 100644
+--- a/search-provider/search-provider.vala
++++ b/search-provider/search-provider.vala
+@@ -10,11 +10,33 @@
+  * license.
+  */
+ 
++public class CallerTracker : Object
++{
++    public BusName? bus { get; set; }
++}
++
++public class Caller
++{
++    private CallerTracker caller_tracker;
++
++    public Caller (CallerTracker c, BusName sender)
++    {
++        caller_tracker = c;
++        caller_tracker.bus = sender;
++    }
++
++    ~Caller ()
++    {
++        caller_tracker.bus = null;
++    }
++}
++
+ [DBus (name = "org.gnome.Shell.SearchProvider2")]
+ public class SearchProvider : Object
+ {
+     private unowned SearchProviderApp application;
+     private Cancellable cancellable;
++    private CallerTracker caller_tracker;
+ 
+     private const int MAX_CACHED_OPERATIONS = 10;
+     private Queue<string> queued_equations;
+@@ -24,6 +46,7 @@ public class SearchProvider : Object
+     {
+         application = app;
+ 
++        caller_tracker = new CallerTracker ();
+         queued_equations = new Queue<string> ();
+         cached_equations = new HashTable<string, string> (str_hash, str_equal);
+     }
+@@ -129,8 +152,10 @@ public class SearchProvider : Object
+         return true;
+     }
+ 
+-    private async string[] get_result_identifier (string[] terms) throws Error
++    private async string[] get_result_identifier (string[] terms, GLib.BusName sender) throws Error
+     {
++        var owner = new Caller (caller_tracker, sender); (void) owner;
++
+         /* We have at most one result: the search terms as one string */
+         var equation = terms_to_equation (terms);
+         if (yield solve_equation (equation))
+@@ -139,14 +164,14 @@ public class SearchProvider : Object
+             return new string[0];
+     }
+ 
+-    public async string[] get_initial_result_set (string[] terms) throws Error
++    public async string[] get_initial_result_set (string[] terms, GLib.BusName sender) throws Error
+     {
+-        return yield get_result_identifier (terms);
++        return yield get_result_identifier (terms, sender);
+     }
+ 
+-    public async string[] get_subsearch_result_set (string[] previous_results, string[] terms) throws Error
++    public async string[] get_subsearch_result_set (string[] previous_results, string[] terms, GLib.BusName sender) throws Error
+     {
+-        return yield get_result_identifier (terms);
++        return yield get_result_identifier (terms, sender);
+     }
+ 
+     public async HashTable<string, Variant>[] get_result_metas (string[] results, GLib.BusName sender) throws Error
+@@ -155,6 +180,8 @@ public class SearchProvider : Object
+         string equation;
+         string result;
+ 
++        var owner = new Caller (caller_tracker, sender); (void) owner;
++
+         equation = terms_to_equation (results);
+ 
+         if (!yield solve_equation (equation))
+@@ -172,6 +199,15 @@ public class SearchProvider : Object
+         return metadata;
+     }
+ 
++    public async void x_ubuntu_cancel (BusName sender)
++    {
++        if (caller_tracker.bus == sender)
++        {
++            debug ("Cancelling Request");
++            cancel ();
++        }
++    }
++
+     private static void spawn_and_display_equation (string[] terms) throws Error
+     {
+         try