[iOSMac] Unable to upload non-image files using drag and drop in WKWebView
authorwenson_hsieh@apple.com <wenson_hsieh@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Mon, 3 Dec 2018 15:42:12 +0000 (15:42 +0000)
committerwenson_hsieh@apple.com <wenson_hsieh@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Mon, 3 Dec 2018 15:42:12 +0000 (15:42 +0000)
https://bugs.webkit.org/show_bug.cgi?id=192283
<rdar://problem/46399461>

Reviewed by Ryosuke Niwa.

Source/WebCore:

Currently on iOS, file URLs aren't generally written to the pasteboard during drag and drop unless the
application providing the data explicitly registers "public.file-url" to item providers. As such, our current
logic on iOS for handling drops does not attempt to prevent "public.file-url" from being advertised as the
"text/uri-list" MIME type in DataTransfer, though we do currently succeed in suppressing access to the file URL.

However, on iOSMac, the scenario in which file URLs are registered to item providers becomes pertinent when
uploading files from other macOS apps (e.g. Finder) into a WKWebView running in iOSMac. Furthermore, the
`preferredPresentationStyle` flag on `NSItemProvider` is unavailable in iOSMac; currently, this flag is our
primary cue on iOS that an item should be treated as an attachment rather than inline data. In order to support
file uploads in iOSMac, we make several adjustments to drop handling logic in iOS to handle the case where the
"public.file-url" type is registered. See below for more details.

Tests:  DragAndDropTests.DataTransferExposePlainTextWithFileURLAsFile
        DragAndDropTests.DataTransferGetDataWhenDroppingImageWithFileURL

* platform/PasteboardItemInfo.h:
(WebCore::PasteboardItemInfo::encode const):
(WebCore::PasteboardItemInfo::decode):

Add a new flag that is set if and only if the item provider contains the "public.file-url" type, and also
contains some non-URL data type that conforms to one of the file types supported for file uploads (i.e.
"public.content", zip archives, and folders).

* platform/cocoa/PasteboardCocoa.mm:
(WebCore::Pasteboard::fileContentState):

Consider the pasteboard to contain files in the case where one or more of the items contains a file URL, along
with some other pasteboard data that can be represented as a file upload.

* platform/ios/PlatformPasteboardIOS.mm:
(WebCore::PlatformPasteboard::informationForItemAtIndex):
(WebCore::PlatformPasteboard::typesSafeForDOMToReadAndWrite const):

If the pasteboard contains "public.file-url", don't consider "text/uri-list" to be one of the data types that's
safe to expose to the page. Our current behavior in this case is that we will advertise "text/uri-list" as a
pasteboard type in the DataTransfer, but if the page attempts to request this information, we simply return the
empty string. Instead, we shouldn't expose "text/uri-list" as a type in the first place.

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

Add a few more `__bridge`-ing casts where appropriate.

(typeConformsToTypes):

Move this further up the file so that it can be used in `NSItemProvider (WebCoreExtras)`.

(-[NSItemProvider web_containsFileURLAndFileUploadContent]):

Add a helper method on NSItemProvider to determine whether an item provider has a file URL, as well as a content
type suitable for file uploads.

(-[WebItemProviderLoadResult canBeRepresentedAsFileUpload]):

This currently always returns `NO` in iOSMac; instead, return `YES` on both iOS and iOSMac in the case where the
item provider contains a file URL and content which may be uploaded.

(-[WebItemProviderPasteboard preferredFileUploadURLAtIndex:fileType:]):
(-[WebItemProviderPasteboard typeIdentifiersToLoad:]):

Refactor this to take an `NSItemProvider` instead of a list of type identifiers, and bail out of loading data
for "public.url" if the item provider contains a file URL.

(-[WebItemProviderPasteboard doAfterLoadingProvidedContentIntoFileURLs:synchronousTimeout:]):
(-[WebItemProviderPasteboard typeIdentifiersToLoadForRegisteredTypeIdentifiers:]): Deleted.

Tools:

Add a new API test to check that an item provider which contains plain text data and a file URL (but is not
marked as an attachment) is still treated as an attachment upon drop. Furthermore, verify that "text/uri-list"
does not expose the actual file URL written to the item provider.

Additionally, rebaseline an existing API test to remove an extraneous "text/uri-list" type that appears in
`DataTransfer.types`, but whose data is inaccessible via `getData` anyways.

