Web expose FileSystemFileEntry, FileSystemDirectoryEntry and friends

third_party/WebKit/Source/bindings/modules/v8/ScriptValueSerializerForModules.cpp

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "bindings/modules/v8/ScriptValueSerializerForModules.h"
 
 #include "bindings/core/v8/SerializationTag.h"
 #include "bindings/core/v8/V8Binding.h"
 #include "bindings/modules/v8/V8CryptoKey.h"
-#include "bindings/modules/v8/V8DOMFileSystem.h"
+#include "bindings/modules/v8/V8FileSystem.h"
 #include "bindings/modules/v8/V8RTCCertificate.h"
 #include "bindings/modules/v8/serialization/WebCryptoSubTags.h"
-#include "modules/filesystem/DOMFileSystem.h"
+#include "modules/filesystem/FileSystem.h"
 #include "modules/peerconnection/RTCCertificate.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebRTCCertificate.h"
 #include "public/platform/WebRTCCertificateGenerator.h"
 #include "wtf/PtrUtil.h"
 #include <memory>
 
 namespace blink {
 
 ScriptValueSerializerForModules::ScriptValueSerializerForModules(
     SerializedScriptValueWriter& writer,
     WebBlobInfoArray* blobInfo,
     ScriptState* scriptState)
     : ScriptValueSerializer(writer, blobInfo, scriptState) {}
 
 ScriptValueSerializer::StateBase*
-ScriptValueSerializerForModules::writeDOMFileSystem(v8::Local<v8::Value> value,
-                                                    StateBase* next) {
-  DOMFileSystem* fs = V8DOMFileSystem::toImpl(value.As<v8::Object>());
+ScriptValueSerializerForModules::writeFileSystem(v8::Local<v8::Value> value,
+                                                 StateBase* next) {
+  FileSystem* fs = V8FileSystem::toImpl(value.As<v8::Object>());
   if (!fs)
     return 0;
   if (!fs->clonable())
     return handleError(Status::DataCloneError,
                        "A FileSystem object could not be cloned.", next);
 
-  toSerializedScriptValueWriterForModules(writer()).writeDOMFileSystem(
+  toSerializedScriptValueWriterForModules(writer()).writeFileSystem(
       fs->type(), fs->name(), fs->rootURL().getString());
   return 0;
 }
 
 bool ScriptValueSerializerForModules::writeCryptoKey(
     v8::Local<v8::Value> value) {
   CryptoKey* key = V8CryptoKey::toImpl(value.As<v8::Object>());
   if (!key)
     return false;
   return toSerializedScriptValueWriterForModules(writer()).writeCryptoKey(
       key->key());
 }
 
 ScriptValueSerializer::StateBase*
 ScriptValueSerializerForModules::writeRTCCertificate(v8::Local<v8::Value> value,
                                                      StateBase* next) {
   RTCCertificate* certificate =
       V8RTCCertificate::toImpl(value.As<v8::Object>());
   if (!certificate)
     return handleError(Status::DataCloneError,
                        "An RTCCertificate object could not be cloned.", next);
   toSerializedScriptValueWriterForModules(writer()).writeRTCCertificate(
       *certificate);
   return nullptr;
 }
 
-void SerializedScriptValueWriterForModules::writeDOMFileSystem(
-    int type,
-    const String& name,
-    const String& url) {
-  append(DOMFileSystemTag);
+void SerializedScriptValueWriterForModules::writeFileSystem(int type,
+                                                            const String& name,
+                                                            const String& url) {
+  append(FileSystemTag);
   doWriteUint32(type);
   doWriteWebCoreString(name);
   doWriteWebCoreString(url);
 }
 
 bool SerializedScriptValueWriterForModules::writeCryptoKey(
     const WebCryptoKey& key) {
   append(static_cast<uint8_t>(CryptoKeyTag));
 
   switch (key.algorithm().paramsType()) {
@@ skipping 187 matching lines @@
 
   doWriteUint32(value);
 }
 
 ScriptValueSerializer::StateBase*
 ScriptValueSerializerForModules::doSerializeObject(
     v8::Local<v8::Object> jsObject,
     StateBase* next) {
   DCHECK(!jsObject.IsEmpty());
 
-  if (V8DOMFileSystem::hasInstance(jsObject, isolate())) {
+  if (V8FileSystem::hasInstance(jsObject, isolate())) {
     greyObject(jsObject);
-    return writeDOMFileSystem(jsObject, next);
+    return writeFileSystem(jsObject, next);
   }
   if (V8CryptoKey::hasInstance(jsObject, isolate())) {
     greyObject(jsObject);
     if (!writeCryptoKey(jsObject))
       return handleError(Status::DataCloneError, "Couldn't serialize key data",
                          next);
     return nullptr;
   }
   if (V8RTCCertificate::hasInstance(jsObject, isolate())) {
     greyObject(jsObject);
     return writeRTCCertificate(jsObject, next);
   }
 
   return ScriptValueSerializer::doSerializeObject(jsObject, next);
 }
 
 bool SerializedScriptValueReaderForModules::read(
     v8::Local<v8::Value>* value,
     ScriptValueDeserializer& deserializer) {
   SerializationTag tag;
   if (!readTag(&tag))
     return false;
   switch (tag) {
-    case DOMFileSystemTag:
-      if (!readDOMFileSystem(value))
+    case FileSystemTag:
+      if (!readFileSystem(value))
         return false;
       deserializer.pushObjectReference(*value);
       break;
     case CryptoKeyTag:
       if (!readCryptoKey(value))
         return false;
       deserializer.pushObjectReference(*value);
       break;
     case RTCCertificateTag:
       if (!readRTCCertificate(value))
         return false;
       deserializer.pushObjectReference(*value);
       break;
     default:
       return SerializedScriptValueReader::readWithTag(tag, value, deserializer);
   }
   return !value->IsEmpty();
 }
 
-bool SerializedScriptValueReaderForModules::readDOMFileSystem(
+bool SerializedScriptValueReaderForModules::readFileSystem(
     v8::Local<v8::Value>* value) {
   uint32_t type;
   String name;
   String url;
   if (!doReadUint32(&type))
     return false;
   if (!readWebCoreString(&name))
     return false;
   if (!readWebCoreString(&url))
     return false;
-  DOMFileSystem* fs = DOMFileSystem::create(
-      getScriptState()->getExecutionContext(), name,
-      static_cast<FileSystemType>(type), KURL(ParsedURLString, url));
+  FileSystem* fs = FileSystem::create(getScriptState()->getExecutionContext(),
+                                      name, static_cast<FileSystemType>(type),
+                                      KURL(ParsedURLString, url));
   *value = toV8(fs, getScriptState()->context()->Global(), isolate());
   return !value->IsEmpty();
 }
 
 bool SerializedScriptValueReaderForModules::readCryptoKey(
     v8::Local<v8::Value>* value) {
   uint32_t rawKeyType;
   if (!doReadUint32(&rawKeyType))
     return false;
 
@@ skipping 309 matching lines @@
     : ScriptValueDeserializer(reader,
                               messagePorts,
                               arrayBufferContents,
                               imageBitmapContents) {}
 
 bool ScriptValueDeserializerForModules::read(v8::Local<v8::Value>* value) {
   return toSerializedScriptValueReaderForModules(reader()).read(value, *this);
 }
 
 }  // namespace blink