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

/* vim: set ts=4 et sw=4 tw=80: */

/* 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 "nsDragService.h"

#include "nsArrayUtils.h"

#include "nsIObserverService.h"

#include "nsWidgetsCID.h"

#include "nsWindow.h"

#include "nsIServiceManager.h"

#include "nsXPCOM.h"

#include "nsISupportsPrimitives.h"

#include "nsIIOService.h"

#include "nsIFileURL.h"

#include "nsNetUtil.h"

#include "mozilla/Logging.h"

#include "nsTArray.h"

#include "nsPrimitiveHelpers.h"

#include "prtime.h"

#include "prthread.h"

#include <dlfcn.h>

#include <gtk/gtk.h>

#include <gdk/gdkx.h>

#include "nsCRT.h"

#include "mozilla/BasicEvents.h"

#include "mozilla/Services.h"

#include "mozilla/ClearOnShutdown.h"

#include "gfxXlibSurface.h"

#include "gfxContext.h"

#include "nsImageToPixbuf.h"

#include "nsPresContext.h"

#include "nsIContent.h"

#include "nsIDocument.h"

#include "nsViewManager.h"

#include "nsIFrame.h"

#include "nsGtkUtils.h"

#include "nsGtkKeyUtils.h"

#include "mozilla/gfx/2D.h"

#include "gfxPlatform.h"

#include "ScreenHelperGTK.h"

#include "nsArrayUtils.h"

#ifdef MOZ_WAYLAND

#include "nsClipboardWayland.h"

#endif

using namespace mozilla;

using namespace mozilla::gfx;

// This sets how opaque the drag image is

#define DRAG_IMAGE_ALPHA_LEVEL 0.5

// These values are copied from GtkDragResult (rather than using GtkDragResult

// directly) so that this code can be compiled against versions of GTK+ that

// do not have GtkDragResult.

// GtkDragResult is available from GTK+ version 2.12.

enum {

  MOZ_GTK_DRAG_RESULT_SUCCESS,

  MOZ_GTK_DRAG_RESULT_NO_TARGET

};

static LazyLogModule sDragLm("nsDragService");

// data used for synthetic periodic motion events sent to the source widget

// grabbing real events for the drag.

static guint sMotionEventTimerID;

static GdkEvent *sMotionEvent;

static GtkWidget *sGrabWidget;

static const char gMimeListType[] = "application/x-moz-internal-item-list";

static const char gMozUrlType[] = "_NETSCAPE_URL";

static const char gTextUriListType[] = "text/uri-list";

static const char gTextPlainUTF8Type[] = "text/plain;charset=utf-8";

static void

invisibleSourceDragBegin(GtkWidget        *aWidget,

                         GdkDragContext   *aContext,

                         gpointer          aData);

static void

invisibleSourceDragEnd(GtkWidget        *aWidget,

                       GdkDragContext   *aContext,

                       gpointer          aData);

static gboolean

invisibleSourceDragFailed(GtkWidget        *aWidget,

                          GdkDragContext   *aContext,

                          gint              aResult,

                          gpointer          aData);

static void

invisibleSourceDragDataGet(GtkWidget        *aWidget,

                           GdkDragContext   *aContext,

                           GtkSelectionData *aSelectionData,

                           guint             aInfo,

                           guint32           aTime,

                           gpointer          aData);

nsDragService::nsDragService()

    : mScheduledTask(eDragTaskNone)

    , mTaskSource(0)

#ifdef MOZ_WAYLAND

    , mPendingWaylandDragContext(nullptr)

    , mTargetWaylandDragContext(nullptr)

#endif

{

    // We have to destroy the hidden widget before the event loop stops

    // running.

    nsCOMPtr<nsIObserverService> obsServ =

        mozilla::services::GetObserverService();

    obsServ->AddObserver(this, "quit-application", false);

    // our hidden source widget

    // Using an offscreen window works around bug 983843.

    mHiddenWidget = gtk_offscreen_window_new();

    // make sure that the widget is realized so that

    // we can use it as a drag source.

    gtk_widget_realize(mHiddenWidget);

    // hook up our internal signals so that we can get some feedback

    // from our drag source

    g_signal_connect(mHiddenWidget, "drag_begin",

                     G_CALLBACK(invisibleSourceDragBegin), this);

    g_signal_connect(mHiddenWidget, "drag_data_get",

                     G_CALLBACK(invisibleSourceDragDataGet), this);

    g_signal_connect(mHiddenWidget, "drag_end",

                     G_CALLBACK(invisibleSourceDragEnd), this);

    // drag-failed is available from GTK+ version 2.12

    guint dragFailedID = g_signal_lookup("drag-failed",

                                         G_TYPE_FROM_INSTANCE(mHiddenWidget));

    if (dragFailedID) {

        g_signal_connect_closure_by_id(mHiddenWidget, dragFailedID, 0,

                                       g_cclosure_new(G_CALLBACK(invisibleSourceDragFailed),

                                                      this, nullptr),

                                       FALSE);

    }

    // set up our logging module

    MOZ_LOG(sDragLm, LogLevel::Debug, ("nsDragService::nsDragService"));

    mCanDrop = false;

    mTargetDragDataReceived = false;

    mTargetDragData = 0;

    mTargetDragDataLen = 0;

}

nsDragService::~nsDragService()

{

    MOZ_LOG(sDragLm, LogLevel::Debug, ("nsDragService::~nsDragService"));

    if (mTaskSource)

        g_source_remove(mTaskSource);

}

NS_IMPL_ISUPPORTS_INHERITED(nsDragService, nsBaseDragService, nsIObserver)

mozilla::StaticRefPtr<nsDragService> sDragServiceInstance;

/* static */ already_AddRefed<nsDragService>

