--- a/widget/gtk/nsClipboard.cpp
+++ b/widget/gtk/nsClipboard.cpp
@@ -268,86 +268,90 @@ nsClipboard::GetData(nsITransferable *aT
             flavorStr.EqualsLiteral(kGIFImageMime)) {
             // Emulate support for image/jpg
             if (flavorStr.EqualsLiteral(kJPGImageMime)) {
                 flavorStr.Assign(kJPEGImageMime);
             }
 
             uint32_t    clipboardDataLength;
             const char* clipboardData =
-                mContext->WaitForClipboardContext(flavorStr.get(),
-                                                  aWhichClipboard,
-                                                  &clipboardDataLength);
+                mContext->GetClipboardData(flavorStr.get(),
+                                           aWhichClipboard,
+                                           &clipboardDataLength);
             if (!clipboardData)
                 continue;
 
             nsCOMPtr<nsIInputStream> byteStream;
             NS_NewByteInputStream(getter_AddRefs(byteStream),
                                   clipboardData,
                                   clipboardDataLength,
                                   NS_ASSIGNMENT_COPY);
             aTransferable->SetTransferData(flavorStr.get(), byteStream,
                                            sizeof(nsIInputStream*));
-            free((void *)clipboardData);
+
+            mContext->ReleaseClipboardData(clipboardData);
             return NS_OK;
         }
 
         // Special case text/unicode since we can convert any
         // string into text/unicode
         if (flavorStr.EqualsLiteral(kUnicodeMime)) {
             uint32_t    clipboardDataLength;
-            const char* rawData =
-                mContext->WaitForClipboardContext(GTK_DEFAULT_MIME_TEXT,
-                                                  aWhichClipboard,
-                                                  &clipboardDataLength);
-            if (!rawData) {
+            const char* clipboardData =
+                mContext->GetClipboardData(GTK_DEFAULT_MIME_TEXT,
+                                           aWhichClipboard,
+                                           &clipboardDataLength);
+            if (!clipboardData) {
                 // If the type was text/unicode and we couldn't get
                 // text off the clipboard, run the next loop
                 // iteration.
                 continue;
             }
 
             // Convert utf-8 into our unicode format.
-            NS_ConvertUTF8toUTF16 ucs2string(rawData, clipboardDataLength);
-            const char* clipboardData = (const char *)ToNewUnicode(ucs2string);
-            clipboardDataLength = ucs2string.Length() * 2;
+            NS_ConvertUTF8toUTF16 ucs2string(clipboardData, clipboardDataLength);
+            const char* unicodeData = (const char *)ToNewUnicode(ucs2string);
+            uint32_t unicodeDataLength = ucs2string.Length() * 2;
             SetTransferableData(aTransferable, flavorStr,
-                                clipboardData, clipboardDataLength);
-            free((void *)rawData);
-            free((void *)clipboardData);
+                                unicodeData, unicodeDataLength);
+            free((void *)unicodeData);
+
+            mContext->ReleaseClipboardData(clipboardData);
             return NS_OK;
         }
 
 
         uint32_t clipboardDataLength;
-        const char* clipboardData = mContext->WaitForClipboardContext(
+        const char* clipboardData = mContext->GetClipboardData(
             flavorStr.get(), aWhichClipboard, &clipboardDataLength);
 
         if (clipboardData) {
             // Special case text/html since we can convert into UCS2
             if (flavorStr.EqualsLiteral(kHTMLMime)) {
                 char16_t* htmlBody = nullptr;
                 int32_t htmlBodyLen = 0;
                 // Convert text/html into our unicode format
                 ConvertHTMLtoUCS2(clipboardData, clipboardDataLength,
                                   &htmlBody, htmlBodyLen);
-                free((void *)clipboardData);
 
                 // Try next data format?
-                if (!htmlBodyLen)
+                if (!htmlBodyLen) {
+                    mContext->ReleaseClipboardData(clipboardData);
                     continue;
+                }
 
                 SetTransferableData(aTransferable, flavorStr,
                                     (const char*)htmlBody, htmlBodyLen * 2);
                 free(htmlBody);
             } else {
                 SetTransferableData(aTransferable, flavorStr,
                                     clipboardData, clipboardDataLength);
-                free((void *)clipboardData);
             }
+
+            mContext->ReleaseClipboardData(clipboardData);
             return NS_OK;
         }
     }
 
     return NS_OK;
 }
 
 NS_IMETHODIMP

