# HG changeset patch

# User msirringhaus@suse.de

# Date 1559294891 -7200

#      Fri May 31 11:28:11 2019 +0200

# Node ID c2aa7198fb925e7fde96abf65b6f68b9b755f112

Description: Add KDE integration to Firefox (toolkit parts)

Author: Wolfgang Rosenauer <wolfgang@rosenauer.org>

Author: Lubos Lunak <lunak@suse.com>

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

     https://bugzilla.novell.com/show_bug.cgi?id=170055

 #ifdef MOZ_BACKGROUNDTASKS

 #  include "mozilla/BackgroundTasks.h"

 #endif

+#include "nsKDEUtils.h"

 #ifdef DEBUG

 #  include <map>

 #endif

   };

+  if (nsKDEUtils::kdeSession()) {  // TODO what if some setup actually requires

+                                   // the helper?

+    for (int i = 0; i < MOZ_ARRAY_LENGTH(specialFiles); ++i) {

+      if (*specialFiles[i] == '\0') {

+        specialFiles[i] = "kde.js";

+        break;

+      }

+    }

+  }

+

   rv = pref_LoadPrefsInDir(defaultPrefDir, specialFiles,

                            ArrayLength(specialFiles));

   if (NS_FAILED(rv)) {

       }

       // Do we care if a file provided by this process fails to load?

-      pref_LoadPrefsInDir(path, nullptr, 0);

+      pref_LoadPrefsInDir(path, specialFiles, ArrayLength(specialFiles));

     }

   }

     "SharedPrefMap.cpp",

 ]

+LOCAL_INCLUDES += [

+    '/toolkit/xre'

+]

+

 gen_all_tuple = tuple(gen_h + gen_cpp + gen_rs)

 GeneratedFile(

         "tablet": Flag,

         "process": StringFlag,

         "backgroundtask": StringFlag,

+        "desktop": StringFlag,

     }

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

         "process",

         "contentaccessible",

         "backgroundtask",

+        "desktop",

     ]

     def __init__(self, base, *flags):

 FINAL_LIBRARY = "xul"

+LOCAL_INCLUDES += [

+    '/toolkit/xre'

+]

+

 with Files("**"):

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

         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);

 #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();

         "UIKitDirProvider.mm",

     ]

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

+    EXPORTS += ['nsKDEUtils.h']

     UNIFIED_SOURCES += [

+        "nsKDEUtils.cpp",

         "nsNativeAppSupportUnix.cpp",

     ]

     CXXFLAGS += CONFIG["MOZ_X11_SM_CFLAGS"]

--- /dev/null

@@ -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;

+  }