nsDragService::GetInstance()

{

  if (gfxPlatform::IsHeadless()) {

    return nullptr;

  }

  if (!sDragServiceInstance) {

    sDragServiceInstance = new nsDragService();

    ClearOnShutdown(&sDragServiceInstance);

  }

  RefPtr<nsDragService> service = sDragServiceInstance.get();

  return service.forget();

}

// nsIObserver

NS_IMETHODIMP

nsDragService::Observe(nsISupports *aSubject, const char *aTopic,

                       const char16_t *aData)

{

  if (!nsCRT::strcmp(aTopic, "quit-application")) {

    MOZ_LOG(sDragLm, LogLevel::Debug,

           ("nsDragService::Observe(\"quit-application\")"));

    if (mHiddenWidget) {

      gtk_widget_destroy(mHiddenWidget);

      mHiddenWidget = 0;

    }

    TargetResetData();

  } else {

    MOZ_ASSERT_UNREACHABLE("unexpected topic");

    return NS_ERROR_UNEXPECTED;

  }

  return NS_OK;

}

// Support for periodic drag events

// http://www.whatwg.org/specs/web-apps/current-work/multipage/dnd.html#drag-and-drop-processing-model

// and the Xdnd protocol both recommend that drag events are sent periodically,

// but GTK does not normally provide this.

//

// Here GTK is periodically stimulated by copies of the most recent mouse

// motion events so as to send drag position messages to the destination when

// appropriate (after it has received a status event from the previous

// message).

//

// (If events were sent only on the destination side then the destination

// would have no message to which it could reply with a drag status.  Without

// sending a drag status to the source, the destination would not be able to

// change its feedback re whether it could accept the drop, and so the

// source's behavior on drop will not be consistent.)

static gboolean

DispatchMotionEventCopy(gpointer aData)

{

    // Clear the timer id before OnSourceGrabEventAfter is called during event

    // dispatch.

    sMotionEventTimerID = 0;

    GdkEvent *event = sMotionEvent;

    sMotionEvent = nullptr;

    // If there is no longer a grab on the widget, then the drag is over and

    // there is no need to continue drag motion.

    if (gtk_widget_has_grab(sGrabWidget)) {

        gtk_propagate_event(sGrabWidget, event);

    }

    gdk_event_free(event);

    // Cancel this timer;

    // We've already started another if the motion event was dispatched.

    return FALSE;

}

static void

OnSourceGrabEventAfter(GtkWidget *widget, GdkEvent *event, gpointer user_data)

