Changeset 222595 in webkit

Timestamp:

Sep 27, 2017, 7:29:16 PM (8 years ago)

Author:

Wenson Hsieh

Message:

Drag event DataTransfer has unexpected types "dyn.ah62d4..."
​https://bugs.webkit.org/show_bug.cgi?id=172526
<rdar://problem/32396081>

Reviewed by Ryosuke Niwa.

Source/WebCore:

Currently, the pasteboard types we expose to web content are simply the types that appear on the platform
pasteboard (i.e. the general NSPasteboard on Mac, and either the general UIPasteboard or a UIDragSession's
NSItemProviders on iOS). This leads to DataTransfer.types exposing many private pasteboard types written by apps
around the system to the page, such as dynamic UTIs, CorePasteboardFlavorTypes, or the "Apple WebKit dummy
pasteboard type". These are not only confusing and not useful for web content (since they mostly hold values of
empty string anyways), but can additionally pose privacy concerns by exposing information meant only for native
applications to unvetted web content.

To address this problem, other browsers (e.g. Chrome and Firefox on Mac) white-list MIME types in DataTransfer's
list of types. By default, when dragging or copying, these are "text/plain", "text/html" and "text/uri-list".
However, this policy alone is insufficient, because the page may also supply its own types, in which case our
naive whitelist would prevent us from delivering them to the page. To address this additional constraint, both
Chrome and Firefox write any custom data supplied by the page to custom pasteboard UTIs
(org.chromium.drag-dummy-type and org.mozilla.custom-clipdata, respectively). The corresponding data is a map
of custom UTI => custom data supplied by the page; upon drop or paste, this mapping is consulted if the page
calls getData() with a custom UTI.

This patch adopts this same approach in WebKit, and introduces the com.apple.WebKit.custom-pasteboard-data UTI
(refer to per-method comments below for more information). These changes are covered by 18 new layout and API
tests, as well as existing drag-and-drop tests.

Tests: editing/pasteboard/data-transfer-get-data-on-drop-custom.html

editing/pasteboard/data-transfer-get-data-on-drop-plain-text.html
editing/pasteboard/data-transfer-get-data-on-drop-rich-text.html
editing/pasteboard/data-transfer-get-data-on-drop-url.html
editing/pasteboard/data-transfer-get-data-on-paste-custom.html
editing/pasteboard/data-transfer-get-data-on-paste-plain-text.html
editing/pasteboard/data-transfer-get-data-on-paste-rich-text.html
DataInteractionTests.DataTransferGetDataWhenDroppingPlainText
DataInteractionTests.DataTransferGetDataWhenDroppingCustomData
DataInteractionTests.DataTransferGetDataWhenDroppingURL
DataInteractionTests.DataTransferGetDataWhenDroppingImageWithFileURL
DataInteractionTests.DataTransferGetDataWhenDroppingRespectsPresentationStyle
DataInteractionTests.DataTransferSetDataCannotWritePlatformTypes
DataInteractionTests.DataTransferGetDataCannotReadPrivatePlatformTypes
UIPasteboardTests.DataTransferGetDataWhenPastingURL
UIPasteboardTests.DataTransferGetDataWhenPastingPlatformRepresentations
UIPasteboardTests.DataTransferSetDataCannotWritePlatformTypes
UIPasteboardTests.DataTransferGetDataCannotReadPrivatePlatformTypes

• CMakeLists.txt:

Add Pasteboard.cpp to the WebCore CMakeList.

• WebCore.xcodeproj/project.pbxproj:
• dom/DataTransfer.cpp:

(WebCore::DataTransfer::getData const):
(WebCore::DataTransfer::createForDragStartEvent):

Make a new static helper function to create a StaticPasteboard-backed DataTransfer when dispatching a dragstart
event. Any data supplied by the page will be written to the static pasteboard of this DataTransfer.

(WebCore::DataTransfer::moveDragState):

Add a new helper on DataTransfer to transfer the data required to initiate a drag from one DataTransfer to
another. This is used in EventHandler to transfer the contents of the temporary DataTransfer modified by the
page during the dragstart event over to the DataTransfer used for the rest of the drag initiation codepath,
which is actually connected to the platform. This includes committing the contents of the other
DataTransfer's StaticPasteboard to the new platform-connected Pasteboard.

(WebCore::DataTransfer::hasDragImage const):

• dom/DataTransfer.h:
• editing/cocoa/EditorCocoa.mm:

(WebCore::Editor::selectionInHTMLFormat):
(WebCore::Editor::writeSelectionToPasteboard):
(WebCore::Editor::writeSelection):

Write an additional HTML markup string on iOS. We already do this for Mac, but this data previously had no use
on iOS. This is needed for to vend the "text/html" representation to the page on iOS when pasting.

• editing/mac/EditorMac.mm:

(WebCore::Editor::selectionInHTMLFormat): Deleted.

• editing/wpe/EditorWPE.cpp:

(WebCore::createFragmentFromPasteboardData):

• page/EventHandler.cpp:

(WebCore::EventHandler::dispatchDragStartEventOnSourceElement):

Renamed from dispatchDragStartEvent to dispatchDragStartEventOnSourceElement. Additionally, simplified the logic
significantly, so that we now just check to see if the StaticPasteboard exposed to the page has any data,
instead of using platform-dependent logic to compare changeCounts. We can do this because StaticPasteboard is
guaranteed to only contain content that the page has supplied during the dragstart event, since it is empty
upon initialization and cannot be written to by the rest of the platform.

(WebCore::EventHandler::handleDrag):

Tweak dispatchDragStartEvent to take a DataTransfer to expose to bindings; at the call site in handleDrag,
create a new DataTransfer backed by a StaticPasteboard that the page may mutate over the course of the dragstart
event. After dispatching to the page, move the dragging information present on the drag start DataTransfer over
to the DragState's DataTransfer. If the drag image has not been set, compute and set the default drag image
element on the DragState's DataTransfer.

(WebCore::EventHandler::dispatchDragStartEvent): Deleted.

• page/EventHandler.h:
• page/Settings.cpp:

(WebCore::Settings::customPasteboardDataEnabled):

• page/Settings.h:

(WebCore::Settings::setCustomPasteboardDataEnabled):

• page/ios/EventHandlerIOS.mm:

(WebCore::EventHandler::createDraggingDataTransfer const): Deleted.

• page/mac/EventHandlerMac.mm:

(WebCore::EventHandler::createDraggingDataTransfer const): Deleted.

• page/win/EventHandlerWin.cpp:

(WebCore::EventHandler::createDraggingDataTransfer const): Deleted.

Remove this helper on both iOS and Mac. This only called createForDrag() before, with the addition of clearing
the platform pasteboard prior to returning. Now that a StaticPasteboard is used when starting a drag, we clear
out the platform pasteboard in platform-invariant code in EventHandler::handleDrag, so these helpers are no
longer useful.

• platform/Pasteboard.cpp: Added.

(WebCore::isSafeTypeForDOMToReadAndWrite):

Add a new helper to determine whether or not a pasteboard type is one of the standard DOM-exposed types. These
are "text/plain", "text/html" and "text/uri-list".

(WebCore::sharedBufferFromCustomData):
(WebCore::customDataFromSharedBuffer):

Add helper methods to serialize and deserialize custom data. The serialized data blob consists of: (1)
versioning information, (2) a dictionary mapping each custom type to a value, and (3) a full list of types
written by the page, in the order they were written.

• platform/Pasteboard.h:

Rename Pasteboard::readString to Pasteboard::readStringForBindings, to reflect that the string being read and
the given type are exposed to and from the DOM.

• platform/PasteboardStrategy.h:
• platform/PasteboardWriterData.h:
• platform/PlatformPasteboard.h:
• platform/StaticPasteboard.cpp:

Split m_stringContents out into m_platformData and m_customData. The former contains type-to-data entries for
the DOM-exposed types, while the second contains entries that don't belong in the former.

(WebCore::StaticPasteboard::hasData):
(WebCore::StaticPasteboard::readStringForBindings):
(WebCore::StaticPasteboard::writeString):
(WebCore::StaticPasteboard::clear):
(WebCore::StaticPasteboard::commitToPasteboard):

Rather than propagate each entry to the client layer one at a time, populate a new PasteboardCustomData struct
and send it to the client layer in one go. This new struct consists of an array of types in the order they were
written by the page, a dictionary of public types (types we want to write directly to the platform pasteboard)
and private types (custom types we want to package under our custom data blob).

(WebCore::StaticPasteboard::readString): Deleted.

• platform/StaticPasteboard.h:
• platform/glib/EventHandlerGLib.cpp:

(WebCore::EventHandler::createDraggingDataTransfer const): Deleted.

• platform/gtk/PasteboardGtk.cpp:

(WebCore::Pasteboard::readStringForBindings):
(WebCore::Pasteboard::writeCustomData):
(WebCore::Pasteboard::readString): Deleted.

• platform/gtk/PlatformPasteboardGtk.cpp:

(WebCore::PlatformPasteboard::typesSafeForDOMToReadAndWrite const):
(WebCore::PlatformPasteboard::write):

Add stub implementations for new custom pasteboard data methods.

• platform/ios/AbstractPasteboard.h:
• platform/ios/PasteboardIOS.mm:

(WebCore::Pasteboard::writeCustomData):

Add new plumbing to ship a custom data (PasteboardCustomData) struct from WebCore to the client layer.

(WebCore::cocoaTypeFromHTMLClipboardType):
(WebCore::readPlatformValueAsString):
(WebCore::Pasteboard::readStringForBindings):
(WebCore::Pasteboard::types):

Rewritten to ask the client layer for DOM-exposed types rather than all types, in the case where custom
pasteboard data is enabled in Settings.

(WebCore::Pasteboard::readString): Deleted.

• platform/ios/PlatformPasteboardIOS.mm:

(WebCore::PlatformPasteboard::bufferForType):
(WebCore::PlatformPasteboard::getPathnamesForType const):
(WebCore::PlatformPasteboard::numberOfFiles const):
(WebCore::PlatformPasteboard::platformPasteboardTypeForSafeTypeForDOMToReadAndWrite):

Add a new helper to map DOM-safe pasteboard types to their platform counterparts.

(WebCore::PlatformPasteboard::write):
(WebCore::safeTypeForDOMToReadAndWriteForPlatformType):

Add a new helper to map platform pasteboard types to their DOM-safe counterparts.

(WebCore::PlatformPasteboard::typesSafeForDOMToReadAndWrite const):

Fetch a list of DOM-exposed types. On iOS, for drag and drop, we have the additional constraint of not being
able to read any data before the drop happens. This is problematic, since the page needs to know the list of
types during 'dragover' events. To support this, we instead keep the array of types in the teamData property of
the generated item provider, which is immediately available, even when dragging across different apps. Note that
we still need to check if the pasteboard contains the full custom data blob here to handle the case where we
copy on Mac and perform a continuity paste on iOS, since teamData does not exist on Mac.

(WebCore::PlatformPasteboard::readString):

Tweak to account for how UIPasteboard may return data blobs when reading values.

(WebCore::PlatformPasteboard::getPathnamesForType): Deleted.
(WebCore::PlatformPasteboard::numberOfFiles): Deleted.

• platform/ios/WebItemProviderPasteboard.h:
• platform/ios/WebItemProviderPasteboard.mm:

(-[WebItemProviderRegistrationInfoList itemProvider]):
(+[WebItemProviderLoadResult loadResultWithItemProvider:typesToLoad:]):
(-[WebItemProviderLoadResult initWithItemProvider:typesToLoad:]):
(-[WebItemProviderLoadResult typesToLoad]):
(-[WebItemProviderLoadResult setFileURL:forType:]):
(-[WebItemProviderLoadResult itemProvider]):
(-[WebItemProviderPasteboard setItemProviders:]):
(-[WebItemProviderPasteboard dataForPasteboardType:]):
(-[WebItemProviderPasteboard typeIdentifiersToLoadForRegisteredTypeIdentfiers:]):
(-[WebItemProviderPasteboard doAfterLoadingProvidedContentIntoFileURLs:synchronousTimeout:]):
(+[WebItemProviderLoadResult emptyLoadResult]): Deleted.
(+[WebItemProviderLoadResult loadResultWithFileURLMap:presentationStyle:]): Deleted.
(-[WebItemProviderLoadResult initWithFileURLMap:presentationStyle:]): Deleted.
(-[WebItemProviderPasteboard typeIdentifierToLoadForRegisteredTypeIdentfiers:]): Deleted.

In the case of drag and drop on iOS, we cannot load any data prior to performing the drop; additionally, any
attempts to load data immediately after the drop is performed in the UI process will fail. This means any and
all data that the web process may require in the future when handling the drop must be loaded out of the item
providers and saved when the drop is being handled in the UI process.

Currently, we only load the highest fidelity type we can handle (or, if we don't know what we can handle, we
select the highest fidelity representation conforming to "public.content"). This is a problematic for supporting
DataTransfer.getData() on drop on iOS, because the page can ask for any of the three web-exposed types. To
address this, we refactor WebItemProviderPasteboard to support loading multiple representations per item being
dropped. At minimum, we will load anything conforming to "public.html", "public.plain-text", "public.url", and
the new "com.apple.WebKit.custom-pasteboard-data" so we have means to answer any question that the page could
ask via DataTransfer.getData(). We additonally load the highest fidelity supported (or content-conformant) type,
if it has not already been loaded as a result of the former.

To make this possible, we refactor WebItemProviderLoadResult to take an item provider and a list of types to
load. -doAfterLoadingProvidedContentIntoFileURLs:synchronousTimeout: then creates a list of load results and
uses each one to represent the results of loading data from its item provider (i.e. a map of UTI => file URL).

• platform/mac/PasteboardMac.mm:

(WebCore::Pasteboard::writeCustomData):
(WebCore::cocoaTypeFromHTMLClipboardType):
(WebCore::readPlatformValueAsString):
(WebCore::Pasteboard::readStringForBindings):

Change readStringForBindings (formerly, readString) so that if support for custom pasteboard data is enabled,
we only allow reading directly from the platform pasteboard if the given type is DOM-safe; otherwise, we consult
the custom data blob, if it exists. Otherwise, if support for custom pasteboard data is disabled, we fall back
to our current behavior.

(WebCore::Pasteboard::types):
(WebCore::Pasteboard::readString): Deleted.

• platform/mac/PlatformPasteboardMac.mm:

(WebCore::PlatformPasteboard::numberOfFiles const):
(WebCore::PlatformPasteboard::getPathnamesForType const):
(WebCore::PlatformPasteboard::stringForType):
(WebCore::safeTypeForDOMToReadAndWriteForPlatformType):
(WebCore::PlatformPasteboard::typesSafeForDOMToReadAndWrite const):

Add support for reading DOM-exposed types and fetching DOM-exposed data off of the pasteboard. The overall idea
here is similar to iOS, though implementation details vary (e.g. no item provider support).

(WebCore::PlatformPasteboard::write):
(WebCore::PlatformPasteboard::platformPasteboardTypeForSafeTypeForDOMToReadAndWrite):
(WebCore::PlatformPasteboard::numberOfFiles): Deleted.
(WebCore::PlatformPasteboard::getPathnamesForType): Deleted.

• platform/win/PasteboardWin.cpp:

(WebCore::Pasteboard::readStringForBindings):
(WebCore::Pasteboard::writeCustomData):
(WebCore::Pasteboard::readString): Deleted.

• platform/wpe/PasteboardWPE.cpp:

(WebCore::Pasteboard::readStringForBindings):
(WebCore::Pasteboard::writeCustomData):
(WebCore::Pasteboard::readString): Deleted.

• platform/wpe/PlatformPasteboardWPE.cpp:

(WebCore::PlatformPasteboard::typesSafeForDOMToReadAndWrite const):
(WebCore::PlatformPasteboard::write):

• testing/InternalSettings.cpp:

(WebCore::InternalSettings::Backup::Backup):
(WebCore::InternalSettings::Backup::restoreTo):
(WebCore::InternalSettings::setCustomPasteboardDataEnabled):

Add a new internal settings hook for layout tests to opt in to using custom pasteboard data. By default, custom
pasteboard data is enabled only in Safari, or on applications linked on or after certain releases of iOS and
macOS.

• testing/InternalSettings.h:
• testing/InternalSettings.idl:

Source/WebKit:

Add boilerplate plumbing and encoder/decoder support for new pasteboard codepaths. See WebCore ChangeLog for
more details.

• Scripts/webkit/messages.py:

(headers_for_type):

• Shared/WebCoreArgumentCoders.cpp:

(IPC::ArgumentCoder<PasteboardCustomData>::encode):
(IPC::ArgumentCoder<PasteboardCustomData>::decode):

Add encoder/decoder support for PasteboardCustomData.

(IPC::ArgumentCoder<PasteboardWebContent>::encode):
(IPC::ArgumentCoder<PasteboardWebContent>::decode):

Encode and decode dataInHTMLFormat.

• Shared/WebCoreArgumentCoders.h:
• UIProcess/Cocoa/WebPasteboardProxyCocoa.mm:

(WebKit::WebPasteboardProxy::typesSafeForDOMToReadAndWrite):
(WebKit::WebPasteboardProxy::writeCustomData):

• UIProcess/WebPasteboardProxy.cpp:

(WebKit::WebPasteboardProxy::typesSafeForDOMToReadAndWrite):
(WebKit::WebPasteboardProxy::writeCustomData):

• UIProcess/WebPasteboardProxy.h:
• UIProcess/WebPasteboardProxy.messages.in:
• WebProcess/WebCoreSupport/WebPlatformStrategies.cpp:

(WebKit::WebPlatformStrategies::typesSafeForDOMToReadAndWrite):
(WebKit::WebPlatformStrategies::writeCustomData):

• WebProcess/WebCoreSupport/WebPlatformStrategies.h:

Source/WebKitLegacy/mac:

Adjust for changes in WebCore. See WebCore ChangeLog for more details.

• WebCoreSupport/WebPlatformStrategies.h:
• WebCoreSupport/WebPlatformStrategies.mm:

(WebPlatformStrategies::webExposedTypes):
(WebPlatformStrategies::writeCustomData):

Tools:

Adds new API tests on iOS to cover various cases of using DataTransfer.setData, DataTransfer.getData, and
DataTransfer.types, as well as their interaction with platform objects (source NSItemProviders in the case of
drag and drop, and the general UIPasteboard for copy and paste).

• TestWebKitAPI/PlatformUtilities.h:
• TestWebKitAPI/TestWebKitAPI.xcodeproj/project.pbxproj:
• TestWebKitAPI/Tests/WebKitCocoa/dump-datatransfer-types.html: Added.

Introduce a new API test harness that both drag-and-drop and copy-and-paste tests use to dump DataTransfer's
web-exposed types and values.

• TestWebKitAPI/Tests/ios/DataInteractionTests.mm:

(checkFirstTypeIsPresentAndSecondTypeIsMissing):
(checkJSONWithLogging):
(TestWebKitAPI::TEST):
(checkTypeIdentifierAndIsNotOtherTypeIdentifier): Deleted.

• TestWebKitAPI/Tests/ios/UIPasteboardTests.mm:

(TestWebKitAPI::checkJSONWithLogging):
(TestWebKitAPI::setUpWebViewForPasteboardTests):
(TestWebKitAPI::TEST):

• TestWebKitAPI/cocoa/PlatformUtilitiesCocoa.mm:

(TestWebKitAPI::Util::jsonMatchesExpectedValues):

LayoutTests:

Add new layout tests on Mac and iOS to test various cases of using DataTransfer.setData, DataTransfer.getData,
and DataTransfer.types for drag-and-drop (tests for Mac WK1 only) and copy-and-paste (all platforms).

• TestExpectations:
• editing/pasteboard/data-transfer-get-data-on-drop-custom-expected.txt: Added.
• editing/pasteboard/data-transfer-get-data-on-drop-custom.html: Added.
• editing/pasteboard/data-transfer-get-data-on-drop-plain-text-expected.txt: Added.
• editing/pasteboard/data-transfer-get-data-on-drop-plain-text.html: Added.
• editing/pasteboard/data-transfer-get-data-on-drop-rich-text-expected.txt: Added.
• editing/pasteboard/data-transfer-get-data-on-drop-rich-text.html: Added.
• editing/pasteboard/data-transfer-get-data-on-drop-url-expected.txt: Added.
• editing/pasteboard/data-transfer-get-data-on-drop-url.html: Added.
• editing/pasteboard/data-transfer-get-data-on-paste-custom-expected.txt: Added.
• editing/pasteboard/data-transfer-get-data-on-paste-custom.html: Added.
• editing/pasteboard/data-transfer-get-data-on-paste-plain-text-expected.txt: Added.
• editing/pasteboard/data-transfer-get-data-on-paste-plain-text.html: Added.
• editing/pasteboard/data-transfer-get-data-on-paste-rich-text-expected.txt: Added.
• editing/pasteboard/data-transfer-get-data-on-paste-rich-text.html: Added.
• platform/ios-simulator-wk1/TestExpectations:

