Changeset 261911 in webkit

Timestamp:

May 20, 2020 5:39:22 AM (4 years ago)

Author:

Carlos Garcia Campos

Message:

[GTK4] Add support for drag and drop operations
​https://bugs.webkit.org/show_bug.cgi?id=211779

Reviewed by Adrian Perez de Castro.

Source/WebCore:

Move the code to create a GdkTexture from an Image from CursorGtk to ImageGtk and add Image::gdkTexture().

• platform/graphics/BitmapImage.h:
• platform/graphics/Image.h:

(WebCore::Image::gdkTexture):

• platform/graphics/gtk/ImageGtk.cpp:

(WebCore::BitmapImage::gdkTexture):

• platform/gtk/CursorGtk.cpp:

(WebCore::createCustomCursor):

Source/WebKit:

• UIProcess/API/gtk/DragSource.h:
• UIProcess/API/gtk/DragSourceGtk4.cpp:

(WebKit::DragSource::begin):

• UIProcess/API/gtk/DropTarget.h:
• UIProcess/API/gtk/DropTargetGtk4.cpp:

(WebKit::DropTarget::DropTarget):
(WebKit::DropTarget::~DropTarget):
(WebKit::DropTarget::accept):
(WebKit::DropReadAsyncData::DropReadAsyncData):
(WebKit::DropTarget::loadData):
(WebKit::DropTarget::didLoadData):
(WebKit::DropTarget::enter):
(WebKit::DropTarget::update):
(WebKit::DropTarget::didPerformAction):
(WebKit::DropTarget::leave):
(WebKit::DropTarget::drop):

Location:

trunk/Source

Files:

• WebCore/ChangeLog (modified) (1 diff)
• WebCore/platform/graphics/BitmapImage.h (modified) (1 diff)
• WebCore/platform/graphics/Image.h (modified) (2 diffs)
• WebCore/platform/graphics/gtk/ImageGtk.cpp (modified) (2 diffs)
• WebCore/platform/gtk/CursorGtk.cpp (modified) (2 diffs)
• WebKit/ChangeLog (modified) (1 diff)
• WebKit/UIProcess/API/gtk/DragSource.h (modified) (2 diffs)
• WebKit/UIProcess/API/gtk/DragSourceGtk4.cpp (modified) (1 diff)
• WebKit/UIProcess/API/gtk/DropTarget.h (modified) (4 diffs)
• WebKit/UIProcess/API/gtk/DropTargetGtk4.cpp (modified) (1 diff)

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2020-05-12  Carlos Garcia Campos  <cgarcia@igalia.com>
+
+        [GTK4] Add support for drag and drop operations
+        https://bugs.webkit.org/show_bug.cgi?id=211779
+
+        Reviewed by Adrian Perez de Castro.
+
+        Move the code to create a GdkTexture from an Image from CursorGtk to ImageGtk and add Image::gdkTexture().
+
+        * platform/graphics/BitmapImage.h:
+        * platform/graphics/Image.h:
+        (WebCore::Image::gdkTexture):
+        * platform/graphics/gtk/ImageGtk.cpp:
+        (WebCore::BitmapImage::gdkTexture):
+        * platform/gtk/CursorGtk.cpp:
+        (WebCore::createCustomCursor):
+
 2020-05-20  Sam Weinig  <weinig@apple.com>
 

trunk/Source/WebCore/platform/graphics/BitmapImage.h

@@ -131 +131 @@
 #if PLATFORM(GTK)
     GdkPixbuf* getGdkPixbuf() override;
+#if USE(GTK4)
+    GdkTexture* gdkTexture() override;
+#endif
 #endif
 

trunk/Source/WebCore/platform/graphics/Image.h

@@ -59 +59 @@
 #if PLATFORM(GTK)
 typedef struct _GdkPixbuf GdkPixbuf;
+#if USE(GTK4)
+typedef struct _GdkTexture GdkTexture;
+#endif
 #endif
 
@@ -171 +174 @@
 #if PLATFORM(GTK)
     virtual GdkPixbuf* getGdkPixbuf() { return nullptr; }
+#if USE(GTK4)
+    virtual GdkTexture* gdkTexture() { return nullptr; }
+#endif
 #endif
 

trunk/Source/WebCore/platform/graphics/gtk/ImageGtk.cpp