{

    // If there is no longer a grab on the widget, then the drag motion is

    // over (though the data may not be fetched yet).

    if (!gtk_widget_has_grab(sGrabWidget))

        return;

    if (event->type == GDK_MOTION_NOTIFY) {

        if (sMotionEvent) {

            gdk_event_free(sMotionEvent);

        }

        sMotionEvent = gdk_event_copy(event);

        // Update the cursor position.  The last of these recorded gets used for

        // the eDragEnd event.

        nsDragService *dragService = static_cast<nsDragService*>(user_data);

        gint scale = ScreenHelperGTK::GetGTKMonitorScaleFactor();

        auto p = LayoutDeviceIntPoint::Round(event->motion.x_root * scale,

                                             event->motion.y_root * scale);

        dragService->SetDragEndPoint(p);

    } else if (sMotionEvent && (event->type == GDK_KEY_PRESS ||

                                event->type == GDK_KEY_RELEASE)) {

        // Update modifier state from key events.

        sMotionEvent->motion.state = event->key.state;

    } else {

        return;

    }

    if (sMotionEventTimerID) {

        g_source_remove(sMotionEventTimerID);

    }

    // G_PRIORITY_DEFAULT_IDLE is lower priority than GDK's redraw idle source

    // and lower than GTK's idle source that sends drag position messages after

    // motion-notify signals.

    //

    // http://www.whatwg.org/specs/web-apps/current-work/multipage/dnd.html#drag-and-drop-processing-model

    // recommends an interval of 350ms +/- 200ms.

    sMotionEventTimerID =

        g_timeout_add_full(G_PRIORITY_DEFAULT_IDLE, 350,

                           DispatchMotionEventCopy, nullptr, nullptr);

}

static GtkWindow*

GetGtkWindow(nsIDocument *aDocument)

{

    if (!aDocument)

        return nullptr;

    nsCOMPtr<nsIPresShell> presShell = aDocument->GetShell();

    if (!presShell)

        return nullptr;

    RefPtr<nsViewManager> vm = presShell->GetViewManager();

    if (!vm)

        return nullptr;

    nsCOMPtr<nsIWidget> widget;

    vm->GetRootWidget(getter_AddRefs(widget));

    if (!widget)

        return nullptr;

    GtkWidget *gtkWidget =

        static_cast<nsWindow*>(widget.get())->GetMozContainerWidget();

    if (!gtkWidget)

        return nullptr;

    GtkWidget *toplevel = nullptr;

    toplevel = gtk_widget_get_toplevel(gtkWidget);

    if (!GTK_IS_WINDOW(toplevel))

        return nullptr;

    return GTK_WINDOW(toplevel);

}

// nsIDragService

NS_IMETHODIMP

nsDragService::InvokeDragSession(nsINode *aDOMNode,

                                 const nsACString& aPrincipalURISpec,

                                 nsIArray * aArrayTransferables,

                                 uint32_t aActionType,

                                 nsContentPolicyType aContentPolicyType =

                                   nsIContentPolicy::TYPE_OTHER)

{

    MOZ_LOG(sDragLm, LogLevel::Debug, ("nsDragService::InvokeDragSession"));

    // If the previous source drag has not yet completed, signal handlers need

    // to be removed from sGrabWidget and dragend needs to be dispatched to

    // the source node, but we can't call EndDragSession yet because we don't

    // know whether or not the drag succeeded.

    if (mSourceNode)

        return NS_ERROR_NOT_AVAILABLE;

    return nsBaseDragService::InvokeDragSession(aDOMNode, aPrincipalURISpec,

                                                aArrayTransferables,

                                                aActionType,

                                                aContentPolicyType);

}

// nsBaseDragService

nsresult

nsDragService::InvokeDragSessionImpl(nsIArray* aArrayTransferables,

                                     const Maybe<CSSIntRegion>& aRegion,

                                     uint32_t aActionType)