Mark new copy and paste tests as [ Pass ], since editing/pasteboard/ is skipped by default for iOS WK1.

• platform/ios-wk1/editing/pasteboard/data-transfer-get-data-on-paste-rich-text-expected.txt: Added.
• platform/ios-wk2/editing/pasteboard/data-transfer-get-data-on-paste-rich-text-expected.txt: Added.

Add iOS-specific baselines. This is due to the generated HTML markup for "text/html" being slightly different
when pasting.

• platform/mac-wk1/TestExpectations:

Location:

trunk

Files:

• LayoutTests/ChangeLog (modified) (1 diff)
• LayoutTests/TestExpectations (modified) (1 diff)
• LayoutTests/editing/pasteboard/data-transfer-get-data-on-drop-custom-expected.txt (added)
• LayoutTests/editing/pasteboard/data-transfer-get-data-on-drop-custom.html (added)
• LayoutTests/editing/pasteboard/data-transfer-get-data-on-drop-plain-text-expected.txt (added)
• LayoutTests/editing/pasteboard/data-transfer-get-data-on-drop-plain-text.html (added)
• LayoutTests/editing/pasteboard/data-transfer-get-data-on-drop-rich-text-expected.txt (added)
• LayoutTests/editing/pasteboard/data-transfer-get-data-on-drop-rich-text.html (added)
• LayoutTests/editing/pasteboard/data-transfer-get-data-on-drop-url-expected.txt (added)
• LayoutTests/editing/pasteboard/data-transfer-get-data-on-drop-url.html (added)
• LayoutTests/editing/pasteboard/data-transfer-get-data-on-paste-custom-expected.txt (added)
• LayoutTests/editing/pasteboard/data-transfer-get-data-on-paste-custom.html (added)
• LayoutTests/editing/pasteboard/data-transfer-get-data-on-paste-plain-text-expected.txt (added)
• LayoutTests/editing/pasteboard/data-transfer-get-data-on-paste-plain-text.html (added)
• LayoutTests/editing/pasteboard/data-transfer-get-data-on-paste-rich-text-expected.txt (added)
• LayoutTests/editing/pasteboard/data-transfer-get-data-on-paste-rich-text.html (added)
• LayoutTests/platform/ios-simulator-wk1/TestExpectations (modified) (1 diff)
• LayoutTests/platform/ios-wk1/editing/pasteboard/data-transfer-get-data-on-paste-rich-text-expected.txt (added)
• LayoutTests/platform/ios-wk2/editing/pasteboard/data-transfer-get-data-on-paste-rich-text-expected.txt (added)
• LayoutTests/platform/mac-wk1/TestExpectations (modified) (1 diff)
• Source/WebCore/CMakeLists.txt (modified) (1 diff)
• Source/WebCore/ChangeLog (modified) (1 diff)
• Source/WebCore/WebCore.xcodeproj/project.pbxproj (modified) (12 diffs)
• Source/WebCore/dom/DataTransfer.cpp (modified) (3 diffs)
• Source/WebCore/dom/DataTransfer.h (modified) (2 diffs)
• Source/WebCore/editing/cocoa/EditorCocoa.mm (modified) (4 diffs)
• Source/WebCore/editing/mac/EditorMac.mm (modified) (1 diff)
• Source/WebCore/editing/wpe/EditorWPE.cpp (modified) (2 diffs)
• Source/WebCore/page/EventHandler.cpp (modified) (3 diffs)
• Source/WebCore/page/EventHandler.h (modified) (2 diffs)
• Source/WebCore/page/Settings.cpp (modified) (3 diffs)
• Source/WebCore/page/Settings.h (modified) (2 diffs)
• Source/WebCore/page/ios/EventHandlerIOS.mm (modified) (1 diff)
• Source/WebCore/page/mac/EventHandlerMac.mm (modified) (1 diff)
• Source/WebCore/page/win/EventHandlerWin.cpp (modified) (1 diff)
• Source/WebCore/platform/Pasteboard.cpp (added)
• Source/WebCore/platform/Pasteboard.h (modified) (5 diffs)
• Source/WebCore/platform/PasteboardStrategy.h (modified) (2 diffs)
• Source/WebCore/platform/PasteboardWriterData.h (modified) (1 diff)
• Source/WebCore/platform/PlatformPasteboard.h (modified) (3 diffs)
• Source/WebCore/platform/StaticPasteboard.cpp (modified) (5 diffs)
• Source/WebCore/platform/StaticPasteboard.h (modified) (2 diffs)
• Source/WebCore/platform/glib/EventHandlerGLib.cpp (modified) (1 diff)
• Source/WebCore/platform/gtk/PasteboardGtk.cpp (modified) (2 diffs)
• Source/WebCore/platform/gtk/PlatformPasteboardGtk.cpp (modified) (1 diff)
• Source/WebCore/platform/ios/AbstractPasteboard.h (modified) (1 diff)
• Source/WebCore/platform/ios/PasteboardIOS.mm (modified) (7 diffs)
• Source/WebCore/platform/ios/PlatformPasteboardIOS.mm (modified) (6 diffs)
• Source/WebCore/platform/ios/WebItemProviderPasteboard.h (modified) (1 diff)
• Source/WebCore/platform/ios/WebItemProviderPasteboard.mm (modified) (11 diffs)
• Source/WebCore/platform/mac/PasteboardMac.mm (modified) (5 diffs)
• Source/WebCore/platform/mac/PlatformPasteboardMac.mm (modified) (5 diffs)
• Source/WebCore/platform/win/PasteboardWin.cpp (modified) (2 diffs)
• Source/WebCore/platform/wpe/PasteboardWPE.cpp (modified) (2 diffs)
• Source/WebCore/platform/wpe/PlatformPasteboardWPE.cpp (modified) (1 diff)
• Source/WebCore/testing/InternalSettings.cpp (modified) (3 diffs)
• Source/WebCore/testing/InternalSettings.h (modified) (2 diffs)
• Source/WebCore/testing/InternalSettings.idl (modified) (1 diff)
• Source/WebKit/ChangeLog (modified) (1 diff)
• Source/WebKit/Scripts/webkit/messages.py (modified) (1 diff)
• Source/WebKit/Shared/WebCoreArgumentCoders.cpp (modified) (4 diffs)
• Source/WebKit/Shared/WebCoreArgumentCoders.h (modified) (2 diffs)
• Source/WebKit/UIProcess/Cocoa/WebPasteboardProxyCocoa.mm (modified) (1 diff)
• Source/WebKit/UIProcess/WebPasteboardProxy.cpp (modified) (1 diff)
• Source/WebKit/UIProcess/WebPasteboardProxy.h (modified) (2 diffs)
• Source/WebKit/UIProcess/WebPasteboardProxy.messages.in (modified) (1 diff)
• Source/WebKit/WebProcess/WebCoreSupport/WebPlatformStrategies.cpp (modified) (1 diff)
• Source/WebKit/WebProcess/WebCoreSupport/WebPlatformStrategies.h (modified) (1 diff)
• Source/WebKitLegacy/mac/ChangeLog (modified) (1 diff)
• Source/WebKitLegacy/mac/WebCoreSupport/WebPlatformStrategies.h (modified) (2 diffs)
• Source/WebKitLegacy/mac/WebCoreSupport/WebPlatformStrategies.mm (modified) (1 diff)
• Tools/ChangeLog (modified) (1 diff)
• Tools/TestWebKitAPI/PlatformUtilities.h (modified) (2 diffs)
• Tools/TestWebKitAPI/TestWebKitAPI.xcodeproj/project.pbxproj (modified) (4 diffs)
• Tools/TestWebKitAPI/Tests/WebKitCocoa/dump-datatransfer-types.html (added)
• Tools/TestWebKitAPI/Tests/ios/DataInteractionTests.mm (modified) (6 diffs)
• Tools/TestWebKitAPI/Tests/ios/UIPasteboardTests.mm (modified) (9 diffs)
• Tools/TestWebKitAPI/cocoa/PlatformUtilitiesCocoa.mm (modified) (1 diff)

trunk/LayoutTests/ChangeLog

@@ +1 @@
+2017-09-27  Wenson Hsieh  <wenson_hsieh@apple.com>
+
+        Drag event DataTransfer has unexpected types "dyn.ah62d4..."
+        https://bugs.webkit.org/show_bug.cgi?id=172526
+        <rdar://problem/32396081>
+
+        Reviewed by Ryosuke Niwa.
+
+        Add new layout tests on Mac and iOS to test various cases of using DataTransfer.setData, DataTransfer.getData,
+        and DataTransfer.types for drag-and-drop (tests for Mac WK1 only) and copy-and-paste (all platforms).
+
+        * TestExpectations:
+        * editing/pasteboard/data-transfer-get-data-on-drop-custom-expected.txt: Added.
+        * editing/pasteboard/data-transfer-get-data-on-drop-custom.html: Added.
+        * editing/pasteboard/data-transfer-get-data-on-drop-plain-text-expected.txt: Added.
+        * editing/pasteboard/data-transfer-get-data-on-drop-plain-text.html: Added.
+        * editing/pasteboard/data-transfer-get-data-on-drop-rich-text-expected.txt: Added.
+        * editing/pasteboard/data-transfer-get-data-on-drop-rich-text.html: Added.
+        * editing/pasteboard/data-transfer-get-data-on-drop-url-expected.txt: Added.
+        * editing/pasteboard/data-transfer-get-data-on-drop-url.html: Added.
+        * editing/pasteboard/data-transfer-get-data-on-paste-custom-expected.txt: Added.
+        * editing/pasteboard/data-transfer-get-data-on-paste-custom.html: Added.
+        * editing/pasteboard/data-transfer-get-data-on-paste-plain-text-expected.txt: Added.
+        * editing/pasteboard/data-transfer-get-data-on-paste-plain-text.html: Added.
+        * editing/pasteboard/data-transfer-get-data-on-paste-rich-text-expected.txt: Added.
+        * editing/pasteboard/data-transfer-get-data-on-paste-rich-text.html: Added.
+        * platform/ios-simulator-wk1/TestExpectations:
+
+        Mark new copy and paste tests as [ Pass ], since editing/pasteboard/ is skipped by default for iOS WK1.
+
+        * platform/ios-wk1/editing/pasteboard/data-transfer-get-data-on-paste-rich-text-expected.txt: Added.
+        * platform/ios-wk2/editing/pasteboard/data-transfer-get-data-on-paste-rich-text-expected.txt: Added.
+
+        Add iOS-specific baselines. This is due to the generated HTML markup for "text/html" being slightly different
+        when pasting.
+
+        * platform/mac-wk1/TestExpectations:
+
 2017-09-27  Zalan Bujtas  <zalan@apple.com>
 

trunk/LayoutTests/TestExpectations

@@ -68 +68 @@
 # Drag and drop via EventSender is only supported on Mac WK1
 editing/pasteboard/drag-drop-href-as-text-data.html [ Skip ]
+editing/pasteboard/data-transfer-get-data-on-drop-custom.html [ Skip ]
+editing/pasteboard/data-transfer-get-data-on-drop-plain-text.html [ Skip ]
+editing/pasteboard/data-transfer-get-data-on-drop-rich-text.html [ Skip ]
+editing/pasteboard/data-transfer-get-data-on-drop-url.html [ Skip ]
 
 # Only iOS supports QuickLook

trunk/LayoutTests/platform/ios-simulator-wk1/TestExpectations

@@ -8 +8 @@
 # Untriage pasteboard test failures
 editing/pasteboard/
+editing/pasteboard/data-transfer-get-data-on-paste-custom.html [ Pass ]
+editing/pasteboard/data-transfer-get-data-on-paste-plain-text.html [ Pass ]
+editing/pasteboard/data-transfer-get-data-on-paste-rich-text.html [ Pass ]

trunk/LayoutTests/platform/mac-wk1/TestExpectations

@@ -8 +8 @@
 fast/forms/attributed-strings.html [ Pass ]
 editing/pasteboard/drag-drop-href-as-text-data.html [ Pass ]
+editing/pasteboard/data-transfer-get-data-on-drop-custom.html [ Pass ]
+editing/pasteboard/data-transfer-get-data-on-drop-plain-text.html [ Pass ]
+editing/pasteboard/data-transfer-get-data-on-drop-rich-text.html [ Pass ]
+editing/pasteboard/data-transfer-get-data-on-drop-url.html [ Pass ]
 
 #//////////////////////////////////////////////////////////////////////////////////////////

trunk/Source/WebCore/CMakeLists.txt

@@ -2331 +2331 @@
     platform/MainThreadSharedTimer.cpp
     platform/NotImplemented.cpp
