Bug: https://bugzilla.mozilla.org/show_bug.cgi?id=140751

diff --git a/modules/libpref/Preferences.cpp b/modules/libpref/Preferences.cpp

--- a/modules/libpref/Preferences.cpp

+++ b/modules/libpref/Preferences.cpp

 #ifdef MOZ_BACKGROUNDTASKS

 #  include "mozilla/BackgroundTasks.h"

 #endif

+#include "nsKDEUtils.h"

 #ifdef DEBUG

 #  include <map>

diff --git a/modules/libpref/moz.build b/modules/libpref/moz.build

--- a/modules/libpref/moz.build

+++ b/modules/libpref/moz.build

     "SharedPrefMap.cpp",

 ]

+LOCAL_INCLUDES += [

+    '/toolkit/xre'

+]

+

 gen_all_tuple = tuple(gen_h + gen_cpp + gen_rs)

 GeneratedFile(

diff --git a/python/mozbuild/mozpack/chrome/flags.py b/python/mozbuild/mozpack/chrome/flags.py

--- a/python/mozbuild/mozpack/chrome/flags.py

+++ b/python/mozbuild/mozpack/chrome/flags.py

         "tablet": Flag,

         "process": StringFlag,

         "backgroundtask": StringFlag,

+        "desktop": StringFlag,

     }

     RE = re.compile(r"([!<>=]+)")

diff --git a/python/mozbuild/mozpack/chrome/manifest.py b/python/mozbuild/mozpack/chrome/manifest.py

--- a/python/mozbuild/mozpack/chrome/manifest.py

+++ b/python/mozbuild/mozpack/chrome/manifest.py

         "process",

         "contentaccessible",

         "backgroundtask",

+        "desktop",

     ]

     def __init__(self, base, *flags):

diff --git a/toolkit/components/downloads/moz.build b/toolkit/components/downloads/moz.build

--- a/toolkit/components/downloads/moz.build

+++ b/toolkit/components/downloads/moz.build

 FINAL_LIBRARY = "xul"

+LOCAL_INCLUDES += [

+    '/toolkit/xre'

+]

+

 with Files("**"):

     BUG_COMPONENT = ("Toolkit", "Downloads API")

diff --git a/toolkit/mozapps/downloads/HelperAppDlg.sys.mjs b/toolkit/mozapps/downloads/HelperAppDlg.sys.mjs

--- a/toolkit/mozapps/downloads/HelperAppDlg.sys.mjs