{

    // make sure that we have an array of transferables to use

    if (!aArrayTransferables)

        return NS_ERROR_INVALID_ARG;

    // set our reference to the transferables.  this will also addref

    // the transferables since we're going to hang onto this beyond the

    // length of this call

    mSourceDataItems = aArrayTransferables;

    // get the list of items we offer for drags

    GtkTargetList *sourceList = GetSourceList();

    if (!sourceList)

        return NS_OK;

    // save our action type

    GdkDragAction action = GDK_ACTION_DEFAULT;

    if (aActionType & DRAGDROP_ACTION_COPY)

        action = (GdkDragAction)(action | GDK_ACTION_COPY);

    if (aActionType & DRAGDROP_ACTION_MOVE)

        action = (GdkDragAction)(action | GDK_ACTION_MOVE);

    if (aActionType & DRAGDROP_ACTION_LINK)

        action = (GdkDragAction)(action | GDK_ACTION_LINK);

    // Create a fake event for the drag so we can pass the time (so to speak).

    // If we don't do this, then, when the timestamp for the pending button

    // release event is used for the ungrab, the ungrab can fail due to the

    // timestamp being _earlier_ than CurrentTime.

    GdkEvent event;

    memset(&event, 0, sizeof(GdkEvent));

    event.type = GDK_BUTTON_PRESS;

    event.button.window = gtk_widget_get_window(mHiddenWidget);

    event.button.time = nsWindow::GetLastUserInputTime();

    // Put the drag widget in the window group of the source node so that the

    // gtk_grab_add during gtk_drag_begin is effective.

    // gtk_window_get_group(nullptr) returns the default window group.

    GtkWindowGroup *window_group =

        gtk_window_get_group(GetGtkWindow(mSourceDocument));

    gtk_window_group_add_window(window_group,

                                GTK_WINDOW(mHiddenWidget));

#ifdef MOZ_WIDGET_GTK

    // Get device for event source

    GdkDisplay *display = gdk_display_get_default();

    GdkDeviceManager *device_manager = gdk_display_get_device_manager(display);

    event.button.device = gdk_device_manager_get_client_pointer(device_manager);

#endif

    // start our drag.

    GdkDragContext *context = gtk_drag_begin(mHiddenWidget,

                                             sourceList,

                                             action,

                                             1,

                                             &event);

    nsresult rv;

    if (context) {

        StartDragSession();

        // GTK uses another hidden window for receiving mouse events.

        sGrabWidget = gtk_window_group_get_current_grab(window_group);

        if (sGrabWidget) {

            g_object_ref(sGrabWidget);

            // Only motion and key events are required but connect to

            // "event-after" as this is never blocked by other handlers.

            g_signal_connect(sGrabWidget, "event-after",

                             G_CALLBACK(OnSourceGrabEventAfter), this);

        }

        // We don't have a drag end point yet.

        mEndDragPoint = LayoutDeviceIntPoint(-1, -1);

        rv = NS_OK;

    }

    else {

        rv = NS_ERROR_FAILURE;

    }

    gtk_target_list_unref(sourceList);

    return rv;

}

bool

nsDragService::SetAlphaPixmap(SourceSurface *aSurface,

                              GdkDragContext *aContext,

                              int32_t aXOffset,

                              int32_t aYOffset,

                              const LayoutDeviceIntRect& dragRect)

{

    GdkScreen* screen = gtk_widget_get_screen(mHiddenWidget);

    // Transparent drag icons need, like a lot of transparency-related things,

    // a compositing X window manager

    if (!gdk_screen_is_composited(screen))

      return false;

#ifdef cairo_image_surface_create

#error "Looks like we're including Mozilla's cairo instead of system cairo"

#endif

    // Prior to GTK 3.9.12, cairo surfaces passed into gtk_drag_set_icon_surface

    // had their shape information derived from the alpha channel and used with

    // the X SHAPE extension instead of being displayed as an ARGB window.

    // See bug 1249604.

    if (gtk_check_version(3, 9, 12))

      return false;

    // TODO: grab X11 pixmap or image data instead of expensive readback.

    cairo_surface_t *surf = cairo_image_surface_create(CAIRO_FORMAT_ARGB32,

                                                       dragRect.width,

                                                       dragRect.height);

    if (!surf)

        return false;

    RefPtr<DrawTarget> dt = gfxPlatform::CreateDrawTargetForData(

                                cairo_image_surface_get_data(surf),

                                nsIntSize(dragRect.width, dragRect.height),

                                cairo_image_surface_get_stride(surf),

                                SurfaceFormat::B8G8R8A8);

    if (!dt)

        return false;

    dt->ClearRect(Rect(0, 0, dragRect.width, dragRect.height));

    dt->DrawSurface(aSurface,

                    Rect(0, 0, dragRect.width, dragRect.height),

                    Rect(0, 0, dragRect.width, dragRect.height),

                    DrawSurfaceOptions(),

                    DrawOptions(DRAG_IMAGE_ALPHA_LEVEL, CompositionOp::OP_SOURCE));

    cairo_surface_mark_dirty(surf);

    cairo_surface_set_device_offset(surf, -aXOffset, -aYOffset);

    // Ensure that the surface is drawn at the correct scale on HiDPI displays.

    static auto sCairoSurfaceSetDeviceScalePtr =

        (void (*)(cairo_surface_t*,double,double))

        dlsym(RTLD_DEFAULT, "cairo_surface_set_device_scale");

    if (sCairoSurfaceSetDeviceScalePtr) {

        gint scale = ScreenHelperGTK::GetGTKMonitorScaleFactor();

        sCairoSurfaceSetDeviceScalePtr(surf, scale, scale);

    }

    gtk_drag_set_icon_surface(aContext, surf);

    cairo_surface_destroy(surf);

    return true;

}

