Add full support for filesystem URLs.

webkit/fileapi/file_system_util.cc

 // Copyright (c) 2011 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 "webkit/fileapi/file_system_util.h"
 
 #include "build/build_config.h"
 
 #include "base/file_path.h"
 #include "base/logging.h"
 #include "base/sys_string_conversions.h"
 #include "base/utf_string_conversions.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/escape.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebCString.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebSecurityOrigin.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebString.h"
 #include "webkit/fileapi/file_system_types.h"
 
 namespace fileapi {
 
-const char kPersistentDir[] = "/persistent/";
-const char kTemporaryDir[] = "/temporary/";
-const char kExternalDir[] = "/external/";
+const char kPersistentDir[] = "/persistent";
+const char kTemporaryDir[] = "/temporary";
+const char kExternalDir[] = "/external";
 
 const char kPersistentName[] = "Persistent";
 const char kTemporaryName[] = "Temporary";
 const char kExternalName[] = "External";
 
 bool CrackFileSystemURL(const GURL& url, GURL* origin_url, FileSystemType* type,
                         FilePath* file_path) {
   GURL origin;
   FileSystemType file_system_type;
 
-  if (url.scheme() != "filesystem")
+  if (!url.is_valid() || !url.SchemeIsFileSystem())
     return false;
+  DCHECK(url.inner_url());
 
-  std::string temp = url.path();
-  // TODO(ericu): This should probably be done elsewhere after the stackable
-  // layers are properly in.  We're supposed to reject any paths that contain
-  // '..' segments, but the GURL constructor is helpfully resolving them for us.
-  // Make sure there aren't any before we call it.
-  size_t pos = temp.find("..");
-  for (; pos != std::string::npos; pos = temp.find("..", pos + 1)) {
-    if ((pos == 0 || temp[pos - 1] == '/') &&
-        (pos == temp.length() - 2 || temp[pos + 2] == '/'))
-      return false;
+  std::string inner_path = url.inner_url()->path();
+  if (inner_path.compare(0, strlen(kPersistentDir), kPersistentDir) == 0) {
+    file_system_type = kFileSystemTypePersistent;
+  } else if (inner_path.compare(0, strlen(kTemporaryDir), kTemporaryDir) == 0) {
+    file_system_type = kFileSystemTypeTemporary;
+  } else if (inner_path.compare(0, strlen(kExternalDir), kExternalDir) == 0) {
+    file_system_type = kFileSystemTypeExternal;
+  } else {
+    return false;
   }
 
-  // bare_url will look something like:
-  //    http://example.com/temporary/dir/file.txt.
-  GURL bare_url(temp);
-
-  // The input URL was malformed, bail out early.
-  if (bare_url.path().empty())
-    return false;
-
-  origin = bare_url.GetOrigin();
-
-  // The input URL was malformed, bail out early.
-  if (origin.is_empty())
-    return false;
-
-  std::string path = net::UnescapeURLComponent(bare_url.path(),
+  std::string path = net::UnescapeURLComponent(url.path(),
       net::UnescapeRule::SPACES | net::UnescapeRule::URL_SPECIAL_CHARS |
       net::UnescapeRule::CONTROL_CHARS);
-  if (path.compare(0, strlen(kPersistentDir), kPersistentDir) == 0) {
-    file_system_type = kFileSystemTypePersistent;
-    path = path.substr(strlen(kPersistentDir));
-  } else if (path.compare(0, strlen(kTemporaryDir), kTemporaryDir) == 0) {
-    file_system_type = kFileSystemTypeTemporary;
-    path = path.substr(strlen(kTemporaryDir));
-  } else if (path.compare(0, strlen(kExternalDir), kExternalDir) == 0) {
-    file_system_type = kFileSystemTypeExternal;
-    path = path.substr(strlen(kExternalDir));
-  } else {
-    return false;
+
+  // Make sure no '..' segments have leaked through after unescaping.
+  size_t pos = path.find("..");
+  for (; pos != std::string::npos; pos = path.find("..", pos + 1)) {
+    if ((pos == 0 || path[pos - 1] == '/') &&
+        (pos == path.length() - 2 || path[pos + 2] == '/'))
+      return false;
   }
 
   // Ensure the path is relative.
   while (!path.empty() && path[0] == '/')
     path.erase(0, 1);
 
   if (origin_url)
-    *origin_url = origin;
+    *origin_url = url.GetOrigin();
   if (type)
     *type = file_system_type;
   if (file_path)
 #if defined(OS_WIN)
     *file_path = FilePath(base::SysUTF8ToWide(path)).
         NormalizeWindowsPathSeparators().StripTrailingSeparators();
 #elif defined(OS_POSIX)
     *file_path = FilePath(path).StripTrailingSeparators();
 #endif
 
   return true;
 }
 
 GURL GetFileSystemRootURI(
     const GURL& origin_url, fileapi::FileSystemType type) {
-  std::string path("filesystem:");
-  path += origin_url.spec();
+  DCHECK(!origin_url.SchemeIsFileSystem());
+
+  std::string inner_url = origin_url.GetWithEmptyPath().spec();
   switch (type) {
   case kFileSystemTypeTemporary:
-    path += (kTemporaryDir + 1);  // We don't want the leading slash.
+    inner_url += (kTemporaryDir + 1);  // We don't want the leading slash.
     break;
   case kFileSystemTypePersistent:
-    path += (kPersistentDir + 1);  // We don't want the leading slash.
+    inner_url += (kPersistentDir + 1);  // We don't want the leading slash.
     break;
   case kFileSystemTypeExternal:
-    path += (kExternalDir + 1);  // We don't want the leading slash.
+    inner_url += (kExternalDir + 1);  // We don't want the leading slash.
     break;
   default:
     NOTREACHED();
     return GURL();
   }
-  return GURL(path);
+
+  return GURL("filesystem:" + inner_url + "/");
 }
 
 FileSystemType QuotaStorageTypeToFileSystemType(
     quota::StorageType storage_type) {
   switch (storage_type) {
     case quota::kStorageTypeTemporary:
       return kFileSystemTypeTemporary;
     case quota::kStorageTypePersistent:
       return kFileSystemTypePersistent;
     default:
@@ skipping 28 matching lines @@
 
   // We need this work-around for file:/// URIs as
   // createFromDatabaseIdentifier returns empty origin_url for them.
   if (origin_url.spec().empty() &&
       origin_identifier.find("file__") == 0)
     return GURL("file:///");
   return origin_url;
 }
 
 }  // namespace fileapi