+    platform/Pasteboard.cpp
     platform/PasteboardWriterData.cpp
     platform/PlatformSpeechSynthesisUtterance.cpp

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2017-09-27  Wenson Hsieh  <wenson_hsieh@apple.com>
+
+        Drag event DataTransfer has unexpected types "dyn.ah62d4..."
+        https://bugs.webkit.org/show_bug.cgi?id=172526
+        <rdar://problem/32396081>
+
+        Reviewed by Ryosuke Niwa.
+
+        Currently, the pasteboard types we expose to web content are simply the types that appear on the platform
+        pasteboard (i.e. the general NSPasteboard on Mac, and either the general UIPasteboard or a UIDragSession's
+        NSItemProviders on iOS). This leads to DataTransfer.types exposing many private pasteboard types written by apps
+        around the system to the page, such as dynamic UTIs, CorePasteboardFlavorTypes, or the "Apple WebKit dummy
+        pasteboard type". These are not only confusing and not useful for web content (since they mostly hold values of
+        empty string anyways), but can additionally pose privacy concerns by exposing information meant only for native
+        applications to unvetted web content.
+
+        To address this problem, other browsers (e.g. Chrome and Firefox on Mac) white-list MIME types in DataTransfer's
+        list of types. By default, when dragging or copying, these are "text/plain", "text/html" and "text/uri-list".
+        However, this policy alone is insufficient, because the page may also supply its own types, in which case our
+        naive whitelist would prevent us from delivering them to the page. To address this additional constraint, both
+        Chrome and Firefox write any custom data supplied by the page to custom pasteboard UTIs
+        (org.chromium.drag-dummy-type and org.mozilla.custom-clipdata, respectively). The corresponding data is a map
+        of custom UTI => custom data supplied by the page; upon drop or paste, this mapping is consulted if the page
+        calls getData() with a custom UTI.
+
+        This patch adopts this same approach in WebKit, and introduces the com.apple.WebKit.custom-pasteboard-data UTI
+        (refer to per-method comments below for more information). These changes are covered by 18 new layout and API
+        tests, as well as existing drag-and-drop tests.
+
+        Tests: editing/pasteboard/data-transfer-get-data-on-drop-custom.html
+               editing/pasteboard/data-transfer-get-data-on-drop-plain-text.html
+               editing/pasteboard/data-transfer-get-data-on-drop-rich-text.html
+               editing/pasteboard/data-transfer-get-data-on-drop-url.html
+               editing/pasteboard/data-transfer-get-data-on-paste-custom.html
+               editing/pasteboard/data-transfer-get-data-on-paste-plain-text.html
+               editing/pasteboard/data-transfer-get-data-on-paste-rich-text.html
+               DataInteractionTests.DataTransferGetDataWhenDroppingPlainText
+               DataInteractionTests.DataTransferGetDataWhenDroppingCustomData
+               DataInteractionTests.DataTransferGetDataWhenDroppingURL
+               DataInteractionTests.DataTransferGetDataWhenDroppingImageWithFileURL
+               DataInteractionTests.DataTransferGetDataWhenDroppingRespectsPresentationStyle
+               DataInteractionTests.DataTransferSetDataCannotWritePlatformTypes
+               DataInteractionTests.DataTransferGetDataCannotReadPrivatePlatformTypes
+               UIPasteboardTests.DataTransferGetDataWhenPastingURL
+               UIPasteboardTests.DataTransferGetDataWhenPastingPlatformRepresentations
+               UIPasteboardTests.DataTransferSetDataCannotWritePlatformTypes
+               UIPasteboardTests.DataTransferGetDataCannotReadPrivatePlatformTypes
+
+        * CMakeLists.txt:
+
+        Add Pasteboard.cpp to the WebCore CMakeList.
+
+        * WebCore.xcodeproj/project.pbxproj:
+        * dom/DataTransfer.cpp:
+        (WebCore::DataTransfer::getData const):
+        (WebCore::DataTransfer::createForDragStartEvent):
+
+        Make a new static helper function to create a StaticPasteboard-backed DataTransfer when dispatching a dragstart
+        event. Any data supplied by the page will be written to the static pasteboard of this DataTransfer.
+
+        (WebCore::DataTransfer::moveDragState):
+
+        Add a new helper on DataTransfer to transfer the data required to initiate a drag from one DataTransfer to
+        another. This is used in EventHandler to transfer the contents of the temporary DataTransfer modified by the
+        page during the dragstart event over to the DataTransfer used for the rest of the drag initiation codepath,
+        which is actually connected to the platform. This includes committing the contents of the other
+        DataTransfer's StaticPasteboard to the new platform-connected Pasteboard.
+
+        (WebCore::DataTransfer::hasDragImage const):
+        * dom/DataTransfer.h:
+        * editing/cocoa/EditorCocoa.mm:
+        (WebCore::Editor::selectionInHTMLFormat):
+        (WebCore::Editor::writeSelectionToPasteboard):
+        (WebCore::Editor::writeSelection):
+
+        Write an additional HTML markup string on iOS. We already do this for Mac, but this data previously had no use
+        on iOS. This is needed for to vend the "text/html" representation to the page on iOS when pasting.
+
+        * editing/mac/EditorMac.mm:
+        (WebCore::Editor::selectionInHTMLFormat): Deleted.
+        * editing/wpe/EditorWPE.cpp:
+        (WebCore::createFragmentFromPasteboardData):
+        * page/EventHandler.cpp:
+        (WebCore::EventHandler::dispatchDragStartEventOnSourceElement):
+
+        Renamed from dispatchDragStartEvent to dispatchDragStartEventOnSourceElement. Additionally, simplified the logic
+        significantly, so that we now just check to see if the StaticPasteboard exposed to the page has any data,
+        instead of using platform-dependent logic to compare changeCounts. We can do this because StaticPasteboard is
+        guaranteed to only contain content that the page has supplied during the dragstart event, since it is empty
+        upon initialization and cannot be written to by the rest of the platform.
+
+        (WebCore::EventHandler::handleDrag):
+
+        Tweak dispatchDragStartEvent to take a DataTransfer to expose to bindings; at the call site in handleDrag,
+        create a new DataTransfer backed by a StaticPasteboard that the page may mutate over the course of the dragstart
+        event. After dispatching to the page, move the dragging information present on the drag start DataTransfer over
+        to the DragState's DataTransfer. If the drag image has not been set, compute and set the default drag image
+        element on the DragState's DataTransfer.
+
+        (WebCore::EventHandler::dispatchDragStartEvent): Deleted.
+        * page/EventHandler.h:
+        * page/Settings.cpp:
+        (WebCore::Settings::customPasteboardDataEnabled):
+        * page/Settings.h:
+        (WebCore::Settings::setCustomPasteboardDataEnabled):
+        * page/ios/EventHandlerIOS.mm:
+        (WebCore::EventHandler::createDraggingDataTransfer const): Deleted.
+        * page/mac/EventHandlerMac.mm:
+        (WebCore::EventHandler::createDraggingDataTransfer const): Deleted.
+        * page/win/EventHandlerWin.cpp:
+        (WebCore::EventHandler::createDraggingDataTransfer const): Deleted.
+
+        Remove this helper on both iOS and Mac. This only called createForDrag() before, with the addition of clearing
+        the platform pasteboard prior to returning. Now that a StaticPasteboard is used when starting a drag, we clear
+        out the platform pasteboard in platform-invariant code in EventHandler::handleDrag, so these helpers are no
+        longer useful.
+
+        * platform/Pasteboard.cpp: Added.
+        (WebCore::isSafeTypeForDOMToReadAndWrite):
+
+        Add a new helper to determine whether or not a pasteboard type is one of the standard DOM-exposed types. These
+        are "text/plain", "text/html" and "text/uri-list".
+
+        (WebCore::sharedBufferFromCustomData):
+        (WebCore::customDataFromSharedBuffer):
+
+        Add helper methods to serialize and deserialize custom data. The serialized data blob consists of: (1)
+        versioning information, (2) a dictionary mapping each custom type to a value, and (3) a full list of types
+        written by the page, in the order they were written.
+
+        * platform/Pasteboard.h:
+
+        Rename Pasteboard::readString to Pasteboard::readStringForBindings, to reflect that the string being read and
+        the given type are exposed to and from the DOM.
+
+        * platform/PasteboardStrategy.h:
+        * platform/PasteboardWriterData.h:
+        * platform/PlatformPasteboard.h:
+        * platform/StaticPasteboard.cpp:
+
+        Split m_stringContents out into m_platformData and m_customData. The former contains type-to-data entries for
+        the DOM-exposed types, while the second contains entries that don't belong in the former.
+
+        (WebCore::StaticPasteboard::hasData):
+        (WebCore::StaticPasteboard::readStringForBindings):
+        (WebCore::StaticPasteboard::writeString):
+        (WebCore::StaticPasteboard::clear):
+        (WebCore::StaticPasteboard::commitToPasteboard):
+
+        Rather than propagate each entry to the client layer one at a time, populate a new PasteboardCustomData struct
+        and send it to the client layer in one go. This new struct consists of an array of types in the order they were
+        written by the page, a dictionary of public types (types we want to write directly to the platform pasteboard)
+        and private types (custom types we want to package under our custom data blob).
+
+        (WebCore::StaticPasteboard::readString): Deleted.
+        * platform/StaticPasteboard.h:
+        * platform/glib/EventHandlerGLib.cpp:
+        (WebCore::EventHandler::createDraggingDataTransfer const): Deleted.
+        * platform/gtk/PasteboardGtk.cpp:
+        (WebCore::Pasteboard::readStringForBindings):
+        (WebCore::Pasteboard::writeCustomData):
+        (WebCore::Pasteboard::readString): Deleted.
+        * platform/gtk/PlatformPasteboardGtk.cpp:
+        (WebCore::PlatformPasteboard::typesSafeForDOMToReadAndWrite const):
+        (WebCore::PlatformPasteboard::write):
+
+        Add stub implementations for new custom pasteboard data methods.
+
+        * platform/ios/AbstractPasteboard.h:
+        * platform/ios/PasteboardIOS.mm:
+        (WebCore::Pasteboard::writeCustomData):
+
+        Add new plumbing to ship a custom data (PasteboardCustomData) struct from WebCore to the client layer.
+
+        (WebCore::cocoaTypeFromHTMLClipboardType):
+        (WebCore::readPlatformValueAsString):
+        (WebCore::Pasteboard::readStringForBindings):
+        (WebCore::Pasteboard::types):
+
+        Rewritten to ask the client layer for DOM-exposed types rather than all types, in the case where custom
+        pasteboard data is enabled in Settings.
+
+        (WebCore::Pasteboard::readString): Deleted.
+        * platform/ios/PlatformPasteboardIOS.mm:
+        (WebCore::PlatformPasteboard::bufferForType):
+        (WebCore::PlatformPasteboard::getPathnamesForType const):
+        (WebCore::PlatformPasteboard::numberOfFiles const):
+        (WebCore::PlatformPasteboard::platformPasteboardTypeForSafeTypeForDOMToReadAndWrite):
+
+        Add a new helper to map DOM-safe pasteboard types to their platform counterparts.
+
+        (WebCore::PlatformPasteboard::write):
+        (WebCore::safeTypeForDOMToReadAndWriteForPlatformType):
+
+        Add a new helper to map platform pasteboard types to their DOM-safe counterparts.
+
+        (WebCore::PlatformPasteboard::typesSafeForDOMToReadAndWrite const):
+
+        Fetch a list of DOM-exposed types. On iOS, for drag and drop, we have the additional constraint of not being
+        able to read any data before the drop happens. This is problematic, since the page needs to know the list of
+        types during 'dragover' events. To support this, we instead keep the array of types in the teamData property of
+        the generated item provider, which is immediately available, even when dragging across different apps. Note that
+        we still need to check if the pasteboard contains the full custom data blob here to handle the case where we
+        copy on Mac and perform a continuity paste on iOS, since teamData does not exist on Mac.
+
+        (WebCore::PlatformPasteboard::readString):
+
+        Tweak to account for how UIPasteboard may return data blobs when reading values.
+
+        (WebCore::PlatformPasteboard::getPathnamesForType): Deleted.
+        (WebCore::PlatformPasteboard::numberOfFiles): Deleted.
+        * platform/ios/WebItemProviderPasteboard.h:
+        * platform/ios/WebItemProviderPasteboard.mm:
+        (-[WebItemProviderRegistrationInfoList itemProvider]):
+        (+[WebItemProviderLoadResult loadResultWithItemProvider:typesToLoad:]):
+        (-[WebItemProviderLoadResult initWithItemProvider:typesToLoad:]):
+        (-[WebItemProviderLoadResult typesToLoad]):
+        (-[WebItemProviderLoadResult setFileURL:forType:]):
+        (-[WebItemProviderLoadResult itemProvider]):
+        (-[WebItemProviderPasteboard setItemProviders:]):
+        (-[WebItemProviderPasteboard dataForPasteboardType:]):
+        (-[WebItemProviderPasteboard typeIdentifiersToLoadForRegisteredTypeIdentfiers:]):
+        (-[WebItemProviderPasteboard doAfterLoadingProvidedContentIntoFileURLs:synchronousTimeout:]):
+        (+[WebItemProviderLoadResult emptyLoadResult]): Deleted.
+        (+[WebItemProviderLoadResult loadResultWithFileURLMap:presentationStyle:]): Deleted.
+        (-[WebItemProviderLoadResult initWithFileURLMap:presentationStyle:]): Deleted.
+        (-[WebItemProviderPasteboard typeIdentifierToLoadForRegisteredTypeIdentfiers:]): Deleted.
+
+        In the case of drag and drop on iOS, we cannot load any data prior to performing the drop; additionally, any
+        attempts to load data immediately after the drop is performed in the UI process will fail. This means any and
+        all data that the web process may require in the future when handling the drop must be loaded out of the item
+        providers and saved when the drop is being handled in the UI process.
+
+        Currently, we only load the highest fidelity type we can handle (or, if we don't know what we can handle, we
+        select the highest fidelity representation conforming to "public.content"). This is a problematic for supporting
+        DataTransfer.getData() on drop on iOS, because the page can ask for any of the three web-exposed types. To
+        address this, we refactor WebItemProviderPasteboard to support loading multiple representations per item being
+        dropped. At minimum, we will load anything conforming to "public.html", "public.plain-text", "public.url", and
+        the new "com.apple.WebKit.custom-pasteboard-data" so we have means to answer any question that the page could
+        ask via DataTransfer.getData(). We additonally load the highest fidelity supported (or content-conformant) type,
+        if it has not already been loaded as a result of the former.
+
+        To make this possible, we refactor WebItemProviderLoadResult to take an item provider and a list of types to
+        load. -doAfterLoadingProvidedContentIntoFileURLs:synchronousTimeout: then creates a list of load results and
+        uses each one to represent the results of loading data from its item provider (i.e. a map of UTI => file URL).
+
+        * platform/mac/PasteboardMac.mm:
+        (WebCore::Pasteboard::writeCustomData):
+        (WebCore::cocoaTypeFromHTMLClipboardType):
+        (WebCore::readPlatformValueAsString):
+        (WebCore::Pasteboard::readStringForBindings):
+
+        Change readStringForBindings (formerly, readString) so that if support for custom pasteboard data is enabled,
+        we only allow reading directly from the platform pasteboard if the given type is DOM-safe; otherwise, we consult
+        the custom data blob, if it exists. Otherwise, if support for custom pasteboard data is disabled, we fall back
+        to our current behavior.
+
+        (WebCore::Pasteboard::types):
+        (WebCore::Pasteboard::readString): Deleted.
+        * platform/mac/PlatformPasteboardMac.mm:
+        (WebCore::PlatformPasteboard::numberOfFiles const):
+        (WebCore::PlatformPasteboard::getPathnamesForType const):
+        (WebCore::PlatformPasteboard::stringForType):
+        (WebCore::safeTypeForDOMToReadAndWriteForPlatformType):
+        (WebCore::PlatformPasteboard::typesSafeForDOMToReadAndWrite const):
+
+        Add support for reading DOM-exposed types and fetching DOM-exposed data off of the pasteboard. The overall idea
+        here is similar to iOS, though implementation details vary (e.g. no item provider support).
+
+        (WebCore::PlatformPasteboard::write):
+        (WebCore::PlatformPasteboard::platformPasteboardTypeForSafeTypeForDOMToReadAndWrite):
+        (WebCore::PlatformPasteboard::numberOfFiles): Deleted.
+        (WebCore::PlatformPasteboard::getPathnamesForType): Deleted.
+        * platform/win/PasteboardWin.cpp:
+        (WebCore::Pasteboard::readStringForBindings):
+        (WebCore::Pasteboard::writeCustomData):
+        (WebCore::Pasteboard::readString): Deleted.
+        * platform/wpe/PasteboardWPE.cpp:
+        (WebCore::Pasteboard::readStringForBindings):
+        (WebCore::Pasteboard::writeCustomData):
+        (WebCore::Pasteboard::readString): Deleted.
+        * platform/wpe/PlatformPasteboardWPE.cpp:
+        (WebCore::PlatformPasteboard::typesSafeForDOMToReadAndWrite const):
+        (WebCore::PlatformPasteboard::write):
+        * testing/InternalSettings.cpp:
+        (WebCore::InternalSettings::Backup::Backup):
+        (WebCore::InternalSettings::Backup::restoreTo):
+        (WebCore::InternalSettings::setCustomPasteboardDataEnabled):
+
+        Add a new internal settings hook for layout tests to opt in to using custom pasteboard data. By default, custom
+        pasteboard data is enabled only in Safari, or on applications linked on or after certain releases of iOS and
+        macOS.
+
+        * testing/InternalSettings.h:
+        * testing/InternalSettings.idl:
+
 2017-09-27  Zalan Bujtas  <zalan@apple.com>
 

trunk/Source/WebCore/WebCore.xcodeproj/project.pbxproj

@@ -1341 +1341 @@
                 2EDF369C122C94B4002F7D4E /* FileReaderSync.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2EDF369A122C94B4002F7D4E /* FileReaderSync.cpp */; };
                 2EDF369D122C94B4002F7D4E /* FileReaderSync.h in Headers */ = {isa = PBXBuildFile; fileRef = 2EDF369B122C94B4002F7D4E /* FileReaderSync.h */; };
+                2EE02A1F1F7324280006AF72 /* Pasteboard.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2EE02A1E1F7324280006AF72 /* Pasteboard.cpp */; };
                 2EEEE55C1B66A047008E2CBC /* WheelEventDeltaFilterMac.mm in Sources */ = {isa = PBXBuildFile; fileRef = 2EEEE55B1B66A047008E2CBC /* WheelEventDeltaFilterMac.mm */; };
                 2EF1BFEA121C9F4200C27627 /* FileStream.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2EF1BFE8121C9F4200C27627 /* FileStream.cpp */; };
@@ -9068 +9069 @@
                 2EDF369A122C94B4002F7D4E /* FileReaderSync.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = FileReaderSync.cpp; sourceTree = "<group>"; };
                 2EDF369B122C94B4002F7D4E /* FileReaderSync.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = FileReaderSync.h; sourceTree = "<group>"; };
+                2EE02A1E1F7324280006AF72 /* Pasteboard.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = Pasteboard.cpp; sourceTree = "<group>"; };
                 2EEEE55B1B66A047008E2CBC /* WheelEventDeltaFilterMac.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = WheelEventDeltaFilterMac.mm; sourceTree = "<group>"; };
                 2EF1BFE8121C9F4200C27627 /* FileStream.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = FileStream.cpp; sourceTree = "<group>"; };
@@ -24643 +24645 @@
                                 98EB1F941313FE0500D0E1EA /* NotImplemented.h */,
                                 4184F5151EAF059800F18BF0 /* OrientationNotifier.h */,
+                                2EE02A1E1F7324280006AF72 /* Pasteboard.cpp */,
                                 4B2708C50AF19EE40065127F /* Pasteboard.h */,
                                 C5F765B414E1D414006C899B /* PasteboardStrategy.h */,
@@ -25893 +25896 @@
                                 BCEA4822097D93020094C9E4 /* RenderBox.cpp */,
                                 BCEA4823097D93020094C9E4 /* RenderBox.h */,
+                                BCEB179B143379F50052EAE9 /* RenderBoxFragmentInfo.h */,
                                 BC96DB450F3A882200573CB3 /* RenderBoxModelObject.cpp */,
                                 BC96DB420F3A880E00573CB3 /* RenderBoxModelObject.h */,
-                                BCEB179B143379F50052EAE9 /* RenderBoxFragmentInfo.h */,
                                 BCEA4826097D93020094C9E4 /* RenderButton.cpp */,
                                 BCEA4827097D93020094C9E4 /* RenderButton.h */,
@@ -25916 +25919 @@
                                 53C8298B13D8D92700DE2DEB /* RenderFlexibleBox.cpp */,
                                 53C8298C13D8D92700DE2DEB /* RenderFlexibleBox.h */,
+                                D70AD65513E1342B005B50B4 /* RenderFragmentContainer.cpp */,
+                                D70AD65613E1342B005B50B4 /* RenderFragmentContainer.h */,
+                                BCE93F461517C6D5008CCF74 /* RenderFragmentContainerSet.cpp */,
+                                BCE93F441517C567008CCF74 /* RenderFragmentContainerSet.h */,
                                 508CCA4E13CF106B003151F3 /* RenderFragmentedFlow.cpp */,
                                 508CCA4D13CF106B003151F3 /* RenderFragmentedFlow.h */,
@@ -25990 +25997 @@
                                 5A574F22131DB93900471B88 /* RenderQuote.cpp */,
                                 5A574F23131DB93900471B88 /* RenderQuote.h */,
-                                D70AD65513E1342B005B50B4 /* RenderFragmentContainer.cpp */,
-                                D70AD65613E1342B005B50B4 /* RenderFragmentContainer.h */,
-                                BCE93F461517C6D5008CCF74 /* RenderFragmentContainerSet.cpp */,
-                                BCE93F441517C567008CCF74 /* RenderFragmentContainerSet.h */,
                                 A871DFDE0A15376B00B12A68 /* RenderReplaced.cpp */,
                                 A871DFDF0A15376B00B12A68 /* RenderReplaced.h */,
@@ -29658 +29661 @@
                                 BC10D76817D8EE71005E2626 /* RenderBlockFlow.h in Headers */,
                                 BCEA4862097D93020094C9E4 /* RenderBox.h in Headers */,
+                                BCEB179C143379F50052EAE9 /* RenderBoxFragmentInfo.h in Headers */,
                                 BC96DB430F3A880E00573CB3 /* RenderBoxModelObject.h in Headers */,
-                                BCEB179C143379F50052EAE9 /* RenderBoxFragmentInfo.h in Headers */,
                                 BCEA4866097D93020094C9E4 /* RenderButton.h in Headers */,
                                 B56579B51824D12A00E79F23 /* RenderChildIterator.h in Headers */,
@@ -29673 +29676 @@
                                 066C77310AB603FD00238CC4 /* RenderFileUploadControl.h in Headers */,
                                 53C8298E13D8D92700DE2DEB /* RenderFlexibleBox.h in Headers */,
+                                D70AD65813E1342B005B50B4 /* RenderFragmentContainer.h in Headers */,
+                                BCE93F451517C567008CCF74 /* RenderFragmentContainerSet.h in Headers */,
                                 508CCA4F13CF106B003151F3 /* RenderFragmentedFlow.h in Headers */,
                                 A871DED30A1530C700B12A68 /* RenderFrame.h in Headers */,
@@ -29723 +29728 @@
                                 B5B65874186FDE4C009C26E8 /* RenderPtr.h in Headers */,
                                 5A574F25131DB93900471B88 /* RenderQuote.h in Headers */,
-                                D70AD65813E1342B005B50B4 /* RenderFragmentContainer.h in Headers */,
-                                BCE93F451517C567008CCF74 /* RenderFragmentContainerSet.h in Headers */,
                                 A871DFE30A15376B00B12A68 /* RenderReplaced.h in Headers */,
                                 BCA846D70DC67A350026C309 /* RenderReplica.h in Headers */,
@@ -33488 +33491 @@
                                 57B5F7EC1E57F1E300F34F90 /* PasswordCredential.cpp in Sources */,
                                 F55B3DC91251F12D003EF269 /* PasswordInputType.cpp in Sources */,
+                                2EE02A1F1F7324280006AF72 /* Pasteboard.cpp in Sources */,
                                 E453901E0EAFCACA003695C8 /* PasteboardIOS.mm in Sources */,
                                 4B2709830AF2E5E00065127F /* PasteboardMac.mm in Sources */,
@@ -33634 +33638 @@
                                 066C77300AB603FD00238CC4 /* RenderFileUploadControl.cpp in Sources */,
                                 53C8298D13D8D92700DE2DEB /* RenderFlexibleBox.cpp in Sources */,
+                                D70AD65713E1342B005B50B4 /* RenderFragmentContainer.cpp in Sources */,
+                                BCE93F471517C6D5008CCF74 /* RenderFragmentContainerSet.cpp in Sources */,
                                 508CCA5013CF106B003151F3 /* RenderFragmentedFlow.cpp in Sources */,
                                 A871DED40A1530C700B12A68 /* RenderFrame.cpp in Sources */,
@@ -33683 +33689 @@
                                 A43BF59C1149292800C643CA /* RenderProgress.cpp in Sources */,
                                 5A574F24131DB93900471B88 /* RenderQuote.cpp in Sources */,
-                                D70AD65713E1342B005B50B4 /* RenderFragmentContainer.cpp in Sources */,
-                                BCE93F471517C6D5008CCF74 /* RenderFragmentContainerSet.cpp in Sources */,
                                 A871DFE20A15376B00B12A68 /* RenderReplaced.cpp in Sources */,
                                 BCA846D60DC67A350026C309 /* RenderReplica.cpp in Sources */,

trunk/Source/WebCore/dom/DataTransfer.cpp

@@ -141 +141 @@
 #endif
 
-    return m_pasteboard->readString(normalizeType(type));
+    return m_pasteboard->readStringForBindings(normalizeType(type));
 }
 
@@ -256 +256 @@
 {
     return adoptRef(*new DataTransfer(StoreMode::ReadWrite, Pasteboard::createForDragAndDrop(), Type::DragAndDropData));
+}
+
+Ref<DataTransfer> DataTransfer::createForDragStartEvent()
+{
+    return adoptRef(*new DataTransfer(StoreMode::ReadWrite, std::make_unique<StaticPasteboard>(), Type::DragAndDropData));
 }
 
@@ -461 +466 @@
 }
 
+void DataTransfer::moveDragState(Ref<DataTransfer>&& other)
+{
+    RELEASE_ASSERT(is<StaticPasteboard>(other->pasteboard()));
+    // We clear the platform pasteboard here to ensure that the pasteboard doesn't contain any data
+    // that may have been written before starting the drag, and after ending the last drag session.
+    // After pushing the static pasteboard's contents to the platform, the pasteboard should only
+    // contain data that was in the static pasteboard.
+    m_pasteboard->clear();
+    downcast<StaticPasteboard>(other->pasteboard()).commitToPasteboard(*m_pasteboard);
+
+    m_dropEffect = other->m_dropEffect;
+    m_effectAllowed = other->m_effectAllowed;
+    m_dragLocation = other->m_dragLocation;
+    m_dragImage = other->m_dragImage;
+    m_dragImageElement = WTFMove(other->m_dragImageElement);
+    m_dragImageLoader = WTFMove(other->m_dragImageLoader);
+    m_itemList = WTFMove(other->m_itemList);
+    m_fileList = WTFMove(other->m_fileList);
+}
+
+bool DataTransfer::hasDragImage() const
+{
+    return m_dragImage || m_dragImageElement;
+}
+
 #endif // ENABLE(DRAG_SUPPORT)
 

trunk/Source/WebCore/dom/DataTransfer.h

@@ -81 +81 @@
 #if ENABLE(DRAG_SUPPORT)
     static Ref<DataTransfer> createForDrag();