NS_IMETHODIMP

nsDragService::StartDragSession()

{

    MOZ_LOG(sDragLm, LogLevel::Debug, ("nsDragService::StartDragSession"));

    return nsBaseDragService::StartDragSession();

}

NS_IMETHODIMP

nsDragService::EndDragSession(bool aDoneDrag, uint32_t aKeyModifiers)

{

    MOZ_LOG(sDragLm, LogLevel::Debug, ("nsDragService::EndDragSession %d",

                                   aDoneDrag));

    if (sGrabWidget) {

        g_signal_handlers_disconnect_by_func(sGrabWidget,

             FuncToGpointer(OnSourceGrabEventAfter), this);

        g_object_unref(sGrabWidget);

        sGrabWidget = nullptr;

        if (sMotionEventTimerID) {

            g_source_remove(sMotionEventTimerID);

            sMotionEventTimerID = 0;

        }

        if (sMotionEvent) {

            gdk_event_free(sMotionEvent);

            sMotionEvent = nullptr;

        }

    }

    // unset our drag action

    SetDragAction(DRAGDROP_ACTION_NONE);

    // We're done with the drag context.

    mTargetDragContextForRemote = nullptr;

#ifdef MOZ_WAYLAND

    mTargetWaylandDragContextForRemote = nullptr;

#endif

    return nsBaseDragService::EndDragSession(aDoneDrag, aKeyModifiers);

}

// nsIDragSession

NS_IMETHODIMP

nsDragService::SetCanDrop(bool aCanDrop)

{

    MOZ_LOG(sDragLm, LogLevel::Debug, ("nsDragService::SetCanDrop %d",

                                   aCanDrop));

    mCanDrop = aCanDrop;

    return NS_OK;

}

NS_IMETHODIMP

nsDragService::GetCanDrop(bool *aCanDrop)

{

    MOZ_LOG(sDragLm, LogLevel::Debug, ("nsDragService::GetCanDrop"));

    *aCanDrop = mCanDrop;

    return NS_OK;

}

static void

UTF16ToNewUTF8(const char16_t* aUTF16,

               uint32_t aUTF16Len,

               char** aUTF8,

               uint32_t* aUTF8Len)

{

  nsDependentSubstring utf16(aUTF16, aUTF16Len);

  *aUTF8 = ToNewUTF8String(utf16, aUTF8Len);

}

static void

UTF8ToNewUTF16(const char* aUTF8,

               uint32_t aUTF8Len,

               char16_t** aUTF16,

               uint32_t* aUTF16Len)

{

  nsDependentCSubstring utf8(aUTF8, aUTF8Len);

  *aUTF16 = UTF8ToNewUnicode(utf8, aUTF16Len);

}

// count the number of URIs in some text/uri-list format data.

static uint32_t

CountTextUriListItems(const char *data,

                      uint32_t datalen)

{

    const char *p = data;

    const char *endPtr = p + datalen;

    uint32_t count = 0;

    while (p < endPtr) {

        // skip whitespace (if any)

        while (p < endPtr && *p != '\0' && isspace(*p))

            p++;

        // if we aren't at the end of the line ...

        if (p != endPtr && *p != '\0' && *p != '\n' && *p != '\r')

            count++;

        // skip to the end of the line

        while (p < endPtr && *p != '\0' && *p != '\n')

            p++;

        p++; // skip the actual newline as well.

    }

    return count;

}

