Collapse fileapi, webkit_blob, webkit_database, quota, and webkit_common namespaces into single sto…

webkit/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 <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"
 
-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 200 matching lines @@
       return GURL(url + "/");
       // 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);
+  std::string origin_identifier = storage::GetIdentifierFromOrigin(origin_url);
   std::string type_string = GetFileSystemTypeString(type);
   DCHECK(!type_string.empty());
   return origin_identifier + ":" + type_string;
 }
 
 FileSystemType QuotaStorageTypeToFileSystemType(
-    quota::StorageType storage_type) {
+    storage::StorageType storage_type) {
   switch (storage_type) {
-    case quota::kStorageTypeTemporary:
+    case storage::kStorageTypeTemporary:
       return kFileSystemTypeTemporary;
-    case quota::kStorageTypePersistent:
+    case storage::kStorageTypePersistent:
       return kFileSystemTypePersistent;
-    case quota::kStorageTypeSyncable:
+    case storage::kStorageTypeSyncable:
       return kFileSystemTypeSyncable;
-    case quota::kStorageTypeQuotaNotManaged:
-    case quota::kStorageTypeUnknown:
+    case storage::kStorageTypeQuotaNotManaged:
+    case storage::kStorageTypeUnknown:
       return kFileSystemTypeUnknown;
   }
   return kFileSystemTypeUnknown;
 }
 
-quota::StorageType FileSystemTypeToQuotaStorageType(FileSystemType type) {
+storage::StorageType FileSystemTypeToQuotaStorageType(FileSystemType type) {
   switch (type) {
     case kFileSystemTypeTemporary:
-      return quota::kStorageTypeTemporary;
+      return storage::kStorageTypeTemporary;
     case kFileSystemTypePersistent:
-      return quota::kStorageTypePersistent;
+      return storage::kStorageTypePersistent;
     case kFileSystemTypeSyncable:
     case kFileSystemTypeSyncableForInternalSync:
-      return quota::kStorageTypeSyncable;
+      return storage::kStorageTypeSyncable;
     case kFileSystemTypePluginPrivate:
-      return quota::kStorageTypeQuotaNotManaged;
+      return storage::kStorageTypeQuotaNotManaged;
     default:
-      return quota::kStorageTypeUnknown;
+      return storage::kStorageTypeUnknown;
   }
 }
 
 std::string GetFileSystemTypeString(FileSystemType type) {
   switch (type) {
     case kFileSystemTypeTemporary:
       return "Temporary";
     case kFileSystemTypePersistent:
       return "Persistent";
     case kFileSystemTypeIsolated:
@@ skipping 110 matching lines @@
   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}.
@@ skipping 84 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