www/firefox: unbreak copy/paste with some terminal emulators

Obtained from:	upstream (Firefox 61)

2 files changed, 448 insertions, 1 deletions

diff --git a/www/firefox/Makefile b/www/firefox/Makefile
index af8779a5f710..e98af0e603ee 100644
--- a/www/firefox/Makefile
+++ b/www/firefox/Makefile
@@ -3,7 +3,7 @@
 
 PORTNAME=	firefox
 DISTVERSION=	59.0.2
-PORTREVISION=	2
+PORTREVISION=	3
 PORTEPOCH=	1
 CATEGORIES=	www ipv6
 MASTER_SITES=	https://hg.mozilla.org/releases/mozilla-release/archive/
diff --git a/www/firefox/files/patch-bug1447925 b/www/firefox/files/patch-bug1447925
new file mode 100644
index 000000000000..60ce7659454d
--- /dev/null
+++ b/www/firefox/files/patch-bug1447925
@@ -0,0 +1,447 @@
+commit d648a9a26195
+Author: Martin Stransky <stransky@redhat.com>
+Date:   Tue Mar 27 15:51:07 2018 +0200
+
+    Bug 1447925 - Add GetClipboardText() to get text data from clipboard, r=jhorak
+    
+    GetClipboardText() calls gtk_clipboard_request_text() to request text clipboard data from Gtk+
+    and leave Gtk+ to do clipboard text format conversions. Also unify data getting code for text/data/targets.
+    
+    MozReview-Commit-ID: 9DGSdOACho1
+    
+    --HG--
+    extra : rebase_source : f1d95609f8a7587a4abc11739db9d17ec5446a7b
+---
+ widget/gtk/nsClipboard.h      |   1 +
+ widget/gtk/nsClipboardX11.cpp | 177 +++++++++++++++++++++++++++++-------------
+ widget/gtk/nsClipboardX11.h   |  39 +++++++---
+ 3 files changed, 152 insertions(+), 65 deletions(-)
+
+diff --git widget/gtk/nsClipboard.h widget/gtk/nsClipboard.h
+index 2be635bca10d..fa3b9b6ff087 100644
+--- widget/gtk/nsClipboard.h
++++ widget/gtk/nsClipboard.h
+@@ -21,6 +21,7 @@ public:
+     virtual const char* GetClipboardData(const char* aMimeType,
+                                          int32_t aWhichClipboard,
+                                          uint32_t* aContentLength) = 0;
++    virtual const char* GetClipboardText(int32_t aWhichClipboard) = 0;
+     virtual void ReleaseClipboardData(const char* aClipboardData) = 0;
+ 
+     virtual GdkAtom* GetTargets(int32_t aWhichClipboard,
+diff --git widget/gtk/nsClipboardX11.cpp widget/gtk/nsClipboardX11.cpp
+index 6a574069dcc4..e8d8522651c2 100644
+--- widget/gtk/nsClipboardX11.cpp
++++ widget/gtk/nsClipboardX11.cpp
+@@ -62,8 +62,10 @@ selection_request_filter(GdkXEvent *gdk_xevent, GdkEvent *event, gpointer data)
+ 
+ nsRetrievalContextX11::nsRetrievalContextX11()
+   : mState(INITIAL)
+-  , mData(nullptr)
+   , mClipboardRequestNumber(0)
++  , mClipboardData(nullptr)
++  , mClipboardDataLength(0)
++  , mTargetMIMEType(gdk_atom_intern("TARGETS", FALSE))
+ {
+     // A custom event filter to workaround attempting to dereference a null
+     // selection requestor in GTK3 versions before 3.11.3. See bug 1178799.
+@@ -139,13 +141,11 @@ checkEventProc(Display *display, XEvent *event, XPointer arg)
+     return False;
+ }
+ 
+-void *
+-nsRetrievalContextX11::Wait()
++bool
++nsRetrievalContextX11::WaitForX11Content()
+ {
+     if (mState == COMPLETED) { // the request completed synchronously
+-        void *data = mData;
+-        mData = nullptr;
+-        return data;
++        return true;
+     }
+ 
+     GdkDisplay *gdkDisplay = gdk_display_get_default();
+@@ -181,9 +181,7 @@ nsRetrievalContextX11::Wait()
+                     DispatchPropertyNotifyEvent(context.cbWidget, &xevent);
+ 
+                 if (mState == COMPLETED) {
+-                    void *data = mData;
+-                    mData = nullptr;
+-                    return data;
++                    return true;
+                 }
+             }
+ 
+@@ -200,11 +198,12 @@ nsRetrievalContextX11::Wait()
+     printf("exceeded clipboard timeout\n");
+ #endif
+     mState = TIMED_OUT;
+-    return nullptr;
++    return false;
+ }
+ 
+ // Call this when data has been retrieved.
+-void nsRetrievalContextX11::Complete(GtkSelectionData* aData,
++void nsRetrievalContextX11::Complete(ClipboardDataType aDataType,
++                                     const void* aData,
+                                      int aDataRequestNumber)
+ {
+   if (mClipboardRequestNumber != aDataRequestNumber) {
+@@ -214,8 +213,54 @@ void nsRetrievalContextX11::Complete(GtkSelectionData* aData,
+ 
+   if (mState == INITIAL) {
+       mState = COMPLETED;
+-      mData = gtk_selection_data_get_length(aData) >= 0 ?
+-              gtk_selection_data_copy(aData) : nullptr;
++
++      MOZ_ASSERT(mClipboardData == nullptr &&
++                 mClipboardDataLength == 0,
++                 "We're leaking clipboard data!");
++
++      switch (aDataType) {
++      case CLIPBOARD_TEXT:
++          {
++              const char* text = static_cast<const char*>(aData);
++              if (text) {
++                  mClipboardDataLength = sizeof(char) * (strlen(text) + 1);
++                  mClipboardData = moz_xmalloc(mClipboardDataLength);
++                  memcpy(mClipboardData, text, mClipboardDataLength);
++              }
++          }
++          break;
++      case CLIPBOARD_TARGETS:
++          {
++              const GtkSelectionData *selection =
++                  static_cast<const GtkSelectionData *>(aData);
++
++              gint n_targets = 0;
++              GdkAtom *targets = nullptr;
++
++              if (!gtk_selection_data_get_targets(selection, &targets, &n_targets) ||
++                  !n_targets) {
++                  return;
++              }
++
++              mClipboardData = targets;
++              mClipboardDataLength = n_targets;
++          }
++          break;
++      case CLIPBOARD_DATA:
++          {
++              const GtkSelectionData *selection =
++                  static_cast<const GtkSelectionData *>(aData);
++
++              gint dataLength = gtk_selection_data_get_length(selection);
++              if (dataLength > 0) {
++                  mClipboardDataLength = dataLength;
++                  mClipboardData = moz_xmalloc(dataLength);
++                  memcpy(mClipboardData, gtk_selection_data_get_data(selection),
++                         dataLength);
++              }
++          }
++          break;
++      }
+   } else {
+       // Already timed out
+       MOZ_ASSERT(mState == TIMED_OUT);
+@@ -233,12 +278,24 @@ clipboard_contents_received(GtkClipboard     *clipboard,
+     delete handler;
+ }
+ 
+-GtkSelectionData*
+-nsRetrievalContextX11::WaitForContents(GtkClipboard *clipboard,
+-                                       const char *aMimeType)
++static void
++clipboard_text_received(GtkClipboard     *clipboard,
++                        const gchar      *text,
++                        gpointer          data)
++{
++    ClipboardRequestHandler *handler =
++        static_cast<ClipboardRequestHandler*>(data);
++    handler->Complete(text);
++    delete handler;
++}
++
++bool
++nsRetrievalContextX11::WaitForClipboardData(ClipboardDataType aDataType,
++                                            GtkClipboard *clipboard,
++                                            const char *aMimeType)
+ {
+     mState = INITIAL;
+-    NS_ASSERTION(!mData, "Leaking clipboard content!");
++    NS_ASSERTION(!mClipboardData, "Leaking clipboard content!");
+ 
+     // Call ClipboardRequestHandler() with unique clipboard request number.
+     // The request number pairs gtk_clipboard_request_contents() data request
+@@ -246,39 +303,45 @@ nsRetrievalContextX11::WaitForContents(GtkClipboard *clipboard,
+     // is provided by Gtk.
+     mClipboardRequestNumber++;
+     ClipboardRequestHandler* handler =
+-        new ClipboardRequestHandler(this, mClipboardRequestNumber);
++        new ClipboardRequestHandler(this, aDataType, mClipboardRequestNumber);
++
++    switch (aDataType) {
++    case CLIPBOARD_DATA:
++        gtk_clipboard_request_contents(clipboard,
++            gdk_atom_intern(aMimeType, FALSE), clipboard_contents_received,
++            handler);
++        break;
++    case CLIPBOARD_TEXT:
++        gtk_clipboard_request_text(clipboard, clipboard_text_received,
++            handler);
++        break;
++    case CLIPBOARD_TARGETS:
++        gtk_clipboard_request_contents(clipboard,
++            mTargetMIMEType, clipboard_contents_received,
++            handler);
++        break;
++    }
+ 
+-    gtk_clipboard_request_contents(clipboard,
+-                                   gdk_atom_intern(aMimeType, FALSE),
+-                                   clipboard_contents_received,
+-                                   handler);
+-    return static_cast<GtkSelectionData*>(Wait());
++    return WaitForX11Content();
+ }
+ 
+ GdkAtom*
+ nsRetrievalContextX11::GetTargets(int32_t aWhichClipboard, int* aTargetNums)
+ {
+-  *aTargetNums = 0;
++    GtkClipboard *clipboard =
++        gtk_clipboard_get(GetSelectionAtom(aWhichClipboard));
+ 
+-  GtkClipboard *clipboard =
+-      gtk_clipboard_get(GetSelectionAtom(aWhichClipboard));
+-
+-  GtkSelectionData *selection_data = WaitForContents(clipboard, "TARGETS");
+-  if (!selection_data)
+-      return nullptr;
++    if (!WaitForClipboardData(CLIPBOARD_TARGETS, clipboard))
++        return nullptr;
+ 
+-  gint n_targets = 0;
+-  GdkAtom *targets = nullptr;
++    *aTargetNums = mClipboardDataLength;
++    GdkAtom* targets = static_cast<GdkAtom*>(mClipboardData);
+ 
+-  if (!gtk_selection_data_get_targets(selection_data, &targets, &n_targets) ||
+-      !n_targets) {
+-      return nullptr;
+-  }
++    // We don't hold the target list internally but we transfer the ownership.
++    mClipboardData = nullptr;
++    mClipboardDataLength = 0;
+ 
+-  gtk_selection_data_free(selection_data);
+-
+-  *aTargetNums = n_targets;
+-  return targets;
++    return targets;
+ }
+ 
+ const char*
+@@ -289,25 +352,31 @@ nsRetrievalContextX11::GetClipboardData(const char* aMimeType,
+     GtkClipboard *clipboard;
+     clipboard = gtk_clipboard_get(GetSelectionAtom(aWhichClipboard));
+ 
+-    GtkSelectionData *selectionData = WaitForContents(clipboard, aMimeType);
+-    if (!selectionData)
++    if (!WaitForClipboardData(CLIPBOARD_DATA, clipboard, aMimeType))
+         return nullptr;
+ 
+-    char* clipboardData = nullptr;
+-    int contentLength = gtk_selection_data_get_length(selectionData);
+-    if (contentLength > 0) {
+-        clipboardData = reinterpret_cast<char*>(
+-            moz_xmalloc(sizeof(char)*contentLength));
+-        memcpy(clipboardData, gtk_selection_data_get_data(selectionData),
+-            sizeof(char)*contentLength);
+-    }
+-    gtk_selection_data_free(selectionData);
++    *aContentLength = mClipboardDataLength;
++    return static_cast<const char*>(mClipboardData);
++}
+ 
+-    *aContentLength = contentLength;
+-    return (const char*)clipboardData;
++const char*
++nsRetrievalContextX11::GetClipboardText(int32_t aWhichClipboard)
++{
++    GtkClipboard *clipboard;
++    clipboard = gtk_clipboard_get(GetSelectionAtom(aWhichClipboard));
++
++    if (!WaitForClipboardData(CLIPBOARD_TEXT, clipboard))
++        return nullptr;
++
++    return static_cast<const char*>(mClipboardData);
+ }
+ 
+ void nsRetrievalContextX11::ReleaseClipboardData(const char* aClipboardData)
+ {
+-    free((void *)aClipboardData);
++    NS_ASSERTION(aClipboardData == mClipboardData,
++        "Releasing unknown clipboard data!");
++    free((void*)aClipboardData);
++
++    mClipboardData = nullptr;
++    mClipboardDataLength = 0;
+ }
+diff --git widget/gtk/nsClipboardX11.h widget/gtk/nsClipboardX11.h
+index 210f6b1fdbd4..9e89e08445dd 100644
+--- widget/gtk/nsClipboardX11.h
++++ widget/gtk/nsClipboardX11.h
+@@ -11,6 +11,12 @@
+ #include "nsIClipboard.h"
+ #include <gtk/gtk.h>
+ 
++enum ClipboardDataType {
++    CLIPBOARD_DATA,
++    CLIPBOARD_TEXT,
++    CLIPBOARD_TARGETS
++};
++
+ class nsRetrievalContextX11 : public nsRetrievalContext
+ {
+ public:
+@@ -19,48 +25,59 @@ public:
+     virtual const char* GetClipboardData(const char* aMimeType,
+                                          int32_t aWhichClipboard,
+                                          uint32_t* aContentLength) override;
++    virtual const char* GetClipboardText(int32_t aWhichClipboard) override;
+     virtual void ReleaseClipboardData(const char* aClipboardData) override;
+ 
+     virtual GdkAtom* GetTargets(int32_t aWhichClipboard,
+                                 int* aTargetNums) override;
+ 
+-    // Call this when data has been retrieved.
+-    void Complete(GtkSelectionData* aData, int aDataRequestNumber);
++    // Call this when data or text has been retrieved.
++    void Complete(ClipboardDataType aDataType,
++                  const void* aData,
++                  int aDataRequestNumber);
+ 
+     nsRetrievalContextX11();
+     virtual ~nsRetrievalContextX11() override;
+ 
+ private:
+-    GtkSelectionData* WaitForContents(GtkClipboard *clipboard,
+-                                      const char *aMimeType);
++    bool WaitForClipboardData(ClipboardDataType aDataType,
++                              GtkClipboard *clipboard,
++                              const char *aMimeType = nullptr);
++
+     /**
+      * Spins X event loop until timing out or being completed. Returns
+      * null if we time out, otherwise returns the completed data (passing
+      * ownership to caller).
+      */
+-    void *Wait();
++    bool WaitForX11Content();
+ 
+-    State mState;
+-    void* mData;
+-    int   mClipboardRequestNumber;
++    State     mState;
++    int       mClipboardRequestNumber;
++    void*     mClipboardData;
++    uint32_t  mClipboardDataLength;
++    GdkAtom   mTargetMIMEType;
+ };
+ 
+ class ClipboardRequestHandler
+ {
+ public:
+-    ClipboardRequestHandler(nsRetrievalContextX11 *aContext, int aDataRequestNumber)
++    ClipboardRequestHandler(nsRetrievalContextX11 *aContext,
++                            ClipboardDataType aDataType,
++                            int aDataRequestNumber)
+       : mContext(aContext)
+       , mDataRequestNumber(aDataRequestNumber)
++      , mDataType(aDataType)
+       {}
+ 
+-    void  Complete(GtkSelectionData* aData)
++    void Complete(const void *aData)
+     {
+-      mContext->Complete(aData, mDataRequestNumber);
++      mContext->Complete(mDataType, aData, mDataRequestNumber);
+     }
+ 
+ private:
+     nsRetrievalContextX11 *mContext;
+     int                    mDataRequestNumber;
++    ClipboardDataType      mDataType;
+ };
+ 
+ #endif /* __nsClipboardX11_h_ */
+
+commit 3a5fb9d15546
+Author: Martin Stransky <stransky@redhat.com>
+Date:   Tue Apr 3 10:30:37 2018 +0200
+
+    Bug 1447925 - Use GetClipboardText() to get text data at nsClipboard::GetData(), r=jhorak
+    
+    MozReview-Commit-ID: 3JnLLyk0BOF
+    
+    --HG--
+    extra : rebase_source : 7bd5faff15d805d19628bdbd9fcd194c89c283a4
+---
+ widget/gtk/nsClipboard.cpp | 7 ++-----
+ widget/gtk/nsClipboard.h   | 7 ++++---
+ 2 files changed, 6 insertions(+), 8 deletions(-)
+
+diff --git widget/gtk/nsClipboard.cpp widget/gtk/nsClipboard.cpp
+index 5e8105987842..36e8d6ad5cee 100644
+--- widget/gtk/nsClipboard.cpp
++++ widget/gtk/nsClipboard.cpp
+@@ -301,11 +301,8 @@ nsClipboard::GetData(nsITransferable *aTransferable, int32_t aWhichClipboard)
+         // Special case text/unicode since we can convert any
+         // string into text/unicode
+         if (flavorStr.EqualsLiteral(kUnicodeMime)) {
+-            uint32_t    clipboardDataLength;
+             const char* clipboardData =
+-                mContext->GetClipboardData(GTK_DEFAULT_MIME_TEXT,
+-                                           aWhichClipboard,
+-                                           &clipboardDataLength);
++                mContext->GetClipboardText(aWhichClipboard);
+             if (!clipboardData) {
+                 // If the type was text/unicode and we couldn't get
+                 // text off the clipboard, run the next loop
+@@ -314,7 +311,7 @@ nsClipboard::GetData(nsITransferable *aTransferable, int32_t aWhichClipboard)
+             }
+ 
+             // Convert utf-8 into our unicode format.
+-            NS_ConvertUTF8toUTF16 ucs2string(clipboardData, clipboardDataLength);
++            NS_ConvertUTF8toUTF16 ucs2string(clipboardData);
+             const char* unicodeData = (const char *)ToNewUnicode(ucs2string);
+             uint32_t unicodeDataLength = ucs2string.Length() * 2;
+             SetTransferableData(aTransferable, flavorStr,
+diff --git widget/gtk/nsClipboard.h widget/gtk/nsClipboard.h
+index fa3b9b6ff087..9b59bf8176f6 100644
+--- widget/gtk/nsClipboard.h
++++ widget/gtk/nsClipboard.h
+@@ -13,17 +13,18 @@
+ #include "nsIBinaryOutputStream.h"
+ #include <gtk/gtk.h>
+ 
+-// Default Gtk MIME for text
+-#define GTK_DEFAULT_MIME_TEXT "UTF8_STRING"
+-
+ class nsRetrievalContext {
+ public:
++    // Get actual clipboard content (GetClipboardData/GetClipboardText)
++    // which has to be released by ReleaseClipboardData().
+     virtual const char* GetClipboardData(const char* aMimeType,
+                                          int32_t aWhichClipboard,
+                                          uint32_t* aContentLength) = 0;
+     virtual const char* GetClipboardText(int32_t aWhichClipboard) = 0;
+     virtual void ReleaseClipboardData(const char* aClipboardData) = 0;
+ 
++    // Get data mime types which can be obtained from clipboard.
++    // The returned array has to be released by g_free().
+     virtual GdkAtom* GetTargets(int32_t aWhichClipboard,
+                                 int* aTargetNum) = 0;
+