* TestWebKitAPI/Tests/ios/DragAndDropTestsIOS.mm:

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@238795 268f45cc-cd09-0410-ab3c-d52691b4dbfc

Source/WebCore/ChangeLog
Source/WebCore/platform/PasteboardItemInfo.h
Source/WebCore/platform/cocoa/PasteboardCocoa.mm
Source/WebCore/platform/ios/PlatformPasteboardIOS.mm
Source/WebCore/platform/ios/WebItemProviderPasteboard.h
Source/WebCore/platform/ios/WebItemProviderPasteboard.mm
Tools/ChangeLog
Tools/TestWebKitAPI/Tests/ios/DragAndDropTestsIOS.mm

index d1ac56f..6cbbea1 100644 (file)
@@ -1,3 +1,77 @@
+2018-12-03  Wenson Hsieh  <wenson_hsieh@apple.com>
+
+        [iOSMac] Unable to upload non-image files using drag and drop in WKWebView
+        https://bugs.webkit.org/show_bug.cgi?id=192283
+        <rdar://problem/46399461>
+
+        Reviewed by Ryosuke Niwa.
+
+        Currently on iOS, file URLs aren't generally written to the pasteboard during drag and drop unless the
+        application providing the data explicitly registers "public.file-url" to item providers. As such, our current
+        logic on iOS for handling drops does not attempt to prevent "public.file-url" from being advertised as the
+        "text/uri-list" MIME type in DataTransfer, though we do currently succeed in suppressing access to the file URL.
+
+        However, on iOSMac, the scenario in which file URLs are registered to item providers becomes pertinent when
+        uploading files from other macOS apps (e.g. Finder) into a WKWebView running in iOSMac. Furthermore, the
+        `preferredPresentationStyle` flag on `NSItemProvider` is unavailable in iOSMac; currently, this flag is our
+        primary cue on iOS that an item should be treated as an attachment rather than inline data. In order to support
+        file uploads in iOSMac, we make several adjustments to drop handling logic in iOS to handle the case where the
+        "public.file-url" type is registered. See below for more details.
+
+        Tests:  DragAndDropTests.DataTransferExposePlainTextWithFileURLAsFile
+                DragAndDropTests.DataTransferGetDataWhenDroppingImageWithFileURL
+
+        * platform/PasteboardItemInfo.h:
+        (WebCore::PasteboardItemInfo::encode const):
+        (WebCore::PasteboardItemInfo::decode):
+
+        Add a new flag that is set if and only if the item provider contains the "public.file-url" type, and also
+        contains some non-URL data type that conforms to one of the file types supported for file uploads (i.e.
+        "public.content", zip archives, and folders).
+
+        * platform/cocoa/PasteboardCocoa.mm:
+        (WebCore::Pasteboard::fileContentState):
+
+        Consider the pasteboard to contain files in the case where one or more of the items contains a file URL, along
+        with some other pasteboard data that can be represented as a file upload.
+
+        * platform/ios/PlatformPasteboardIOS.mm:
+        (WebCore::PlatformPasteboard::informationForItemAtIndex):
+        (WebCore::PlatformPasteboard::typesSafeForDOMToReadAndWrite const):
+
+        If the pasteboard contains "public.file-url", don't consider "text/uri-list" to be one of the data types that's
+        safe to expose to the page. Our current behavior in this case is that we will advertise "text/uri-list" as a
+        pasteboard type in the DataTransfer, but if the page attempts to request this information, we simply return the
+        empty string. Instead, we shouldn't expose "text/uri-list" as a type in the first place.
+
+        * platform/ios/WebItemProviderPasteboard.h:
+        * platform/ios/WebItemProviderPasteboard.mm:
+
+        Add a few more `__bridge`-ing casts where appropriate.
+
+        (typeConformsToTypes):
+
+        Move this further up the file so that it can be used in `NSItemProvider (WebCoreExtras)`.
+
+        (-[NSItemProvider web_containsFileURLAndFileUploadContent]):
+
+        Add a helper method on NSItemProvider to determine whether an item provider has a file URL, as well as a content
+        type suitable for file uploads.
+
+        (-[WebItemProviderLoadResult canBeRepresentedAsFileUpload]):
+
+        This currently always returns `NO` in iOSMac; instead, return `YES` on both iOS and iOSMac in the case where the
+        item provider contains a file URL and content which may be uploaded.
+
+        (-[WebItemProviderPasteboard preferredFileUploadURLAtIndex:fileType:]):
+        (-[WebItemProviderPasteboard typeIdentifiersToLoad:]):
+
+        Refactor this to take an `NSItemProvider` instead of a list of type identifiers, and bail out of loading data
+        for "public.url" if the item provider contains a file URL.
+
+        (-[WebItemProviderPasteboard doAfterLoadingProvidedContentIntoFileURLs:synchronousTimeout:]):
+        (-[WebItemProviderPasteboard typeIdentifiersToLoadForRegisteredTypeIdentifiers:]): Deleted.
+
 2018-12-02  Zalan Bujtas  <zalan@apple.com>
 
         Add a runtime feature flag for LayoutFormattingContext.