// extract an item from text/uri-list formatted data and convert it to

// unicode.

static void

GetTextUriListItem(const char *data,

                   uint32_t datalen,

                   uint32_t aItemIndex,

                   char16_t **convertedText,

                   uint32_t *convertedTextLen)

{

    const char *p = data;

    const char *endPtr = p + datalen;

    unsigned int count = 0;

    *convertedText = nullptr;

    while (p < endPtr) {

        // skip whitespace (if any)

        while (p < endPtr && *p != '\0' && isspace(*p))

            p++;

        // if we aren't at the end of the line, we have a url

        if (p != endPtr && *p != '\0' && *p != '\n' && *p != '\r')

            count++;

        // this is the item we are after ...

        if (aItemIndex + 1 == count) {

            const char *q = p;

            while (q < endPtr && *q != '\0' && *q != '\n' && *q != '\r')

              q++;

            UTF8ToNewUTF16(p, q - p, convertedText, convertedTextLen);

            break;

        }

        // skip to the end of the line

        while (p < endPtr && *p != '\0' && *p != '\n')

            p++;

        p++; // skip the actual newline as well.

    }

    // didn't find the desired item, so just pass the whole lot

    if (!*convertedText) {

        UTF8ToNewUTF16(data, datalen, convertedText, convertedTextLen);

    }

}

NS_IMETHODIMP

nsDragService::GetNumDropItems(uint32_t * aNumItems)

