FileAPI: Add WebFileSystem::resolveURL

Source/modules/filesystem/DOMFileSystemBase.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 78 matching lines @@
 
 bool DOMFileSystemBase::crackFileSystemURL(const KURL& url, FileSystemType& type, String& filePath)
 {
     if (!url.protocolIs("filesystem"))
         return false;
 
     if (!url.innerURL())
         return false;
 
     String typeString = url.innerURL()->path().substring(1);
-    if (typeString == temporaryPathPrefix)
-        type = FileSystemTypeTemporary;
-    else if (typeString == persistentPathPrefix)
-        type = FileSystemTypePersistent;
-    else if (typeString == externalPathPrefix)
-        type = FileSystemTypeExternal;
-    else
+    if (!pathPrefixToFileSystemType(typeString, type))
         return false;
 
     filePath = decodeURLEscapeSequences(url.path());
     return true;
 }
 
+KURL DOMFileSystemBase::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();
+
+    StringBuilder result;
+    result.append("filesystem:");
+    result.append(origin);
+    result.append("/");
+    result.append(typeString);
+    result.append("/");

[abarth-chromium, 2013/09/13 17:33:01]

You should use use operator+ as follows:

String result = "filesystem:" + origin + "/" + typeString + "/";

That's maximally efficient because we'll allocate exactly the right size buffer
for the result.

[nhiroki, 2013/09/16 16:36:07]

Done.

+    return KURL(ParsedURLString, result.toString());
+}
+
 bool DOMFileSystemBase::supportsToURL() const
 {
     ASSERT(isValidType(m_type));
     return m_type != FileSystemTypeIsolated;
 }
 
 KURL DOMFileSystemBase::createFileSystemURL(const EntryBase* entry) const
 {
     return createFileSystemURL(entry->fullPath());
 }
@@ skipping 16 matching lines @@
     }
 
     // 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());
     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);
+
+    if (!DOMFilePath::isAbsolute(path))
+        path = DOMFilePath::append(base->fullPath(), path);
+    absolutePath = DOMFilePath::removeExtraParentReferences(path);
+
+    if ((type == FileSystemTypeTemporary || type == FileSystemTypePersistent) && !DOMFilePath::isValidPath(absolutePath))
+        return false;
+    return true;

[abarth-chromium, 2013/09/13 17:33:01]

There's no need to write "return false" or "return true".  You can just return
the boolean directly:

return (type != FileSystemTypeTemporary && type != FileSystemTypePersistent) ||
DOMFilePath::isValidPath(absolutePath);

(I might have screwed up the logic.)

[nhiroki, 2013/09/16 16:36:07]

Done.

+}
+
+bool DOMFileSystemBase::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;
+}
+
 bool DOMFileSystemBase::getMetadata(const EntryBase* entry, PassRefPtr<MetadataCallback> successCallback, PassRefPtr<ErrorCallback> errorCallback, SynchronousType synchronousType)
 {
     OwnPtr<AsyncFileSystemCallbacks> callbacks(MetadataCallbacks::create(successCallback, errorCallback, this));
     callbacks->setShouldBlockUntilCompletion(synchronousType == Synchronous);
     fileSystem()->readMetadata(createFileSystemURL(entry), callbacks.release());
     return true;
 }
 
 static bool verifyAndGetDestinationPathForCopyOrMove(const EntryBase* source, EntryBase* parent, const String& newName, String& destinationPath)
 {
@@ skipping 17 matching lines @@
 
     destinationPath = parent->fullPath();
     if (!newName.isEmpty())
         destinationPath = DOMFilePath::append(destinationPath, newName);
     else
         destinationPath = DOMFilePath::append(destinationPath, source->name());
 
     return true;
 }
 
-static bool pathToAbsolutePath(FileSystemType type, const EntryBase* base, String path, String& absolutePath)
-{
-    ASSERT(base);
-
-    if (!DOMFilePath::isAbsolute(path))
-        path = DOMFilePath::append(base->fullPath(), path);
-    absolutePath = DOMFilePath::removeExtraParentReferences(path);
-
-    if ((type == FileSystemTypeTemporary || type == FileSystemTypePersistent) && !DOMFilePath::isValidPath(absolutePath))
-        return false;
-    return true;
-}
-
 bool DOMFileSystemBase::move(const EntryBase* source, EntryBase* parent, const String& newName, PassRefPtr<EntryCallback> successCallback, PassRefPtr<ErrorCallback> errorCallback, SynchronousType synchronousType)
 {
     String destinationPath;
     if (!verifyAndGetDestinationPathForCopyOrMove(source, parent, newName, destinationPath))
         return false;
 
     OwnPtr<AsyncFileSystemCallbacks> callbacks(EntryCallbacks::create(successCallback, errorCallback, parent->filesystem(), destinationPath, source->isDirectory()));
     callbacks->setShouldBlockUntilCompletion(synchronousType == Synchronous);
 
     fileSystem()->move(createFileSystemURL(source), parent->filesystem()->createFileSystemURL(destinationPath), callbacks.release());
@@ skipping 87 matching lines @@
     ASSERT(DOMFilePath::isAbsolute(path));
 
     OwnPtr<AsyncFileSystemCallbacks> callbacks(EntriesCallbacks::create(successCallback, errorCallback, reader, path));
     callbacks->setShouldBlockUntilCompletion(synchronousType == Synchronous);
 
     fileSystem()->readDirectory(createFileSystemURL(path), callbacks.release());
     return true;
 }
 
 } // namespace WebCore