index e11743d..bd59962 100644 (file)
@@ -41,6 +41,7 @@ struct PasteboardItemInfo {
     String contentTypeForFileUpload;
     String suggestedFileName;
     bool isNonTextType { false };
+    bool containsFileURLAndFileUploadContent { false };
     PasteboardItemPresentationStyle preferredPresentationStyle { PasteboardItemPresentationStyle::Unspecified };
 
     template<class Encoder> void encode(Encoder&) const;
@@ -50,7 +51,7 @@ struct PasteboardItemInfo {
 template<class Encoder>
 void PasteboardItemInfo::encode(Encoder& encoder) const
 {
-    encoder << pathForFileUpload << contentTypeForFileUpload << suggestedFileName << isNonTextType;
+    encoder << pathForFileUpload << contentTypeForFileUpload << suggestedFileName << isNonTextType << containsFileURLAndFileUploadContent;
     encoder.encodeEnum(preferredPresentationStyle);
 }
 
@@ -70,6 +71,9 @@ std::optional<PasteboardItemInfo> PasteboardItemInfo::decode(Decoder& decoder)
     if (!decoder.decode(result.isNonTextType))
         return std::nullopt;
 
+    if (!decoder.decode(result.containsFileURLAndFileUploadContent))
+        return std::nullopt;
+
     if (!decoder.decodeEnum(result.preferredPresentationStyle))
         return std::nullopt;
 
index 3e487ba..250a2af 100644 (file)
@@ -162,7 +162,7 @@ Pasteboard::FileContentState Pasteboard::fileContentState()
             if (item.preferredPresentationStyle != PasteboardItemPresentationStyle::Unspecified)
                 return item.preferredPresentationStyle == PasteboardItemPresentationStyle::Attachment;
 
-            return !item.suggestedFileName.isEmpty() || item.isNonTextType;
+            return !item.suggestedFileName.isEmpty() || item.isNonTextType || item.containsFileURLAndFileUploadContent;
         });
     }
 #endif
index b049147..58f0534 100644 (file)
@@ -154,6 +154,7 @@ PasteboardItemInfo PlatformPasteboard::informationForItemAtIndex(int index)
 #if PASTEBOARD_SUPPORTS_PRESENTATION_STYLE_AND_TEAM_DATA
     info.preferredPresentationStyle = pasteboardItemPresentationStyle(itemProvider.preferredPresentationStyle);
 #endif
+    info.containsFileURLAndFileUploadContent = itemProvider.web_containsFileURLAndFileUploadContent;
     info.suggestedFileName = itemProvider.suggestedName;
     for (NSString *typeIdentifier in itemProvider.registeredTypeIdentifiers) {
         CFStringRef cfTypeIdentifier = (CFStringRef)typeIdentifier;
@@ -531,6 +532,9 @@ Vector<String> PlatformPasteboard::typesSafeForDOMToReadAndWrite(const String& o
                 BOOL ableToDetermineProtocolOfPasteboardURL = ![m_pasteboard isKindOfClass:[WebItemProviderPasteboard class]];
                 if (ableToDetermineProtocolOfPasteboardURL && stringForType(kUTTypeURL).isEmpty())
                     continue;
+
+                if ([[m_pasteboard pasteboardTypes] containsObject:(__bridge NSString *)kUTTypeFileURL])
+                    continue;
             }
             domPasteboardTypes.add(WTFMove(domTypeAsString));
         }