+    static Ref<DataTransfer> createForDragStartEvent();
     static Ref<DataTransfer> createForDrop(StoreMode, const DragData&);
 
@@ -94 +95 @@
     void updateDragImage();
     RefPtr<Element> dragImageElement() const;
+
+    void moveDragState(Ref<DataTransfer>&&);
+    bool hasDragImage() const;
 #endif
 

trunk/Source/WebCore/editing/cocoa/EditorCocoa.mm

@@ -51 +51 @@
 #import "WebContentReader.h"
 #import "WebCoreNSURLExtras.h"
+#import "markup.h"
 #import <pal/spi/cocoa/NSAttributedStringSPI.h>
 #import <wtf/BlockObjCExceptions.h>
@@ -144 +145 @@
 }
 
+String Editor::selectionInHTMLFormat()
+{
+    if (auto range = selectedRange())
+        return createMarkup(*range, nullptr, AnnotateForInterchange, false, ResolveNonLocalURLs);
+    return { };
+}
+
 void Editor::writeSelectionToPasteboard(Pasteboard& pasteboard)
 {
@@ -154 +162 @@
     content.dataInRTFFormat = dataInRTFFormat(attributedString);
     content.dataInAttributedStringFormat = archivedDataForAttributedString(attributedString);
-    // FIXME: Why don't we want this on iOS?
-#if PLATFORM(MAC)
     content.dataInHTMLFormat = selectionInHTMLFormat();
-#endif
     content.dataInStringFormat = stringSelectionForPasteboardWithImageAltText();
     client()->getClientPasteboardDataForRange(selectedRange().get(), content.clientTypes, content.clientData);
@@ -174 +179 @@
     webContent.dataInRTFFormat = dataInRTFFormat(attributedString);
     webContent.dataInAttributedStringFormat = archivedDataForAttributedString(attributedString);
-    // FIXME: Why don't we want this on iOS?
-#if PLATFORM(MAC)
     webContent.dataInHTMLFormat = selectionInHTMLFormat();
-#endif
     webContent.dataInStringFormat = stringSelectionForPasteboardWithImageAltText();
     client()->getClientPasteboardDataForRange(selectedRange().get(), webContent.clientTypes, webContent.clientData);

trunk/Source/WebCore/editing/mac/EditorMac.mm

@@ -183 +183 @@
 }
 