+++ b/toolkit/mozapps/downloads/HelperAppDlg.sys.mjs

         this.chosenApp = params.handlerApp;

       }

     } else if ("@mozilla.org/applicationchooser;1" in Cc) {

-      var nsIApplicationChooser = Ci.nsIApplicationChooser;

-      var appChooser = Cc["@mozilla.org/applicationchooser;1"].createInstance(

-        nsIApplicationChooser

-      );

-      appChooser.init(

-        this.mDialog,

-        this.dialogElement("strings").getString("chooseAppFilePickerTitle")

-      );

-      var contentTypeDialogObj = this;

-      let appChooserCallback = function appChooserCallback_done(aResult) {

-        if (aResult) {

-          contentTypeDialogObj.chosenApp = aResult.QueryInterface(

-            Ci.nsILocalHandlerApp

-          );

-        }

-        contentTypeDialogObj.finishChooseApp();

-      };

-      appChooser.open(this.mLauncher.MIMEInfo.MIMEType, appChooserCallback);

-      // The finishChooseApp is called from appChooserCallback

-      return;

+      // handle the KDE case which is implemented in the filepicker

+      // therefore falling back to Gtk2 like behaviour if KDE is running

+      // FIXME this should be better handled in the nsIApplicationChooser

+      // interface

+      var env = Components.classes["@mozilla.org/process/environment;1"]

+                          .getService(Components.interfaces.nsIEnvironment);

+      if (env.get('KDE_FULL_SESSION') == "true")

+      {

+        var nsIFilePicker = Ci.nsIFilePicker;

+        var fp = Cc["@mozilla.org/filepicker;1"]

+                    .createInstance(nsIFilePicker);

+        fp.init(this.mDialog,

+                this.dialogElement("strings").getString("chooseAppFilePickerTitle"),

+                nsIFilePicker.modeOpen);

+

+        fp.appendFilters(nsIFilePicker.filterApps);

+

+        fp.open(aResult => {

+          if (aResult == nsIFilePicker.returnOK && fp.file) {

+            // Remember the file they chose to run.

+            var localHandlerApp =

+              Cc["@mozilla.org/uriloader/local-handler-app;1"].

+                         createInstance(Ci.nsILocalHandlerApp);

+            localHandlerApp.executable = fp.file;

+            this.chosenApp = localHandlerApp;

+          }

+          this.finishChooseApp();

+        });

+      } else {

+        var nsIApplicationChooser = Ci.nsIApplicationChooser;

+        var appChooser = Cc["@mozilla.org/applicationchooser;1"].createInstance(

+          nsIApplicationChooser

+        );

+        appChooser.init(

+          this.mDialog,

+          this.dialogElement("strings").getString("chooseAppFilePickerTitle")

+        );

+        var contentTypeDialogObj = this;

+        let appChooserCallback = function appChooserCallback_done(aResult) {

+          if (aResult) {

+            contentTypeDialogObj.chosenApp = aResult.QueryInterface(

+              Ci.nsILocalHandlerApp

+            );

+          }

+          contentTypeDialogObj.finishChooseApp();

+        };

+        appChooser.open(this.mLauncher.MIMEInfo.MIMEType, appChooserCallback);

+        // The finishChooseApp is called from appChooserCallback

+        return;

+      }

     } else {

       var nsIFilePicker = Ci.nsIFilePicker;

       var fp = Cc["@mozilla.org/filepicker;1"].createInstance(nsIFilePicker);

diff --git a/toolkit/system/unixproxy/nsUnixSystemProxySettings.cpp b/toolkit/system/unixproxy/nsUnixSystemProxySettings.cpp

--- a/toolkit/system/unixproxy/nsUnixSystemProxySettings.cpp

+++ b/toolkit/system/unixproxy/nsUnixSystemProxySettings.cpp

 #include "nsISupportsPrimitives.h"

 #include "nsIGSettingsService.h"

 #include "nsReadableUtils.h"

+#include "nsPrintfCString.h"

+#include "nsKDEUtils.h"

 using namespace mozilla;

                                  nsACString& aResult);

   nsresult SetProxyResultFromGSettings(const char* aKeyBase, const char* aType,

                                        nsACString& aResult);

