Migrate DragMsg_TargetDrop to Mojo

Migrate the legacy IPC message DragMsg_TargetDrop to the TargetDrop Mojo
message in blink.mojom.FrameWidget.

To support this operation, this CL adds blink.mojom.DragData, a Mojo
type representing the same data as blink::WebDragData, and a typemap.
This typemap is a temporary measure to work around the fact that several
methods using WebDragData cross the content/Blink boundary and cannot
use the Mojo type directly. In the future, WebDragData may be completely
replaced by its Mojo version.

Bug: 1039255
Change-Id: Ide4dd659ac967cf976db04b86eff111b5b9ef336
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2232326
Commit-Queue: Henrique Ferreiro <hferreiro@igalia.com>
Reviewed-by: Marijn Kruisselbrink <mek@chromium.org>
Reviewed-by: Dave Tapuska <dtapuska@chromium.org>
Reviewed-by: Kinuko Yasuda <kinuko@chromium.org>
Cr-Commit-Position: refs/heads/master@{#787558}

content/browser/renderer_host/render_widget_host_impl.cc

@@ -15,6 +15,7 @@
 #include "base/auto_reset.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
+#include "base/check.h"
 #include "base/command_line.h"
 #include "base/hash/hash.h"
 #include "base/i18n/rtl.h"
@@ -102,6 +103,7 @@
 #include "skia/ext/platform_canvas.h"
 #include "storage/browser/file_system/isolated_context.h"
 #include "third_party/blink/public/common/input/synthetic_web_input_event_builders.h"
+#include "third_party/blink/public/mojom/page/drag.mojom.h"
 #include "ui/base/clipboard/clipboard_constants.h"
 #include "ui/base/ui_base_switches.h"
 #include "ui/display/display_switches.h"
@@ -244,6 +246,60 @@ std::vector<DropData::Metadata> DropDataToMetaData(const DropData& drop_data) {
   return metadata;
 }
 
+blink::mojom::DragDataPtr DropDataToDragData(const DropData& drop_data) {
+  // These fields are currently unused when dragging into Blink.
+  DCHECK(drop_data.download_metadata.empty());
+  DCHECK(drop_data.file_contents.empty());
+  DCHECK(drop_data.file_contents_content_disposition.empty());
+
+  std::vector<blink::mojom::DragItemPtr> items;
+  if (drop_data.text) {
+    blink::mojom::DragItemStringPtr item = blink::mojom::DragItemString::New();
+    item->string_type = ui::kMimeTypeText;
+    item->string_data = *drop_data.text;
+    items.push_back(blink::mojom::DragItem::NewString(std::move(item)));
+  }
+  if (!drop_data.url.is_empty()) {
+    blink::mojom::DragItemStringPtr item = blink::mojom::DragItemString::New();
+    item->string_type = ui::kMimeTypeURIList;
+    item->string_data = base::UTF8ToUTF16(drop_data.url.spec());
+    item->title = drop_data.url_title;
+    items.push_back(blink::mojom::DragItem::NewString(std::move(item)));
+  }
+  if (drop_data.html) {
+    blink::mojom::DragItemStringPtr item = blink::mojom::DragItemString::New();
+    item->string_type = ui::kMimeTypeHTML;
+    item->string_data = *drop_data.html;
+    item->base_url = drop_data.html_base_url;
+    items.push_back(blink::mojom::DragItem::NewString(std::move(item)));
+  }
+  for (const ui::FileInfo& file : drop_data.filenames) {
+    blink::mojom::DragItemFilePtr item = blink::mojom::DragItemFile::New();
+    item->path = file.path;
+    item->display_name = file.display_name;
+    items.push_back(blink::mojom::DragItem::NewFile(std::move(item)));
+  }
+  for (const content::DropData::FileSystemFileInfo& file_system_file :
+       drop_data.file_system_files) {
+    blink::mojom::DragItemFileSystemFilePtr item =
+        blink::mojom::DragItemFileSystemFile::New();
+    item->url = file_system_file.url;
+    item->size = file_system_file.size;
+    item->file_system_id = file_system_file.filesystem_id;
+    items.push_back(blink::mojom::DragItem::NewFileSystemFile(std::move(item)));
+  }
+  for (const std::pair<base::string16, base::string16> data :
+       drop_data.custom_data) {
+    blink::mojom::DragItemStringPtr item = blink::mojom::DragItemString::New();
+    item->string_type = base::UTF16ToUTF8(data.first);
+    item->string_data = data.second;
+    items.push_back(blink::mojom::DragItem::NewString(std::move(item)));
+  }
+
+  return blink::mojom::DragData::New(
+      std::move(items), base::UTF16ToUTF8(drop_data.filesystem_id));
+}
+
 class UnboundWidgetInputHandler : public blink::mojom::WidgetInputHandler {
  public:
   void SetFocus(bool focused) override {
@@ -1738,9 +1794,7 @@ void RenderWidgetHostImpl::DragTargetDragOver(
     const gfx::PointF& screen_point,
     WebDragOperationsMask operations_allowed,
     int key_modifiers) {
-  // TODO(dtapuska): Remove this null check once all of the Drag IPCs
-  // come over the mojo channels. It will be guaranteed that this
-  // will be non-null.
+  // TODO(https://crbug.com/1102769): Replace with a for_frame() check.
   if (blink_frame_widget_) {
     blink_frame_widget_->DragTargetDragOver(
         ConvertWindowPointToViewport(client_point), screen_point,
@@ -1753,9 +1807,7 @@ void RenderWidgetHostImpl::DragTargetDragOver(
 void RenderWidgetHostImpl::DragTargetDragLeave(
     const gfx::PointF& client_point,
     const gfx::PointF& screen_point) {
-  // TODO(dtapuska): Remove this null check once all of the Drag IPCs
-  // come over the mojo channels. It will be guaranteed that this
-  // will be non-null.
+  // TODO(https://crbug.com/1102769): Replace with a for_frame() check.
   if (blink_frame_widget_) {
     gfx::PointF viewport_point = client_point;
     if (IsUseZoomForDSFEnabled())
@@ -1765,22 +1817,25 @@ void RenderWidgetHostImpl::DragTargetDragLeave(
 }
 
 void RenderWidgetHostImpl::DragTargetDrop(const DropData& drop_data,
-                                          const gfx::PointF& client_pt,
-                                          const gfx::PointF& screen_pt,
+                                          const gfx::PointF& client_point,
+                                          const gfx::PointF& screen_point,
                                           int key_modifiers) {
-  DropData drop_data_with_permissions(drop_data);
-  GrantFileAccessFromDropData(&drop_data_with_permissions);
-  Send(new DragMsg_TargetDrop(GetRoutingID(), drop_data_with_permissions,
-                              client_pt, screen_pt, key_modifiers));
+  // TODO(https://crbug.com/1102769): Replace with a for_frame() check.
+  if (blink_frame_widget_) {
+    DropData drop_data_with_permissions(drop_data);
+    GrantFileAccessFromDropData(&drop_data_with_permissions);
+    blink_frame_widget_->DragTargetDrop(
+        DropDataToDragData(drop_data_with_permissions),
+        ConvertWindowPointToViewport(client_point), screen_point,
+        key_modifiers);
+  }
 }
 
 void RenderWidgetHostImpl::DragSourceEndedAt(
     const gfx::PointF& client_point,
     const gfx::PointF& screen_point,
     blink::WebDragOperation operation) {
-  // TODO(dtapuska): Remove this null check once all of the Drag IPCs
-  // come over the mojo channels. It will be guaranteed that this
-  // will be non-null.
+  // TODO(https://crbug.com/1102769): Replace with a for_frame() check.
   if (blink_frame_widget_) {
     blink_frame_widget_->DragSourceEndedAt(
         ConvertWindowPointToViewport(client_point), screen_point, operation);
@@ -1788,9 +1843,7 @@ void RenderWidgetHostImpl::DragSourceEndedAt(
 }
 
 void RenderWidgetHostImpl::DragSourceSystemDragEnded() {
-  // TODO(dtapuska): Remove this null check once all of the Drag IPCs
-  // come over the mojo channels. It will be guaranteed that this
-  // will be non-null.
+  // TODO(https://crbug.com/1102769): Replace with a for_frame() check.
   if (blink_frame_widget_)
     blink_frame_widget_->DragSourceSystemDragEnded();
 }

content/browser/renderer_host/render_widget_host_impl.h

@@ -247,8 +247,8 @@ class CONTENT_EXPORT RenderWidgetHostImpl
   // |drop_data| must have been filtered. The embedder should call
   // FilterDropData before passing the drop data to RWHI.
   void DragTargetDrop(const DropData& drop_data,
-                      const gfx::PointF& client_pt,
-                      const gfx::PointF& screen_pt,
+                      const gfx::PointF& client_point,
+                      const gfx::PointF& screen_point,
                       int key_modifiers) override;
   void DragSourceEndedAt(const gfx::PointF& client_pt,
                          const gfx::PointF& screen_pt,

content/common/drag_messages.h

@@ -28,12 +28,6 @@ IPC_MESSAGE_ROUTED5(DragMsg_TargetDragEnter,
                     blink::WebDragOperationsMask /* ops_allowed */,
                     int /* key_modifiers */)
 
-IPC_MESSAGE_ROUTED4(DragMsg_TargetDrop,
-                    content::DropData /* drop_data */,
-                    gfx::PointF /* client_pt */,
-                    gfx::PointF /* screen_pt */,
-                    int /* key_modifiers */)
-
 // Messages sent from the renderer to the browser.
 
 // Used to tell the parent the user started dragging in the content area. The

content/public/test/fake_frame_widget.h

@@ -9,6 +9,7 @@
 #include "build/build_config.h"
 #include "mojo/public/cpp/bindings/associated_receiver.h"
 #include "mojo/public/cpp/bindings/pending_associated_receiver.h"
+#include "third_party/blink/public/mojom/page/drag.mojom.h"
 #include "third_party/blink/public/mojom/page/widget.mojom.h"
 #include "ui/base/ui_base_types.h"
 
@@ -37,6 +38,10 @@ class FakeFrameWidget : public blink::mojom::FrameWidget {
                           DragTargetDragOverCallback callback) override {}
   void DragTargetDragLeave(const gfx::PointF& point_in_viewport,
                            const gfx::PointF& screen_point) override {}
+  void DragTargetDrop(blink::mojom::DragDataPtr drag_data,
+                      const gfx::PointF& point_in_viewport,
+                      const gfx::PointF& screen_point,
+                      uint32_t key_modifiers) override {}
   void DragSourceEndedAt(const gfx::PointF& client_point,
                          const gfx::PointF& screen_point,
                          blink::WebDragOperation operation) override {}

content/renderer/render_widget.cc

@@ -235,72 +235,6 @@ WebDragData DropMetaDataToWebDragData(
   return result;
 }
 
-WebDragData DropDataToWebDragData(const DropData& drop_data) {
-  std::vector<WebDragData::Item> item_list;
-
-  // These fields are currently unused when dragging into WebKit.
-  DCHECK(drop_data.download_metadata.empty());
-  DCHECK(drop_data.file_contents.empty());
-  DCHECK(drop_data.file_contents_content_disposition.empty());
-
-  if (drop_data.text) {
-    WebDragData::Item item;
-    item.storage_type = WebDragData::Item::kStorageTypeString;
-    item.string_type = WebString::FromUTF8(ui::kMimeTypeText);
-    item.string_data = WebString::FromUTF16(*drop_data.text);
-    item_list.push_back(item);
-  }
-
-  if (!drop_data.url.is_empty()) {
-    WebDragData::Item item;
-    item.storage_type = WebDragData::Item::kStorageTypeString;
-    item.string_type = WebString::FromUTF8(ui::kMimeTypeURIList);
-    item.string_data = WebString::FromUTF8(drop_data.url.spec());
-    item.title = WebString::FromUTF16(drop_data.url_title);
-    item_list.push_back(item);
-  }
-
-  if (drop_data.html) {
-    WebDragData::Item item;
-    item.storage_type = WebDragData::Item::kStorageTypeString;
-    item.string_type = WebString::FromUTF8(ui::kMimeTypeHTML);
-    item.string_data = WebString::FromUTF16(*drop_data.html);
-    item.base_url = drop_data.html_base_url;
-    item_list.push_back(item);
-  }
-
-  for (const ui::FileInfo& filename : drop_data.filenames) {
-    WebDragData::Item item;
-    item.storage_type = WebDragData::Item::kStorageTypeFilename;
-    item.filename_data = blink::FilePathToWebString(filename.path);
-    item.display_name_data =
-        blink::FilePathToWebString(base::FilePath(filename.display_name));
-    item_list.push_back(item);
-  }
-
-  for (const DropData::FileSystemFileInfo& file : drop_data.file_system_files) {
-    WebDragData::Item item;
-    item.storage_type = WebDragData::Item::kStorageTypeFileSystemFile;
-    item.file_system_url = file.url;
-    item.file_system_file_size = file.size;
-    item.file_system_id = blink::WebString::FromASCII(file.filesystem_id);
-    item_list.push_back(item);
-  }
-
-  for (const auto& data : drop_data.custom_data) {
-    WebDragData::Item item;
-    item.storage_type = WebDragData::Item::kStorageTypeString;
-    item.string_type = WebString::FromUTF16(data.first);
-    item.string_data = WebString::FromUTF16(data.second);
-    item_list.push_back(item);
-  }
-
-  WebDragData result;
-  result.SetItems(item_list);
-  result.SetFilesystemId(WebString::FromUTF16(drop_data.filesystem_id));
-  return result;
-}
-
 #if BUILDFLAG(ENABLE_PLUGINS)
 blink::WebTextInputType ConvertTextInputType(ui::TextInputType type) {
   // Check the type is in the range representable by ui::TextInputType.
@@ -516,7 +450,6 @@ bool RenderWidget::OnMessageReceived(const IPC::Message& message) {
     IPC_MESSAGE_HANDLER(WidgetMsg_WaitForNextFrameForTests,
                         OnWaitNextFrameForTests)
     IPC_MESSAGE_HANDLER(DragMsg_TargetDragEnter, OnDragTargetDragEnter)
-    IPC_MESSAGE_HANDLER(DragMsg_TargetDrop, OnDragTargetDrop)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
@@ -1720,19 +1653,6 @@ void RenderWidget::OnDragTargetDragEnter(
   Send(new DragHostMsg_UpdateDragCursor(routing_id(), operation));
 }
 
-void RenderWidget::OnDragTargetDrop(const DropData& drop_data,
-                                    const gfx::PointF& client_point,
-                                    const gfx::PointF& screen_point,
-                                    int key_modifiers) {
-  blink::WebFrameWidget* frame_widget = GetFrameWidget();
-  if (!frame_widget)
-    return;
-
-  frame_widget->DragTargetDrop(DropDataToWebDragData(drop_data),
-                               ConvertWindowPointToViewport(client_point),
-                               screen_point, key_modifiers);
-}
-
 void RenderWidget::ConvertViewportToWindow(blink::WebRect* rect) {
   if (compositor_deps_->IsUseZoomForDSFEnabled()) {
     float reverse = 1 / GetOriginalScreenInfo().device_scale_factor;

content/renderer/render_widget.h

@@ -484,10 +484,6 @@ class CONTENT_EXPORT RenderWidget
       const gfx::PointF& screen_pt,
       blink::WebDragOperationsMask operations_allowed,
       int key_modifiers);
-  void OnDragTargetDrop(const DropData& drop_data,
-                        const gfx::PointF& client_pt,
-                        const gfx::PointF& screen_pt,
-                        int key_modifiers);
   void OnDragSourceEnded(const gfx::PointF& client_point,
                          const gfx::PointF& screen_point,
                          blink::WebDragOperation drag_operation);

third_party/blink/public/mojom/BUILD.gn

@@ -104,6 +104,7 @@ mojom("mojom_platform") {
     "notifications/notification_service.mojom",
     "oom_intervention/oom_intervention.mojom",
     "page/display_cutout.mojom",
+    "page/drag.mojom",
     "page/page.mojom",
     "page/page_visibility_state.mojom",
     "page/spatial_navigation.mojom",
@@ -287,8 +288,20 @@ mojom("mojom_platform") {
       traits_public_deps = [ "//ui/base/clipboard:clipboard_types" ]
     },
   ]
+  blink_cpp_typemaps = [
+    {
+      types = [
+        {
+          mojom = "blink.mojom.DragData"
+          cpp = "::blink::WebDragData"
+        },
+      ]
+      traits_headers =
+          [ "//third_party/blink/renderer/platform/mojo/drag_mojom_traits.h" ]
+    },
+  ]
   cpp_typemaps += shared_cpp_typemaps
-  blink_cpp_typemaps = shared_cpp_typemaps
+  blink_cpp_typemaps += shared_cpp_typemaps
 
   export_class_attribute = "BLINK_COMMON_EXPORT"
   export_define = "BLINK_COMMON_IMPLEMENTATION=1"

third_party/blink/public/mojom/page/drag.mojom

+// Copyright 2020 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+module blink.mojom;
+
+import "mojo/public/mojom/base/file_path.mojom";
+import "mojo/public/mojom/base/string16.mojom";
+import "url/mojom/url.mojom";
+
+// "Verb" of a drag-and-drop operation as negotiated between the source and
+// destination. It's typemapped to blink::WebDragOperation.
+enum DragOperation {
+  kNone,
+  kCopy,
+  kLink,
+  kGeneric,
+  kPrivate,
+  kMove,
+  kDelete,
+};
+
+// This struct encodes what drag-and-drop operations are allowed. It's
+// typemapped to blink::WebDragOperationsMask.
+// TODO(https://crbug.com/1082291): Change this to a bitset if/when mojom
+// supports bitset types.
+struct AllowedDragOperations {
+  bool allow_copy;
+  bool allow_link;
+  bool allow_generic;
+  bool allow_private;
+  bool allow_move;
+  bool allow_delete;
+};
+
+// Used when dragging images, links, plain text, HTML content or other
+// arbitrary data.
+struct DragItemString {
+  // Mime type of the dragged data.
+  string string_type;
+  // Depending of the value of `string_type`, it contains the dragged link,
+  // text, HTML markup or any other data.
+  mojo_base.mojom.String16 string_data;
+
+  // Title associated with a link. Only valid when string_type == "text/uri-list".
+  mojo_base.mojom.String16 title;
+
+  // Stores the base URL for the contained markup. Only valid when string_type
+  // == "text/html".
+  url.mojom.Url base_url;
+};
+
+// Used for dragging a list of files.
+struct DragItemFile {
+  mojo_base.mojom.FilePath path;
+  mojo_base.mojom.FilePath display_name;
+};
+
+// Only used when dragging images out of Blink.
+struct DragItemBinary {
+  // Image data.
+  array<uint8> data;
+  url.mojom.Url source_url;
+  mojo_base.mojom.FilePath filename_extension;
+  // Content-Disposition response header.
+  string content_disposition;
+};
+
+// Used for dragging files using the FileSystem API.
+struct DragItemFileSystemFile {
+  url.mojom.Url url;
+  int64 size;
+  string file_system_id;
+};
+
+union DragItem {
+  DragItemString string;
+  DragItemFile file;
+  DragItemBinary binary;
+  DragItemFileSystemFile file_system_file;
+};
+
+// Holds data that may be exchanged through a drag-n-drop operation.
+struct DragData {
+  array<DragItem> items;
+  string file_system_id;  // Only used when dragging into Blink to represent a
+                          // new isolated file system to access the dropped
+                          // files.
+};
+

third_party/blink/public/mojom/page/widget.mojom

@@ -9,6 +9,7 @@ import "mojo/public/mojom/base/string16.mojom";
 import "mojo/public/mojom/base/text_direction.mojom";
 import "third_party/blink/public/mojom/frame/intrinsic_sizing_info.mojom";
 import "third_party/blink/public/mojom/input/input_handler.mojom";
+import "third_party/blink/public/mojom/page/drag.mojom";
 import "ui/base/mojom/ui_base_types.mojom";
 import "ui/base/ime/mojom/text_input_state.mojom";
 import "ui/base/cursor/mojom/cursor.mojom";
@@ -17,31 +18,6 @@ import "ui/gfx/geometry/mojom/geometry.mojom";
 [EnableIf=is_mac]
 import "ui/base/mojom/attributed_string.mojom";
 
-// "Verb" of a drag-and-drop operation as negotiated between the source and
-// destination. It's typemapped to blink::WebDragOperation.
-enum DragOperation {
-  kNone,
-  kCopy,
-  kLink,
-  kGeneric,
-  kPrivate,
-  kMove,
-  kDelete,
-};
-
-// This struct encodes what drag-and-drop operations are allowed. It's
-// typemapped to blink::WebDragOperationsMask.
-// TODO(https://crbug.com/1082291): Change this to a bitset if/when mojom
-// supports bitset types.
-struct AllowedDragOperations {
-  bool allow_copy;
-  bool allow_link;
-  bool allow_generic;
-  bool allow_private;
-  bool allow_move;
-  bool allow_delete;
-};
-
 // Implemented in Blink, this interface defines frame-widget-specific methods that
 // will be invoked from the browser process (e.g. blink::WebFrameWidget).
 interface FrameWidget {
@@ -61,6 +37,12 @@ interface FrameWidget {
   DragTargetDragLeave(gfx.mojom.PointF point_in_viewport,
                       gfx.mojom.PointF screen_point);
 
+  // Notifies the Widget of a drag drop operation.
+  DragTargetDrop(DragData drag_data,
+                 gfx.mojom.PointF point_in_viewport,
+                 gfx.mojom.PointF screen_point,
+                 uint32 key_modifiers);
+
   // Notifies the Widget that a drag has terminated.
   DragSourceEndedAt(gfx.mojom.PointF point_in_viewport,
                     gfx.mojom.PointF screen_point,

third_party/blink/renderer/core/clipboard/data_object.cc

@@ -30,6 +30,7 @@
 
 #include "third_party/blink/renderer/core/clipboard/data_object.h"
 
+#include "base/notreached.h"
 #include "third_party/blink/public/platform/platform.h"
 #include "third_party/blink/public/platform/web_drag_data.h"
 #include "third_party/blink/renderer/core/clipboard/clipboard_mime_types.h"

third_party/blink/renderer/core/frame/web_frame_widget_base.h

@@ -222,10 +222,6 @@ class CORE_EXPORT WebFrameWidgetBase
                                        const gfx::PointF& screen_point,
                                        WebDragOperationsMask operations_allowed,
                                        uint32_t key_modifiers) override;
-  void DragTargetDrop(const WebDragData&,
-                      const gfx::PointF& point_in_viewport,
-                      const gfx::PointF& screen_point,
-                      uint32_t key_modifiers) override;
   void SendOverscrollEventFromImplSide(
       const gfx::Vector2dF& overscroll_delta,
       cc::ElementId scroll_latched_element_id) override;
@@ -345,6 +341,10 @@ class CORE_EXPORT WebFrameWidgetBase
                           DragTargetDragOverCallback callback) override;
   void DragTargetDragLeave(const gfx::PointF& point_in_viewport,
                            const gfx::PointF& screen_point) override;
+  void DragTargetDrop(const WebDragData&,
+                      const gfx::PointF& point_in_viewport,
+                      const gfx::PointF& screen_point,
+                      uint32_t key_modifiers) override;
   void DragSourceEndedAt(const gfx::PointF& point_in_viewport,
                          const gfx::PointF& screen_point,
                          WebDragOperation) override;

third_party/blink/renderer/platform/BUILD.gn

@@ -1235,6 +1235,8 @@ jumbo_component("platform") {
     "mojo/big_string_mojom_traits.h",
     "mojo/bluetooth_mojom_traits.cc",
     "mojo/bluetooth_mojom_traits.h",
+    "mojo/drag_mojom_traits.cc",
+    "mojo/drag_mojom_traits.h",
     "mojo/features.cc",
     "mojo/features.h",
     "mojo/fetch_api_request_headers_mojom_traits.h",
@@ -1581,6 +1583,8 @@ jumbo_component("platform") {
   public_deps = [
     ":blink_platform_public_deps",
     ":platform_export",
+    "//mojo/public/cpp/base",
+    "//mojo/public/cpp/bindings",
     "//third_party/blink/renderer/platform/blob",
     "//third_party/blink/renderer/platform/heap",
     "//third_party/blink/renderer/platform/instrumentation",
@@ -1603,8 +1607,6 @@ jumbo_component("platform") {
     "//media",
     "//media/capture:capture_switches",
     "//media/capture/mojom:video_capture",
-    "//mojo/public/cpp/base",
-    "//mojo/public/cpp/bindings",
     "//mojo/public/cpp/bindings:wtf_support",
     "//services/service_manager/public/cpp",
     "//services/viz/public/cpp/gpu",

third_party/blink/renderer/platform/mojo/drag_mojom_traits.cc

+// Copyright 2020 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "third_party/blink/renderer/platform/mojo/drag_mojom_traits.h"
+
+#include "base/files/file_path.h"
+#include "base/notreached.h"
+#include "base/strings/string16.h"
+#include "third_party/blink/public/platform/file_path_conversion.h"
+#include "third_party/blink/public/platform/web_string.h"
+#include "third_party/blink/public/platform/web_vector.h"
+#include "third_party/blink/renderer/platform/wtf/text/wtf_string.h"
+
+namespace mojo {
+
+// static
+WTF::String StructTraits<
+    blink::mojom::DragItemStringDataView,
+    blink::WebDragData::Item>::string_type(blink::WebDragData::Item item) {
+  return item.string_type;
+}
+
+// static
+WTF::String
+StructTraits<blink::mojom::DragItemStringDataView, blink::WebDragData::Item>::
+    string_data(const blink::WebDragData::Item& item) {
+  return item.string_data;
+}
+
+// static
+WTF::String StructTraits<
+    blink::mojom::DragItemStringDataView,
+    blink::WebDragData::Item>::title(const blink::WebDragData::Item& item) {
+  return item.title;
+}
+
+// static
+blink::KURL StructTraits<
+    blink::mojom::DragItemStringDataView,
+    blink::WebDragData::Item>::base_url(const blink::WebDragData::Item& item) {
+  return item.base_url;
+}
+
+// static
+bool StructTraits<
+    blink::mojom::DragItemStringDataView,
+    blink::WebDragData::Item>::Read(blink::mojom::DragItemStringDataView data,
+                                    blink::WebDragData::Item* out) {
+  blink::WebDragData::Item item;
+  WTF::String string_type;
+  base::string16 string_data, title;
+  blink::KURL url;
+  if (!data.ReadStringType(&string_type) ||
+      !data.ReadStringData(&string_data) || !data.ReadTitle(&title) ||
+      !data.ReadBaseUrl(&url))
+    return false;
+
+  item.storage_type = blink::WebDragData::Item::kStorageTypeString;
+  item.string_type = string_type;
+  item.string_data = blink::WebString::FromUTF16(string_data);
+  item.title = blink::WebString::FromUTF16(title);
+  item.base_url = url;
+  *out = std::move(item);
+  return true;
+}
+
+// static
+base::FilePath StructTraits<
+    blink::mojom::DragItemFileDataView,
+    blink::WebDragData::Item>::path(const blink::WebDragData::Item& item) {
+  return WebStringToFilePath(item.filename_data);
+}
+
+// static
+base::FilePath
+StructTraits<blink::mojom::DragItemFileDataView, blink::WebDragData::Item>::
+    display_name(const blink::WebDragData::Item& item) {
+  return WebStringToFilePath(item.display_name_data);
+}
+
+// static
+bool StructTraits<
+    blink::mojom::DragItemFileDataView,
+    blink::WebDragData::Item>::Read(blink::mojom::DragItemFileDataView data,
+                                    blink::WebDragData::Item* out) {
+  blink::WebDragData::Item item;
+  base::FilePath filename_data, display_name_data;
+  if (!data.ReadPath(&filename_data) ||
+      !data.ReadDisplayName(&display_name_data))
+    return false;
+
+  item.storage_type = blink::WebDragData::Item::kStorageTypeFilename;
+  item.filename_data = blink::FilePathToWebString(filename_data);
+  item.display_name_data = blink::FilePathToWebString(display_name_data);
+  *out = std::move(item);
+  return true;
+}
+
+// static
+blink::WebVector<uint8_t> StructTraits<
+    blink::mojom::DragItemBinaryDataView,
+    blink::WebDragData::Item>::data(const blink::WebDragData::Item& item) {
+  return item.binary_data.Copy();
+}
+
+// static
+blink::KURL
+StructTraits<blink::mojom::DragItemBinaryDataView, blink::WebDragData::Item>::
+    source_url(const blink::WebDragData::Item& item) {
+  return item.binary_data_source_url;
+}
+
+// static
+base::FilePath
+StructTraits<blink::mojom::DragItemBinaryDataView, blink::WebDragData::Item>::
+    filename_extension(const blink::WebDragData::Item& item) {
+  return WebStringToFilePath(item.binary_data_filename_extension);
+}
+
+// static
+WTF::String
+StructTraits<blink::mojom::DragItemBinaryDataView, blink::WebDragData::Item>::
+    content_disposition(const blink::WebDragData::Item& item) {
+  return item.binary_data_content_disposition;
+}
+
+// static
+bool StructTraits<
+    blink::mojom::DragItemBinaryDataView,
+    blink::WebDragData::Item>::Read(blink::mojom::DragItemBinaryDataView data,
+                                    blink::WebDragData::Item* out) {
+  // storage_type == kBinary should not happen when dragging into Blink.
+  NOTREACHED();
+  return true;
+}
+
+//  static
+blink::KURL StructTraits<
+    blink::mojom::DragItemFileSystemFileDataView,
+    blink::WebDragData::Item>::url(const blink::WebDragData::Item& item) {
+  return item.file_system_url;
+}
+
+//  static
+int64_t StructTraits<
+    blink::mojom::DragItemFileSystemFileDataView,
+    blink::WebDragData::Item>::size(const blink::WebDragData::Item& item) {
+  return item.file_system_file_size;
+}
+
+//  static
+WTF::String StructTraits<blink::mojom::DragItemFileSystemFileDataView,
+                         blink::WebDragData::Item>::
+    file_system_id(const blink::WebDragData::Item& item) {
+  return item.file_system_id;
+}
+
+// static
+bool StructTraits<blink::mojom::DragItemFileSystemFileDataView,
+                  blink::WebDragData::Item>::
+    Read(blink::mojom::DragItemFileSystemFileDataView data,
+         blink::WebDragData::Item* out) {
+  blink::WebDragData::Item item;
+  blink::KURL file_system_url;
+  WTF::String file_system_id;
+  if (!data.ReadUrl(&file_system_url) ||
+      !data.ReadFileSystemId(&file_system_id))
+    return false;
+
+  item.storage_type = blink::WebDragData::Item::kStorageTypeFileSystemFile;
+  item.file_system_url = file_system_url;
+  item.file_system_file_size = data.size();
+  item.file_system_id = file_system_id;
+  *out = std::move(item);
+  return true;
+}
+
+// static
+bool UnionTraits<blink::mojom::DragItemDataView, blink::WebDragData::Item>::
+    Read(blink::mojom::DragItemDataView data, blink::WebDragData::Item* out) {
+  blink::WebDragData::Item item;
+  switch (data.tag()) {
+    case blink::mojom::DragItemDataView::Tag::STRING:
+      return data.ReadString(out);
+    case blink::mojom::DragItemDataView::Tag::FILE:
+      return data.ReadFile(out);
+    case blink::mojom::DragItemDataView::Tag::BINARY:
+      return data.ReadBinary(out);
+    case blink::mojom::DragItemDataView::Tag::FILE_SYSTEM_FILE:
+      return data.ReadFileSystemFile(out);
+  }
+  NOTREACHED();
+  return false;
+}
+
+// static
+blink::mojom::DragItemDataView::Tag
+UnionTraits<blink::mojom::DragItemDataView, blink::WebDragData::Item>::GetTag(
+    const blink::WebDragData::Item& item) {
+  switch (item.storage_type) {
+    case blink::WebDragData::Item::kStorageTypeString:
+      return blink::mojom::DragItemDataView::Tag::STRING;
+    case blink::WebDragData::Item::kStorageTypeFilename:
+      return blink::mojom::DragItemDataView::Tag::FILE;
+    case blink::WebDragData::Item::kStorageTypeBinaryData:
+      return blink::mojom::DragItemDataView::Tag::BINARY;
+    case blink::WebDragData::Item::kStorageTypeFileSystemFile:
+      return blink::mojom::DragItemDataView::Tag::FILE_SYSTEM_FILE;
+  }
+  NOTREACHED();
+  return blink::mojom::DragItemDataView::Tag::STRING;
+}
+
+// static
+blink::WebVector<blink::WebDragData::Item>
+StructTraits<blink::mojom::DragDataDataView, blink::WebDragData>::items(
+    const blink::WebDragData& drag_data) {
+  return drag_data.Items();
+}
+
+// static
+WTF::String StructTraits<blink::mojom::DragDataDataView, blink::WebDragData>::
+    file_system_id(const blink::WebDragData& drag_data) {
+  return drag_data.FilesystemId();
+}
+
+// static
+bool StructTraits<blink::mojom::DragDataDataView, blink::WebDragData>::Read(
+    blink::mojom::DragDataDataView data,
+    blink::WebDragData* out) {
+  blink::WebVector<blink::WebDragData::Item> items;
+  WTF::String file_system_id;
+  if (!data.ReadItems(&items) || !data.ReadFileSystemId(&file_system_id))
+    return false;
+
+  blink::WebDragData drag_data;
+  drag_data.SetItems(std::move(items));
+  drag_data.SetFilesystemId(file_system_id);
+  *out = std::move(drag_data);
+  return true;
+}
+
+}  // namespace mojo

third_party/blink/renderer/platform/mojo/drag_mojom_traits.h

+// Copyright 2020 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef THIRD_PARTY_BLINK_RENDERER_PLATFORM_MOJO_DRAG_MOJOM_TRAITS_H_
+#define THIRD_PARTY_BLINK_RENDERER_PLATFORM_MOJO_DRAG_MOJOM_TRAITS_H_
+
+#include <stdint.h>
+
+#include <string>
+
+#include "mojo/public/cpp/base/file_path_mojom_traits.h"
+#include "mojo/public/cpp/base/string16_mojom_traits.h"
+#include "mojo/public/cpp/bindings/array_traits_web_vector.h"
+#include "mojo/public/cpp/bindings/string_traits_wtf.h"
+#include "mojo/public/cpp/bindings/struct_traits.h"
+#include "mojo/public/cpp/bindings/union_traits.h"
+#include "third_party/blink/public/mojom/page/drag.mojom-shared.h"
+#include "third_party/blink/public/platform/web_drag_data.h"
+#include "third_party/blink/renderer/platform/mojo/kurl_mojom_traits.h"
+#include "third_party/blink/renderer/platform/weborigin/kurl.h"
+#include "third_party/blink/renderer/platform/wtf/forward.h"
+
+namespace blink {
+template <typename T>
+class WebVector;
+}
+
+namespace mojo {
+
+template <>
+struct StructTraits<blink::mojom::DragItemStringDataView,
+                    blink::WebDragData::Item> {
+  static WTF::String string_type(blink::WebDragData::Item item);
+  static WTF::String string_data(const blink::WebDragData::Item& item);
+  static WTF::String title(const blink::WebDragData::Item& item);
+  static blink::KURL base_url(const blink::WebDragData::Item& item);
+  static bool Read(blink::mojom::DragItemStringDataView data,
+                   blink::WebDragData::Item* out);
+};
+
+template <>
+struct StructTraits<blink::mojom::DragItemFileDataView,
+                    blink::WebDragData::Item> {
+  static base::FilePath path(const blink::WebDragData::Item& item);
+  static base::FilePath display_name(const blink::WebDragData::Item& item);
+  static bool Read(blink::mojom::DragItemFileDataView data,
+                   blink::WebDragData::Item* out);
+};
+
+template <>
+struct StructTraits<blink::mojom::DragItemBinaryDataView,
+                    blink::WebDragData::Item> {
+  static blink::WebVector<uint8_t> data(const blink::WebDragData::Item& item);
+  static blink::KURL source_url(const blink::WebDragData::Item& item);
+  static base::FilePath filename_extension(
+      const blink::WebDragData::Item& item);
+  static WTF::String content_disposition(const blink::WebDragData::Item& item);
+  static bool Read(blink::mojom::DragItemBinaryDataView data,
+                   blink::WebDragData::Item* out);
+};
+
+template <>
+struct StructTraits<blink::mojom::DragItemFileSystemFileDataView,
+                    blink::WebDragData::Item> {
+  static blink::KURL url(const blink::WebDragData::Item& item);
+  static int64_t size(const blink::WebDragData::Item& item);
+  static WTF::String file_system_id(const blink::WebDragData::Item& item);
+  static bool Read(blink::mojom::DragItemFileSystemFileDataView data,
+                   blink::WebDragData::Item* out);
+};
+
+template <>
+struct UnionTraits<blink::mojom::DragItemDataView, blink::WebDragData::Item> {
+  static const blink::WebDragData::Item& string(
+      const blink::WebDragData::Item& item) {
+    return item;
+  }
+  static const blink::WebDragData::Item& file(
+      const blink::WebDragData::Item& item) {
+    return item;
+  }
+  static const blink::WebDragData::Item& binary(
+      const blink::WebDragData::Item& item) {
+    return item;
+  }
+  static const blink::WebDragData::Item& file_system_file(
+      const blink::WebDragData::Item& item) {
+    return item;
+  }
+  static bool Read(blink::mojom::DragItemDataView data,
+                   blink::WebDragData::Item* out);
+  static blink::mojom::DragItemDataView::Tag GetTag(
+      const blink::WebDragData::Item& item);
+};
+
+template <>
+struct StructTraits<blink::mojom::DragDataDataView, blink::WebDragData> {
+  static blink::WebVector<blink::WebDragData::Item> items(
+      const blink::WebDragData& drag_data);
+  static WTF::String file_system_id(const blink::WebDragData& drag_data);
+  static bool Read(blink::mojom::DragDataDataView data,
+                   blink::WebDragData* out);
+};
+
+}  // namespace mojo
+
+#endif  // THIRD_PARTY_BLINK_RENDERER_PLATFORM_MOJO_DRAG_MOJOM_TRAITS_H_