Move storage-related files from webkit/ to new top-level directory storage/

storage/common/fileapi/file_system_util.cc

 // Copyright (c) 2012 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/common/fileapi/file_system_util.h"
+#include "storage/common/fileapi/file_system_util.h"
 
 #include <algorithm>
 
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/strings/string_util.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "net/base/escape.h"
 #include "net/base/net_errors.h"
 #include "url/gurl.h"
-#include "webkit/common/database/database_identifier.h"
+#include "storage/common/database/database_identifier.h"
 
-namespace fileapi {
+namespace storage {
 
 const char kPersistentDir[] = "/persistent";
 const char kTemporaryDir[] = "/temporary";
 const char kIsolatedDir[] = "/isolated";
 const char kExternalDir[] = "/external";
 const char kTestDir[] = "/test";
 
 const base::FilePath::CharType VirtualPath::kRoot[] = FILE_PATH_LITERAL("/");
 const base::FilePath::CharType VirtualPath::kSeparator = FILE_PATH_LITERAL('/');
 
@@ skipping 12 matching lines @@
       path.find_last_of(base::FilePath::kSeparators);
   if (last_separator != base::FilePath::StringType::npos &&
       last_separator < path.size() - 1)
     path.erase(0, last_separator + 1);
 
   return base::FilePath(path);
 }
 
 base::FilePath VirtualPath::DirName(const base::FilePath& virtual_path) {
   typedef base::FilePath::StringType StringType;
-  StringType  path = virtual_path.value();
+  StringType path = virtual_path.value();
 
   // The logic below is taken from that of base::FilePath::DirName, except
   // that this version never cares about '//' or drive-letters even on win32.
 
   // Strip trailing separators.
   while (path.size() > 1 && base::FilePath::IsSeparator(path[path.size() - 1]))
     path.resize(path.size() - 1);
 
   StringType::size_type last_separator =
       path.find_last_of(base::FilePath::kSeparators);
@@ skipping 54 matching lines @@
   std::vector<base::FilePath::StringType>::const_iterator it;
   for (it = stringtype_components.begin(); it != stringtype_components.end();
        ++it) {
     components->push_back(base::FilePath(*it).AsUTF8Unsafe());
   }
 }
 
 base::FilePath::StringType VirtualPath::GetNormalizedFilePath(
     const base::FilePath& path) {
   base::FilePath::StringType normalized_path = path.value();
-  const size_t num_separators = base::FilePath::StringType(
-      base::FilePath::kSeparators).length();
+  const size_t num_separators =
+      base::FilePath::StringType(base::FilePath::kSeparators).length();
   for (size_t i = 0; i < num_separators; ++i) {
-    std::replace(normalized_path.begin(), normalized_path.end(),
-                 base::FilePath::kSeparators[i], kSeparator);
+    std::replace(normalized_path.begin(),
+                 normalized_path.end(),
+                 base::FilePath::kSeparators[i],
+                 kSeparator);
   }
 
-  return (IsAbsolute(normalized_path)) ?
-      normalized_path : base::FilePath::StringType(kRoot) + normalized_path;
+  return (IsAbsolute(normalized_path))
+             ? normalized_path
+             : base::FilePath::StringType(kRoot) + normalized_path;
 }
 
 bool VirtualPath::IsAbsolute(const base::FilePath::StringType& path) {
   return path.find(kRoot) == 0;
 }
 
 bool VirtualPath::IsRootPath(const base::FilePath& path) {
   std::vector<base::FilePath::StringType> components;
   VirtualPath::GetComponents(path, &components);
   return (path.empty() || components.empty() ||
-          (components.size() == 1 &&
-           components[0] == VirtualPath::kRoot));
+          (components.size() == 1 && components[0] == VirtualPath::kRoot));
 }
 
 bool ParseFileSystemSchemeURL(const GURL& url,
                               GURL* origin_url,
                               FileSystemType* type,
                               base::FilePath* virtual_path) {
   GURL origin;
   FileSystemType file_system_type = kFileSystemTypeUnknown;
 
   if (!url.is_valid() || !url.SchemeIsFileSystem())
     return false;
 
   const struct {
     FileSystemType type;
     const char* dir;
   } kValidTypes[] = {
-    { kFileSystemTypePersistent, kPersistentDir },
-    { kFileSystemTypeTemporary, kTemporaryDir },
-    { kFileSystemTypeIsolated, kIsolatedDir },
-    { kFileSystemTypeExternal, kExternalDir },
-    { kFileSystemTypeTest, kTestDir },
-  };
+        {kFileSystemTypePersistent, kPersistentDir},
+        {kFileSystemTypeTemporary, kTemporaryDir},
+        {kFileSystemTypeIsolated, kIsolatedDir},
+        {kFileSystemTypeExternal, kExternalDir},
+        {kFileSystemTypeTest, kTestDir},
+    };
 
   // A path of the inner_url contains only mount type part (e.g. "/temporary").
   DCHECK(url.inner_url());
   std::string inner_path = url.inner_url()->path();
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kValidTypes); ++i) {
     if (inner_path == kValidTypes[i].dir) {
       file_system_type = kValidTypes[i].type;
       break;
     }
   }
 
   if (file_system_type == kFileSystemTypeUnknown)
     return false;
 