+  nsresult GetProxyFromKDE(const nsACString& aScheme, const nsACString& aHost,

+                           PRInt32 aPort, nsACString& aResult);

 };

 NS_IMPL_ISUPPORTS(nsUnixSystemProxySettings, nsISystemProxySettings)

                                                    const nsACString& aHost,

                                                    const int32_t aPort,

                                                    nsACString& aResult) {

+  if (nsKDEUtils::kdeSupport())

+    return GetProxyFromKDE(aScheme, aHost, aPort, aResult);

+

   if (mProxySettings) {

     nsresult rv = GetProxyFromGSettings(aScheme, aHost, aPort, aResult);

     if (NS_SUCCEEDED(rv)) return rv;

   return GetProxyFromEnvironment(aScheme, aHost, aPort, aResult);

 }

+nsresult nsUnixSystemProxySettings::GetProxyFromKDE(const nsACString& aScheme,

+                                                    const nsACString& aHost,

+                                                    PRInt32 aPort,

+                                                    nsACString& aResult) {

+  nsAutoCString url;

+  url = aScheme;

+  url += "://";

+  url += aHost;

+  if (aPort >= 0) {

+    url += ":";

+    url += nsPrintfCString("%d", aPort);

+  }

+  nsTArray<nsCString> command;

+  command.AppendElement("GETPROXY"_ns);

+  command.AppendElement(url);

+  nsTArray<nsCString> result;

+  if (!nsKDEUtils::command(command, &result) || result.Length() != 1)

+    return NS_ERROR_FAILURE;

+  aResult = result[0];

+  return NS_OK;

+}

+

 NS_IMPL_COMPONENT_FACTORY(nsUnixSystemProxySettings) {

   auto result = MakeRefPtr<nsUnixSystemProxySettings>();

   result->Init();

diff --git a/toolkit/xre/moz.build b/toolkit/xre/moz.build

--- a/toolkit/xre/moz.build

+++ b/toolkit/xre/moz.build

         "UIKitDirProvider.mm",

     ]

 elif CONFIG["MOZ_WIDGET_TOOLKIT"] == "gtk":

+    EXPORTS += ['nsKDEUtils.h']

     UNIFIED_SOURCES += [

+        "nsKDEUtils.cpp",

         "nsNativeAppSupportUnix.cpp",

     ]

     CXXFLAGS += CONFIG["MOZ_X11_SM_CFLAGS"]

diff --git a/toolkit/xre/nsKDEUtils.cpp b/toolkit/xre/nsKDEUtils.cpp

new file mode 100644

--- /dev/null

+++ b/toolkit/xre/nsKDEUtils.cpp

@@ -0,0 +1,286 @@

+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */

+/* This Source Code Form is subject to the terms of the Mozilla Public

+ * License, v. 2.0. If a copy of the MPL was not distributed with this

+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

+

+#include "nsKDEUtils.h"

+#include "nsIWidget.h"

+#include "nsISupportsPrimitives.h"

+#include "nsIMutableArray.h"

+#include "nsComponentManagerUtils.h"

+#include "nsArrayUtils.h"

+

+#include <gtk/gtk.h>

+

+#include <limits.h>

+#include <stdio.h>

+#include <sys/wait.h>

+#include <sys/resource.h>

+#include <unistd.h>

+#include <X11/Xlib.h>

+// copied from X11/X.h as a hack since for an unknown

+// reason it's not picked up from X11/X.h

+#ifndef None

+#  define None 0L /* universal null resource or null atom */

+#endif

+

+// #define DEBUG_KDE

+#ifdef DEBUG_KDE

+#  define KMOZILLAHELPER "kmozillahelper"

+#else

+// not need for lib64, it's a binary

+#  define KMOZILLAHELPER "/usr/lib/mozilla/kmozillahelper"

+#endif

+

+#define KMOZILLAHELPER_VERSION 6

+#define MAKE_STR2(n) #n

+#define MAKE_STR(n) MAKE_STR2(n)

+

+static bool getKdeSession() {

+  if (PR_GetEnv("KDE_FULL_SESSION")) {

+    return true;

+  }

+  return false;

+}

+

+static bool getKdeSupport() {

+  nsTArray<nsCString> command;

+  command.AppendElement("CHECK"_ns);

+  command.AppendElement("KMOZILLAHELPER_VERSION"_ns);

+  bool kde = nsKDEUtils::command(command);

+#ifdef DEBUG_KDE

+  fprintf(stderr, "KDE RUNNING %d\n", kde);

+#endif

+  return kde;

+}

+

+nsKDEUtils::nsKDEUtils() : commandFile(NULL), replyFile(NULL) {}

+

+nsKDEUtils::~nsKDEUtils() {

+  //    closeHelper(); not actually useful, exiting will close the fd too

+}

+

+nsKDEUtils* nsKDEUtils::self() {

+  static nsKDEUtils s;

+  return &s;

+}

+

+static bool helperRunning = false;

+static bool helperFailed = false;

+

+bool nsKDEUtils::kdeSession() {

+  static bool session = getKdeSession();

+  return session;

+}

+

+bool nsKDEUtils::kdeSupport() {

+  static bool support = kdeSession() && getKdeSupport();

+  return support && helperRunning;

+}

+

+struct nsKDECommandData {

+  FILE* file;

+  nsTArray<nsCString>* output;

+  GMainLoop* loop;

+  bool success;

+};

+

+static gboolean kdeReadFunc(GIOChannel*, GIOCondition, gpointer data) {

+  nsKDECommandData* p = static_cast<nsKDECommandData*>(data);

+  char buf[8192];  // TODO big enough

+  bool command_done = false;

+  bool command_failed = false;

+  while (!command_done && !command_failed &&

+         fgets(buf, 8192, p->file) !=

+             NULL) {  // TODO what if the kernel splits a line into two chunks?

+                      // #ifdef DEBUG_KDE

+    //         fprintf( stderr, "READ: %s %d\n", buf, feof( p->file ));

+    // #endif

+    if (char* eol = strchr(buf, '\n')) *eol = '\0';

+    command_done = (strcmp(buf, "\\1") == 0);

+    command_failed = (strcmp(buf, "\\0") == 0);

+    nsAutoCString line(buf);

+    line.ReplaceSubstring("\\n", "\n");

+    line.ReplaceSubstring(

+        "\\"

+        "\\",

+        "\\");  //  \\ -> \ , i.e. unescape

+    if (p->output && !(command_done || command_failed))

+      p->output->AppendElement(nsCString(buf));  // TODO utf8?

+  }

+  bool quit = false;

+  if (feof(p->file) || command_failed) {

+    quit = true;

+    p->success = false;

+  }

+  if (command_done) {  // reading one reply finished

+    quit = true;

+    p->success = true;

+  }

+  if (quit) {

+    if (p->loop) g_main_loop_quit(p->loop);

+    return FALSE;

+  }

+  return TRUE;

+}

+

+bool nsKDEUtils::command(const nsTArray<nsCString>& command,

+                         nsTArray<nsCString>* output) {

+  return self()->internalCommand(command, NULL, false, output);

+}

+

+bool nsKDEUtils::command(nsIArray* command, nsIArray** output) {

+  nsTArray<nsCString> in;

+  PRUint32 length;

+  command->GetLength(&length);

+  for (PRUint32 i = 0; i < length; i++) {

+    nsCOMPtr<nsISupportsCString> str = do_QueryElementAt(command, i);

+    if (str) {

+      nsAutoCString s;

+      str->GetData(s);

+      in.AppendElement(s);

+    }

+  }

+

+  nsTArray<nsCString> out;

+  bool ret = self()->internalCommand(in, NULL, false, &out);

+

+  if (!output) return ret;

+

+  nsCOMPtr<nsIMutableArray> result = do_CreateInstance(NS_ARRAY_CONTRACTID);

+  if (!result) return false;

+

+  for (PRUint32 i = 0; i < out.Length(); i++) {

+    nsCOMPtr<nsISupportsCString> rstr =

+        do_CreateInstance(NS_SUPPORTS_CSTRING_CONTRACTID);

+    if (!rstr) return false;

+

+    rstr->SetData(out[i]);

+    result->AppendElement(rstr);

+  }

+

+  NS_ADDREF(*output = result);

+  return ret;

+}

+

+bool nsKDEUtils::commandBlockUi(const nsTArray<nsCString>& command,

+                                GtkWindow* parent,

+                                nsTArray<nsCString>* output) {

+  return self()->internalCommand(command, parent, true, output);

+}

+

+bool nsKDEUtils::internalCommand(const nsTArray<nsCString>& command,

+                                 GtkWindow* parent, bool blockUi,

+                                 nsTArray<nsCString>* output) {

+  if (!startHelper()) return false;

+  feedCommand(command);

+  // do not store the data in 'this' but in extra structure, just in case there

+  // is reentrancy (can there be? the event loop is re-entered)

+  nsKDECommandData data;

+  data.file = replyFile;

+  data.output = output;

+  data.success = false;

+  if (blockUi) {

+    data.loop = g_main_loop_new(NULL, FALSE);

+    GtkWidget* window = gtk_window_new(GTK_WINDOW_TOPLEVEL);

+    if (parent && gtk_window_get_group(parent))

+      gtk_window_group_add_window(gtk_window_get_group(parent),

+                                  GTK_WINDOW(window));

+    gtk_widget_realize(window);

+    gtk_widget_set_sensitive(window, TRUE);

+    gtk_grab_add(window);

+    GIOChannel* channel = g_io_channel_unix_new(fileno(data.file));

+    g_io_add_watch(channel,

+                   static_cast<GIOCondition>(G_IO_IN | G_IO_ERR | G_IO_HUP),

+                   kdeReadFunc, &data);

+    g_io_channel_unref(channel);

+    g_main_loop_run(data.loop);

+    g_main_loop_unref(data.loop);

+    gtk_grab_remove(window);

+    gtk_widget_destroy(window);

+  } else {

+    data.loop = NULL;

+    while (kdeReadFunc(NULL, static_cast<GIOCondition>(0), &data))

+      ;

+  }

+  return data.success;

+}

+

+bool nsKDEUtils::startHelper() {

+  if (helperRunning) return true;

+  if (helperFailed) return false;