@@ -30 +30 @@
 #include "SharedBuffer.h"
 #include <cairo.h>
+#include <gdk/gdk.h>
 #include <wtf/glib/GRefPtr.h>
 #include <wtf/glib/GUniquePtr.h>
@@ -60 +61 @@
 }
 
+#if USE(GTK4)
+GdkTexture* BitmapImage::gdkTexture()
+{
+    RefPtr<cairo_surface_t> surface = nativeImageForCurrentFrame();
+    if (!surface)
+        return nullptr;
+
+    ASSERT(cairo_image_surface_get_format(surface.get()) == CAIRO_FORMAT_ARGB32);
+    auto width = cairo_image_surface_get_width(surface.get());
+    auto height = cairo_image_surface_get_height(surface.get());
+    auto stride = cairo_image_surface_get_stride(surface.get());
+    auto* data = cairo_image_surface_get_data(surface.get());
+    GRefPtr<GBytes> bytes = adoptGRef(g_bytes_new_with_free_func(data, height * stride, [](gpointer data) {
+        cairo_surface_destroy(static_cast<cairo_surface_t*>(data));
+    }, surface.leakRef()));
+    return gdk_memory_texture_new(width, height, GDK_MEMORY_DEFAULT, bytes.get(), stride);
 }
+#endif
+
+}

trunk/Source/WebCore/platform/gtk/CursorGtk.cpp

@@ -56 +56 @@
 static GRefPtr<GdkCursor> createCustomCursor(Image* image, const IntPoint& hotSpot)
 {
+#if USE(GTK4)
+    auto texture = adoptGRef(image->gdkTexture());
+    if (!texture)
+        return nullptr;
+
+    IntPoint effectiveHotSpot = determineHotSpot(image, hotSpot);
+    return adoptGRef(gdk_cursor_new_from_texture(texture.get(), effectiveHotSpot.x(), effectiveHotSpot.y(), fallbackCursor().get()));
+#else
     RefPtr<cairo_surface_t> surface = image->nativeImageForCurrentFrame();
     if (!surface)
@@ -61 +69 @@
 
     IntPoint effectiveHotSpot = determineHotSpot(image, hotSpot);
-
-#if USE(GTK4)
-    ASSERT(cairo_image_surface_get_format(surface.get()) == CAIRO_FORMAT_ARGB32);
-    auto width = cairo_image_surface_get_width(surface.get());
-    auto height = cairo_image_surface_get_height(surface.get());
-    auto stride = cairo_image_surface_get_stride(surface.get());
-    GRefPtr<GBytes> bytes = adoptGRef(g_bytes_new_with_free_func(cairo_image_surface_get_data(surface.get()), height * stride,
-        [](gpointer data) {
-            cairo_surface_destroy(static_cast<cairo_surface_t*>(data));
-        }, surface.leakRef()));
-    auto texture = adoptGRef(gdk_memory_texture_new(width, height, GDK_MEMORY_A8R8G8B8_PREMULTIPLIED, bytes.get(), stride));
-    return adoptGRef(gdk_cursor_new_from_texture(texture.get(), effectiveHotSpot.x(), effectiveHotSpot.y(), fallbackCursor().get()));
-#else
     return adoptGRef(gdk_cursor_new_from_surface(gdk_display_get_default(), surface.get(), effectiveHotSpot.x(), effectiveHotSpot.y()));
 #endif // USE(GTK4)

trunk/Source/WebKit/ChangeLog

@@ +1 @@
+2020-05-12  Carlos Garcia Campos  <cgarcia@igalia.com>
+
+        [GTK4] Add support for drag and drop operations
+        https://bugs.webkit.org/show_bug.cgi?id=211779
+
+        Reviewed by Adrian Perez de Castro.
+
+        * UIProcess/API/gtk/DragSource.h:
+        * UIProcess/API/gtk/DragSourceGtk4.cpp:
+        (WebKit::DragSource::begin):
+        * UIProcess/API/gtk/DropTarget.h:
+        * UIProcess/API/gtk/DropTargetGtk4.cpp:
+        (WebKit::DropTarget::DropTarget):
+        (WebKit::DropTarget::~DropTarget):
+        (WebKit::DropTarget::accept):
+        (WebKit::DropReadAsyncData::DropReadAsyncData):
+        (WebKit::DropTarget::loadData):
+        (WebKit::DropTarget::didLoadData):
+        (WebKit::DropTarget::enter):
+        (WebKit::DropTarget::update):
+        (WebKit::DropTarget::didPerformAction):
+        (WebKit::DropTarget::leave):
+        (WebKit::DropTarget::drop):
+
 2020-05-19  Wenson Hsieh  <wenson_hsieh@apple.com>
 

trunk/Source/WebKit/UIProcess/API/gtk/DragSource.h

@@ -36 +36 @@
 typedef struct _GtkWidget GtkWidget;
 
-#if !USE(GTK4)
+#if USE(GTK4)
+typedef struct _GdkDrag GdkDrag;
+#else
 typedef struct _GdkDragContext GdkDragContext;
 #endif
@@ -55 +57 @@
 private:
     GtkWidget* m_webView { nullptr };
-#if !USE(GTK4)
+#if USE(GTK4)
+    GRefPtr<GdkDrag> m_drag;
+#else
     GRefPtr<GdkDragContext> m_drag;
 #endif

trunk/Source/WebKit/UIProcess/API/gtk/DragSourceGtk4.cpp

@@ -45 +45 @@
 }
 
