Web expose FileSystemFileEntry, FileSystemDirectoryEntry and friends

third_party/WebKit/Source/modules/filesystem/FileSystemBase.cpp

 /*
  * Copyright (C) 2010 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 10 matching lines @@
  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include "modules/filesystem/DOMFileSystemBase.h"
+#include "modules/filesystem/FileSystemBase.h"
 
 #include "core/dom/ExecutionContext.h"
 #include "core/fileapi/File.h"
 #include "core/fileapi/FileError.h"
 #include "core/html/VoidCallback.h"
 #include "modules/filesystem/DOMFilePath.h"
-#include "modules/filesystem/DirectoryEntry.h"
-#include "modules/filesystem/DirectoryReaderBase.h"
-#include "modules/filesystem/EntriesCallback.h"
-#include "modules/filesystem/Entry.h"
-#include "modules/filesystem/EntryBase.h"
-#include "modules/filesystem/EntryCallback.h"
 #include "modules/filesystem/FileSystemCallbacks.h"
-#include "modules/filesystem/MetadataCallback.h"
+#include "modules/filesystem/FileSystemDirectoryEntry.h"
+#include "modules/filesystem/FileSystemDirectoryReaderBase.h"
+#include "modules/filesystem/FileSystemEntriesCallback.h"
+#include "modules/filesystem/FileSystemEntry.h"
+#include "modules/filesystem/FileSystemEntryBase.h"
+#include "modules/filesystem/FileSystemEntryCallback.h"
+#include "modules/filesystem/FileSystemMetadataCallback.h"
 #include "platform/weborigin/SecurityOrigin.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebFileSystem.h"
 #include "public/platform/WebFileSystemCallbacks.h"
 #include "wtf/text/StringBuilder.h"
 #include "wtf/text/TextEncoding.h"
 #include <memory>
 
 namespace blink {
 
-const char DOMFileSystemBase::persistentPathPrefix[] = "persistent";
-const char DOMFileSystemBase::temporaryPathPrefix[] = "temporary";
-const char DOMFileSystemBase::isolatedPathPrefix[] = "isolated";
-const char DOMFileSystemBase::externalPathPrefix[] = "external";
+const char FileSystemBase::persistentPathPrefix[] = "persistent";
+const char FileSystemBase::temporaryPathPrefix[] = "temporary";
+const char FileSystemBase::isolatedPathPrefix[] = "isolated";
+const char FileSystemBase::externalPathPrefix[] = "external";
 
-DOMFileSystemBase::DOMFileSystemBase(ExecutionContext* context,
-                                     const String& name,
-                                     FileSystemType type,
-                                     const KURL& rootURL)
+FileSystemBase::FileSystemBase(ExecutionContext* context,
+                               const String& name,
+                               FileSystemType type,
+                               const KURL& rootURL)
     : m_context(context),
       m_name(name),
       m_type(type),
       m_filesystemRootURL(rootURL),
       m_clonable(false) {}
 
-DOMFileSystemBase::~DOMFileSystemBase() {}
+FileSystemBase::~FileSystemBase() {}
 
-DEFINE_TRACE(DOMFileSystemBase) {
+DEFINE_TRACE(FileSystemBase) {
   visitor->trace(m_context);
 }
 
-WebFileSystem* DOMFileSystemBase::fileSystem() const {
+WebFileSystem* FileSystemBase::fileSystem() const {
   Platform* platform = Platform::current();
   if (!platform)
     return nullptr;
   return platform->fileSystem();
 }
 
-SecurityOrigin* DOMFileSystemBase::getSecurityOrigin() const {
+SecurityOrigin* FileSystemBase::getSecurityOrigin() const {
   return m_context->getSecurityOrigin();
 }
 
-bool DOMFileSystemBase::isValidType(FileSystemType type) {
+bool FileSystemBase::isValidType(FileSystemType type) {
   return type == FileSystemTypeTemporary || type == FileSystemTypePersistent ||
          type == FileSystemTypeIsolated || type == FileSystemTypeExternal;
 }
 
-KURL DOMFileSystemBase::createFileSystemRootURL(const String& origin,
-                                                FileSystemType type) {
+KURL FileSystemBase::createFileSystemRootURL(const String& origin,
+                                             FileSystemType type) {
   String typeString;
   if (type == FileSystemTypeTemporary)
     typeString = temporaryPathPrefix;
   else if (type == FileSystemTypePersistent)
     typeString = persistentPathPrefix;
   else if (type == FileSystemTypeExternal)
     typeString = externalPathPrefix;
   else
     return KURL();
 
   String result = "filesystem:" + origin + "/" + typeString + "/";
   return KURL(ParsedURLString, result);
 }
 
-bool DOMFileSystemBase::supportsToURL() const {
-  ASSERT(isValidType(m_type));
+bool FileSystemBase::supportsToURL() const {
+  DCHECK(isValidType(m_type));
   return m_type != FileSystemTypeIsolated;
 }
 
-KURL DOMFileSystemBase::createFileSystemURL(const EntryBase* entry) const {
+KURL FileSystemBase::createFileSystemURL(
+    const FileSystemEntryBase* entry) const {
   return createFileSystemURL(entry->fullPath());
 }
 
-KURL DOMFileSystemBase::createFileSystemURL(const String& fullPath) const {
-  ASSERT(DOMFilePath::isAbsolute(fullPath));
+KURL FileSystemBase::createFileSystemURL(const String& fullPath) const {
+  DCHECK(DOMFilePath::isAbsolute(fullPath));
 
   if (type() == FileSystemTypeExternal) {
     // For external filesystem originString could be different from what we have
     // in m_filesystemRootURL.
     StringBuilder result;
     result.append("filesystem:");
     result.append(getSecurityOrigin()->toString());
     result.append('/');
     result.append(externalPathPrefix);
     result.append(m_filesystemRootURL.path());
     // Remove the extra leading slash.
     result.append(encodeWithURLEscapeSequences(fullPath.substring(1)));
     return KURL(ParsedURLString, result.toString());
   }
 
   // For regular types we can just append the entry's fullPath to the
   // m_filesystemRootURL that should look like
   // 'filesystem:<origin>/<typePrefix>'.
-  ASSERT(!m_filesystemRootURL.isEmpty());
+  DCHECK(!m_filesystemRootURL.isEmpty());
   KURL url = m_filesystemRootURL;
   // Remove the extra leading slash.
   url.setPath(url.path() + encodeWithURLEscapeSequences(fullPath.substring(1)));
   return url;
 }
 
-bool DOMFileSystemBase::pathToAbsolutePath(FileSystemType type,
-                                           const EntryBase* base,
-                                           String path,
-                                           String& absolutePath) {
-  ASSERT(base);
+bool FileSystemBase::pathToAbsolutePath(FileSystemType type,
+                                        const FileSystemEntryBase* base,
+                                        String path,
+                                        String& absolutePath) {
+  DCHECK(base);
 
   if (!DOMFilePath::isAbsolute(path))
     path = DOMFilePath::append(base->fullPath(), path);
   absolutePath = DOMFilePath::removeExtraParentReferences(path);
 
   return (type != FileSystemTypeTemporary &&
           type != FileSystemTypePersistent) ||
          DOMFilePath::isValidPath(absolutePath);
 }
 
-bool DOMFileSystemBase::pathPrefixToFileSystemType(const String& pathPrefix,
-                                                   FileSystemType& type) {
+bool FileSystemBase::pathPrefixToFileSystemType(const String& pathPrefix,
+                                                FileSystemType& type) {
   if (pathPrefix == temporaryPathPrefix) {
     type = FileSystemTypeTemporary;
     return true;
   }
 
   if (pathPrefix == persistentPathPrefix) {
     type = FileSystemTypePersistent;
     return true;
   }
 
   if (pathPrefix == externalPathPrefix) {
     type = FileSystemTypeExternal;
     return true;
   }
 
   return false;
 }
 
-File* DOMFileSystemBase::createFile(const FileMetadata& metadata,
-                                    const KURL& fileSystemURL,
-                                    FileSystemType type,
-                                    const String name) {
+File* FileSystemBase::createFile(const FileMetadata& metadata,
+                                 const KURL& fileSystemURL,
+                                 FileSystemType type,
+                                 const String name) {
   // For regular filesystem types (temporary or persistent), we should not cache
   // file metadata as it could change File semantics.  For other filesystem
   // types (which could be platform-specific ones), there's a chance that the
   // files are on remote filesystem.  If the port has returned metadata just
   // pass it to File constructor (so we may cache the metadata).
   // FIXME: We should use the snapshot metadata for all files.
   // https://www.w3.org/Bugs/Public/show_bug.cgi?id=17746
   if (type == FileSystemTypeTemporary || type == FileSystemTypePersistent)
     return File::createForFileSystemFile(metadata.platformPath, name);
 
   const File::UserVisibility userVisibility = (type == FileSystemTypeExternal)
                                                   ? File::IsUserVisible
                                                   : File::IsNotUserVisible;
 
   if (!metadata.platformPath.isEmpty()) {
     // If the platformPath in the returned metadata is given, we create a File
     // object for the snapshot path.
     return File::createForFileSystemFile(name, metadata, userVisibility);
-  } else {
-    // Otherwise we create a File object for the fileSystemURL.
-    return File::createForFileSystemFile(fileSystemURL, metadata,
-                                         userVisibility);
   }
+
+  // Otherwise we create a File object for the fileSystemURL.
+  return File::createForFileSystemFile(fileSystemURL, metadata, userVisibility);
 }
 
-void DOMFileSystemBase::getMetadata(const EntryBase* entry,
-                                    MetadataCallback* successCallback,
-                                    ErrorCallbackBase* errorCallback,
-                                    SynchronousType synchronousType) {
+void FileSystemBase::getMetadata(const FileSystemEntryBase* entry,
+                                 FileSystemMetadataCallback* successCallback,
+                                 ErrorCallbackBase* errorCallback,
+                                 SynchronousType synchronousType) {
   if (!fileSystem()) {
     reportError(errorCallback, FileError::kAbortErr);
     return;
   }
 
   std::unique_ptr<AsyncFileSystemCallbacks> callbacks(MetadataCallbacks::create(
       successCallback, errorCallback, m_context, this));
   callbacks->setShouldBlockUntilCompletion(synchronousType == Synchronous);
   fileSystem()->readMetadata(createFileSystemURL(entry), std::move(callbacks));
 }
 
-static bool verifyAndGetDestinationPathForCopyOrMove(const EntryBase* source,
-                                                     EntryBase* parent,
-                                                     const String& newName,
-                                                     String& destinationPath) {
-  ASSERT(source);
+static bool verifyAndGetDestinationPathForCopyOrMove(
+    const FileSystemEntryBase* source,
+    FileSystemEntryBase* parent,
+    const String& newName,
+    String& destinationPath) {
+  DCHECK(source);
 
   if (!parent || !parent->isDirectory())
     return false;
 
   if (!newName.isEmpty() && !DOMFilePath::isValidName(newName))
     return false;
 
   const bool isSameFileSystem =
       (*source->filesystem() == *parent->filesystem());
 
@@ skipping 11 matching lines @@
 
   destinationPath = parent->fullPath();
   if (!newName.isEmpty())
     destinationPath = DOMFilePath::append(destinationPath, newName);
   else
     destinationPath = DOMFilePath::append(destinationPath, source->name());
 
   return true;
 }
 
-void DOMFileSystemBase::move(const EntryBase* source,
-                             EntryBase* parent,
-                             const String& newName,
-                             EntryCallback* successCallback,
-                             ErrorCallbackBase* errorCallback,
-                             SynchronousType synchronousType) {
+void FileSystemBase::move(const FileSystemEntryBase* source,
+                          FileSystemEntryBase* parent,
+                          const String& newName,
+                          FileSystemEntryCallback* successCallback,
+                          ErrorCallbackBase* errorCallback,
+                          SynchronousType synchronousType) {
   if (!fileSystem()) {
     reportError(errorCallback, FileError::kAbortErr);
     return;
   }
 
   String destinationPath;
   if (!verifyAndGetDestinationPathForCopyOrMove(source, parent, newName,
                                                 destinationPath)) {
     reportError(errorCallback, FileError::kInvalidModificationErr);
     return;
   }
 
   std::unique_ptr<AsyncFileSystemCallbacks> callbacks(EntryCallbacks::create(
       successCallback, errorCallback, m_context, parent->filesystem(),
       destinationPath, source->isDirectory()));
   callbacks->setShouldBlockUntilCompletion(synchronousType == Synchronous);
 
   fileSystem()->move(createFileSystemURL(source),
                      parent->filesystem()->createFileSystemURL(destinationPath),
                      std::move(callbacks));
 }
 
-void DOMFileSystemBase::copy(const EntryBase* source,
-                             EntryBase* parent,
-                             const String& newName,
-                             EntryCallback* successCallback,
-                             ErrorCallbackBase* errorCallback,
-                             SynchronousType synchronousType) {
+void FileSystemBase::copy(const FileSystemEntryBase* source,
+                          FileSystemEntryBase* parent,
+                          const String& newName,
+                          FileSystemEntryCallback* successCallback,
+                          ErrorCallbackBase* errorCallback,
+                          SynchronousType synchronousType) {
   if (!fileSystem()) {
     reportError(errorCallback, FileError::kAbortErr);
     return;
   }
 
   String destinationPath;
   if (!verifyAndGetDestinationPathForCopyOrMove(source, parent, newName,
                                                 destinationPath)) {
     reportError(errorCallback, FileError::kInvalidModificationErr);
     return;
   }
 
   std::unique_ptr<AsyncFileSystemCallbacks> callbacks(EntryCallbacks::create(
       successCallback, errorCallback, m_context, parent->filesystem(),
       destinationPath, source->isDirectory()));
   callbacks->setShouldBlockUntilCompletion(synchronousType == Synchronous);
 
   fileSystem()->copy(createFileSystemURL(source),
                      parent->filesystem()->createFileSystemURL(destinationPath),
                      std::move(callbacks));
 }
 
-void DOMFileSystemBase::remove(const EntryBase* entry,
-                               VoidCallback* successCallback,
-                               ErrorCallbackBase* errorCallback,
-                               SynchronousType synchronousType) {
+void FileSystemBase::remove(const FileSystemEntryBase* entry,
+                            VoidCallback* successCallback,
+                            ErrorCallbackBase* errorCallback,
+                            SynchronousType synchronousType) {
   if (!fileSystem()) {
     reportError(errorCallback, FileError::kAbortErr);
     return;
   }
 
-  ASSERT(entry);
+  DCHECK(entry);
   // We don't allow calling remove() on the root directory.
   if (entry->fullPath() == String(DOMFilePath::root)) {
     reportError(errorCallback, FileError::kInvalidModificationErr);
     return;
   }
 
   std::unique_ptr<AsyncFileSystemCallbacks> callbacks(
       VoidCallbacks::create(successCallback, errorCallback, m_context, this));
   callbacks->setShouldBlockUntilCompletion(synchronousType == Synchronous);
 
   fileSystem()->remove(createFileSystemURL(entry), std::move(callbacks));
 }
 
-void DOMFileSystemBase::removeRecursively(const EntryBase* entry,
-                                          VoidCallback* successCallback,
-                                          ErrorCallbackBase* errorCallback,
-                                          SynchronousType synchronousType) {
+void FileSystemBase::removeRecursively(const FileSystemEntryBase* entry,
+                                       VoidCallback* successCallback,
+                                       ErrorCallbackBase* errorCallback,
+                                       SynchronousType synchronousType) {
   if (!fileSystem()) {
     reportError(errorCallback, FileError::kAbortErr);
     return;
   }
 
-  ASSERT(entry && entry->isDirectory());
+  DCHECK(entry && entry->isDirectory());
   // We don't allow calling remove() on the root directory.
   if (entry->fullPath() == String(DOMFilePath::root)) {
     reportError(errorCallback, FileError::kInvalidModificationErr);
     return;
   }
 
   std::unique_ptr<AsyncFileSystemCallbacks> callbacks(
       VoidCallbacks::create(successCallback, errorCallback, m_context, this));
   callbacks->setShouldBlockUntilCompletion(synchronousType == Synchronous);
 
   fileSystem()->removeRecursively(createFileSystemURL(entry),
                                   std::move(callbacks));
 }
 
-void DOMFileSystemBase::getParent(const EntryBase* entry,
-                                  EntryCallback* successCallback,
-                                  ErrorCallbackBase* errorCallback) {
+void FileSystemBase::getParent(const FileSystemEntryBase* entry,
+                               FileSystemEntryCallback* successCallback,
+                               ErrorCallbackBase* errorCallback) {
   if (!fileSystem()) {
     reportError(errorCallback, FileError::kAbortErr);
     return;
   }
 
-  ASSERT(entry);
+  DCHECK(entry);
   String path = DOMFilePath::getDirectory(entry->fullPath());
 
   fileSystem()->directoryExists(
       createFileSystemURL(path),
       EntryCallbacks::create(successCallback, errorCallback, m_context, this,
                              path, true));
 }
 
-void DOMFileSystemBase::getFile(const EntryBase* entry,
-                                const String& path,
-                                const FileSystemFlags& flags,
-                                EntryCallback* successCallback,
-                                ErrorCallbackBase* errorCallback,
-                                SynchronousType synchronousType) {
+void FileSystemBase::getFile(const FileSystemEntryBase* entry,
+                             const String& path,
+                             const FileSystemFlags& flags,
+                             FileSystemEntryCallback* successCallback,
+                             ErrorCallbackBase* errorCallback,
+                             SynchronousType synchronousType) {
   if (!fileSystem()) {
     reportError(errorCallback, FileError::kAbortErr);
     return;
   }
 
   String absolutePath;
   if (!pathToAbsolutePath(m_type, entry, path, absolutePath)) {
     reportError(errorCallback, FileError::kInvalidModificationErr);
     return;
   }
 
   std::unique_ptr<AsyncFileSystemCallbacks> callbacks(EntryCallbacks::create(
       successCallback, errorCallback, m_context, this, absolutePath, false));
   callbacks->setShouldBlockUntilCompletion(synchronousType == Synchronous);
 
-  if (flags.createFlag())
+  if (flags.createFlag()) {
     fileSystem()->createFile(createFileSystemURL(absolutePath),
                              flags.exclusive(), std::move(callbacks));
-  else
+  } else {
     fileSystem()->fileExists(createFileSystemURL(absolutePath),
                              std::move(callbacks));
+  }
 }
 
-void DOMFileSystemBase::getDirectory(const EntryBase* entry,
-                                     const String& path,
-                                     const FileSystemFlags& flags,
-                                     EntryCallback* successCallback,
-                                     ErrorCallbackBase* errorCallback,
-                                     SynchronousType synchronousType) {
+void FileSystemBase::getDirectory(const FileSystemEntryBase* entry,
+                                  const String& path,
+                                  const FileSystemFlags& flags,
+                                  FileSystemEntryCallback* successCallback,
+                                  ErrorCallbackBase* errorCallback,
+                                  SynchronousType synchronousType) {
   if (!fileSystem()) {
     reportError(errorCallback, FileError::kAbortErr);
     return;
   }
 
   String absolutePath;
   if (!pathToAbsolutePath(m_type, entry, path, absolutePath)) {
     reportError(errorCallback, FileError::kInvalidModificationErr);
     return;
   }
 
   std::unique_ptr<AsyncFileSystemCallbacks> callbacks(EntryCallbacks::create(
       successCallback, errorCallback, m_context, this, absolutePath, true));
   callbacks->setShouldBlockUntilCompletion(synchronousType == Synchronous);
 
-  if (flags.createFlag())
+  if (flags.createFlag()) {
     fileSystem()->createDirectory(createFileSystemURL(absolutePath),
                                   flags.exclusive(), std::move(callbacks));
-  else
+  } else {
     fileSystem()->directoryExists(createFileSystemURL(absolutePath),
                                   std::move(callbacks));
+  }
 }
 
-int DOMFileSystemBase::readDirectory(DirectoryReaderBase* reader,
-                                     const String& path,
-                                     EntriesCallback* successCallback,
-                                     ErrorCallbackBase* errorCallback,
-                                     SynchronousType synchronousType) {
+int FileSystemBase::readDirectory(FileSystemDirectoryReaderBase* reader,
+                                  const String& path,
+                                  FileSystemEntriesCallback* successCallback,
+                                  ErrorCallbackBase* errorCallback,
+                                  SynchronousType synchronousType) {
   if (!fileSystem()) {
     reportError(errorCallback, FileError::kAbortErr);
     return 0;
   }
 
-  ASSERT(DOMFilePath::isAbsolute(path));
+  DCHECK(DOMFilePath::isAbsolute(path));
 
   std::unique_ptr<AsyncFileSystemCallbacks> callbacks(EntriesCallbacks::create(
       successCallback, errorCallback, m_context, reader, path));
   callbacks->setShouldBlockUntilCompletion(synchronousType == Synchronous);
 
   return fileSystem()->readDirectory(createFileSystemURL(path),
                                      std::move(callbacks));
 }
 
-bool DOMFileSystemBase::waitForAdditionalResult(int callbacksId) {
+bool FileSystemBase::waitForAdditionalResult(int callbacksId) {
   if (!fileSystem())
     return false;
   return fileSystem()->waitForAdditionalResult(callbacksId);
 }
 
 }  // namespace blink