-String Editor::selectionInHTMLFormat()
-{
-    return createMarkup(*selectedRange(), nullptr, AnnotateForInterchange, false, ResolveNonLocalURLs);
-}
-
 RefPtr<SharedBuffer> Editor::imageInWebArchiveFormat(Element& imageElement)
 {

trunk/Source/WebCore/editing/wpe/EditorWPE.cpp

@@ -44 +44 @@
 
     if (types.contains("text/html;charset=utf-8") && frame.document()) {
-        String markup = pasteboard.readString("text/html;charset=utf-8");
+        String markup = pasteboard.readStringForBindings("text/html;charset=utf-8");
         if (RefPtr<DocumentFragment> fragment = createFragmentFromMarkup(*frame.document(), markup, emptyString(), DisallowScriptingAndPluginContent))
             return fragment;
@@ -54 +54 @@
     if (types.contains("text/plain;charset=utf-8")) {
         chosePlainText = true;
-        if (RefPtr<DocumentFragment> fragment = createFragmentFromText(range, pasteboard.readString("text/plain;charset=utf-8")))
+        if (RefPtr<DocumentFragment> fragment = createFragmentFromText(range, pasteboard.readStringForBindings("text/plain;charset=utf-8")))
             return fragment;
     }

trunk/Source/WebCore/page/EventHandler.cpp

@@ -87 +87 @@
 #include "ShadowRoot.h"
 #include "SpatialNavigation.h"
+#include "StaticPasteboard.h"
 #include "StyleCachedImage.h"
 #include "TextEvent.h"
@@ -3548 +3549 @@
 }
 
-bool EventHandler::dispatchDragStartEvent(HasNonDefaultPasteboardData& hasNonDefaultPasteboardData)
-{
-#if PLATFORM(COCOA)
-    auto changeCountBeforeDragStart = dragState().dataTransfer->pasteboard().changeCount();
-#endif
-
-    bool mayStartDrag = dispatchDragSrcEvent(eventNames().dragstartEvent, m_mouseDown);
-
-#if PLATFORM(COCOA)
-    hasNonDefaultPasteboardData = changeCountBeforeDragStart != dragState().dataTransfer->pasteboard().changeCount() ? HasNonDefaultPasteboardData::Yes : HasNonDefaultPasteboardData::No;
-#else
-    hasNonDefaultPasteboardData = dragState().dataTransfer->pasteboard().hasData() ? HasNonDefaultPasteboardData::Yes : HasNonDefaultPasteboardData::No;
-#endif
-
-    return mayStartDrag && !m_frame.selection().selection().isInPasswordField();
+bool EventHandler::dispatchDragStartEventOnSourceElement(DataTransfer& dataTransfer)
+{
+    return !dispatchDragEvent(eventNames().dragstartEvent, *dragState().source, m_mouseDown, &dataTransfer) && !m_frame.selection().selection().isInPasswordField();
 }
     
@@ -3668 +3657 @@
     invalidateDataTransfer();
 
-    dragState().dataTransfer = createDraggingDataTransfer();
+    dragState().dataTransfer = DataTransfer::createForDrag();
     HasNonDefaultPasteboardData hasNonDefaultPasteboardData = HasNonDefaultPasteboardData::No;
     
     if (dragState().shouldDispatchEvents) {
-        // Check to see if the is a DOM based drag. If it is, get the DOM specified drag image and offset.
-        if (dragState().type == DragSourceActionDHTML) {
-            if (RenderObject* renderer = dragState().source->renderer()) {
-                // FIXME: This doesn't work correctly with transforms.
-                FloatPoint absPos = renderer->localToAbsolute();
-                IntSize delta = m_mouseDownPos - roundedIntPoint(absPos);
+        auto dragStartDataTransfer = DataTransfer::createForDragStartEvent();
+        m_mouseDownMayStartDrag = dispatchDragStartEventOnSourceElement(dragStartDataTransfer);
+        hasNonDefaultPasteboardData = dragStartDataTransfer->pasteboard().hasData() ? HasNonDefaultPasteboardData::Yes : HasNonDefaultPasteboardData::No;
+        dragState().dataTransfer->moveDragState(WTFMove(dragStartDataTransfer));
+
+        if (dragState().source && dragState().type == DragSourceActionDHTML && !dragState().dataTransfer->hasDragImage()) {
+            dragState().source->document().updateStyleIfNeeded();
+            if (auto* renderer = dragState().source->renderer()) {
+                auto absolutePosition = renderer->localToAbsolute();
+                auto delta = m_mouseDownPos - roundedIntPoint(absolutePosition);
                 dragState().dataTransfer->setDragImage(dragState().source.get(), delta.width(), delta.height());
             } else {
-                // The renderer has disappeared, this can happen if the onStartDrag handler has hidden
-                // the element in some way.  In this case we just kill the drag.
+                dispatchDragSrcEvent(eventNames().dragendEvent, event.event());
                 m_mouseDownMayStartDrag = false;
                 invalidateDataTransfer();
                 dragState().source = nullptr;
-
                 return true;
             }
-        } 
-
-        m_mouseDownMayStartDrag = dispatchDragStartEvent(hasNonDefaultPasteboardData);
+        }
 
         dragState().dataTransfer->makeInvalidForSecurity();

trunk/Source/WebCore/page/EventHandler.h

@@ -325 +325 @@
     static DragState& dragState();
     static const Seconds TextDragDelay;
-    Ref<DataTransfer> createDraggingDataTransfer() const;
 #endif
 
@@ -406 +405 @@
 
     bool dispatchDragSrcEvent(const AtomicString& eventType, const PlatformMouseEvent&);
-    bool dispatchDragStartEvent(HasNonDefaultPasteboardData&);
+    bool dispatchDragStartEventOnSourceElement(DataTransfer&);
 
     bool dragHysteresisExceeded(const FloatPoint&) const;

trunk/Source/WebCore/page/Settings.cpp

@@ -49 +49 @@
 #include <wtf/StdLibExtras.h>
 
+#if PLATFORM(COCOA)
+#include <wtf/spi/darwin/dyldSPI.h>
+#endif
+
 #if ENABLE(MEDIA_STREAM) && USE(AVFOUNDATION)
 #include "RealtimeMediaSourceCenterMac.h"
@@ -116 +120 @@
 #endif
 bool Settings::gManageAudioSession = false;
+bool Settings::gCustomPasteboardDataEnabled = false;
 
 // NOTEs
@@ -138 +143 @@
 #endif
     ;
+}
+
+bool Settings::customPasteboardDataEnabled()
+{
+    static std::once_flag initializeCustomPasteboardDataToDefaultValue;
+    std::call_once(initializeCustomPasteboardDataToDefaultValue, [] {
+#if PLATFORM(IOS) && __IPHONE_OS_VERSION_MAX_ALLOWED >= 110300
+        gCustomPasteboardDataEnabled = IOSApplication::isMobileSafari() || dyld_get_program_sdk_version() >= DYLD_IOS_VERSION_11_3;
+#elif PLATFORM(MAC) && __MAC_OS_X_VERSION_MAX_ALLOWED >= 101304
+        // FIXME: Update this linked-on check once the correct macro is in the SDK.
+        gCustomPasteboardDataEnabled = MacApplication::isSafari() || dyld_get_program_sdk_version() > DYLD_MACOSX_VERSION_10_13;
+#else
+        gCustomPasteboardDataEnabled = false;
+#endif
+    });
+    return gCustomPasteboardDataEnabled;
 }
 

trunk/Source/WebCore/page/Settings.h

@@ -305 +305 @@
 #endif
 
+    static void setCustomPasteboardDataEnabled(bool enabled) { gCustomPasteboardDataEnabled = enabled; }
+    WEBCORE_EXPORT static bool customPasteboardDataEnabled();
+
 #if ENABLE(LEGACY_ENCRYPTED_MEDIA)
     void setMediaKeysStorageDirectory(const String& directory) { m_mediaKeysStorageDirectory = directory; }
@@ -420 +423 @@
 #endif
     WEBCORE_EXPORT static bool gManageAudioSession;
+    WEBCORE_EXPORT static bool gCustomPasteboardDataEnabled;
 
 #if ENABLE(LEGACY_ENCRYPTED_MEDIA)

trunk/Source/WebCore/page/ios/EventHandlerIOS.mm

@@ -562 +562 @@
 #if ENABLE(DRAG_SUPPORT)
 
-Ref<DataTransfer> EventHandler::createDraggingDataTransfer() const
-{
-    Pasteboard("data interaction pasteboard").clear();
-    return DataTransfer::createForDrag();
-}
-
 bool EventHandler::eventLoopHandleMouseDragged(const MouseEventWithHitTestResults&)
 {

trunk/Source/WebCore/page/mac/EventHandlerMac.mm

@@ -719 +719 @@
 }
 
-#if ENABLE(DRAG_SUPPORT)
-
-Ref<DataTransfer> EventHandler::createDraggingDataTransfer() const
-{
-    // Must be done before ondragstart adds types and data to the pboard,
-    // also done for security, as it erases data from the last drag.
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wdeprecated-declarations"
-    auto pasteboard = std::make_unique<Pasteboard>(NSDragPboard);
-#pragma clang diagnostic pop
-    pasteboard->clear();
-    return DataTransfer::createForDrag();
-}
-
-#endif
-
 bool EventHandler::tabsToAllFormControls(KeyboardEvent& event) const
 {

trunk/Source/WebCore/page/win/EventHandlerWin.cpp

@@ -92 +92 @@
 }
 
-#if ENABLE(DRAG_SUPPORT)
-
-Ref<DataTransfer> EventHandler::createDraggingDataTransfer() const
-{
-    return DataTransfer::createForDrag();
-}
-
-#endif
-
 void EventHandler::focusDocumentView()
 {

trunk/Source/WebCore/platform/Pasteboard.h

@@ -28 +28 @@
 #include "DragImage.h"
 #include "URL.h"
+#include <wtf/HashMap.h>
 #include <wtf/Noncopyable.h>
 #include <wtf/Vector.h>
@@ -146 +147 @@
 };
 
+// FIXME: We need to ensure that the contents of sameOriginCustomData are not accessible across different origins.
+struct PasteboardCustomData {
+    Vector<String> orderedTypes;
+    HashMap<String, String> platformData;
+    HashMap<String, String> sameOriginCustomData;
+};
+
+WEBCORE_EXPORT Ref<SharedBuffer> sharedBufferFromCustomData(const PasteboardCustomData&);
+WEBCORE_EXPORT PasteboardCustomData customDataFromSharedBuffer(const SharedBuffer&);
+
+#if PLATFORM(COCOA)
+const char customWebKitPasteboardDataType[] = "com.apple.WebKit.custom-pasteboard-data";
+#endif
+
+bool isSafeTypeForDOMToReadAndWrite(const String& type);
+
 class Pasteboard {
     WTF_MAKE_NONCOPYABLE(Pasteboard); WTF_MAKE_FAST_ALLOCATED;
@@ -169 +186 @@
     virtual bool hasData();
     virtual Vector<String> types();
-    virtual String readString(const String& type);
+    virtual String readStringForBindings(const String& type);
 
     virtual void writeString(const String& type, const String& data);
@@ -232 +249 @@
 #endif
 
+    void writeCustomData(const PasteboardCustomData&);
+
 private:
 #if PLATFORM(IOS)
@@ -245 +264 @@
 #endif
 
+#if PLATFORM(COCOA)
+    String readStringForPlatformType(const String&);
+#endif
+
 #if PLATFORM(GTK)
     void writeToClipboard();

trunk/Source/WebCore/platform/PasteboardStrategy.h

@@ -38 +38 @@
 struct PasteboardURL;
 struct PasteboardWebContent;
+struct PasteboardCustomData;
 
 class PasteboardStrategy {
@@ -72 +73 @@
 #endif
 
+    virtual Vector<String> typesSafeForDOMToReadAndWrite(const String& pasteboardName) = 0;
+    virtual long writeCustomData(const PasteboardCustomData&, const String& pasteboardName) = 0;
+
 #if PLATFORM(GTK)
     virtual void writeToClipboard(const String& pasteboardName, const SelectionData&) = 0;

trunk/Source/WebCore/platform/PasteboardWriterData.h

@@ -56 +56 @@
         RefPtr<SharedBuffer> dataInRTFFormat;
         RefPtr<SharedBuffer> dataInAttributedStringFormat;
-        // FIXME: Why don't we want this on iOS?
-#if PLATFORM(MAC)
         String dataInHTMLFormat;
-#endif
         String dataInStringFormat;
         Vector<String> clientTypes;

trunk/Source/WebCore/platform/PlatformPasteboard.h

@@ -50 +50 @@
 class SharedBuffer;
 class URL;
+struct PasteboardCustomData;
 struct PasteboardImage;
 struct PasteboardURL;
@@ -65 +66 @@
     WEBCORE_EXPORT static String uniqueName();
 
+    WEBCORE_EXPORT static String platformPasteboardTypeForSafeTypeForDOMToReadAndWrite(const String& domType);
+
     WEBCORE_EXPORT void getTypes(Vector<String>& types);
     WEBCORE_EXPORT RefPtr<SharedBuffer> bufferForType(const String& pasteboardType);
-    WEBCORE_EXPORT void getPathnamesForType(Vector<String>& pathnames, const String& pasteboardType);
+    WEBCORE_EXPORT void getPathnamesForType(Vector<String>& pathnames, const String& pasteboardType) const;
     WEBCORE_EXPORT String stringForType(const String& pasteboardType);
     WEBCORE_EXPORT long changeCount() const;
@@ -90 +93 @@
     WEBCORE_EXPORT URL readURL(int index, const String& pasteboardType, String& title);
     WEBCORE_EXPORT int count();
-    WEBCORE_EXPORT int numberOfFiles();
+    WEBCORE_EXPORT int numberOfFiles() const;
+
+    WEBCORE_EXPORT long write(const PasteboardCustomData&);
+    WEBCORE_EXPORT Vector<String> typesSafeForDOMToReadAndWrite() const;
 
 #if PLATFORM(GTK)

trunk/Source/WebCore/platform/StaticPasteboard.cpp

@@ -27 +27 @@
 #include "StaticPasteboard.h"
 
+#include "Settings.h"
+#include "SharedBuffer.h"
+
 namespace WebCore {
 
@@ -35 +38 @@
 bool StaticPasteboard::hasData()
 {
-    return !m_stringContents.isEmpty();
+    return !m_platformData.isEmpty() || !m_customData.isEmpty();
 }
 
-String StaticPasteboard::readString(const String& type)
+String StaticPasteboard::readStringForBindings(const String& type)
 {
-    if (!m_stringContents.contains(type))
-        return { };
-    return m_stringContents.get(type);
+    if (m_platformData.contains(type))
+        return m_platformData.get(type);
+
+    if (m_customData.contains(type))
+        return m_customData.get(type);
+
+    return { };
 }
 
 void StaticPasteboard::writeString(const String& type, const String& value)
 {
-    auto result = m_stringContents.set(type, value);
-    if (result.isNewEntry)
+    auto& pasteboardData = isSafeTypeForDOMToReadAndWrite(type) ? m_platformData : m_customData;
+    if (pasteboardData.set(type, value).isNewEntry)
         m_types.append(type);
     else {
@@ -59 +66 @@
 void StaticPasteboard::clear()
 {
-    m_stringContents.clear();
+    m_customData.clear();
+    m_platformData.clear();
     m_types.clear();
 }
@@ -65 +73 @@
 void StaticPasteboard::clear(const String& type)
 {
-    if (!m_stringContents.remove(type))
+    if (!m_platformData.remove(type) && !m_customData.remove(type))
         return;
     m_types.removeFirst(type);
@@ -71 +79 @@
 }
 
-// FIXME: Copy the entire StaticPasteboard to UIProcess instead of writing each string.
 void StaticPasteboard::commitToPasteboard(Pasteboard& pasteboard)
 {
-    for (auto& type : m_types)
-        pasteboard.writeString(type, m_stringContents.get(type));
+    if (m_platformData.isEmpty() && m_customData.isEmpty())
+        return;
+
+    if (Settings::customPasteboardDataEnabled()) {
+        pasteboard.writeCustomData({ WTFMove(m_types), WTFMove(m_platformData), WTFMove(m_customData) });
+        return;
+    }
+
+    for (auto& entry : m_platformData)
+        pasteboard.writeString(entry.key, entry.value);
+    for (auto& entry : m_customData)
+        pasteboard.writeString(entry.key, entry.value);
 }
 

trunk/Source/WebCore/platform/StaticPasteboard.h

@@ -43 +43 @@
     bool hasData() final;
     Vector<String> types() final { return m_types; }
-    String readString(const String& type) final;
+    String readStringForBindings(const String& type) final;
 
     void writeString(const String& type, const String& data) final;
@@ -68 +68 @@
 private:
     Vector<String> m_types;
-    HashMap<String, String> m_stringContents;
+    HashMap<String, String> m_platformData;
+    HashMap<String, String> m_customData;
 };
 

trunk/Source/WebCore/platform/glib/EventHandlerGLib.cpp

@@ -102 +102 @@
 }
 
-#if ENABLE(DRAG_SUPPORT)
-
-Ref<DataTransfer> EventHandler::createDraggingDataTransfer() const
-{
-    return DataTransfer::createForDrag();
-}
-
-#endif
-
 bool EventHandler::passMousePressEventToSubframe(MouseEventWithHitTestResults& mev, Frame* subframe)
 {

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

@@ -286 +286 @@
 }
 
-String Pasteboard::readString(const String& type)
+String Pasteboard::readStringForBindings(const String& type)
 {
     readFromClipboard();
@@ -318 +318 @@
 }
 
-}
+void Pasteboard::writeCustomData(const PasteboardCustomData&)
+{
+}
+
+}

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

@@ -47 +47 @@
 }
 
+Vector<String> PlatformPasteboard::typesSafeForDOMToReadAndWrite() const
+{
+    return { };
 }
+
+long PlatformPasteboard::write(const PasteboardCustomData&)
+{
+    return 0;
+}
+
+}

trunk/Source/WebCore/platform/ios/AbstractPasteboard.h

@@ -44 +44 @@
 
 - (NSArray<NSString *> *)pasteboardTypes;
+- (NSData *)dataForPasteboardType:(NSString *)pasteboardType;
 - (NSArray *)dataForPasteboardType:(NSString *)pasteboardType inItemSet:(NSIndexSet *)itemSet;
 - (NSArray *)valuesForPasteboardType:(NSString *)pasteboardType inItemSet:(NSIndexSet *)itemSet;

trunk/Source/WebCore/platform/ios/PasteboardIOS.mm

@@ -43 +43 @@
 #import "NotImplemented.h"
 #import "PasteboardStrategy.h"
+#import "PlatformPasteboard.h"
 #import "PlatformStrategies.h"
 #import "RenderImage.h"
 #import "RuntimeApplicationChecks.h"
+#import "Settings.h"
 #import "SharedBuffer.h"
 #import "Text.h"
@@ -132 +134 @@
 {
     return std::make_unique<Pasteboard>(changeCountForPasteboard());
+}
+
+void Pasteboard::writeCustomData(const PasteboardCustomData& data)
+{
+    m_changeCount = platformStrategies()->pasteboardStrategy()->writeCustomData(data, m_pasteboardName);
 }
 
@@ -321 +328 @@
 static RetainPtr<NSString> cocoaTypeFromHTMLClipboardType(const String& type)
 {
-    // Ignore any trailing charset - JS strings are Unicode, which encapsulates the charset issue.
-    if (type == "text/plain")
-#if __IPHONE_OS_VERSION_MIN_REQUIRED >= 110000
-        return (NSString *)kUTTypePlainText;
-#else
-        return (NSString *)kUTTypeText;
-#endif
-
-    // Special case because UTI doesn't work with Cocoa's URL type.
-    if (type == "text/uri-list")
-        return (NSString *)kUTTypeURL;
+    if (NSString *platformType = PlatformPasteboard::platformPasteboardTypeForSafeTypeForDOMToReadAndWrite(type)) {
+        if (platformType.length)
+            return platformType;
+    }
 
     // Try UTI now.
@@ -357 +357 @@
 }
 
-String Pasteboard::readString(const String& type)
+static String readPlatformValueAsString(const String& domType, long changeCount, const String& pasteboardName)
 {
     PasteboardStrategy& strategy = *platformStrategies()->pasteboardStrategy();
 
-    int numberOfItems = strategy.getPasteboardItemsCount(m_pasteboardName);
+    int numberOfItems = strategy.getPasteboardItemsCount(pasteboardName);
 
     if (!numberOfItems)
@@ -367 +367 @@
 
     // Grab the value off the pasteboard corresponding to the cocoaType.
-    RetainPtr<NSString> cocoaType = cocoaTypeFromHTMLClipboardType(type);
+    RetainPtr<NSString> cocoaType = cocoaTypeFromHTMLClipboardType(domType);
 
     NSString *cocoaValue = nil;
@@ -373 +373 @@
     if ([cocoaType isEqualToString:(NSString *)kUTTypeURL]) {
         String title;
-        URL url = strategy.readURLFromPasteboard(0, kUTTypeURL, m_pasteboardName, title);
+        URL url = strategy.readURLFromPasteboard(0, kUTTypeURL, pasteboardName, title);
         if (!url.isNull())
             cocoaValue = [(NSURL *)url absoluteString];
-    } else if ([cocoaType isEqualToString:(NSString *)kUTTypeText]) {
-        String value = strategy.readStringFromPasteboard(0, kUTTypeText, m_pasteboardName);
+    } else if ([cocoaType isEqualToString:(NSString *)kUTTypePlainText]) {
+        String value = strategy.readStringFromPasteboard(0, kUTTypePlainText, pasteboardName);
         if (!value.isNull())
             cocoaValue = [(NSString *)value precomposedStringWithCanonicalMapping];
-    } else if (cocoaType) {
-        if (RefPtr<SharedBuffer> buffer = strategy.readBufferFromPasteboard(0, cocoaType.get(), m_pasteboardName))
-            cocoaValue = [[[NSString alloc] initWithData:buffer->createNSData().get() encoding:NSUTF8StringEncoding] autorelease];
-    }
+    } else if (cocoaType)
+        cocoaValue = (NSString *)strategy.readStringFromPasteboard(0, cocoaType.get(), pasteboardName);
 
     // Enforce changeCount ourselves for security. We check after reading instead of before to be
     // sure it doesn't change between our testing the change count and accessing the data.
-    if (cocoaValue && m_changeCount == changeCountForPasteboard(m_pasteboardName))
+    if (cocoaValue && changeCount == changeCountForPasteboard(pasteboardName))
         return cocoaValue;
 
     return String();
+}
+
+String Pasteboard::readStringForBindings(const String& type)
+{
+    if (!Settings::customPasteboardDataEnabled() || isSafeTypeForDOMToReadAndWrite(type))
+        return readPlatformValueAsString(type, m_changeCount, m_pasteboardName);
+
+    if (auto buffer = platformStrategies()->pasteboardStrategy()->bufferForType(customWebKitPasteboardDataType, m_pasteboardName)) {
+        NSString *customDataValue = customDataFromSharedBuffer(*buffer).sameOriginCustomData.get(type);
+        if (customDataValue.length)
+            return customDataValue;
+    }
+
+    return { };
 }
 
@@ -426 +438 @@
 Vector<String> Pasteboard::types()
 {
-    Vector<String> cocoaTypes;
-    platformStrategies()->pasteboardStrategy()->getTypes(cocoaTypes, m_pasteboardName);
+    Vector<String> types;
+    if (Settings::customPasteboardDataEnabled())
+        types = platformStrategies()->pasteboardStrategy()->typesSafeForDOMToReadAndWrite(m_pasteboardName);
+    else
+        platformStrategies()->pasteboardStrategy()->getTypes(types, m_pasteboardName);
 
     // Enforce changeCount ourselves for security. We check after reading instead of before to be
     // sure it doesn't change between our testing the change count and accessing the data.
-    if (m_changeCount != changeCountForPasteboard(m_pasteboardName))
-        return Vector<String>();
+    auto changeCount = changeCountForPasteboard(m_pasteboardName);
+    if (m_changeCount != changeCount)
+        return { };
+
+    if (Settings::customPasteboardDataEnabled())
+        return types;
 
     ListHashSet<String> result;
-    for (auto cocoaType : cocoaTypes)
+    for (auto cocoaType : types)
         addHTMLClipboardTypesForCocoaType(result, cocoaType);
 

trunk/Source/WebCore/platform/ios/PlatformPasteboardIOS.mm

@@ -38 +38 @@
 #import <UIKit/UIPasteboard.h>
 #import <pal/spi/ios/UIKitSPI.h>
+#import <wtf/ListHashSet.h>
 #import <wtf/SoftLinking.h>
+#import <wtf/text/StringHash.h>
 
 SOFT_LINK_FRAMEWORK(UIKit)
@@ -82 +84 @@
 }
 
-RefPtr<SharedBuffer> PlatformPasteboard::bufferForType(const String&)
-{
+RefPtr<SharedBuffer> PlatformPasteboard::bufferForType(const String& type)
+{
+    if (NSData *data = [m_pasteboard dataForPasteboardType:type])
+        return SharedBuffer::create(data);
     return nullptr;
 }
 
-void PlatformPasteboard::getPathnamesForType(Vector<String>&, const String&)
-{
-}
-
-int PlatformPasteboard::numberOfFiles()
+void PlatformPasteboard::getPathnamesForType(Vector<String>&, const String&) const
+{
+}
+
+int PlatformPasteboard::numberOfFiles() const
 {
     return [m_pasteboard respondsToSelector:@selector(numberOfFiles)] ? [m_pasteboard numberOfFiles] : 0;
@@ -174 +178 @@
 }
 
+String PlatformPasteboard::platformPasteboardTypeForSafeTypeForDOMToReadAndWrite(const String& domType)
+{
+    if (domType == "text/plain")
+        return kUTTypePlainText;
+
+    if (domType == "text/html")
+        return kUTTypeHTML;
+
+    if (domType == "text/uri-list")
+        return kUTTypeURL;
+
+    return { };
+}
+
 static NSString *webIOSPastePboardType = @"iOS rich content paste pasteboard type";
 
@@ -274 +292 @@
     if (content.dataInRTFFormat)
         [representationsToRegister addData:content.dataInRTFFormat->createNSData().get() forType:(NSString *)kUTTypeRTF];
+
+    if (!content.dataInHTMLFormat.isEmpty()) {
+        NSData *htmlAsData = [(NSString *)content.dataInHTMLFormat dataUsingEncoding:NSUTF8StringEncoding];
+        [representationsToRegister addData:htmlAsData forType:(NSString *)kUTTypeHTML];
+    }
 
     if (!content.dataInStringFormat.isEmpty())
@@ -397 +420 @@
 }
 
+static const char *safeTypeForDOMToReadAndWriteForPlatformType(const String& platformType)
+{
+    auto cfType = platformType.createCFString();
+    if (UTTypeConformsTo(cfType.get(), kUTTypePlainText))
+        return ASCIILiteral("text/plain");
+
+    if (UTTypeConformsTo(cfType.get(), kUTTypeHTML))
+        return ASCIILiteral("text/html");
+
+    if (UTTypeConformsTo(cfType.get(), kUTTypeURL))
+        return ASCIILiteral("text/uri-list");
+
+    return nullptr;
+}
+
+Vector<String> PlatformPasteboard::typesSafeForDOMToReadAndWrite() const
+{
+    ListHashSet<String> domPasteboardTypes;
+    for (NSItemProvider *provider in [m_pasteboard itemProviders]) {
+        if (!provider.teamData.length)
+            continue;
+
+        id teamDataObject = [NSKeyedUnarchiver unarchiveObjectWithData:provider.teamData];
+        if (!teamDataObject || ![teamDataObject isKindOfClass:[NSDictionary class]])
+            continue;
+
+        id customTypes = [(NSDictionary *)teamDataObject objectForKey:@(customWebKitPasteboardDataType)];
+        if (![customTypes isKindOfClass:[NSArray class]])
+            continue;
+
+        for (NSString *type in customTypes)
+            domPasteboardTypes.add(type);
+    }
+
+    if (NSData *serializedCustomData = [m_pasteboard dataForPasteboardType:@(customWebKitPasteboardDataType)]) {
+        auto buffer = SharedBuffer::create(serializedCustomData);
+        for (auto& type : customDataFromSharedBuffer(buffer.get()).orderedTypes)
+            domPasteboardTypes.add(type);
+    }
+
+    for (NSString *type in [m_pasteboard pasteboardTypes]) {
+        if ([type isEqualToString:@(customWebKitPasteboardDataType)])
+            continue;
+
+        if (isSafeTypeForDOMToReadAndWrite(type)) {
+            domPasteboardTypes.add(type);
+            continue;
+        }
+
+        if (auto* coercedType = safeTypeForDOMToReadAndWriteForPlatformType(type))
+            domPasteboardTypes.add(String::fromUTF8(coercedType));
+    }
+
+    Vector<String> result;
+    copyToVector(domPasteboardTypes, result);
+    return result;
+}
+
+long PlatformPasteboard::write(const PasteboardCustomData& data)
+{
+    auto representationsToRegister = adoptNS([[WebItemProviderRegistrationInfoList alloc] init]);
+    [representationsToRegister setPreferredPresentationStyle:WebPreferredPresentationStyleInline];
+
+    if (data.sameOriginCustomData.size()) {
+        if (auto serializedSharedBuffer = sharedBufferFromCustomData(data)->createNSData()) {
+            // We stash the list of supplied pasteboard types in teamData here for compatibility with drag and drop.
+            // Since the contents of item providers cannot be loaded prior to drop, but the pasteboard types are
+            // contained within the custom data blob and we need to vend them to the page when firing `dragover`
+            // events, we need an additional in-memory representation of the pasteboard types array that contains
+            // all of the custom types. We use the teamData property, available on NSItemProvider on iOS, to store
+            // this information, since the contents of teamData are immediately available prior to the drop.
+            NSMutableArray<NSString *> *typesAsNSArray = [NSMutableArray array];
+            for (auto& type : data.orderedTypes)
+                [typesAsNSArray addObject:type];
+            [representationsToRegister setTeamData:[NSKeyedArchiver archivedDataWithRootObject:@{ @(customWebKitPasteboardDataType) : typesAsNSArray }]];
+            [representationsToRegister addData:serializedSharedBuffer.get() forType:@(customWebKitPasteboardDataType)];
+        }
+    }
+
+    for (auto& type : data.orderedTypes) {
+        NSString *stringValue = data.platformData.get(type);
+        if (!stringValue.length)
+            continue;
+
+        auto cocoaType = platformPasteboardTypeForSafeTypeForDOMToReadAndWrite(type).createCFString();
+        if (UTTypeConformsTo(cocoaType.get(), kUTTypeURL))
+            [representationsToRegister addRepresentingObject:[NSURL URLWithString:stringValue]];
+        else if (UTTypeConformsTo(cocoaType.get(), kUTTypePlainText))
+            [representationsToRegister addRepresentingObject:stringValue];
+        else
+            [representationsToRegister addData:[stringValue dataUsingEncoding:NSUTF8StringEncoding] forType:(NSString *)cocoaType.get()];
+    }
+
+    registerItemToPasteboard(representationsToRegister.get(), m_pasteboard.get());
+    return [m_pasteboard changeCount];
+}
+
 int PlatformPasteboard::count()
 {
@@ -417 +537 @@
     NSIndexSet *indexSet = [NSIndexSet indexSetWithIndex:index];
 
-    RetainPtr<NSArray> pasteboardItem = [m_pasteboard valuesForPasteboardType:type inItemSet:indexSet];
-
-    if (![pasteboardItem count])
-        return String();
-
-    id value = [pasteboardItem objectAtIndex:0];
+    NSArray *pasteboardValues = [m_pasteboard valuesForPasteboardType:type inItemSet:indexSet];
+    if (!pasteboardValues.count) {
+        NSArray<NSData *> *pasteboardData = [m_pasteboard dataForPasteboardType:type inItemSet:indexSet];
+        if (!pasteboardData.count)
+            return { };
+        pasteboardValues = pasteboardData;
+    }
+
+    RetainPtr<id> value = [pasteboardValues objectAtIndex:0];
+    if ([value isKindOfClass:[NSData class]])
+        value = adoptNS([[NSString alloc] initWithData:(NSData *)value.get() encoding:NSUTF8StringEncoding]);
     
     if (type == String(kUTTypePlainText) || type == String(kUTTypeHTML)) {
         ASSERT([value isKindOfClass:[NSString class]]);
-        return [value isKindOfClass:[NSString class]] ? value : nil;
+        return [value isKindOfClass:[NSString class]] ? value.get() : nil;
     }
     if (type == String(kUTTypeText)) {
         ASSERT([value isKindOfClass:[NSString class]] || [value isKindOfClass:[NSAttributedString class]]);
         if ([value isKindOfClass:[NSString class]])
-            return value;
+            return value.get();
         if ([value isKindOfClass:[NSAttributedString class]])
             return [(NSAttributedString *)value string];
     } else if (type == String(kUTTypeURL)) {
-        ASSERT([value isKindOfClass:[NSURL class]]);
+        ASSERT([value isKindOfClass:[NSURL class]] || [value isKindOfClass:[NSString class]]);
+        if ([value isKindOfClass:[NSString class]])
+            value = [NSURL URLWithString:value.get()];
         if ([value isKindOfClass:[NSURL class]] && allowReadingURLAtIndex((NSURL *)value, index))
             return [(NSURL *)value absoluteString];

trunk/Source/WebCore/platform/ios/WebItemProviderPasteboard.h

@@ -72 +72 @@
 
 @property (nonatomic) WebPreferredPresentationStyle preferredPresentationStyle;
+@property (nonatomic, copy) NSData *teamData;
 
 - (NSUInteger)numberOfItems;

trunk/Source/WebCore/platform/ios/WebItemProviderPasteboard.mm

@@ -51 +51 @@
 
 typedef void(^ItemProviderDataLoadCompletionHandler)(NSData *, NSError *);
-typedef NSDictionary<NSString *, NSURL *> TypeToFileURLMap;
+typedef NSMutableDictionary<NSString *, NSURL *> TypeToFileURLMap;
 
 @interface WebItemProviderRegistrationInfo ()
@@ -189 +189 @@
     [itemProvider setSuggestedName:self.suggestedName];
     [itemProvider setPreferredPresentationStyle:uiPreferredPresentationStyle(self.preferredPresentationStyle)];
+    [itemProvider setTeamData:self.teamData];
     return itemProvider.autorelease();
 }
@@ -213 +214 @@
 @interface WebItemProviderLoadResult : NSObject
 
-+ (instancetype)loadResultWithFileURLMap:(TypeToFileURLMap *)fileURLs presentationStyle:(UIPreferredPresentationStyle)presentationStyle;
-+ (instancetype)emptyLoadResult;
-
+- (instancetype)initWithItemProvider:(NSItemProvider *)itemProvider typesToLoad:(NSArray<NSString *> *)typesToLoad;
 - (NSURL *)fileURLForType:(NSString *)type;
+- (void)setFileURL:(NSURL *)url forType:(NSString *)type;
 @property (nonatomic, readonly) NSArray<NSURL *> *loadedFileURLs;
 @property (nonatomic, readonly) NSArray<NSString *> *loadedTypeIdentifiers;
 @property (nonatomic, readonly) BOOL canBeRepresentedAsFileUpload;
+@property (nonatomic, readonly) NSItemProvider *itemProvider;
+@property (nonatomic, readonly) NSArray<NSString *> *typesToLoad;
 
 @end
@@ -225 +227 @@
 @implementation WebItemProviderLoadResult {
     RetainPtr<TypeToFileURLMap> _fileURLs;
-}
-
-+ (instancetype)emptyLoadResult
-{
-    return [[[self alloc] initWithFileURLMap:@{ } presentationStyle:UIPreferredPresentationStyleUnspecified] autorelease];
-}
-
-+ (instancetype)loadResultWithFileURLMap:(TypeToFileURLMap *)fileURLs presentationStyle:(UIPreferredPresentationStyle)presentationStyle
-{
-    return [[[self alloc] initWithFileURLMap:fileURLs presentationStyle:presentationStyle] autorelease];
-}
-
-- (instancetype)initWithFileURLMap:(TypeToFileURLMap *)fileURLs presentationStyle:(UIPreferredPresentationStyle)presentationStyle
+    RetainPtr<NSItemProvider> _itemProvider;
+    RetainPtr<NSArray<NSString *>> _typesToLoad;
+}
+
++ (instancetype)loadResultWithItemProvider:(NSItemProvider *)itemProvider typesToLoad:(NSArray<NSString *> *)typesToLoad
+{
+    return [[[self alloc] initWithItemProvider:itemProvider typesToLoad:typesToLoad] autorelease];
+}
+
+- (instancetype)initWithItemProvider:(NSItemProvider *)itemProvider typesToLoad:(NSArray<NSString *> *)typesToLoad
 {
     if (!(self = [super init]))
         return nil;
 
-    _fileURLs = fileURLs;
-    _canBeRepresentedAsFileUpload = presentationStyle != UIPreferredPresentationStyleInline;
+    _fileURLs = adoptNS([[NSMutableDictionary alloc] init]);
+    _itemProvider = itemProvider;
+    _typesToLoad = typesToLoad;
+    _canBeRepresentedAsFileUpload = itemProvider.preferredPresentationStyle != UIPreferredPresentationStyleInline;
 
     return self;
 }
 
+- (NSArray<NSString *> *)typesToLoad
+{
+    return _typesToLoad.get();
+}
+
 - (NSURL *)fileURLForType:(NSString *)type
 {
@@ -253 +259 @@
 }
 
+- (void)setFileURL:(NSURL *)url forType:(NSString *)type
+{
+    [_fileURLs setObject:url forKey:type];
+}
+
 - (NSArray<NSURL *> *)loadedFileURLs
 {
@@ -261 +272 @@
 {
     return [_fileURLs allKeys];
+}
+
+- (NSItemProvider *)itemProvider
+{
+    return _itemProvider.get();
 }
 
@@ -344 +360 @@
     _itemProviders = itemProviders;
     _changeCount++;
+
+    if (!itemProviders.count)
+        _loadResults = { };
 }
 
@@ -368 +387 @@
     }
     return nil;
+}
+
+- (NSData *)dataForPasteboardType:(NSString *)pasteboardType
+{
+    return [self dataForPasteboardType:pasteboardType inItemSet:[NSIndexSet indexSetWithIndexesInRange:NSMakeRange(0, self.numberOfItems)]].firstObject;
 }
 