-void DragSource::begin(SelectionData&&, DragOperation, RefPtr<ShareableBitmap>&&)
+void DragSource::begin(SelectionData&& selectionData, DragOperation operation, RefPtr<ShareableBitmap>&& image)
 {
+    if (m_drag) {
+        gdk_drag_drop_done(m_drag.get(), FALSE);
+        m_drag = nullptr;
+    }
+
+    m_selectionData = WTFMove(selectionData);
+
+    Vector<GdkContentProvider*> providers;
+    if (m_selectionData->hasMarkup()) {
+        CString markup = m_selectionData->markup().utf8();
+        GRefPtr<GBytes> bytes = adoptGRef(g_bytes_new(markup.data(), markup.length()));
+        providers.append(gdk_content_provider_new_for_bytes("text/html", bytes.get()));
+    }
+
+    if (m_selectionData->hasURIList()) {
+        CString uriList = m_selectionData->uriList().utf8();
+        GRefPtr<GBytes> bytes = adoptGRef(g_bytes_new(uriList.data(), uriList.length()));
+        providers.append(gdk_content_provider_new_for_bytes("text/uri-list", bytes.get()));
+    }
+
+    if (m_selectionData->hasURL()) {
+        CString urlString = m_selectionData->url().string().utf8();
+        gchar* url = g_strdup_printf("%s\n%s", urlString.data(), m_selectionData->hasText() ? m_selectionData->text().utf8().data() : urlString.data());
+        GRefPtr<GBytes> bytes = adoptGRef(g_bytes_new_take(url, strlen(url)));
+        providers.append(gdk_content_provider_new_for_bytes("_NETSCAPE_URL", bytes.get()));
+    }
+
+    if (m_selectionData->hasImage()) {
+        GRefPtr<GdkPixbuf> pixbuf = adoptGRef(m_selectionData->image()->getGdkPixbuf());
+        providers.append(gdk_content_provider_new_typed(GDK_TYPE_PIXBUF, pixbuf.get()));
+    }
+
+    if (m_selectionData->hasText())
+        providers.append(gdk_content_provider_new_typed(G_TYPE_STRING, m_selectionData->text().utf8().data()));
+
+    if (m_selectionData->canSmartReplace()) {
+        GRefPtr<GBytes> bytes = adoptGRef(g_bytes_new(nullptr, 0));
+        providers.append(gdk_content_provider_new_for_bytes("application/vnd.webkitgtk.smartpaste", bytes.get()));
+    }
+
+    auto* surface = gtk_native_get_surface(gtk_widget_get_native(m_webView));
+    auto* device = gdk_seat_get_pointer(gdk_display_get_default_seat(gtk_widget_get_display(m_webView)));
+    GRefPtr<GdkContentProvider> provider = adoptGRef(gdk_content_provider_new_union(providers.data(), providers.size()));
+    m_drag = adoptGRef(gdk_drag_begin(surface, device, provider.get(), dragOperationToGdkDragActions(operation), 0, 0));
+    g_signal_connect(m_drag.get(), "dnd-finished", G_CALLBACK(+[](GdkDrag* gtkDrag, gpointer userData) {
+        auto& drag = *static_cast<DragSource*>(userData);
+        if (drag.m_drag.get() != gtkDrag)
+            return;
+
+        drag.m_selectionData = WTF::nullopt;
+        drag.m_drag = nullptr;
+
+        GdkDevice* device = gdk_drag_get_device(gtkDrag);
+        double x = 0;
+        double y = 0;
+        gdk_device_get_surface_at_position(device, &x, &y);
+
+        auto* page = webkitWebViewBaseGetPage(WEBKIT_WEB_VIEW_BASE(drag.m_webView));
+        ASSERT(page);
+
+        IntPoint point(x, y);
+        page->dragEnded(point, point, gdkDragActionToDragOperation(gdk_drag_get_selected_action(gtkDrag)));
+    }), this);
+
+    g_signal_connect(m_drag.get(), "cancel", G_CALLBACK(+[](GdkDrag* gtkDrag, GdkDragCancelReason, gpointer userData) {
+        auto& drag = *static_cast<DragSource*>(userData);
+        if (drag.m_drag.get() != gtkDrag)
+            return;
+
+        drag.m_selectionData = WTF::nullopt;
+        drag.m_drag = nullptr;
+    }), this);
+
+    auto* dragIcon = gtk_drag_icon_get_for_drag(m_drag.get());
+    RefPtr<Image> iconImage = image ? image->createImage() : nullptr;
+    if (iconImage) {
+        if (GRefPtr<GdkTexture> texture = adoptGRef(iconImage->gdkTexture())) {
+            gdk_drag_set_hotspot(m_drag.get(), -gdk_texture_get_width(texture.get()) / 2, -gdk_texture_get_height(texture.get()) / 2);
+            auto* picture = gtk_picture_new_for_paintable(GDK_PAINTABLE(texture.get()));
+            gtk_drag_icon_set_child(GTK_DRAG_ICON(dragIcon), picture);
+            return;
+        }
+    }
+
+    gdk_drag_set_hotspot(m_drag.get(), -2, -2);
+    auto* child = gtk_image_new_from_icon_name("text-x-generic");
+    gtk_image_set_icon_size(GTK_IMAGE(child), GTK_ICON_SIZE_LARGE);
+    gtk_drag_icon_set_child(GTK_DRAG_ICON(dragIcon), child);
 }
 

