Fix webkitGetEntry for non-native files.

third_party/WebKit/Source/core/clipboard/DataObject.cpp

 /*
  * Copyright (c) 2008, 2009, 2012 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 88 matching lines @@
   if (!internalAddStringItem(item))
     return nullptr;
   return item;
 }
 
 DataObjectItem* DataObject::add(File* file) {
   if (!file)
     return nullptr;
 
   DataObjectItem* item = DataObjectItem::createFromFile(file);
-  m_itemList.append(item);
+  internalAddFileItem(item);
   return item;
 }
 
+DataObjectItem* DataObject::add(File* file, const String& fileSystemId) {
+  if (!file)
+    return nullptr;
+
+  DataObjectItem* item =
+      DataObjectItem::createFromFileWithFileSystemId(file, fileSystemId);
+  internalAddFileItem(item);
+  return item;
+}
+
 void DataObject::clearData(const String& type) {
   for (size_t i = 0; i < m_itemList.size(); ++i) {
     if (m_itemList[i]->kind() == DataObjectItem::StringKind &&
         m_itemList[i]->type() == type) {
       // Per the spec, type must be unique among all items of kind 'string'.
       m_itemList.remove(i);
       return;
     }
   }
 }
@@ skipping 76 matching lines @@
 Vector<String> DataObject::filenames() const {
   Vector<String> results;
   for (size_t i = 0; i < m_itemList.size(); ++i) {
     if (m_itemList[i]->isFilename())
       results.append(toFile(m_itemList[i]->getAsFile())->path());
   }
   return results;
 }
 
 void DataObject::addFilename(const String& filename,
-                             const String& displayName) {
-  internalAddFileItem(DataObjectItem::createFromFile(
-      File::createForUserProvidedFile(filename, displayName)));
+                             const String& displayName,
+                             const String& fileSystemId) {
+  internalAddFileItem(DataObjectItem::createFromFileWithFileSystemId(
+      File::createForUserProvidedFile(filename, displayName), fileSystemId));
 }
 
 void DataObject::addSharedBuffer(const String& name,
                                  PassRefPtr<SharedBuffer> buffer) {
   internalAddFileItem(
       DataObjectItem::createFromSharedBuffer(name, std::move(buffer)));
 }
 
 DataObject::DataObject() : m_modifiers(0) {}
 
@@ skipping 23 matching lines @@
   m_itemList.append(item);
 }
 
 DEFINE_TRACE(DataObject) {
   visitor->trace(m_itemList);
   Supplementable<DataObject>::trace(visitor);
 }
 
 DataObject* DataObject::create(WebDragData data) {
   DataObject* dataObject = create();
+  bool hasFileSystem = false;
 
   WebVector<WebDragData::Item> items = data.items();
   for (unsigned i = 0; i < items.size(); ++i) {
     WebDragData::Item item = items[i];
 
     switch (item.storageType) {
       case WebDragData::Item::StorageTypeString:
         if (String(item.stringType) == mimeTypeTextURIList)
           dataObject->setURLAndTitle(item.stringData, item.title);
         else if (String(item.stringType) == mimeTypeTextHTML)
           dataObject->setHTMLAndBaseURL(item.stringData, item.baseURL);
         else
           dataObject->setData(item.stringType, item.stringData);
         break;
       case WebDragData::Item::StorageTypeFilename:
-        dataObject->addFilename(item.filenameData, item.displayNameData);
+        hasFileSystem = true;
+        dataObject->addFilename(item.filenameData, item.displayNameData,
+                                data.filesystemId());
         break;
       case WebDragData::Item::StorageTypeBinaryData:
         // This should never happen when dragging in.
         break;
       case WebDragData::Item::StorageTypeFileSystemFile: {
         // FIXME: The file system URL may refer a user visible file, see
         // http://crbug.com/429077
+        hasFileSystem = true;
         FileMetadata fileMetadata;
         fileMetadata.length = item.fileSystemFileSize;
-        dataObject->add(File::createForFileSystemFile(
-            item.fileSystemURL, fileMetadata, File::IsNotUserVisible));
+
+        dataObject->add(
+            File::createForFileSystemFile(item.fileSystemURL, fileMetadata,
+                                          File::IsNotUserVisible),
+            item.fileSystemId);
       } break;
     }
   }
 
-  if (!data.filesystemId().isNull())
-    DraggedIsolatedFileSystem::prepareForDataObject(dataObject,
-                                                    data.filesystemId());
+  dataObject->setFilesystemId(data.filesystemId());
+
+  if (hasFileSystem) {
+    DraggedIsolatedFileSystem::prepareForDataObject(dataObject);
+  }

[kinuko, 2016/12/13 14:45:10]

nit: no need of { } for single-line body)

[hirono, 2016/12/14 04:54:55]

Done.

+
   return dataObject;
 }
 
 WebDragData DataObject::toWebDragData() {
   WebDragData data;
   data.initialize();
   data.setModifierKeyState(m_modifiers);
   WebVector<WebDragData::Item> itemList(length());
 
   for (size_t i = 0; i < length(); ++i) {
@@ skipping 12 matching lines @@
         if (blob->isFile()) {
           File* file = toFile(blob);
           if (file->hasBackingFile()) {
             item.storageType = WebDragData::Item::StorageTypeFilename;
             item.filenameData = file->path();
             item.displayNameData = file->name();
           } else if (!file->fileSystemURL().isEmpty()) {
             item.storageType = WebDragData::Item::StorageTypeFileSystemFile;
             item.fileSystemURL = file->fileSystemURL();
             item.fileSystemFileSize = file->size();
+            item.fileSystemId = originalItem->fileSystemId();
           } else {
             // FIXME: support dragging constructed Files across renderers, see
             // http://crbug.com/394955
             item.storageType = WebDragData::Item::StorageTypeString;
             item.stringType = "text/plain";
             item.stringData = file->name();
           }
         } else {
           ASSERT_NOT_REACHED();
         }
       } else {
         ASSERT_NOT_REACHED();
       }
     } else {
       ASSERT_NOT_REACHED();
     }
     item.title = originalItem->title();
     item.baseURL = originalItem->baseURL();
     itemList[i] = item;
   }
   data.swapItems(itemList);
   return data;
 }
 
 }  // namespace blink