@@ -505 +529 @@
 }
 
-- (NSString *)typeIdentifierToLoadForRegisteredTypeIdentfiers:(NSArray<NSString *> *)registeredTypeIdentifiers
-{
+- (NSArray<NSString *> *)typeIdentifiersToLoadForRegisteredTypeIdentfiers:(NSArray<NSString *> *)registeredTypeIdentifiers
+{
+    NSMutableSet *typesToLoad = [NSMutableSet set];
     NSString *highestFidelityContentType = nil;
+
+    // First, we want to either load the highest fidelity supported type or the highest fidelity generic content type.
     for (NSString *registeredTypeIdentifier in registeredTypeIdentifiers) {
-        if (typeConformsToTypes(registeredTypeIdentifier, _supportedTypeIdentifiers.get()))
-            return registeredTypeIdentifier;
+        if (typeConformsToTypes(registeredTypeIdentifier, _supportedTypeIdentifiers.get())) {
+            [typesToLoad addObject:registeredTypeIdentifier];
+            break;
+        }
 
         if (!highestFidelityContentType && UTTypeConformsTo((CFStringRef)registeredTypeIdentifier, kUTTypeContent))
             highestFidelityContentType = registeredTypeIdentifier;
     }
-    return highestFidelityContentType;
+    if (!typesToLoad.count && highestFidelityContentType)
+        [typesToLoad addObject:highestFidelityContentType];
+
+    // For compatibility with DataTransfer APIs, additionally load web-exposed types. Since this is the only chance to
+    // fault in any data at all, we need to load up front any information that the page may ask for later down the line.
+    NSString *customPasteboardDataUTI = @(customWebKitPasteboardDataType);
+    for (NSString *registeredTypeIdentifier in registeredTypeIdentifiers) {
+        if ([typesToLoad containsObject:registeredTypeIdentifier])
+            continue;
+        if ([registeredTypeIdentifier isEqualToString:customPasteboardDataUTI])
+            [typesToLoad addObject:customPasteboardDataUTI];
+        if (UTTypeConformsTo((CFStringRef)registeredTypeIdentifier, kUTTypeURL))
+            [typesToLoad addObject:(NSString *)kUTTypeURL];
+        if (UTTypeConformsTo((CFStringRef)registeredTypeIdentifier, kUTTypeHTML))
+            [typesToLoad addObject:(NSString *)kUTTypeHTML];
+        if (UTTypeConformsTo((CFStringRef)registeredTypeIdentifier, kUTTypePlainText))
+            [typesToLoad addObject:(NSString *)kUTTypePlainText];
+    }
+
+    return typesToLoad.allObjects;
 }
 
@@ -531 +579 @@
 
     // First, figure out which item providers we want to try and load files from.
-    auto itemProvidersToLoad = adoptNS([[NSMutableArray alloc] init]);
-    auto typeIdentifiersToLoad = adoptNS([[NSMutableArray alloc] init]);
-    auto indicesOfitemProvidersToLoad = adoptNS([[NSMutableArray alloc] init]);
+    BOOL foundAnyDataToLoad = NO;
     RetainPtr<WebItemProviderPasteboard> protectedSelf = self;
-    [_itemProviders enumerateObjectsUsingBlock:[protectedSelf, itemProvidersToLoad, typeIdentifiersToLoad, indicesOfitemProvidersToLoad, loadResults] (UIItemProvider *itemProvider, NSUInteger index, BOOL *) {
-        NSString *typeIdentifierToLoad = [protectedSelf typeIdentifierToLoadForRegisteredTypeIdentfiers:itemProvider.registeredTypeIdentifiers];
-        if (typeIdentifierToLoad) {
-            [itemProvidersToLoad addObject:itemProvider];
-            [typeIdentifiersToLoad addObject:typeIdentifierToLoad];
-            [indicesOfitemProvidersToLoad addObject:@(index)];
-        }
-        [loadResults addObject:[WebItemProviderLoadResult emptyLoadResult]];
-    }];
-
-    if (![itemProvidersToLoad count]) {
+    for (NSItemProvider *itemProvider in _itemProviders.get()) {
+        NSArray<NSString *> *typeIdentifiersToLoad = [protectedSelf typeIdentifiersToLoadForRegisteredTypeIdentfiers:itemProvider.registeredTypeIdentifiers];
+        foundAnyDataToLoad |= typeIdentifiersToLoad.count;
+        [loadResults addObject:[WebItemProviderLoadResult loadResultWithItemProvider:itemProvider typesToLoad:typeIdentifiersToLoad]];
+    }
+
+    if (!foundAnyDataToLoad) {
         action(@[ ]);
         return;
@@ -553 +595 @@
     auto synchronousFileLoadingGroup = adoptOSObject(dispatch_group_create());
     auto fileLoadingGroup = adoptOSObject(dispatch_group_create());
-    for (NSUInteger index = 0; index < [itemProvidersToLoad count]; ++index) {
-        RetainPtr<UIItemProvider> itemProvider = [itemProvidersToLoad objectAtIndex:index];
-        RetainPtr<NSString> typeIdentifier = [typeIdentifiersToLoad objectAtIndex:index];
-        NSUInteger indexInItemProviderArray = [[indicesOfitemProvidersToLoad objectAtIndex:index] unsignedIntegerValue];
-        RetainPtr<NSString> suggestedName = [itemProvider suggestedName];
-        auto presentationStyle = [itemProvider preferredPresentationStyle];
-        dispatch_group_enter(fileLoadingGroup.get());
-        dispatch_group_enter(synchronousFileLoadingGroup.get());
-        [itemProvider loadFileRepresentationForTypeIdentifier:typeIdentifier.get() completionHandler:[synchronousFileLoadingGroup, setFileURLsLock, indexInItemProviderArray, suggestedName, typeIdentifier, loadResults, fileLoadingGroup, presentationStyle] (NSURL *url, NSError *) {
-            // After executing this completion block, UIKit removes the file at the given URL. However, we need this data to persist longer for the web content process.
-            // To address this, we hard link the given URL to a new temporary file in the temporary directory. This follows the same flow as regular file upload, in
-            // WKFileUploadPanel.mm. The temporary files are cleaned up by the system at a later time.
-            if (NSURL *destination = linkTemporaryItemProviderFilesToDropStagingDirectory(url, suggestedName.get(), typeIdentifier.get())) {
-                WebItemProviderLoadResult *loadResult = [WebItemProviderLoadResult loadResultWithFileURLMap:@{ typeIdentifier.get() : destination } presentationStyle:presentationStyle];
-                [setFileURLsLock lock];
-                [loadResults setObject:loadResult atIndexedSubscript:indexInItemProviderArray];
-                [setFileURLsLock unlock];
-            }
-            dispatch_group_leave(fileLoadingGroup.get());
-            dispatch_group_leave(synchronousFileLoadingGroup.get());
-        }];
+    for (WebItemProviderLoadResult *loadResult in loadResults.get()) {
+        for (NSString *typeToLoad in loadResult.typesToLoad) {
+            dispatch_group_enter(fileLoadingGroup.get());
+            dispatch_group_enter(synchronousFileLoadingGroup.get());
+            [loadResult.itemProvider loadFileRepresentationForTypeIdentifier:typeToLoad completionHandler:[protectedLoadResult = retainPtr(loadResult), synchronousFileLoadingGroup, setFileURLsLock, protectedTypeToLoad = retainPtr(typeToLoad), fileLoadingGroup] (NSURL *url, NSError *) {
+                // After executing this completion block, UIKit removes the file at the given URL. However, we need this data to persist longer for the web content process.
+                // To address this, we hard link the given URL to a new temporary file in the temporary directory. This follows the same flow as regular file upload, in
+                // WKFileUploadPanel.mm. The temporary files are cleaned up by the system at a later time.
+                if (NSURL *destination = linkTemporaryItemProviderFilesToDropStagingDirectory(url, [protectedLoadResult itemProvider].suggestedName, protectedTypeToLoad.get())) {
+                    [setFileURLsLock lock];
+                    [protectedLoadResult setFileURL:destination forType:protectedTypeToLoad.get()];
+                    [setFileURLsLock unlock];
+                }
+                dispatch_group_leave(fileLoadingGroup.get());
+                dispatch_group_leave(synchronousFileLoadingGroup.get());
+            }];
+        }
     }
 

trunk/Source/WebCore/platform/mac/PasteboardMac.mm

@@ -44 +44 @@
 #import "MIMETypeRegistry.h"
 #import "PasteboardStrategy.h"
+#import "PlatformPasteboard.h"
 #import "PlatformStrategies.h"
 #import "RenderImage.h"
+#import "Settings.h"
 #import "Text.h"
 #import "URL.h"
@@ -196 +198 @@
 }
 
+void Pasteboard::writeCustomData(const PasteboardCustomData& data)
+{
+    m_changeCount = platformStrategies()->pasteboardStrategy()->writeCustomData(data, m_pasteboardName);
+}
+
 void Pasteboard::writePlainText(const String& text, SmartReplaceOption smartReplaceOption)
 {
@@ -461 +468 @@
 static String cocoaTypeFromHTMLClipboardType(const String& type)
 {
-    // Ignore any trailing charset - strings are already UTF-16, and the charset issue has already been dealt with.
-    if (type == "text/plain")
-        return NSStringPboardType;
-    if (type == "text/uri-list") {
-        // Special case because UTI doesn't work with Cocoa's URL type.
-        return NSURLPboardType;
+    if (NSString *platformType = PlatformPasteboard::platformPasteboardTypeForSafeTypeForDOMToReadAndWrite(type)) {
+        if (platformType.length)
+            return platformType;
     }
 
@@ -508 +512 @@
 }
 
-String Pasteboard::readString(const String& type)
-{
-    const String& cocoaType = cocoaTypeFromHTMLClipboardType(type);
+static String readPlatformValueAsString(const String& domType, long changeCount, const String& pasteboardName)
+{
+    const String& cocoaType = cocoaTypeFromHTMLClipboardType(domType);
     String cocoaValue;
 
     if (cocoaType == String(NSStringPboardType))
-        cocoaValue = [platformStrategies()->pasteboardStrategy()->stringForType(cocoaType, m_pasteboardName) precomposedStringWithCanonicalMapping];
+        cocoaValue = [platformStrategies()->pasteboardStrategy()->stringForType(cocoaType, pasteboardName) precomposedStringWithCanonicalMapping];
     else if (!cocoaType.isEmpty())
-        cocoaValue = platformStrategies()->pasteboardStrategy()->stringForType(cocoaType, m_pasteboardName);
+        cocoaValue = platformStrategies()->pasteboardStrategy()->stringForType(cocoaType, pasteboardName);
 
     // Enforce changeCount ourselves for security.  We check after reading instead of before to be
     // sure it doesn't change between our testing the change count and accessing the data.
-    if (!cocoaValue.isEmpty() && m_changeCount == platformStrategies()->pasteboardStrategy()->changeCount(m_pasteboardName))
+    if (!cocoaValue.isEmpty() && changeCount == platformStrategies()->pasteboardStrategy()->changeCount(pasteboardName))
         return cocoaValue;
 
     return String();
+}
+
+String Pasteboard::readStringForBindings(const String& type)
+{
+    if (!Settings::customPasteboardDataEnabled() || isSafeTypeForDOMToReadAndWrite(type))
+        return readPlatformValueAsString(type, m_changeCount, m_pasteboardName);
+
+    if (auto buffer = platformStrategies()->pasteboardStrategy()->bufferForType(customWebKitPasteboardDataType, m_pasteboardName)) {
+        NSString *customDataValue = customDataFromSharedBuffer(*buffer).sameOriginCustomData.get(type);
+        if (customDataValue.length)
+            return customDataValue;
+    }
+
+    return { };
 }
 
@@ -595 +613 @@
 {
     Vector<String> types;
-    platformStrategies()->pasteboardStrategy()->getTypes(types, m_pasteboardName);
+    if (Settings::customPasteboardDataEnabled())
+        types = platformStrategies()->pasteboardStrategy()->typesSafeForDOMToReadAndWrite(m_pasteboardName);
+    else
+        platformStrategies()->pasteboardStrategy()->getTypes(types, m_pasteboardName);
 
     // Enforce changeCount ourselves for security. We check after reading instead of before to be
     // sure it doesn't change between our testing the change count and accessing the data.
     if (m_changeCount != platformStrategies()->pasteboardStrategy()->changeCount(m_pasteboardName))
-        return Vector<String>();
+        return { };
+
+    if (Settings::customPasteboardDataEnabled())
+        return types;
 
     ListHashSet<String> result;

trunk/Source/WebCore/platform/mac/PlatformPasteboardMac.mm

@@ -25 +25 @@
 
 #import "config.h"
+#import "PlatformPasteboard.h"
+
 #import "Color.h"
+#import "Pasteboard.h"
+#import "Settings.h"
 #import "URL.h"
-#import "PlatformPasteboard.h"
 #import "SharedBuffer.h"
+#import <wtf/HashCountedSet.h>
+#import <wtf/ListHashSet.h>
+#import <wtf/text/StringHash.h>
 
 namespace WebCore {
@@ -54 +60 @@
 }
 
-int PlatformPasteboard::numberOfFiles()
+int PlatformPasteboard::numberOfFiles() const
 {
     Vector<String> files;
@@ -63 +69 @@
 }
 
-void PlatformPasteboard::getPathnamesForType(Vector<String>& pathnames, const String& pasteboardType)
+void PlatformPasteboard::getPathnamesForType(Vector<String>& pathnames, const String& pasteboardType) const
 {
     NSArray* paths = [m_pasteboard.get() propertyListForType:pasteboardType];
@@ -76 +82 @@
 String PlatformPasteboard::stringForType(const String& pasteboardType)
 {
-    if (pasteboardType == String(NSURLPboardType))
-        return [[NSURL URLFromPasteboard:m_pasteboard.get()] absoluteString];
-
-    return [m_pasteboard.get() stringForType:pasteboardType];
+    if (pasteboardType == String(NSURLPboardType)) {
+        if (NSURL *urlFromPasteboard = [NSURL URLFromPasteboard:m_pasteboard.get()])
+            return urlFromPasteboard.absoluteString;
+
+        URL url([NSURL URLWithString:[m_pasteboard stringForType:NSURLPboardType]]);
+        if (!url.isValid())
+            return { };
+        return url.string();
+    }
+
+    return [m_pasteboard stringForType:pasteboardType];
+}
+
+static const char* safeTypeForDOMToReadAndWriteForPlatformType(const String& platformType)
+{
+    if (platformType == String(NSStringPboardType) || platformType == String(NSPasteboardTypeString))
+        return ASCIILiteral("text/plain");
+
+    if (platformType == String(NSURLPboardType))
+        return ASCIILiteral("text/uri-list");
+
+    if (platformType == String(NSHTMLPboardType))
+        return ASCIILiteral("text/html");
+
+    if (platformType == String(NSFilenamesPboardType) || platformType == String(NSFilesPromisePboardType))
+        return ASCIILiteral("Files");
+
+    return nullptr;
+}
+
+Vector<String> PlatformPasteboard::typesSafeForDOMToReadAndWrite() const
+{
+    ListHashSet<String> domPasteboardTypes;
+    if (NSData *serializedCustomData = [m_pasteboard dataForType:@(customWebKitPasteboardDataType)]) {
+        auto buffer = SharedBuffer::create(serializedCustomData);
+        for (auto& type : customDataFromSharedBuffer(buffer.get()).orderedTypes)
+            domPasteboardTypes.add(type);
+    }
+
+    NSArray<NSString *> *allTypes = [m_pasteboard types];
+    for (NSString *type in allTypes) {
+        if ([type isEqualToString:@(customWebKitPasteboardDataType)])
+            continue;
+
+        if (isSafeTypeForDOMToReadAndWrite(type))
+            domPasteboardTypes.add(type);
+        else if (auto* domType = safeTypeForDOMToReadAndWriteForPlatformType(type)) {
+            auto coercedType = String::fromUTF8(domType);
+            if (coercedType == "Files" && !numberOfFiles())
+                continue;
+            domPasteboardTypes.add(WTFMove(coercedType));
+        }
+    }
+
+    Vector<String> result;
+    copyToVector(domPasteboardTypes, result);
+    return result;
+}
+
+long PlatformPasteboard::write(const PasteboardCustomData& data)
+{
+    NSMutableArray *types = [NSMutableArray array];
+    for (auto& entry : data.platformData)
+        [types addObject:platformPasteboardTypeForSafeTypeForDOMToReadAndWrite(entry.key)];
+    if (data.sameOriginCustomData.size())
+        [types addObject:@(customWebKitPasteboardDataType)];
+
+    [m_pasteboard declareTypes:types owner:nil];
+
+    for (auto& entry : data.platformData) {
+        auto platformType = platformPasteboardTypeForSafeTypeForDOMToReadAndWrite(entry.key);
+        ASSERT(!platformType.isEmpty());
+        if (!platformType.isEmpty())
+            [m_pasteboard setString:entry.value forType:platformType];
+    }
+
+    if (data.sameOriginCustomData.size()) {
+        if (auto serializedCustomData = sharedBufferFromCustomData(data)->createNSData())
+            [m_pasteboard setData:serializedCustomData.get() forType:@(customWebKitPasteboardDataType)];
+    }
+
+    return changeCount();
 }
 
@@ -85 +169 @@
 {
     return [m_pasteboard.get() changeCount];
+}
+
+String PlatformPasteboard::platformPasteboardTypeForSafeTypeForDOMToReadAndWrite(const String& domType)
+{
+    if (domType == "text/plain")
+        return NSStringPboardType;
+
+    if (domType == "text/html")
+        return NSHTMLPboardType;
+
+    if (domType == "text/uri-list")
+        return NSURLPboardType;
+
+    return { };
 }
 

trunk/Source/WebCore/platform/win/PasteboardWin.cpp

@@ -278 +278 @@
 }
 
-String Pasteboard::readString(const String& type)
+String Pasteboard::readStringForBindings(const String& type)
 {
     if (!m_dataObject && m_dragDataMap.isEmpty())
@@ -1055 +1055 @@
 }
 
+void Pasteboard::writeCustomData(const PasteboardCustomData&)
+{
+}
+
 } // namespace WebCore

trunk/Source/WebCore/platform/wpe/PasteboardWPE.cpp

@@ -57 +57 @@
 }
 
-String Pasteboard::readString(const String& type)
+String Pasteboard::readStringForBindings(const String& type)
 {
     return platformStrategies()->pasteboardStrategy()->readStringFromPasteboard(0, type);
@@ -123 +123 @@
 }
 
+void Pasteboard::writeCustomData(const PasteboardCustomData&)
+{
+}
+
 } // namespace WebCore

trunk/Source/WebCore/platform/wpe/PlatformPasteboardWPE.cpp

@@ -117 +117 @@
 }
 
+Vector<String> PlatformPasteboard::typesSafeForDOMToReadAndWrite() const
+{
+    return { };
+}
+
+long PlatformPasteboard::write(const PasteboardCustomData&)
+{
+    return 0;
+}
+
 } // namespace WebCore

trunk/Source/WebCore/testing/InternalSettings.cpp

@@ -115 +115 @@
     , m_shouldManageAudioSessionCategory(Settings::shouldManageAudioSessionCategory())
 #endif
+    , m_customPasteboardDataEnabled(Settings::customPasteboardDataEnabled())
 {
 }
@@ -211 +212 @@
     Settings::setShouldManageAudioSessionCategory(m_shouldManageAudioSessionCategory);
 #endif
+    Settings::setCustomPasteboardDataEnabled(m_customPasteboardDataEnabled);
 }
 
@@ -853 +855 @@
 }
 
+ExceptionOr<void> InternalSettings::setCustomPasteboardDataEnabled(bool enabled)
+{
+    Settings::setCustomPasteboardDataEnabled(enabled);
+    return { };
+}
+
 static InternalSettings::ForcedAccessibilityValue settingsToInternalSettingsValue(Settings::ForcedAccessibilityValue value)
 {

trunk/Source/WebCore/testing/InternalSettings.h

@@ -98 +98 @@
     ExceptionOr<void> setShouldMockBoldSystemFontForAccessibility(bool);
     ExceptionOr<void> setShouldManageAudioSessionCategory(bool);
+    ExceptionOr<void> setCustomPasteboardDataEnabled(bool);
 
     enum class FrameFlatteningValue { Disabled, EnabledForNonFullScreenIFrames, FullyEnabled };
@@ -205 +206 @@
         bool m_shouldManageAudioSessionCategory;
 #endif
+        bool m_customPasteboardDataEnabled;
     };
 