{

    MOZ_LOG(sDragLm, LogLevel::Debug, ("nsDragService::GetNumDropItems"));

    if (!mTargetWidget) {

        MOZ_LOG(sDragLm, LogLevel::Debug,

               ("*** warning: GetNumDropItems \

               called without a valid target widget!\n"));

        *aNumItems = 0;

        return NS_OK;

    }

#ifdef MOZ_WAYLAND

    // TODO: Wayland implementation of text/uri-list.

    if (!mTargetDragContext) {

        *aNumItems = 1;

        return NS_OK;

    }

#endif

    bool isList = IsTargetContextList();

    if (isList)

        mSourceDataItems->GetLength(aNumItems);

    else {

        GdkAtom gdkFlavor = gdk_atom_intern(gTextUriListType, FALSE);

        GetTargetDragData(gdkFlavor);

        if (mTargetDragData) {

            const char *data = reinterpret_cast<char*>(mTargetDragData);

            *aNumItems = CountTextUriListItems(data, mTargetDragDataLen);

        } else

            *aNumItems = 1;

    }

    MOZ_LOG(sDragLm, LogLevel::Debug, ("%d items", *aNumItems));

    return NS_OK;

}

NS_IMETHODIMP

nsDragService::GetData(nsITransferable * aTransferable,

                       uint32_t aItemIndex)

{

    MOZ_LOG(sDragLm, LogLevel::Debug, ("nsDragService::GetData %d", aItemIndex));

    // make sure that we have a transferable

    if (!aTransferable)

        return NS_ERROR_INVALID_ARG;

    if (!mTargetWidget) {

        MOZ_LOG(sDragLm, LogLevel::Debug,

               ("*** warning: GetData \

               called without a valid target widget!\n"));

        return NS_ERROR_FAILURE;

    }

    // get flavor list that includes all acceptable flavors (including

    // ones obtained through conversion). Flavors are nsISupportsStrings

    // so that they can be seen from JS.

    nsCOMPtr<nsIArray> flavorList;

    nsresult rv = aTransferable->FlavorsTransferableCanImport(

                        getter_AddRefs(flavorList));

    if (NS_FAILED(rv))

        return rv;

    // count the number of flavors

    uint32_t cnt;

    flavorList->GetLength(&cnt);

    unsigned int i;

    // check to see if this is an internal list

    bool isList = IsTargetContextList();

    if (isList) {

        MOZ_LOG(sDragLm, LogLevel::Debug, ("it's a list..."));

        // find a matching flavor

        for (i = 0; i < cnt; ++i) {

            nsCOMPtr<nsISupportsCString> currentFlavor;

            currentFlavor = do_QueryElementAt(flavorList, i);

            if (!currentFlavor)

                continue;

            nsCString flavorStr;

            currentFlavor->ToString(getter_Copies(flavorStr));

            MOZ_LOG(sDragLm,

                   LogLevel::Debug,

                   ("flavor is %s\n", flavorStr.get()));

            // get the item with the right index

            nsCOMPtr<nsITransferable> item =

                do_QueryElementAt(mSourceDataItems, aItemIndex);

            if (!item)

                continue;

            nsCOMPtr<nsISupports> data;

            uint32_t tmpDataLen = 0;

            MOZ_LOG(sDragLm, LogLevel::Debug,

                   ("trying to get transfer data for %s\n",

                   flavorStr.get()));

            rv = item->GetTransferData(flavorStr.get(),

                                       getter_AddRefs(data),

                                       &tmpDataLen);

            if (NS_FAILED(rv)) {

                MOZ_LOG(sDragLm, LogLevel::Debug, ("failed.\n"));

                continue;

            }

            MOZ_LOG(sDragLm, LogLevel::Debug, ("succeeded.\n"));

            rv = aTransferable->SetTransferData(flavorStr.get(), data,

                                                tmpDataLen);

            if (NS_FAILED(rv)) {

                MOZ_LOG(sDragLm,

                       LogLevel::Debug,

                       ("fail to set transfer data into transferable!\n"));

                continue;

            }

            // ok, we got the data

            return NS_OK;

        }

        // if we got this far, we failed

        return NS_ERROR_FAILURE;

    }

    // Now walk down the list of flavors. When we find one that is

    // actually present, copy out the data into the transferable in that

    // format. SetTransferData() implicitly handles conversions.

    for ( i = 0; i < cnt; ++i ) {

        nsCOMPtr<nsISupportsCString> currentFlavor;

        currentFlavor = do_QueryElementAt(flavorList, i);

        if (currentFlavor) {

            // find our gtk flavor

            nsCString flavorStr;

            currentFlavor->ToString(getter_Copies(flavorStr));

            GdkAtom gdkFlavor = gdk_atom_intern(flavorStr.get(), FALSE);

            MOZ_LOG(sDragLm, LogLevel::Debug,

                   ("looking for data in type %s, gdk flavor %p\n",

                   flavorStr.get(), gdkFlavor));

            bool dataFound = false;

            if (gdkFlavor) {

                GetTargetDragData(gdkFlavor);

            }

            if (mTargetDragData) {

                MOZ_LOG(sDragLm, LogLevel::Debug, ("dataFound = true\n"));

                dataFound = true;

            }

            else {

                MOZ_LOG(sDragLm, LogLevel::Debug, ("dataFound = false\n"));

                // Dragging and dropping from the file manager would cause us

                // to parse the source text as a nsIFile URL.

                if (flavorStr.EqualsLiteral(kFileMime)) {

                    gdkFlavor = gdk_atom_intern(kTextMime, FALSE);

                    GetTargetDragData(gdkFlavor);

                    if (!mTargetDragData) {

                        gdkFlavor = gdk_atom_intern(gTextUriListType, FALSE);

                        GetTargetDragData(gdkFlavor);

                    }

                    if (mTargetDragData) {

                        const char* text = static_cast<char*>(mTargetDragData);

                        char16_t* convertedText = nullptr;

                        uint32_t convertedTextLen = 0;

                        GetTextUriListItem(text, mTargetDragDataLen, aItemIndex,

                                           &convertedText, &convertedTextLen);

                        if (convertedText) {

                            nsCOMPtr<nsIIOService> ioService = do_GetIOService(&rv);

                            nsCOMPtr<nsIURI> fileURI;

                            rv = ioService->NewURI(NS_ConvertUTF16toUTF8(convertedText),

                                                   nullptr, nullptr, getter_AddRefs(fileURI));

                            if (NS_SUCCEEDED(rv)) {

                                nsCOMPtr<nsIFileURL> fileURL = do_QueryInterface(fileURI, &rv);

                                if (NS_SUCCEEDED(rv)) {

                                    nsCOMPtr<nsIFile> file;

                                    rv = fileURL->GetFile(getter_AddRefs(file));

                                    if (NS_SUCCEEDED(rv)) {

                                        // The common wrapping code at the end of

                                        // this function assumes the data is text

                                        // and calls text-specific operations.

                                        // Make a secret hideout here for nsIFile

                                        // objects and return early.

                                        aTransferable->SetTransferData(flavorStr.get(), file,

                                                                       convertedTextLen);

                                        g_free(convertedText);

                                        return NS_OK;

                                    }

                                }

                            }

                            g_free(convertedText);

                        }

                        continue;

                    }

                }

                // if we are looking for text/unicode and we fail to find it

                // on the clipboard first, try again with text/plain. If that

                // is present, convert it to unicode.

                if (flavorStr.EqualsLiteral(kUnicodeMime)) {

                    MOZ_LOG(sDragLm, LogLevel::Debug,

                           ("we were looking for text/unicode... \

                           trying with text/plain;charset=utf-8\n"));

                    gdkFlavor = gdk_atom_intern(gTextPlainUTF8Type, FALSE);

                    GetTargetDragData(gdkFlavor);

                    if (mTargetDragData) {

                        MOZ_LOG(sDragLm, LogLevel::Debug, ("Got textplain data\n"));

                        const char* castedText =

                                    reinterpret_cast<char*>(mTargetDragData);

                        char16_t* convertedText = nullptr;

                        NS_ConvertUTF8toUTF16 ucs2string(castedText,

                                                         mTargetDragDataLen);

                        convertedText = ToNewUnicode(ucs2string);

                        if ( convertedText ) {

                            MOZ_LOG(sDragLm, LogLevel::Debug,

                                   ("successfully converted plain text \

                                   to unicode.\n"));

                            // out with the old, in with the new

                            g_free(mTargetDragData);

                            mTargetDragData = convertedText;

                            mTargetDragDataLen = ucs2string.Length() * 2;

                            dataFound = true;

                        } // if plain text data on clipboard

                    } else {

                        MOZ_LOG(sDragLm, LogLevel::Debug,

                               ("we were looking for text/unicode... \

                               trying again with text/plain\n"));

                        gdkFlavor = gdk_atom_intern(kTextMime, FALSE);

                        GetTargetDragData(gdkFlavor);

                        if (mTargetDragData) {

                            MOZ_LOG(sDragLm, LogLevel::Debug, ("Got textplain data\n"));

                            const char* castedText =

                                        reinterpret_cast<char*>(mTargetDragData);

                            char16_t* convertedText = nullptr;

                            uint32_t convertedTextLen = 0;

                            UTF8ToNewUTF16(castedText, mTargetDragDataLen,

                                           &convertedText, &convertedTextLen);

                            if ( convertedText ) {

                                MOZ_LOG(sDragLm, LogLevel::Debug,

                                       ("successfully converted plain text \

                                       to unicode.\n"));

                                // out with the old, in with the new

                                g_free(mTargetDragData);

                                mTargetDragData = convertedText;

                                mTargetDragDataLen = convertedTextLen * 2;

                                dataFound = true;

                            } // if plain text data on clipboard

                        } // if plain text flavor present

                    } // if plain text charset=utf-8 flavor present

                } // if looking for text/unicode

                // if we are looking for text/x-moz-url and we failed to find

                // it on the clipboard, try again with text/uri-list, and then

                // _NETSCAPE_URL

                if (flavorStr.EqualsLiteral(kURLMime)) {

                    MOZ_LOG(sDragLm, LogLevel::Debug,

                           ("we were looking for text/x-moz-url...\

                           trying again with text/uri-list\n"));

                    gdkFlavor = gdk_atom_intern(gTextUriListType, FALSE);

                    GetTargetDragData(gdkFlavor);

                    if (mTargetDragData) {

                        MOZ_LOG(sDragLm, LogLevel::Debug,

                               ("Got text/uri-list data\n"));

                        const char *data =

                                   reinterpret_cast<char*>(mTargetDragData);

                        char16_t* convertedText = nullptr;

                        uint32_t convertedTextLen = 0;

                        GetTextUriListItem(data, mTargetDragDataLen, aItemIndex,

                                           &convertedText, &convertedTextLen);

                        if ( convertedText ) {

                            MOZ_LOG(sDragLm, LogLevel::Debug,

                                   ("successfully converted \

                                   _NETSCAPE_URL to unicode.\n"));