trunk/Source/WebKit/UIProcess/API/gtk/DropTarget.h

@@ -38 +38 @@
 typedef struct _GtkWidget GtkWidget;
 
-#if !USE(GTK4)
+#if USE(GTK4)
+typedef struct _GdkDrop GdkDrop;
+#else
 typedef struct _GdkDragContext GdkDragContext;
 typedef struct _GtkSelectionData GtkSelectionData;
@@ -62 +64 @@
     void drop(WebCore::IntPoint&&, unsigned = 0);
 
-#if !USE(GTK4)
+#if USE(GTK4)
+    void loadData(const char* mimeType, CompletionHandler<void(GRefPtr<GBytes>&&)>&&);
+    void didLoadData();
+#else
     void dataReceived(WebCore::IntPoint&&, GtkSelectionData*, unsigned, unsigned);
     void leaveTimerFired();
@@ -68 +73 @@
 
     GtkWidget* m_webView { nullptr };
-#if !USE(GTK4)
+#if USE(GTK4)
+    GRefPtr<GdkDrop> m_drop;
+#else
     GRefPtr<GdkDragContext> m_drop;
 #endif
@@ -75 +82 @@
     Optional<WebCore::SelectionData> m_selectionData;
     WebCore::DragOperation m_operation { WebCore::DragOperationNone };
-#if !USE(GTK4)
+#if USE(GTK4)
+    GRefPtr<GCancellable> m_cancellable;
+#else
     RunLoop::Timer<DropTarget> m_leaveTimer;
 #endif

trunk/Source/WebKit/UIProcess/API/gtk/DropTargetGtk4.cpp

@@ -38 +38 @@
 using namespace WebCore;
 