trunk/Source/WebCore/testing/InternalSettings.idl

@@ -107 +107 @@
 
     [MayThrowException] void setShouldManageAudioSessionCategory(boolean should);
+    [MayThrowException] void setCustomPasteboardDataEnabled(boolean enabled);
 };
 

trunk/Source/WebKit/ChangeLog

@@ +1 @@
+2017-09-27  Wenson Hsieh  <wenson_hsieh@apple.com>
+
+        Drag event DataTransfer has unexpected types "dyn.ah62d4..."
+        https://bugs.webkit.org/show_bug.cgi?id=172526
+        <rdar://problem/32396081>
+
+        Reviewed by Ryosuke Niwa.
+
+        Add boilerplate plumbing and encoder/decoder support for new pasteboard codepaths. See WebCore ChangeLog for
+        more details.
+
+        * Scripts/webkit/messages.py:
+        (headers_for_type):
+        * Shared/WebCoreArgumentCoders.cpp:
+        (IPC::ArgumentCoder<PasteboardCustomData>::encode):
+        (IPC::ArgumentCoder<PasteboardCustomData>::decode):
+
+        Add encoder/decoder support for PasteboardCustomData.
+
+        (IPC::ArgumentCoder<PasteboardWebContent>::encode):
+        (IPC::ArgumentCoder<PasteboardWebContent>::decode):
+
+        Encode and decode dataInHTMLFormat.
+
+        * Shared/WebCoreArgumentCoders.h:
+        * UIProcess/Cocoa/WebPasteboardProxyCocoa.mm:
+        (WebKit::WebPasteboardProxy::typesSafeForDOMToReadAndWrite):
+        (WebKit::WebPasteboardProxy::writeCustomData):
+        * UIProcess/WebPasteboardProxy.cpp:
+        (WebKit::WebPasteboardProxy::typesSafeForDOMToReadAndWrite):
+        (WebKit::WebPasteboardProxy::writeCustomData):
+        * UIProcess/WebPasteboardProxy.h:
+        * UIProcess/WebPasteboardProxy.messages.in:
+        * WebProcess/WebCoreSupport/WebPlatformStrategies.cpp:
+        (WebKit::WebPlatformStrategies::typesSafeForDOMToReadAndWrite):
+        (WebKit::WebPlatformStrategies::writeCustomData):
+        * WebProcess/WebCoreSupport/WebPlatformStrategies.h:
+
 2017-09-27  Alex Christensen  <achristensen@webkit.org>
 

trunk/Source/WebKit/Scripts/webkit/messages.py

@@ -364 +364 @@
         'WebCore::KeypressCommand': ['<WebCore/KeyboardEvent.h>'],
         'WebCore::MediaConstraints': ['<WebCore/MediaConstraints.h>'],
+        'WebCore::PasteboardCustomData': ['<WebCore/Pasteboard.h>'],
         'WebCore::PasteboardImage': ['<WebCore/Pasteboard.h>'],
         'WebCore::PasteboardURL': ['<WebCore/Pasteboard.h>'],

trunk/Source/WebKit/Shared/WebCoreArgumentCoders.cpp

@@ -92 +92 @@
 #endif // PLATFORM(IOS)
 
-#if PLATFORM(IOS) || PLATFORM(WPE)
+#if PLATFORM(COCOA) || PLATFORM(WPE) || PLATFORM(GTK)
 #include <WebCore/Pasteboard.h>
 #endif
@@ -1579 +1579 @@
 }
 
+void ArgumentCoder<PasteboardCustomData>::encode(Encoder& encoder, const PasteboardCustomData& data)
+{
+    encoder << data.orderedTypes;
+    encoder << data.platformData;
+    encoder << data.sameOriginCustomData;
+}
+
+bool ArgumentCoder<PasteboardCustomData>::decode(Decoder& decoder, PasteboardCustomData& data)
+{
+    if (!decoder.decode(data.orderedTypes))
+        return false;
+
+    if (!decoder.decode(data.platformData))
+        return false;
+
+    if (!decoder.decode(data.sameOriginCustomData))
+        return false;
+
+    return true;
+}
+
 #if PLATFORM(IOS)
 
@@ -1665 +1686 @@
     encoder << content.canSmartCopyOrDelete;
     encoder << content.dataInStringFormat;
+    encoder << content.dataInHTMLFormat;
 
     encodeSharedBuffer(encoder, content.dataInWebArchiveFormat.get());
@@ -1679 +1701 @@
         return false;
     if (!decoder.decode(content.dataInStringFormat))
+        return false;
+    if (!decoder.decode(content.dataInHTMLFormat))
         return false;
     if (!decodeSharedBuffer(decoder, content.dataInWebArchiveFormat))

trunk/Source/WebKit/Shared/WebCoreArgumentCoders.h

@@ -100 +100 @@
 struct MimeClassInfo;
 struct PasteboardImage;
+struct PasteboardCustomData;
 struct PasteboardURL;
 struct PluginInfo;
@@ -426 +427 @@
 #endif
 
+template<> struct ArgumentCoder<WebCore::PasteboardCustomData> {
+    static void encode(Encoder&, const WebCore::PasteboardCustomData&);
+    static bool decode(Decoder&, WebCore::PasteboardCustomData&);
+};
+
 #if USE(SOUP)
 template<> struct ArgumentCoder<WebCore::SoupNetworkProxySettings> {

trunk/Source/WebKit/UIProcess/Cocoa/WebPasteboardProxyCocoa.mm

@@ -140 +140 @@
 }
 
+void WebPasteboardProxy::typesSafeForDOMToReadAndWrite(const String& pasteboardName, Vector<String>& types)
+{
+    types = PlatformPasteboard(pasteboardName).typesSafeForDOMToReadAndWrite();
+}
+
+void WebPasteboardProxy::writeCustomData(const WebCore::PasteboardCustomData& data, const String& pasteboardName, uint64_t& newChangeCount)
+{
+    newChangeCount = PlatformPasteboard(pasteboardName).write(data);
+}
+
 #if PLATFORM(IOS)
 void WebPasteboardProxy::getPasteboardTypesByFidelityForItemAtIndex(uint64_t index, const String& pasteboardName, Vector<String>& types)

trunk/Source/WebKit/UIProcess/WebPasteboardProxy.cpp

@@ -62 +62 @@
 }
 
+#if !PLATFORM(COCOA)
+
+void WebPasteboardProxy::typesSafeForDOMToReadAndWrite(const String&, Vector<String>& types)
+{
+    types = { };
+}
+
+void WebPasteboardProxy::writeCustomData(const WebCore::PasteboardCustomData&, const String&, uint64_t& newChangeCount)
+{
+    newChangeCount = 0;
+}
+
+#endif
+
 } // namespace WebKit

trunk/Source/WebKit/UIProcess/WebPasteboardProxy.h

@@ -33 +33 @@
 namespace WebCore {
 class Color;
+struct PasteboardCustomData;
 struct PasteboardImage;
 struct PasteboardURL;
@@ -97 +98 @@
 #endif
 
+    void writeCustomData(const WebCore::PasteboardCustomData&, const String& pasteboardName, uint64_t& newChangeCount);
+    void typesSafeForDOMToReadAndWrite(const String& pasteboardName, Vector<String>& types);
+
 #if PLATFORM(GTK)
     void writeToClipboard(const String& pasteboardName, const WebSelectionData&);

trunk/Source/WebKit/UIProcess/WebPasteboardProxy.messages.in

@@ -36 +36 @@
 #endif
 
+    WriteCustomData(struct WebCore::PasteboardCustomData data, String pasteboardName) -> (uint64_t changeCount)
+    TypesSafeForDOMToReadAndWrite(String pasteboardName) -> (Vector<String> types)
+
 #if PLATFORM(COCOA)
     # Pasteboard messages.

trunk/Source/WebKit/WebProcess/WebCoreSupport/WebPlatformStrategies.cpp

@@ -399 +399 @@
 #endif // PLATFORM(WPE)
 
+Vector<String> WebPlatformStrategies::typesSafeForDOMToReadAndWrite(const String& pasteboardName)
+{
+    Vector<String> types;
+    WebProcess::singleton().parentProcessConnection()->sendSync(Messages::WebPasteboardProxy::TypesSafeForDOMToReadAndWrite(pasteboardName), Messages::WebPasteboardProxy::TypesSafeForDOMToReadAndWrite::Reply(types), 0);
+    return types;
+}
+
+long WebPlatformStrategies::writeCustomData(const WebCore::PasteboardCustomData& data, const String& pasteboardName)
+{
+    uint64_t newChangeCount;
+    WebProcess::singleton().parentProcessConnection()->sendSync(Messages::WebPasteboardProxy::WriteCustomData(data, pasteboardName), Messages::WebPasteboardProxy::WriteCustomData::Reply(newChangeCount), 0);
+    return newChangeCount;
+}
+
 } // namespace WebKit

trunk/Source/WebKit/WebProcess/WebCoreSupport/WebPlatformStrategies.h

@@ -97 +97 @@
     void writeToPasteboard(const String& pasteboardType, const String&) override;
 #endif
+
+    Vector<String> typesSafeForDOMToReadAndWrite(const String& pasteboardName) override;
+    long writeCustomData(const WebCore::PasteboardCustomData&, const String&) override;
 };
 

trunk/Source/WebKitLegacy/mac/ChangeLog

@@ +1 @@
+2017-09-27  Wenson Hsieh  <wenson_hsieh@apple.com>
+
+        Drag event DataTransfer has unexpected types "dyn.ah62d4..."
+        https://bugs.webkit.org/show_bug.cgi?id=172526
+        <rdar://problem/32396081>
+
+        Reviewed by Ryosuke Niwa.
+
+        Adjust for changes in WebCore. See WebCore ChangeLog for more details.
+
+        * WebCoreSupport/WebPlatformStrategies.h:
+        * WebCoreSupport/WebPlatformStrategies.mm:
+        (WebPlatformStrategies::webExposedTypes):
+        (WebPlatformStrategies::writeCustomData):
+
 2017-09-27  Matt Lewis  <jlewis3@apple.com>
 

trunk/Source/WebKitLegacy/mac/WebCoreSupport/WebPlatformStrategies.h

@@ -33 +33 @@
 struct PasteboardImage;
 struct PasteboardWebContent;
+struct PasteboardCustomData;
 
 class WebPlatformStrategies : public WebCore::PlatformStrategies, private WebCore::CookiesStrategy, private WebCore::PasteboardStrategy {
@@ -80 +81 @@
     WebCore::URL url(const String& pasteboardName) override;
 
+    long writeCustomData(const WebCore::PasteboardCustomData&, const String& pasteboardName) override;
+    Vector<String> typesSafeForDOMToReadAndWrite(const String& pasteboardName) override;
+
     long addTypes(const Vector<String>& pasteboardTypes, const String& pasteboardName) override;
     long setTypes(const Vector<String>& pasteboardTypes, const String& pasteboardName) override;

trunk/Source/WebKitLegacy/mac/WebCoreSupport/WebPlatformStrategies.mm

@@ -180 +180 @@
 }
 
+Vector<String> WebPlatformStrategies::typesSafeForDOMToReadAndWrite(const String& pasteboardName)
+{
+    return PlatformPasteboard(pasteboardName).typesSafeForDOMToReadAndWrite();
+}
+
+long WebPlatformStrategies::writeCustomData(const WebCore::PasteboardCustomData& data, const String& pasteboardName)
+{
+    return PlatformPasteboard(pasteboardName).write(data);
+}
+
 #if PLATFORM(IOS)
 void WebPlatformStrategies::getTypesByFidelityForItemAtIndex(Vector<String>& types, uint64_t index, const String& pasteboardName)

trunk/Tools/ChangeLog

@@ +1 @@
+2017-09-27  Wenson Hsieh  <wenson_hsieh@apple.com>
+
+        Drag event DataTransfer has unexpected types "dyn.ah62d4..."
+        https://bugs.webkit.org/show_bug.cgi?id=172526
+        <rdar://problem/32396081>
+
+        Reviewed by Ryosuke Niwa.
+
+        Adds new API tests on iOS to cover various cases of using DataTransfer.setData, DataTransfer.getData, and
+        DataTransfer.types, as well as their interaction with platform objects (source NSItemProviders in the case of
+        drag and drop, and the general UIPasteboard for copy and paste).
+
+        * TestWebKitAPI/PlatformUtilities.h:
+        * TestWebKitAPI/TestWebKitAPI.xcodeproj/project.pbxproj:
+        * TestWebKitAPI/Tests/WebKitCocoa/dump-datatransfer-types.html: Added.
+
+        Introduce a new API test harness that both drag-and-drop and copy-and-paste tests use to dump DataTransfer's
+        web-exposed types and values.
+
+        * TestWebKitAPI/Tests/ios/DataInteractionTests.mm:
+        (checkFirstTypeIsPresentAndSecondTypeIsMissing):
+        (checkJSONWithLogging):
+        (TestWebKitAPI::TEST):
+        (checkTypeIdentifierAndIsNotOtherTypeIdentifier): Deleted.
+        * TestWebKitAPI/Tests/ios/UIPasteboardTests.mm:
+        (TestWebKitAPI::checkJSONWithLogging):
+        (TestWebKitAPI::setUpWebViewForPasteboardTests):
+        (TestWebKitAPI::TEST):
+        * TestWebKitAPI/cocoa/PlatformUtilitiesCocoa.mm:
+        (TestWebKitAPI::Util::jsonMatchesExpectedValues):
+
 2017-09-27  Lucas Forschler  <lforschler@apple.com>
 

trunk/Tools/TestWebKitAPI/PlatformUtilities.h

@@ -37 +37 @@
 #if USE(FOUNDATION)
 OBJC_CLASS NSString;
+OBJC_CLASS NSDictionary;
 #endif
 
@@ -49 +50 @@
 #if USE(FOUNDATION)
 std::string toSTD(NSString *);
+bool jsonMatchesExpectedValues(NSString *jsonString, NSDictionary *expected);
 #endif
 

trunk/Tools/TestWebKitAPI/TestWebKitAPI.xcodeproj/project.pbxproj

@@ -98 +98 @@
                 2E7765CF16C4D81100BA2BB1 /* mainMac.mm in Sources */ = {isa = PBXBuildFile; fileRef = 2E7765CE16C4D81100BA2BB1 /* mainMac.mm */; };
                 2E9896151D8F093800739892 /* text-and-password-inputs.html in Copy Resources */ = {isa = PBXBuildFile; fileRef = 2E9896141D8F092B00739892 /* text-and-password-inputs.html */; };
+                2EB29D5E1F762DB90023A5F1 /* dump-datatransfer-types.html in Copy Resources */ = {isa = PBXBuildFile; fileRef = 2EB29D5D1F762DA50023A5F1 /* dump-datatransfer-types.html */; };
                 2ECFF5551D9B12F800B55394 /* NowPlayingControlsTests.mm in Sources */ = {isa = PBXBuildFile; fileRef = 2ECFF5541D9B12F800B55394 /* NowPlayingControlsTests.mm */; };
                 2EFF06C31D88621E0004BB30 /* large-video-offscreen.html in Copy Resources */ = {isa = PBXBuildFile; fileRef = 2EFF06C21D8862120004BB30 /* large-video-offscreen.html */; };
@@ -846 +847 @@
                                 F4D5E4E81F0C5D38008C1A49 /* dragstart-clear-selection.html in Copy Resources */,
                                 F4194AD11F5A320100ADD83F /* drop-targets.html in Copy Resources */,
+                                2EB29D5E1F762DB90023A5F1 /* dump-datatransfer-types.html in Copy Resources */,
                                 A155022C1E050D0300A24C57 /* duplicate-completion-handler-calls.html in Copy Resources */,
                                 9984FACE1CFFB090008D198C /* editable-body.html in Copy Resources */,
@@ -1147 +1149 @@
                 2E7EF7AC1F266A8100DFB67C /* AppKitSPI.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = AppKitSPI.h; sourceTree = "<group>"; };
                 2E9896141D8F092B00739892 /* text-and-password-inputs.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = "text-and-password-inputs.html"; sourceTree = "<group>"; };
+                2EB29D5D1F762DA50023A5F1 /* dump-datatransfer-types.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = "dump-datatransfer-types.html"; sourceTree = "<group>"; };
                 2ECFF5541D9B12F800B55394 /* NowPlayingControlsTests.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = NowPlayingControlsTests.mm; sourceTree = "<group>"; };
                 2EFF06C21D8862120004BB30 /* large-video-offscreen.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = "large-video-offscreen.html"; sourceTree = "<group>"; };
@@ -2203 +2206 @@
                                 F4D5E4E71F0C5D27008C1A49 /* dragstart-clear-selection.html */,
                                 F4194AD01F5A2EA500ADD83F /* drop-targets.html */,
+                                2EB29D5D1F762DA50023A5F1 /* dump-datatransfer-types.html */,
                                 A155022B1E050BC500A24C57 /* duplicate-completion-handler-calls.html */,
                                 9984FACD1CFFB038008D198C /* editable-body.html */,

trunk/Tools/TestWebKitAPI/Tests/ios/DataInteractionTests.mm

@@ -126 +126 @@
 }
 
-static void checkTypeIdentifierAndIsNotOtherTypeIdentifier(DataInteractionSimulator *simulator, NSString *firstType, NSString *secondType)
+static void checkFirstTypeIsPresentAndSecondTypeIsMissing(DataInteractionSimulator *simulator, CFStringRef firstType, CFStringRef secondType)
 {
     NSArray *registeredTypes = [simulator.sourceItemProviders.firstObject registeredTypeIdentifiers];
-    EXPECT_TRUE([registeredTypes containsObject:firstType]);
-    EXPECT_FALSE([registeredTypes containsObject:secondType]);
+    EXPECT_TRUE([registeredTypes containsObject:(NSString *)firstType]);
+    EXPECT_FALSE([registeredTypes containsObject:(NSString *)secondType]);
 }
 
@@ -175 +175 @@
 }
 
+#if __IPHONE_OS_VERSION_MIN_REQUIRED >= 110300
+
+static void checkJSONWithLogging(NSString *jsonString, NSDictionary *expected)
+{
+    BOOL success = TestWebKitAPI::Util::jsonMatchesExpectedValues(jsonString, expected);
+    EXPECT_TRUE(success);
+    if (!success)
+        NSLog(@"Expected JSON: %@ to match values: %@", jsonString, expected);
+}
+
+#endif // __IPHONE_OS_VERSION_MIN_REQUIRED >= 110300
+
 static void runTestWithTemporaryTextFile(void(^runTest)(NSURL *fileURL))
 {
@@ -241 +253 @@
     EXPECT_TRUE([observedEventNames containsObject:DataInteractionPerformOperationEventName]);
     checkSelectionRectsWithLogging(@[ makeCGRectValue(1, 201, 215, 174) ], [dataInteractionSimulator finalSelectionRects]);
-    checkTypeIdentifierAndIsNotOtherTypeIdentifier(dataInteractionSimulator.get(), (NSString *)kUTTypePNG, (NSString *)kUTTypeFileURL);
+    checkFirstTypeIsPresentAndSecondTypeIsMissing(dataInteractionSimulator.get(), kUTTypePNG, kUTTypeFileURL);
     checkEstimatedSize(dataInteractionSimulator.get(), { 215, 174 });
 }
@@ -271 +283 @@
     EXPECT_TRUE([observedEventNames containsObject:DataInteractionOverEventName]);
     EXPECT_TRUE([observedEventNames containsObject:DataInteractionPerformOperationEventName]);
-    checkTypeIdentifierAndIsNotOtherTypeIdentifier(dataInteractionSimulator.get(), (NSString *)kUTTypePNG, (NSString *)kUTTypeFileURL);
+    checkFirstTypeIsPresentAndSecondTypeIsMissing(dataInteractionSimulator.get(), kUTTypePNG, kUTTypeFileURL);
     checkEstimatedSize(dataInteractionSimulator.get(), { 215, 174 });
 }
@@ -1208 +1220 @@
     [dataInteractionSimulator runFrom:CGPointMake(200, 400) to:CGPointMake(200, 150)];
     EXPECT_WK_STREQ("PASS", [webView stringByEvaluatingJavaScript:@"target.textContent"].UTF8String);