-  std::string path = net::UnescapeURLComponent(url.path(),
+  std::string path = net::UnescapeURLComponent(
+      url.path(),
       net::UnescapeRule::SPACES | net::UnescapeRule::URL_SPECIAL_CHARS |
-      net::UnescapeRule::CONTROL_CHARS);
+          net::UnescapeRule::CONTROL_CHARS);
 
   // Ensure the path is relative.
   while (!path.empty() && path[0] == '/')
     path.erase(0, 1);
 
   base::FilePath converted_path = base::FilePath::FromUTF8Unsafe(path);
 
   // All parent references should have been resolved in the renderer.
   if (converted_path.ReferencesParent())
     return false;
 
   if (origin_url)
     *origin_url = url.GetOrigin();
   if (type)
     *type = file_system_type;
   if (virtual_path)
-    *virtual_path = converted_path.NormalizePathSeparators().
-        StripTrailingSeparators();
+    *virtual_path =
+        converted_path.NormalizePathSeparators().StripTrailingSeparators();
 
   return true;
 }
 
 GURL GetFileSystemRootURI(const GURL& origin_url, FileSystemType type) {
   // origin_url is based on a security origin, so http://foo.com or file:///
   // instead of the corresponding filesystem URL.
   DCHECK(!origin_url.SchemeIsFileSystem());
 
   std::string url = "filesystem:" + origin_url.GetWithEmptyPath().spec();
   switch (type) {
     case kFileSystemTypeTemporary:
       url += (kTemporaryDir + 1);  // We don't want the leading slash.
       return GURL(url + "/");
     case kFileSystemTypePersistent:
       url += (kPersistentDir + 1);  // We don't want the leading slash.
       return GURL(url + "/");
     case kFileSystemTypeExternal:
       url += (kExternalDir + 1);  // We don't want the leading slash.
       return GURL(url + "/");
     case kFileSystemTypeIsolated:
       url += (kIsolatedDir + 1);  // We don't want the leading slash.
       return GURL(url + "/");
     case kFileSystemTypeTest:
       url += (kTestDir + 1);  // We don't want the leading slash.
       return GURL(url + "/");
-      // Internal types are always pointed via isolated or external URLs.
+    // Internal types are always pointed via isolated or external URLs.
     default:
       NOTREACHED();
   }
   NOTREACHED();
   return GURL();
 }
 
 std::string GetFileSystemName(const GURL& origin_url, FileSystemType type) {
   std::string origin_identifier =
       webkit_database::GetIdentifierFromOrigin(origin_url);
@@ skipping 75 matching lines @@
       return "PluginPrivate";
     case kFileSystemTypeCloudDevice:
       return "CloudDevice";
     case kFileSystemTypeProvided:
       return "Provided";
     case kFileSystemTypeDeviceMediaAsFileStorage:
       return "DeviceMediaStorage";
     case kFileSystemInternalTypeEnumStart:
     case kFileSystemInternalTypeEnumEnd:
       NOTREACHED();
-      // Fall through.
+    // Fall through.
     case kFileSystemTypeUnknown:
       return "Unknown";
   }
   NOTREACHED();
   return std::string();
 }
 
 std::string FilePathToString(const base::FilePath& file_path) {
 #if defined(OS_WIN)
   return base::UTF16ToUTF8(file_path.value());
 #elif defined(OS_POSIX)
   return file_path.value();
 #endif
 }
 
 base::FilePath StringToFilePath(const std::string& file_path_string) {
 #if defined(OS_WIN)
   return base::FilePath(base::UTF8ToUTF16(file_path_string));
 #elif defined(OS_POSIX)
   return base::FilePath(file_path_string);
 #endif
 }
 