index 1f1af86..e2a6c9a 100644 (file)
@@ -37,6 +37,10 @@ typedef NS_ENUM(NSInteger, WebPreferredPresentationStyle) {
 
 NS_ASSUME_NONNULL_BEGIN
 
+@interface NSItemProvider (WebCoreExtras)
+@property (nonatomic, readonly) BOOL web_containsFileURLAndFileUploadContent;
+@end
+
 /*! A WebItemProviderRegistrar encapsulates a single call to register something to an item provider.
  @discussion Classes that implement this protocol each represent a different way of writing data to
  an item provider. Some examples include setting a chunk of data corresponding to a type identifier,
index 9fdf6eb..c7b75a5 100644 (file)
@@ -53,6 +53,39 @@ typedef NSMutableDictionary<NSString *, NSURL *> TypeToFileURLMap;
 using WebCore::Pasteboard;
 using WebCore::PasteboardCustomData;
 
+static BOOL typeConformsToTypes(NSString *type, NSArray *conformsToTypes)
+{
+    for (NSString *conformsToType in conformsToTypes) {
+        if (UTTypeConformsTo((__bridge CFStringRef)type, (__bridge CFStringRef)conformsToType))
+            return YES;
+    }
+    return NO;
+}
+
+@implementation NSItemProvider (WebCoreExtras)
+
+- (BOOL)web_containsFileURLAndFileUploadContent
+{
+    BOOL containsFileURL = NO;
+    BOOL containsContentForFileUpload = NO;
+    for (NSString *identifier in self.registeredTypeIdentifiers) {
+        if (UTTypeConformsTo((__bridge CFStringRef)identifier, kUTTypeFileURL)) {
+            containsFileURL = YES;
+            continue;
+        }
+
+        if (UTTypeConformsTo((__bridge CFStringRef)identifier, kUTTypeURL))
+            continue;
+
+        containsContentForFileUpload |= typeConformsToTypes(identifier, Pasteboard::supportedFileUploadPasteboardTypes());
+        if (containsContentForFileUpload && containsFileURL)
+            return YES;
+    }
+    return NO;
+}
+
+@end
+
 @interface WebItemProviderDataRegistrar : NSObject <WebItemProviderRegistrar>
 - (instancetype)initWithData:(NSData *)data type:(NSString *)utiType;
 @property (nonatomic, readonly) NSString *typeIdentifier;
@@ -342,8 +375,11 @@ static UIPreferredPresentationStyle uiPreferredPresentationStyle(WebPreferredPre
 
 - (BOOL)canBeRepresentedAsFileUpload
 {
+    if ([_itemProvider web_containsFileURLAndFileUploadContent])
+        return YES;
+
 #if PLATFORM(IOSMAC)
-    return false;
+    return NO;
 #else
     return [_itemProvider preferredPresentationStyle] != UIPreferredPresentationStyleInline;
 #endif
@@ -606,11 +642,11 @@ static Class classForTypeIdentifier(NSString *typeIdentifier, NSString *&outType
     NSItemProvider *itemProvider = [result itemProvider];
     for (NSString *registeredTypeIdentifier in itemProvider.registeredTypeIdentifiers) {
         // Search for the highest fidelity non-private type identifier we loaded from the item provider.
-        if (!UTTypeIsDeclared((CFStringRef)registeredTypeIdentifier) && !UTTypeIsDynamic((CFStringRef)registeredTypeIdentifier))
+        if (!UTTypeIsDeclared((__bridge CFStringRef)registeredTypeIdentifier) && !UTTypeIsDynamic((__bridge CFStringRef)registeredTypeIdentifier))
             continue;
 
         for (NSString *loadedTypeIdentifier in [result loadedTypeIdentifiers]) {
-            if (!UTTypeConformsTo((CFStringRef)registeredTypeIdentifier, (CFStringRef)loadedTypeIdentifier))
+            if (!UTTypeConformsTo((__bridge CFStringRef)registeredTypeIdentifier, (__bridge CFStringRef)loadedTypeIdentifier))
                 continue;
 
             if (outFileType)
@@ -632,16 +668,6 @@ static Class classForTypeIdentifier(NSString *typeIdentifier, NSString *&outType
     return fileURLs;
 }
 
-static BOOL typeConformsToTypes(NSString *type, NSArray *conformsToTypes)
-{
-    // A type is considered appropriate to load if it conforms to one or more supported types.
-    for (NSString *conformsToType in conformsToTypes) {
-        if (UTTypeConformsTo((CFStringRef)type, (CFStringRef)conformsToType))
-            return YES;
-    }
-    return NO;
-}
-
 - (NSInteger)numberOfFiles
 {
     NSArray *supportedFileTypes = Pasteboard::supportedFileUploadPasteboardTypes();
@@ -688,16 +714,18 @@ static NSURL *linkTemporaryItemProviderFilesToDropStagingDirectory(NSURL *url, N
     return [fileManager linkItemAtURL:url toURL:destination error:nil] ? destination : nil;
 }
 
-- (NSArray<NSString *> *)typeIdentifiersToLoadForRegisteredTypeIdentifiers:(NSArray<NSString *> *)registeredTypeIdentifiers
+- (NSArray<NSString *> *)typeIdentifiersToLoad:(NSItemProvider *)itemProvider
 {
     auto typesToLoad = adoptNS([[NSMutableOrderedSet alloc] init]);
     NSString *highestFidelitySupportedType = nil;
     NSString *highestFidelityContentType = nil;
 
-    BOOL containsFlatRTFD = [registeredTypeIdentifiers containsObject:(NSString *)kUTTypeFlatRTFD];
+    NSArray<NSString *> *registeredTypeIdentifiers = itemProvider.registeredTypeIdentifiers;
+    BOOL containsFile = itemProvider.web_containsFileURLAndFileUploadContent;
+    BOOL containsFlatRTFD = [registeredTypeIdentifiers containsObject:(__bridge NSString *)kUTTypeFlatRTFD];
     // First, search for the highest fidelity supported type or the highest fidelity generic content type.
     for (NSString *registeredTypeIdentifier in registeredTypeIdentifiers) {
-        if (containsFlatRTFD && [registeredTypeIdentifier isEqualToString:(NSString *)kUTTypeRTFD]) {
+        if (containsFlatRTFD && [registeredTypeIdentifier isEqualToString:(__bridge NSString *)kUTTypeRTFD]) {
             // In the case where attachments are enabled and we're accepting all types of content using attachment
             // elements as a fallback representation, if the source writes attributed strings to the pasteboard with
             // com.apple.rtfd at a higher fidelity than com.apple.flat-rtfd, we'll end up loading only com.apple.rtfd
@@ -707,6 +735,9 @@ static NSURL *linkTemporaryItemProviderFilesToDropStagingDirectory(NSURL *url, N
             continue;
         }
 
+        if (containsFile && UTTypeConformsTo((__bridge CFStringRef)registeredTypeIdentifier, kUTTypeURL))
+            continue;
+
         if (!highestFidelitySupportedType && typeConformsToTypes(registeredTypeIdentifier, _supportedTypeIdentifiers.get()))
             highestFidelitySupportedType = registeredTypeIdentifier;
 
@@ -721,9 +752,9 @@ static NSURL *linkTemporaryItemProviderFilesToDropStagingDirectory(NSURL *url, N
         if ([registeredTypeIdentifier isEqualToString:highestFidelityContentType]
             || [registeredTypeIdentifier isEqualToString:highestFidelitySupportedType]
             || [registeredTypeIdentifier isEqualToString:customPasteboardDataUTI]
-            || UTTypeConformsTo((CFStringRef)registeredTypeIdentifier, kUTTypeURL)
-            || UTTypeConformsTo((CFStringRef)registeredTypeIdentifier, kUTTypeHTML)
-            || UTTypeConformsTo((CFStringRef)registeredTypeIdentifier, kUTTypePlainText))
+            || (!containsFile && UTTypeConformsTo((__bridge CFStringRef)registeredTypeIdentifier, kUTTypeURL))
+            || UTTypeConformsTo((__bridge CFStringRef)registeredTypeIdentifier, kUTTypeHTML)
+            || UTTypeConformsTo((__bridge CFStringRef)registeredTypeIdentifier, kUTTypePlainText))
             [typesToLoad addObject:registeredTypeIdentifier];
     }
 
@@ -746,7 +777,7 @@ static NSURL *linkTemporaryItemProviderFilesToDropStagingDirectory(NSURL *url, N
     BOOL foundAnyDataToLoad = NO;
     RetainPtr<WebItemProviderPasteboard> protectedSelf = self;
     for (NSItemProvider *itemProvider in _itemProviders.get()) {
-        NSArray<NSString *> *typeIdentifiersToLoad = [protectedSelf typeIdentifiersToLoadForRegisteredTypeIdentifiers:itemProvider.registeredTypeIdentifiers];
+        NSArray<NSString *> *typeIdentifiersToLoad = [protectedSelf typeIdentifiersToLoad:itemProvider];
         foundAnyDataToLoad |= typeIdentifiersToLoad.count;
         [loadResults addObject:[WebItemProviderLoadResult loadResultWithItemProvider:itemProvider typesToLoad:typeIdentifiersToLoad]];
     }
index c1ea44c..96dd57f 100644 (file)
@@ -1,3 +1,20 @@
+2018-12-03  Wenson Hsieh  <wenson_hsieh@apple.com>
+
+        [iOSMac] Unable to upload non-image files using drag and drop in WKWebView
+        https://bugs.webkit.org/show_bug.cgi?id=192283
+        <rdar://problem/46399461>
+
+        Reviewed by Ryosuke Niwa.
+
+        Add a new API test to check that an item provider which contains plain text data and a file URL (but is not
+        marked as an attachment) is still treated as an attachment upon drop. Furthermore, verify that "text/uri-list"
+        does not expose the actual file URL written to the item provider.
+
+        Additionally, rebaseline an existing API test to remove an extraneous "text/uri-list" type that appears in
+        `DataTransfer.types`, but whose data is inaccessible via `getData` anyways.
+
+        * TestWebKitAPI/Tests/ios/DragAndDropTestsIOS.mm:
+
 2018-12-01  Don Olmstead  <don.olmstead@sony.com>
 
         Cleanup WebKit Features
index 29ef674..2c81e57 100644 (file)
@@ -1646,8 +1646,8 @@ TEST(DragAndDropTests, DataTransferGetDataWhenDroppingImageWithFileURL)
 
     // 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": @{ @"Files": @"", @"text/uri-list": @"" },
-        @"drop": @{ @"Files": @"", @"text/uri-list": @"" }
+        @"dragover": @{ @"Files": @"" },
+        @"drop": @{ @"Files": @"" }
     });
 }
 
@@ -1772,6 +1772,29 @@ TEST(DragAndDropTests, DataTransferSuppressGetDataDueToPresenceOfTextFile)
     EXPECT_WK_STREQ("('hello.txt', text/plain)", [webView stringByEvaluatingJavaScript:@"files.textContent"]);
 }
 
+TEST(DragAndDropTests, DataTransferExposePlainTextWithFileURLAsFile)
+{
+    auto webView = adoptNS([[TestWKWebView alloc] initWithFrame:CGRectMake(0, 0, 320, 500)]);
+    [webView synchronouslyLoadTestPageNamed:@"DataTransfer"];
+    auto simulator = adoptNS([[DragAndDropSimulator alloc] initWithWebView:webView.get()]);
+
+    auto itemProvider = adoptNS([[NSItemProvider alloc] init]);
+    NSData *urlAsData = [@"file:///some/file/path.txt" dataUsingEncoding:NSUTF8StringEncoding];
+    [itemProvider registerDataRepresentationForTypeIdentifier:(__bridge NSString *)kUTTypeFileURL withData:urlAsData];
+    [itemProvider registerDataRepresentationForTypeIdentifier:(__bridge NSString *)kUTTypeURL withData:urlAsData];
+    [itemProvider registerObject:@"Hello world" visibility:NSItemProviderRepresentationVisibilityAll];
+
+    [simulator setExternalItemProviders:@[ itemProvider.get() ]];
+    [simulator runFrom:CGPointZero to:CGPointMake(50, 100)];
+
+    EXPECT_WK_STREQ("Files", [webView stringByEvaluatingJavaScript:@"types.textContent"]);
+    EXPECT_WK_STREQ("", [webView stringByEvaluatingJavaScript:@"textData.textContent"]);
+    EXPECT_WK_STREQ("", [webView stringByEvaluatingJavaScript:@"urlData.textContent"]);
+    EXPECT_WK_STREQ("", [webView stringByEvaluatingJavaScript:@"htmlData.textContent"]);
+    EXPECT_WK_STREQ("(FILE, text/plain)", [webView stringByEvaluatingJavaScript:@"items.textContent"]);
+    EXPECT_WK_STREQ("('text.txt', text/plain)", [webView stringByEvaluatingJavaScript:@"files.textContent"]);
+}
+
 TEST(DragAndDropTests, DataTransferGetDataCannotReadPrivateArbitraryTypes)
 {
     auto webView = adoptNS([[TestWKWebView alloc] initWithFrame:CGRectMake(0, 0, 320, 500)]);