+enum DropTargetType { Markup, Text, URIList, NetscapeURL, SmartPaste };
+
 DropTarget::DropTarget(GtkWidget* webView)
     : m_webView(webView)
 {
+    auto* formatsBuilder = gdk_content_formats_builder_new();
+    gdk_content_formats_builder_add_gtype(formatsBuilder, G_TYPE_STRING);
+    gdk_content_formats_builder_add_mime_type(formatsBuilder, "text/html");
+    gdk_content_formats_builder_add_mime_type(formatsBuilder, "text/uri-list");
+    gdk_content_formats_builder_add_mime_type(formatsBuilder, "_NETSCAPE_URL");
+    gdk_content_formats_builder_add_mime_type(formatsBuilder, "application/vnd.webkitgtk.smartpaste");
+    auto* target = gtk_drop_target_async_new(gdk_content_formats_builder_free_to_formats(formatsBuilder),
+        static_cast<GdkDragAction>(GDK_ACTION_COPY | GDK_ACTION_MOVE | GDK_ACTION_LINK));
+    g_signal_connect(target, "accept", G_CALLBACK(+[](GtkDropTargetAsync*, GdkDrop* gdkDrop, gpointer userData) -> gboolean {
+        auto& drop = *static_cast<DropTarget*>(userData);
+        drop.m_drop = gdkDrop;
+        drop.accept();
+        return TRUE;
+    }), this);
+
+    g_signal_connect(target, "drag-enter", G_CALLBACK(+[](GtkDropTargetAsync*, GdkDrop* gdkDrop, double x, double y, gpointer userData) -> GdkDragAction {
+        auto& drop = *static_cast<DropTarget*>(userData);
+        if (drop.m_drop != gdkDrop)
+            return static_cast<GdkDragAction>(0);
+
+        drop.enter({ clampToInteger(x), clampToInteger(y) });
+        return dragOperationToSingleGdkDragAction(drop.m_operation);
+    }), this);
+
+    g_signal_connect(target, "drag-motion", G_CALLBACK(+[](GtkDropTargetAsync*, GdkDrop* gdkDrop, double x, double y, gpointer userData) -> GdkDragAction {
+        auto& drop = *static_cast<DropTarget*>(userData);
+        if (drop.m_drop != gdkDrop)
+            return static_cast<GdkDragAction>(0);
+
+        drop.update({ clampToInteger(x), clampToInteger(y) });
+        return dragOperationToSingleGdkDragAction(drop.m_operation);
+    }), this);
+
+    g_signal_connect(target, "drag-leave", G_CALLBACK(+[](GtkDropTargetAsync*, GdkDrop* gdkDrop, gpointer userData) {
+        auto& drop = *static_cast<DropTarget*>(userData);
+        if (drop.m_drop != gdkDrop)
+            return;
+
+        drop.leave();
+    }), this);
+
+    g_signal_connect(target, "drop", G_CALLBACK(+[](GtkDropTargetAsync*, GdkDrop* gdkDrop, double x, double y, gpointer userData) -> gboolean {
+        auto& drop = *static_cast<DropTarget*>(userData);
+        if (drop.m_drop != gdkDrop)
+            return FALSE;
+
+        drop.drop({ clampToInteger(x), clampToInteger(y) });
+        return TRUE;
+    }), this);
+
+    gtk_widget_add_controller(m_webView, GTK_EVENT_CONTROLLER(target));
 }
 
 DropTarget::~DropTarget()
 {
+    g_cancellable_cancel(m_cancellable.get());
 }
 
 void DropTarget::accept(unsigned)
 {
-}
-
-void DropTarget::loadData(const char*, CompletionHandler<void(GRefPtr<GBytes>&&)>&&)
-{
+    m_position = WTF::nullopt;
+    m_selectionData = SelectionData();
+    m_dataRequestCount = 0;
+    m_cancellable = adoptGRef(g_cancellable_new());
+
+    // WebCore needs the selection data to decide, so we need to preload the
+    // data of targets we support. Once all data requests are done we start
+    // notifying the web process about the DND events.
+    auto* formats = gdk_drop_get_formats(m_drop.get());
+    if (gdk_content_formats_contain_gtype(formats, G_TYPE_STRING)) {
+        m_dataRequestCount++;
+        gdk_drop_read_value_async(m_drop.get(), G_TYPE_STRING, G_PRIORITY_DEFAULT, m_cancellable.get(), [](GObject* gdkDrop, GAsyncResult* result, gpointer userData) {
+            GUniqueOutPtr<GError> error;
+            const GValue* value = gdk_drop_read_value_finish(GDK_DROP(gdkDrop), result, &error.outPtr());
+            if (g_error_matches(error.get(), G_IO_ERROR, G_IO_ERROR_CANCELLED))
+                return;
+
+            auto& drop = *static_cast<DropTarget*>(userData);
+            if (value && G_VALUE_HOLDS(value, G_TYPE_STRING))
+                drop.m_selectionData->setText(String::fromUTF8(g_value_get_string(value)));
+            drop.didLoadData();
+        }, this);
+    }
+
+    static const char* const supportedMimeTypes[] = {
+        "text/html",
+        "_NETSCAPE_URL",
+        "text/uri-list",
+        "application/vnd.webkitgtk.smartpaste"
+    };
+
+    for (unsigned i = 0; i < G_N_ELEMENTS(supportedMimeTypes); ++i) {
+        if (!gdk_content_formats_contain_mime_type(formats, supportedMimeTypes[i]))
+            continue;
+
+        m_dataRequestCount++;
+        loadData(supportedMimeTypes[i], [this, mimeType = String::fromUTF8(supportedMimeTypes[i]), cancellable = m_cancellable](GRefPtr<GBytes>&& data) {
+            if (g_cancellable_is_cancelled(cancellable.get()))
+                return;
+
+            if (!data) {
+                didLoadData();
+                return;
+            }
+
+            if (mimeType == "text/html"_s) {
+                gsize length;
+                const auto* markupData = g_bytes_get_data(data.get(), &length);
+                if (length) {
+                    // If data starts with UTF-16 BOM assume it's UTF-16, otherwise assume UTF-8.
+                    if (length >= 2 && reinterpret_cast<const UChar*>(markupData)[0] == 0xFEFF)
+                        m_selectionData->setMarkup(String(reinterpret_cast<const UChar*>(markupData) + 1, (length / 2) - 1));
+                    else
+                        m_selectionData->setMarkup(String::fromUTF8(reinterpret_cast<const char*>(markupData), length));
+                }
+            } else if (mimeType == "_NETSCAPE_URL") {
+                gsize length;
+                const auto* urlData = g_bytes_get_data(data.get(), &length);
+                if (length) {
+                    Vector<String> tokens = String::fromUTF8(reinterpret_cast<const char*>(urlData), length).split('\n');
+                    URL url({ }, tokens[0]);
+                    if (url.isValid())
+                        m_selectionData->setURL(url, tokens.size() > 1 ? tokens[1] : String());
+                }
+            } else if (mimeType == "text/uri-list") {
+                gsize length;
+                const auto* uriListData = g_bytes_get_data(data.get(), &length);
+                if (length)
+                    m_selectionData->setURIList(String::fromUTF8(reinterpret_cast<const char*>(uriListData), length));
+            } else if (mimeType == "application/vnd.webkitgtk.smartpaste")
+                m_selectionData->setCanSmartReplace(true);
+
+            didLoadData();
+        });
+    }
+}
+
+struct DropReadAsyncData {
+    WTF_MAKE_STRUCT_FAST_ALLOCATED;
+
+    DropReadAsyncData(GCancellable* cancellable, CompletionHandler<void(GRefPtr<GBytes>&&)>&& handler)
+        : cancellable(cancellable)
+        , completionHandler(WTFMove(handler))
+    {
+    }
+
+    GRefPtr<GCancellable> cancellable;
+    CompletionHandler<void(GRefPtr<GBytes>&&)> completionHandler;
+};
+
+void DropTarget::loadData(const char* mimeType, CompletionHandler<void(GRefPtr<GBytes>&&)>&& completionHandler)
+{
+    const char* mimeTypes[] = { mimeType, nullptr };
+    gdk_drop_read_async(m_drop.get(), mimeTypes, G_PRIORITY_DEFAULT, m_cancellable.get(), [](GObject* gdkDrop, GAsyncResult* result, gpointer userData) {
+        std::unique_ptr<DropReadAsyncData> data(static_cast<DropReadAsyncData*>(userData));
+        GRefPtr<GInputStream> inputStream = adoptGRef(gdk_drop_read_finish(GDK_DROP(gdkDrop), result, nullptr, nullptr));
+        if (!inputStream) {
+            data->completionHandler(nullptr);
+            return;
+        }
+
+        auto* cancellable = data->cancellable.get();
+        GRefPtr<GOutputStream> outputStream = adoptGRef(g_memory_output_stream_new_resizable());
+        g_output_stream_splice_async(outputStream.get(), inputStream.get(),
+            static_cast<GOutputStreamSpliceFlags>(G_OUTPUT_STREAM_SPLICE_CLOSE_SOURCE | G_OUTPUT_STREAM_SPLICE_CLOSE_TARGET),
+            G_PRIORITY_DEFAULT, cancellable, [](GObject* stream, GAsyncResult* result, gpointer userData) {
+                std::unique_ptr<DropReadAsyncData> data(static_cast<DropReadAsyncData*>(userData));
+                GUniqueOutPtr<GError> error;
+                gssize writtenBytes = g_output_stream_splice_finish(G_OUTPUT_STREAM(stream), result, &error.outPtr());
+                if (writtenBytes <= 0) {
+                    data->completionHandler(nullptr);
+                    return;
+                }
+                GRefPtr<GBytes> bytes = adoptGRef(g_memory_output_stream_steal_as_bytes(G_MEMORY_OUTPUT_STREAM(stream)));
+                data->completionHandler(WTFMove(bytes));
+            }, data.release());
+    }, new DropReadAsyncData(m_cancellable.get(), WTFMove(completionHandler)));
 }
 
 void DropTarget::didLoadData()
 {
-}
-
-void DropTarget::enter(IntPoint&&, unsigned)
-{
-}
-
-void DropTarget::update(IntPoint&&, unsigned)
-{
+    if (--m_dataRequestCount)
+        return;
+
+    m_cancellable = nullptr;
+
+    if (!m_position) {
+        // Enter hasn't been emitted yet, so just wait for it.
+        return;
+    }
+
+    // Call enter again.
+    enter(IntPoint(m_position.value()));
+}
+
+void DropTarget::enter(IntPoint&& position, unsigned)
+{
+    m_position = WTFMove(position);
+    if (m_cancellable)
+        return;
+
+    auto* page = webkitWebViewBaseGetPage(WEBKIT_WEB_VIEW_BASE(m_webView));
+    ASSERT(page);
+    page->resetCurrentDragInformation();
+
+    DragData dragData(&m_selectionData.value(), *m_position, *m_position, gdkDragActionToDragOperation(gdk_drop_get_actions(m_drop.get())));
+    page->dragEntered(dragData);
+}
+
+void DropTarget::update(IntPoint&& position, unsigned)
+{
+    m_position = WTFMove(position);
+    if (m_cancellable)
+        return;
+
+    auto* page = webkitWebViewBaseGetPage(WEBKIT_WEB_VIEW_BASE(m_webView));
+    ASSERT(page);
+
+    DragData dragData(&m_selectionData.value(), *m_position, *m_position, gdkDragActionToDragOperation(gdk_drop_get_actions(m_drop.get())));
+    page->dragUpdated(dragData);
 }
 
 void DropTarget::didPerformAction()
 {
+    if (!m_drop)
+        return;
+
+    auto* page = webkitWebViewBaseGetPage(WEBKIT_WEB_VIEW_BASE(m_webView));
+    ASSERT(page);
+
+    auto operation = page->currentDragOperation();
+    if (operation == m_operation)
+        return;
+
+    m_operation = operation;
+    gdk_drop_status(m_drop.get(), dragOperationToGdkDragActions(m_operation), dragOperationToSingleGdkDragAction(m_operation));
 }
 
 void DropTarget::leave()
 {
-}
-
-void DropTarget::drop(IntPoint&&, unsigned)
-{
+    g_cancellable_cancel(m_cancellable.get());
+    m_drop = nullptr;
+    m_position = WTF::nullopt;
+    m_selectionData = WTF::nullopt;
+    m_cancellable = nullptr;
+}
+
+void DropTarget::drop(IntPoint&& position, unsigned)
+{
+    m_position = WTFMove(position);
+    auto* page = webkitWebViewBaseGetPage(WEBKIT_WEB_VIEW_BASE(m_webView));
+    ASSERT(page);
+
+    DragData dragData(&m_selectionData.value(), *m_position, *m_position, gdkDragActionToDragOperation(gdk_drop_get_actions(m_drop.get())));
+    page->performDragOperation(dragData, { }, { }, { });
+    gdk_drop_finish(m_drop.get(), gdk_drop_get_actions(m_drop.get()));
 }