-    checkTypeIdentifierAndIsNotOtherTypeIdentifier(dataInteractionSimulator.get(), (NSString *)kUTTypePNG, (NSString *)kUTTypeFileURL);
+    checkFirstTypeIsPresentAndSecondTypeIsMissing(dataInteractionSimulator.get(), kUTTypePNG, kUTTypeFileURL);
     checkEstimatedSize(dataInteractionSimulator.get(), { 2000, 2000 });
 }
@@ -1468 +1480 @@
 }
 
+#if __IPHONE_OS_VERSION_MIN_REQUIRED >= 110300
+
+TEST(DataInteractionTests, DataTransferGetDataWhenDroppingPlainText)
+{
+    auto webView = adoptNS([[TestWKWebView alloc] initWithFrame:CGRectMake(0, 0, 320, 500)]);
+    [webView synchronouslyLoadTestPageNamed:@"dump-datatransfer-types"];
+    auto simulator = adoptNS([[DataInteractionSimulator alloc] initWithWebView:webView.get()]);
+
+    [webView stringByEvaluatingJavaScript:@"select(plain)"];
+    [simulator runFrom:CGPointMake(50, 75) to:CGPointMake(50, 375)];
+    checkJSONWithLogging([webView stringByEvaluatingJavaScript:@"output.value"], @{
+        @"dragover": @{ @"text/plain" : @"" },
+        @"drop": @{ @"text/plain" : @"Plain text" }
+    });
+}
+
+TEST(DataInteractionTests, DataTransferGetDataWhenDroppingCustomData)
+{
+    auto webView = adoptNS([[TestWKWebView alloc] initWithFrame:CGRectMake(0, 0, 320, 500)]);
+    [webView synchronouslyLoadTestPageNamed:@"dump-datatransfer-types"];
+    auto simulator = adoptNS([[DataInteractionSimulator alloc] initWithWebView:webView.get()]);
+
+    [webView stringByEvaluatingJavaScript:@"select(rich)"];
+    [webView stringByEvaluatingJavaScript:@"writeCustomData = true"];
+    [simulator runFrom:CGPointMake(50, 225) to:CGPointMake(50, 375)];
+    checkJSONWithLogging([webView stringByEvaluatingJavaScript:@"output.value"], @{
+        @"dragover" : @{
+            @"text/plain" : @"",
+            @"foo/plain" : @"",
+            @"text/html" : @"",
+            @"bar/html" : @"",
+            @"text/uri-list" : @"",
+            @"baz/uri-list" : @""
+        },
+        @"drop" : @{
+            @"text/plain" : @"ben bitdiddle",
+            @"foo/plain" : @"eva lu ator",
+            @"text/html" : @"<b>bold text</b>",
+            @"bar/html" : @"<i>italic text</i>",
+            @"text/uri-list" : @"https://www.apple.com/",
+            @"baz/uri-list" : @"https://www.webkit.org"
+        }
+    });
+}
+
+TEST(DataInteractionTests, DataTransferGetDataWhenDroppingURL)
+{
+    auto webView = adoptNS([[TestWKWebView alloc] initWithFrame:CGRectMake(0, 0, 320, 500)]);
+    [webView synchronouslyLoadTestPageNamed:@"dump-datatransfer-types"];
+    auto simulator = adoptNS([[DataInteractionSimulator alloc] initWithWebView:webView.get()]);
+
+    [webView stringByEvaluatingJavaScript:@"rich.innerHTML = '<a href=\"https://www.apple.com/\">This is a link.</a>'"];
+    [simulator runFrom:CGPointMake(50, 225) to:CGPointMake(50, 375)];
+    checkJSONWithLogging([webView stringByEvaluatingJavaScript:@"output.value"], @{
+        @"dragover": @{ @"text/uri-list" : @"" },
+        @"drop": @{ @"text/uri-list" : @"https://www.apple.com/" }
+    });
+}
+
+TEST(DataInteractionTests, DataTransferGetDataWhenDroppingImageWithFileURL)
+{
+    auto webView = adoptNS([[TestWKWebView alloc] initWithFrame:CGRectMake(0, 0, 320, 500)]);
+    [webView synchronouslyLoadTestPageNamed:@"dump-datatransfer-types"];
+    auto simulator = adoptNS([[DataInteractionSimulator alloc] initWithWebView:webView.get()]);
+
+    auto itemProvider = adoptNS([[UIItemProvider alloc] init]);
+    NSURL *iconURL = [[NSBundle mainBundle] URLForResource:@"icon" withExtension:@"png" subdirectory:@"TestWebKitAPI.resources"];
+    [itemProvider registerFileRepresentationForTypeIdentifier:(NSString *)kUTTypePNG fileOptions:0 visibility:NSItemProviderRepresentationVisibilityAll loadHandler:[protectedIconURL = retainPtr(iconURL)] (FileLoadCompletionBlock completionHandler) -> NSProgress * {
+        completionHandler(protectedIconURL.get(), NO, nil);
+        return nil;
+    }];
+    [itemProvider registerObject:iconURL visibility:UIItemProviderRepresentationOptionsVisibilityAll];
+    [simulator setExternalItemProviders:@[ itemProvider.get() ]];
+
+    [simulator runFrom:CGPointMake(300, 375) to:CGPointMake(50, 375)];
+
+    // File URLs should never be exposed directly to web content, so DataTransfer.getData should return an empty string here.
+    checkJSONWithLogging([webView stringByEvaluatingJavaScript:@"output.value"], @{
+        @"dragover": @{ @"text/uri-list" : @"" },
+        @"drop": @{ @"text/uri-list" : @"" }
+    });
+}
+
+TEST(DataInteractionTests, DataTransferGetDataWhenDroppingRespectsPresentationStyle)
+{
+    auto webView = adoptNS([[TestWKWebView alloc] initWithFrame:CGRectMake(0, 0, 320, 500)]);
+    [webView synchronouslyLoadTestPageNamed:@"dump-datatransfer-types"];
+    auto simulator = adoptNS([[DataInteractionSimulator alloc] initWithWebView:webView.get()]);
+
+    runTestWithTemporaryTextFile(^(NSURL *fileURL) {
+        auto itemProvider = adoptNS([[UIItemProvider alloc] init]);
+        [itemProvider registerFileRepresentationForTypeIdentifier:(NSString *)kUTTypeUTF8PlainText fileOptions:0 visibility:NSItemProviderRepresentationVisibilityAll loadHandler:[protectedFileURL = retainPtr(fileURL)] (FileLoadCompletionBlock completionHandler) -> NSProgress * {
+            completionHandler(protectedFileURL.get(), NO, nil);
+            return nil;
+        }];
+        [simulator setExternalItemProviders:@[ itemProvider.get() ]];
+
+        [itemProvider setPreferredPresentationStyle:UIPreferredPresentationStyleAttachment];
+        [simulator runFrom:CGPointMake(300, 375) to:CGPointMake(50, 375)];
+        checkJSONWithLogging([webView stringByEvaluatingJavaScript:@"output.value"], @{
+            @"dragover": @{ @"text/plain" : @"" },
+            @"drop": @{ @"text/plain" : @"" }
+        });
+
+        [itemProvider setPreferredPresentationStyle:UIPreferredPresentationStyleInline];
+        [simulator runFrom:CGPointMake(300, 375) to:CGPointMake(50, 375)];
+        checkJSONWithLogging([webView stringByEvaluatingJavaScript:@"output.value"], @{
+            @"dragover": @{ @"text/plain" : @"" },
+            @"drop": @{ @"text/plain" : @"This is a tiny blob of text." }
+        });
+    });
+}
+
+TEST(DataInteractionTests, DataTransferSetDataCannotWritePlatformTypes)
+{
+    auto webView = adoptNS([[TestWKWebView alloc] initWithFrame:CGRectMake(0, 0, 320, 500)]);
+    [webView synchronouslyLoadTestPageNamed:@"dump-datatransfer-types"];
+    auto simulator = adoptNS([[DataInteractionSimulator alloc] initWithWebView:webView.get()]);
+
+    [webView stringByEvaluatingJavaScript:@"select(rich)"];
+    [webView stringByEvaluatingJavaScript:@"customData = { 'text/plain' : 'foo', 'com.adobe.pdf' : 'try and decode me!' }"];
+    [webView stringByEvaluatingJavaScript:@"writeCustomData = true"];
+
+    [simulator runFrom:CGPointMake(50, 225) to:CGPointMake(50, 375)];
+    checkFirstTypeIsPresentAndSecondTypeIsMissing(simulator.get(), kUTTypeUTF8PlainText, kUTTypePDF);
+    checkJSONWithLogging([webView stringByEvaluatingJavaScript:@"output.value"], @{
+        @"dragover": @{
+            @"text/plain": @"",
+            @"com.adobe.pdf": @""
+        },
+        @"drop": @{
+            @"text/plain": @"foo",
+            @"com.adobe.pdf": @"try and decode me!"
+        }
+    });
+}
+
+TEST(DataInteractionTests, DataTransferGetDataCannotReadPrivateArbitraryTypes)
+{
+    auto webView = adoptNS([[TestWKWebView alloc] initWithFrame:CGRectMake(0, 0, 320, 500)]);
+    [webView synchronouslyLoadTestPageNamed:@"dump-datatransfer-types"];
+    auto simulator = adoptNS([[DataInteractionSimulator alloc] initWithWebView:webView.get()]);
+
+    auto itemProvider = adoptNS([[UIItemProvider alloc] init]);
+    [itemProvider registerDataRepresentationForTypeIdentifier:(NSString *)kUTTypeMP3 visibility:NSItemProviderRepresentationVisibilityAll loadHandler:^NSProgress *(DataLoadCompletionBlock completionHandler)
+    {
+        completionHandler([@"this is a test" dataUsingEncoding:NSUTF8StringEncoding], nil);
+        return nil;
+    }];
+    [itemProvider registerDataRepresentationForTypeIdentifier:@"org.WebKit.TestWebKitAPI.custom-pasteboard-type" visibility:NSItemProviderRepresentationVisibilityAll loadHandler:^NSProgress *(DataLoadCompletionBlock completionHandler)
+    {
+        completionHandler([@"this is another test" dataUsingEncoding:NSUTF8StringEncoding], nil);
+        return nil;
+    }];
+    [simulator setExternalItemProviders:@[ itemProvider.get() ]];
+    [itemProvider setPreferredPresentationStyle:UIPreferredPresentationStyleInline];
+    [simulator runFrom:CGPointMake(300, 375) to:CGPointMake(50, 375)];
+    checkJSONWithLogging([webView stringByEvaluatingJavaScript:@"output.value"], @{
+        @"dragover": @{ },
+        @"drop": @{ }
+    });
+}
+
+#endif // __IPHONE_OS_VERSION_MIN_REQUIRED >= 110300
+
 } // namespace TestWebKitAPI
 

trunk/Tools/TestWebKitAPI/Tests/ios/UIPasteboardTests.mm

@@ -37 +37 @@
 #import <wtf/SoftLinking.h>
 
+typedef void (^DataLoadCompletionBlock)(NSData *, NSError *);
+
+#if __IPHONE_OS_VERSION_MIN_REQUIRED >= 110300
+
+static void checkJSONWithLogging(NSString *jsonString, NSDictionary *expected)
+{
+    BOOL success = TestWebKitAPI::Util::jsonMatchesExpectedValues(jsonString, expected);
+    EXPECT_TRUE(success);
+    if (!success)
+        NSLog(@"Expected JSON: %@ to match values: %@", jsonString, expected);
+}
+
+#endif // __IPHONE_OS_VERSION_MIN_REQUIRED >= 110300
+
 namespace TestWebKitAPI {
 
@@ -44 +58 @@
 }
 
-RetainPtr<TestWKWebView> setUpWebViewForPasteboardTests()
+RetainPtr<TestWKWebView> setUpWebViewForPasteboardTests(NSString *pageName)
 {
     // UIPasteboard's type coercion codepaths only take effect when the UIApplication has been initialized.
@@ -57 +71 @@
     preferences._javaScriptCanAccessClipboard = YES;
     preferences._domPasteAllowed = YES;
-    [webView synchronouslyLoadTestPageNamed:@"rich-and-plain-text"];
+    [webView synchronouslyLoadTestPageNamed:pageName];
     return webView;
 }
@@ -63 +77 @@
 TEST(UIPasteboardTests, CopyPlainTextWritesConcreteTypes)
 {
-    auto webView = setUpWebViewForPasteboardTests();
+    auto webView = setUpWebViewForPasteboardTests(@"rich-and-plain-text");
     [webView stringByEvaluatingJavaScript:@"selectPlainText()"];
     [webView stringByEvaluatingJavaScript:@"document.execCommand('copy')"];
@@ -73 +87 @@
 TEST(UIPasteboardTests, CopyRichTextWritesConcreteTypes)
 {
-    auto webView = setUpWebViewForPasteboardTests();
+    auto webView = setUpWebViewForPasteboardTests(@"rich-and-plain-text");
     [webView stringByEvaluatingJavaScript:@"selectRichText()"];
     [webView stringByEvaluatingJavaScript:@"document.execCommand('copy')"];
@@ -81 +95 @@
 }
 
-#if __IPHONE_OS_VERSION_MIN_REQUIRED >= 110000
-
 TEST(UIPasteboardTests, DoNotPastePlainTextAsURL)
 {
-    auto webView = setUpWebViewForPasteboardTests();
+    auto webView = setUpWebViewForPasteboardTests(@"rich-and-plain-text");
 
     NSString *testString = @"[helloworld]";
@@ -102 +114 @@
 TEST(UIPasteboardTests, PastePlainTextAsURL)
 {
-    auto webView = setUpWebViewForPasteboardTests();
+    auto webView = setUpWebViewForPasteboardTests(@"rich-and-plain-text");
 
     NSString *testString = @"https://www.apple.com/iphone";
@@ -119 +131 @@
 TEST(UIPasteboardTests, PasteURLWithPlainTextAsURL)
 {
-    auto webView = setUpWebViewForPasteboardTests();
+    auto webView = setUpWebViewForPasteboardTests(@"rich-and-plain-text");
 
     NSString *testString = @"thisisdefinitelyaurl";
@@ -134 +146 @@
 }
 
-#endif // __IPHONE_OS_VERSION_MIN_REQUIRED >= 110000
+#if __IPHONE_OS_VERSION_MIN_REQUIRED >= 110300
+
+TEST(UIPasteboardTests, DataTransferGetDataWhenPastingURL)
+{
+    auto webView = setUpWebViewForPasteboardTests(@"dump-datatransfer-types");
+
+    NSString *testURLString = @"https://www.apple.com/";
+    [UIPasteboard generalPasteboard].URL = [NSURL URLWithString:testURLString];
+
+    [webView stringByEvaluatingJavaScript:@"destination.focus()"];
+    [webView stringByEvaluatingJavaScript:@"document.execCommand('paste')"];
+    checkJSONWithLogging([webView stringByEvaluatingJavaScript:@"output.value"], @{
+        @"paste" : @{
+            @"text/plain" : testURLString,
+            @"text/uri-list" : testURLString
+        }
+    });
+}
+
+TEST(UIPasteboardTests, DataTransferGetDataWhenPastingPlatformRepresentations)
+{
+    auto webView = setUpWebViewForPasteboardTests(@"dump-datatransfer-types");
+
+    // This simulates how a native app on iOS might write to the pasteboard when copying.
+    RetainPtr<NSURL> testURL = [NSURL URLWithString:@"https://www.apple.com/"];
+    RetainPtr<NSString> testPlainTextString = @"WebKit";
+    RetainPtr<NSString> testMarkupString = @"<a href='https://www.webkit.org/'>The WebKit Project</a>";
+    auto itemProvider = adoptNS([[NSItemProvider alloc] init]);
+    [itemProvider registerDataRepresentationForTypeIdentifier:(NSString *)kUTTypeHTML visibility:NSItemProviderRepresentationVisibilityAll loadHandler:^NSProgress *(DataLoadCompletionBlock completionHandler)
+    {
+        completionHandler([testMarkupString dataUsingEncoding:NSUTF8StringEncoding], nil);
+        return nil;
+    }];
+    [itemProvider registerObject:testURL.get() visibility:NSItemProviderRepresentationVisibilityAll];
+    [itemProvider registerObject:testPlainTextString.get() visibility:NSItemProviderRepresentationVisibilityAll];
+
+    [UIPasteboard generalPasteboard].itemProviders = @[ itemProvider.get() ];
+    [webView stringByEvaluatingJavaScript:@"destination.focus()"];
+    [webView stringByEvaluatingJavaScript:@"document.execCommand('paste')"];
+    checkJSONWithLogging([webView stringByEvaluatingJavaScript:@"output.value"], @{
+        @"paste" : @{
+            @"text/plain" : testPlainTextString.get(),
+            @"text/uri-list" : [testURL absoluteString],
+            @"text/html" : testMarkupString.get()
+        }
+    });
+}
+
+TEST(UIPasteboardTests, DataTransferSetDataCannotWritePlatformTypes)
+{
+    auto webView = setUpWebViewForPasteboardTests(@"dump-datatransfer-types");
+
+    [webView stringByEvaluatingJavaScript:@"customData = { 'text/plain' : '年年年', '年年年年年年' : 'test', 'com.adobe.pdf' : '🔥🔥🔥', 'text/rtf' : 'not actually rich text!' }"];
+    [webView stringByEvaluatingJavaScript:@"writeCustomData = true"];
+    [webView stringByEvaluatingJavaScript:@"select(rich)"];
+    [webView stringByEvaluatingJavaScript:@"document.execCommand('copy')"];
+    [webView stringByEvaluatingJavaScript:@"destination.focus()"];
+    [webView stringByEvaluatingJavaScript:@"document.execCommand('paste')"];
+    checkJSONWithLogging([webView stringByEvaluatingJavaScript:@"output.value"], @{
+        @"paste": @{
+            @"text/plain": @"年年年",
+            @"年年年年年年": @"test",
+            @"com.adobe.pdf": @"🔥🔥🔥",
+            @"text/rtf": @"not actually rich text!"
+        }
+    });
+
+    // Most importantly, the system pasteboard should not contain the PDF UTI.
+    NSData *pdfData = [[UIPasteboard generalPasteboard] dataForPasteboardType:(NSString *)kUTTypePDF];
+    EXPECT_EQ(0UL, pdfData.length);
+
+    // However, the system pasteboard should contain a plain text string.
+    EXPECT_WK_STREQ("年年年", [UIPasteboard generalPasteboard].string);
+}
+
+TEST(UIPasteboardTests, DataTransferGetDataCannotReadArbitraryPlatformTypes)
+{
+    auto webView = setUpWebViewForPasteboardTests(@"dump-datatransfer-types");
+    auto itemProvider = adoptNS([[NSItemProvider alloc] init]);
+    [itemProvider registerDataRepresentationForTypeIdentifier:(NSString *)kUTTypeMP3 visibility:NSItemProviderRepresentationVisibilityAll loadHandler:^NSProgress *(DataLoadCompletionBlock completionHandler)
+    {
+        completionHandler([@"this is a test" dataUsingEncoding:NSUTF8StringEncoding], nil);
+        return nil;
+    }];
+    [itemProvider registerDataRepresentationForTypeIdentifier:@"org.WebKit.TestWebKitAPI.custom-pasteboard-type" visibility:NSItemProviderRepresentationVisibilityAll loadHandler:^NSProgress *(DataLoadCompletionBlock completionHandler)
+    {
+        completionHandler([@"this is another test" dataUsingEncoding:NSUTF8StringEncoding], nil);
+        return nil;
+    }];
+
+    [webView stringByEvaluatingJavaScript:@"destination.focus()"];
+    [webView stringByEvaluatingJavaScript:@"document.execCommand('paste')"];
+    checkJSONWithLogging([webView stringByEvaluatingJavaScript:@"output.value"], @{
+        @"paste": @{ }
+    });
+}
+
+#endif // __IPHONE_OS_VERSION_MIN_REQUIRED >= 110300
 
 } // namespace TestWebKitAPI

trunk/Tools/TestWebKitAPI/cocoa/PlatformUtilitiesCocoa.mm

@@ -45 +45 @@
 }
 
+bool jsonMatchesExpectedValues(NSString *jsonString, NSDictionary *expected)
+{
+    NSError *error = nil;
+    id result = [NSJSONSerialization JSONObjectWithData:[jsonString dataUsingEncoding:NSUTF8StringEncoding] options:0 error:&error];
+    if (error)
+        NSLog(@"Encountered error: %@ while serializing JSON string.", error);
+    return [expected isEqualToDictionary:result];
+}
+
 #if WK_API_ENABLED
 NSString * const TestPlugInClassNameParameter = @"TestPlugInPrincipalClassName";