--- a/widget/gtk/nsClipboard.h
+++ b/widget/gtk/nsClipboard.h
@@ -13,20 +13,21 @@
 #include "nsIBinaryOutputStream.h"
 #include <gtk/gtk.h>
 
 // Default Gtk MIME for text
 #define GTK_DEFAULT_MIME_TEXT "UTF8_STRING"
 
 class nsRetrievalContext {
 public:
-    // Returned data must be released by free()
-    virtual const char* WaitForClipboardContext(const char* aMimeType,
-                                                int32_t aWhichClipboard,
-                                                uint32_t* aContentLength) = 0;
+    virtual const char* GetClipboardData(const char* aMimeType,
+                                         int32_t aWhichClipboard,
+                                         uint32_t* aContentLength) = 0;
+    virtual void ReleaseClipboardData(const char* aClipboardData) = 0;
+
     virtual GdkAtom* GetTargets(int32_t aWhichClipboard,
                                 int* aTargetNum) = 0;
 
     nsRetrievalContext() {};
     virtual ~nsRetrievalContext() {};
 
 protected:
     // Idle timeout for receiving selection and property notify events (microsec)

--- a/widget/gtk/nsClipboardX11.cpp
+++ b/widget/gtk/nsClipboardX11.cpp
@@ -277,19 +277,19 @@ nsRetrievalContextX11::GetTargets(int32_
 
   gtk_selection_data_free(selection_data);
 
   *aTargetNums = n_targets;
   return targets;
 }
 
 const char*
-nsRetrievalContextX11::WaitForClipboardContext(const char* aMimeType,
-                                               int32_t aWhichClipboard,
-                                               uint32_t* aContentLength)
+nsRetrievalContextX11::GetClipboardData(const char* aMimeType,
+                                        int32_t aWhichClipboard,
+                                        uint32_t* aContentLength)
 {
     GtkClipboard *clipboard;
     clipboard = gtk_clipboard_get(GetSelectionAtom(aWhichClipboard));
 
     GtkSelectionData *selectionData = WaitForContents(clipboard, aMimeType);
     if (!selectionData)
         return nullptr;
 
@@ -301,8 +301,13 @@ nsRetrievalContextX11::WaitForClipboardC
         memcpy(clipboardData, gtk_selection_data_get_data(selectionData),
             sizeof(char)*contentLength);
     }
     gtk_selection_data_free(selectionData);
 
     *aContentLength = contentLength;
     return (const char*)clipboardData;
 }
+
+void nsRetrievalContextX11::ReleaseClipboardData(const char* aClipboardData)
+{
+    free((void *)aClipboardData);
+}

--- a/widget/gtk/nsClipboardX11.h
+++ b/widget/gtk/nsClipboardX11.h
@@ -11,18 +11,21 @@
 #include "nsIClipboard.h"
 #include <gtk/gtk.h>
 
 class nsRetrievalContextX11 : public nsRetrievalContext
 {
 public:
     enum State { INITIAL, COMPLETED, TIMED_OUT };
 
-    virtual const char* WaitForClipboardContext(const char* aMimeType,
-        int32_t aWhichClipboard, uint32_t* aContentLength) override;
+    virtual const char* GetClipboardData(const char* aMimeType,
+                                         int32_t aWhichClipboard,
+                                         uint32_t* aContentLength) override;
+    virtual void ReleaseClipboardData(const char* aClipboardData);
+
     virtual GdkAtom* GetTargets(int32_t aWhichClipboard,
                                 int* aTargetNums) override;
 
     // Call this when data has been retrieved.
     void Complete(GtkSelectionData* aData, int aDataRequestNumber);
 
     nsRetrievalContextX11();
     virtual ~nsRetrievalContextX11() override;