-blink::WebFileError FileErrorToWebFileError(
-    base::File::Error error_code) {
+blink::WebFileError FileErrorToWebFileError(base::File::Error error_code) {
   switch (error_code) {
     case base::File::FILE_ERROR_NOT_FOUND:
       return blink::WebFileErrorNotFound;
     case base::File::FILE_ERROR_INVALID_OPERATION:
     case base::File::FILE_ERROR_EXISTS:
     case base::File::FILE_ERROR_NOT_EMPTY:
       return blink::WebFileErrorInvalidModification;
     case base::File::FILE_ERROR_NOT_A_DIRECTORY:
     case base::File::FILE_ERROR_NOT_A_FILE:
       return blink::WebFileErrorTypeMismatch;
     case base::File::FILE_ERROR_ACCESS_DENIED:
       return blink::WebFileErrorNoModificationAllowed;
     case base::File::FILE_ERROR_FAILED:
       return blink::WebFileErrorInvalidState;
     case base::File::FILE_ERROR_ABORT:
       return blink::WebFileErrorAbort;
     case base::File::FILE_ERROR_SECURITY:
       return blink::WebFileErrorSecurity;
     case base::File::FILE_ERROR_NO_SPACE:
       return blink::WebFileErrorQuotaExceeded;
     case base::File::FILE_ERROR_INVALID_URL:
       return blink::WebFileErrorEncoding;
     default:
       return blink::WebFileErrorInvalidModification;
   }
 }
 
-bool GetFileSystemPublicType(
-    const std::string type_string,
-    blink::WebFileSystemType* type) {
+bool GetFileSystemPublicType(const std::string type_string,
+                             blink::WebFileSystemType* type) {
   DCHECK(type);
   if (type_string == "Temporary") {
     *type = blink::WebFileSystemTypeTemporary;
     return true;
   }
   if (type_string == "Persistent") {
     *type = blink::WebFileSystemTypePersistent;
     return true;
   }
   if (type_string == "Isolated") {
     *type = blink::WebFileSystemTypeIsolated;
     return true;
   }
   if (type_string == "External") {
     *type = blink::WebFileSystemTypeExternal;
     return true;
   }
   NOTREACHED();
   return false;
 }
 
 std::string GetIsolatedFileSystemName(const GURL& origin_url,
                                       const std::string& filesystem_id) {
-  std::string name(fileapi::GetFileSystemName(
-      origin_url, fileapi::kFileSystemTypeIsolated));
+  std::string name(
+      storage::GetFileSystemName(origin_url, storage::kFileSystemTypeIsolated));
   name.append("_");
   name.append(filesystem_id);
   return name;
 }
 
 bool CrackIsolatedFileSystemName(const std::string& filesystem_name,
                                  std::string* filesystem_id) {
   DCHECK(filesystem_id);
 
   // |filesystem_name| is of the form {origin}:isolated_{filesystem_id}.
   std::string start_token(":");
-  start_token = start_token.append(
-      GetFileSystemTypeString(kFileSystemTypeIsolated)).append("_");
+  start_token =
+      start_token.append(GetFileSystemTypeString(kFileSystemTypeIsolated))
+          .append("_");
   // WebKit uses different case in its constant for isolated file system
   // names, so we do a case insensitive compare by converting both strings
   // to uppercase.
   // TODO(benwells): Remove this when WebKit uses the same constant.
   start_token = StringToUpperASCII(start_token);
   std::string filesystem_name_upper = StringToUpperASCII(filesystem_name);
   size_t pos = filesystem_name_upper.find(start_token);
   if (pos == std::string::npos)
     return false;
   if (pos == 0)
     return false;
 
-  *filesystem_id = filesystem_name.substr(pos + start_token.length(),
-                                          std::string::npos);
+  *filesystem_id =
+      filesystem_name.substr(pos + start_token.length(), std::string::npos);
   if (filesystem_id->empty())
     return false;
 
   return true;
 }
 
 bool ValidateIsolatedFileSystemId(const std::string& filesystem_id) {
   const size_t kExpectedFileSystemIdSize = 32;
   if (filesystem_id.size() != kExpectedFileSystemIdSize)
     return false;
   const std::string kExpectedChars("ABCDEF0123456789");
   return base::ContainsOnlyChars(filesystem_id, kExpectedChars);
 }
 
 std::string GetIsolatedFileSystemRootURIString(
     const GURL& origin_url,
     const std::string& filesystem_id,
     const std::string& optional_root_name) {
-  std::string root = GetFileSystemRootURI(origin_url,
-                                          kFileSystemTypeIsolated).spec();
+  std::string root =
+      GetFileSystemRootURI(origin_url, kFileSystemTypeIsolated).spec();
   if (base::FilePath::FromUTF8Unsafe(filesystem_id).ReferencesParent())
     return std::string();
   root.append(net::EscapePath(filesystem_id));
   root.append("/");
   if (!optional_root_name.empty()) {
     if (base::FilePath::FromUTF8Unsafe(optional_root_name).ReferencesParent())
       return std::string();
     root.append(net::EscapePath(optional_root_name));
     root.append("/");
   }
   return root;
 }
 
-std::string GetExternalFileSystemRootURIString(
-    const GURL& origin_url,
-    const std::string& mount_name) {
-  std::string root = GetFileSystemRootURI(origin_url,
-                                          kFileSystemTypeExternal).spec();
+std::string GetExternalFileSystemRootURIString(const GURL& origin_url,
+                                               const std::string& mount_name) {
+  std::string root =
+      GetFileSystemRootURI(origin_url, kFileSystemTypeExternal).spec();
   if (base::FilePath::FromUTF8Unsafe(mount_name).ReferencesParent())
     return std::string();
   root.append(net::EscapePath(mount_name));
   root.append("/");
   return root;
 }
 
 base::File::Error NetErrorToFileError(int error) {
   switch (error) {
     case net::OK:
@@ skipping 19 matching lines @@
     case net::ERR_CONNECTION_ABORTED:
       return base::File::FILE_ERROR_ABORT;
     case net::ERR_ADDRESS_INVALID:
     case net::ERR_INVALID_URL:
       return base::File::FILE_ERROR_INVALID_URL;
     default:
       return base::File::FILE_ERROR_FAILED;
   }
 }
 
-}  // namespace fileapi
+}  // namespace storage