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

webkit/browser/fileapi/obfuscated_file_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/browser/fileapi/obfuscated_file_util.h"
 
 #include <queue>
 #include <string>
 #include <vector>
 
@@ skipping 25 matching lines @@
 
 // Example of various paths:
 //   void ObfuscatedFileUtil::DoSomething(const FileSystemURL& url) {
 //     base::FilePath virtual_path = url.path();
 //     base::FilePath local_path = GetLocalFilePath(url);
 //
 //     NativeFileUtil::DoSomething(local_path);
 //     file_util::DoAnother(local_path);
 //  }
 
-namespace fileapi {
+namespace storage {
 
 namespace {
 
 typedef SandboxDirectoryDatabase::FileId FileId;
 typedef SandboxDirectoryDatabase::FileInfo FileInfo;
 
 void InitFileInfo(
     SandboxDirectoryDatabase::FileInfo* file_info,
     SandboxDirectoryDatabase::FileId parent_id,
     const base::FilePath::StringType& file_name) {
   DCHECK(file_info);
   file_info->parent_id = parent_id;
   file_info->name = file_name;
 }
 
 // Costs computed as per crbug.com/86114, based on the LevelDB implementation of
 // path storage under Linux.  It's not clear if that will differ on Windows, on
 // which base::FilePath uses wide chars [since they're converted to UTF-8 for
 // storage anyway], but as long as the cost is high enough that one can't cheat
 // on quota by storing data in paths, it doesn't need to be all that accurate.
 const int64 kPathCreationQuotaCost = 146;  // Bytes per inode, basically.
 const int64 kPathByteQuotaCost = 2;  // Bytes per byte of path length in UTF-8.
 
 int64 UsageForPath(size_t length) {
   return kPathCreationQuotaCost +
       static_cast<int64>(length) * kPathByteQuotaCost;
 }
 
 bool AllocateQuota(FileSystemOperationContext* context, int64 growth) {
-  if (context->allowed_bytes_growth() == quota::QuotaManager::kNoLimit)
+  if (context->allowed_bytes_growth() == storage::QuotaManager::kNoLimit)
     return true;
 
   int64 new_quota = context->allowed_bytes_growth() - growth;
   if (growth > 0 && new_quota < 0)
     return false;
   context->set_allowed_bytes_growth(new_quota);
   return true;
 }
 
 void UpdateUsage(
@@ skipping 133 matching lines @@
   virtual ~ObfuscatedOriginEnumerator() {}
 
   // Returns the next origin.  Returns empty if there are no more origins.
   virtual GURL Next() OVERRIDE {
     OriginRecord record;
     if (!origins_.empty()) {
       record = origins_.back();
       origins_.pop_back();
     }
     current_ = record;
-    return webkit_database::GetOriginFromIdentifier(record.origin);
+    return storage::GetOriginFromIdentifier(record.origin);
   }
 
   // Returns the current origin's information.
   virtual bool HasTypeDirectory(const std::string& type_string) const OVERRIDE {
     if (current_.path.empty())
       return false;
     if (type_string.empty()) {
       NOTREACHED();
       return false;
     }
     base::FilePath path =
         base_file_path_.Append(current_.path).AppendASCII(type_string);
     return base::DirectoryExists(path);
   }
 
  private:
   std::vector<OriginRecord> origins_;
   OriginRecord current_;
   base::FilePath base_file_path_;
 };
 
 ObfuscatedFileUtil::ObfuscatedFileUtil(
-    quota::SpecialStoragePolicy* special_storage_policy,
+    storage::SpecialStoragePolicy* special_storage_policy,
     const base::FilePath& file_system_directory,
     leveldb::Env* env_override,
     base::SequencedTaskRunner* file_task_runner,
     const GetTypeStringForURLCallback& get_type_string_for_url,
     const std::set<std::string>& known_type_strings,
     SandboxFileSystemBackendDelegate* sandbox_delegate)
     : special_storage_policy_(special_storage_policy),
       file_system_directory_(file_system_directory),
       env_override_(env_override),
       db_flush_delay_seconds_(10 * 60),  // 10 mins.
       file_task_runner_(file_task_runner),
       get_type_string_for_url_(get_type_string_for_url),
       known_type_strings_(known_type_strings),
       sandbox_delegate_(sandbox_delegate) {
 }
 
 ObfuscatedFileUtil::~ObfuscatedFileUtil() {
   DropDatabases();
 }
 
 base::File ObfuscatedFileUtil::CreateOrOpen(
     FileSystemOperationContext* context,
     const FileSystemURL& url, int file_flags) {
   base::File file = CreateOrOpenInternal(context, url, file_flags);
   if (file.IsValid() && file_flags & base::File::FLAG_WRITE &&
-      context->quota_limit_type() == quota::kQuotaLimitTypeUnlimited &&
+      context->quota_limit_type() == storage::kQuotaLimitTypeUnlimited &&
       sandbox_delegate_) {
     sandbox_delegate_->StickyInvalidateUsageCache(url.origin(), url.type());
   }
   return file.Pass();
 }
 
 base::File::Error ObfuscatedFileUtil::EnsureFileExists(
     FileSystemOperationContext* context,
     const FileSystemURL& url,
     bool* created) {
@@ skipping 282 matching lines @@
    * Move-without-overwrite
    *  Just update metadata
    */
   error = base::File::FILE_ERROR_FAILED;
   if (copy) {
     if (overwrite) {
       error = NativeFileUtil::CopyOrMoveFile(
           src_local_path,
           dest_local_path,
           option,
-          fileapi::NativeFileUtil::CopyOrMoveModeForDestination(
+          storage::NativeFileUtil::CopyOrMoveModeForDestination(
               dest_url, true /* copy */));
     } else {  // non-overwrite
       error = CreateFile(context, src_local_path, dest_url, &dest_file_info);
     }
   } else {
     if (overwrite) {
       if (db->OverwritingMoveFile(src_file_id, dest_file_id)) {
         if (base::File::FILE_OK !=
             NativeFileUtil::DeleteFile(dest_local_path))
           LOG(WARNING) << "Leaked a backing file.";
@@ skipping 82 matching lines @@
   else
     growth += UsageForPath(dest_file_info.name.size());
   if (!AllocateQuota(context, growth))
     return base::File::FILE_ERROR_NO_SPACE;
 
   base::File::Error error;
   if (overwrite) {
     base::FilePath dest_local_path =
         DataPathToLocalPath(dest_url, dest_file_info.data_path);
     error = NativeFileUtil::CopyOrMoveFile(
-        src_file_path, dest_local_path,
+        src_file_path,
+        dest_local_path,
         FileSystemOperation::OPTION_NONE,
-        fileapi::NativeFileUtil::CopyOrMoveModeForDestination(dest_url,
+        storage::NativeFileUtil::CopyOrMoveModeForDestination(dest_url,
                                                               true /* copy */));
   } else {
     error = CreateFile(context, src_file_path, dest_url, &dest_file_info);
   }
 
   if (error != base::File::FILE_OK)
     return error;
 
   if (overwrite) {
     context->change_observers()->Notify(
@@ skipping 72 matching lines @@
     return base::File::FILE_ERROR_NOT_EMPTY;
   int64 growth = -UsageForPath(file_info.name.size());
   AllocateQuota(context, growth);
   UpdateUsage(context, url, growth);
   TouchDirectory(db, file_info.parent_id);
   context->change_observers()->Notify(
       &FileChangeObserver::OnRemoveDirectory, MakeTuple(url));
   return base::File::FILE_OK;
 }
 
-webkit_blob::ScopedFile ObfuscatedFileUtil::CreateSnapshotFile(
+storage::ScopedFile ObfuscatedFileUtil::CreateSnapshotFile(
     FileSystemOperationContext* context,
     const FileSystemURL& url,
     base::File::Error* error,
     base::File::Info* file_info,
     base::FilePath* platform_path) {
   // We're just returning the local file information.
   *error = GetFileInfo(context, url, file_info, platform_path);
   if (*error == base::File::FILE_OK && file_info->is_directory) {
     *file_info = base::File::Info();
     *error = base::File::FILE_ERROR_NOT_A_FILE;
   }
-  return webkit_blob::ScopedFile();
+  return storage::ScopedFile();
 }
 
 scoped_ptr<FileSystemFileUtil::AbstractFileEnumerator>
     ObfuscatedFileUtil::CreateFileEnumerator(
     FileSystemOperationContext* context,
     const FileSystemURL& root_url,
     bool recursive) {
   SandboxDirectoryDatabase* db = GetDirectoryDatabase(root_url, false);
   if (!db) {
     return scoped_ptr<AbstractFileEnumerator>(new EmptyFileEnumerator());
@@ skipping 87 matching lines @@
         // Other type's directory exists; just return true here.
         return true;
       }
     }
   }
 
   // No other directories seem exist. Try deleting the entire origin directory.
   InitOriginDatabase(origin, false);
   if (origin_database_) {
     origin_database_->RemovePathForOrigin(
-        webkit_database::GetIdentifierFromOrigin(origin));
+        storage::GetIdentifierFromOrigin(origin));
   }
   if (!base::DeleteFile(origin_path, true /* recursive */))
     return false;
 
   return true;
 }
 
 ObfuscatedFileUtil::AbstractOriginEnumerator*
 ObfuscatedFileUtil::CreateOriginEnumerator() {
   std::vector<SandboxOriginDatabase::OriginRecord> origins;
@@ skipping 29 matching lines @@
   return UsageForPath(VirtualPath::BaseName(path).value().size());
 }
 
 void ObfuscatedFileUtil::MaybePrepopulateDatabase(
     const std::vector<std::string>& type_strings_to_prepopulate) {
   SandboxPrioritizedOriginDatabase database(file_system_directory_,
                                             env_override_);
   std::string origin_string = database.GetPrimaryOrigin();
   if (origin_string.empty() || !database.HasOriginPath(origin_string))
     return;
-  const GURL origin = webkit_database::GetOriginFromIdentifier(origin_string);
+  const GURL origin = storage::GetOriginFromIdentifier(origin_string);
 
   // Prepopulate the directory database(s) if and only if this instance
   // has primary origin and the directory database is already there.
   for (size_t i = 0; i < type_strings_to_prepopulate.size(); ++i) {
     const std::string type_string = type_strings_to_prepopulate[i];
     // Only handles known types.
     if (!ContainsKey(known_type_strings_, type_string))
       continue;
     base::File::Error error = base::File::FILE_ERROR_FAILED;
     base::FilePath path = GetDirectoryForOriginAndType(
@@ skipping 131 matching lines @@
     if (base::PathExists(dest_local_path)) {
       if (!base::DeleteFile(dest_local_path, true /* recursive */))
         return base::File::FILE_ERROR_FAILED;
       LOG(WARNING) << "A stray file detected";
       InvalidateUsageCache(context, dest_url.origin(), dest_url.type());
     }
 
     error = NativeFileUtil::EnsureFileExists(dest_local_path, &created);
   } else {
     error = NativeFileUtil::CopyOrMoveFile(
-        src_file_path, dest_local_path,
+        src_file_path,
+        dest_local_path,
         FileSystemOperation::OPTION_NONE,
-        fileapi::NativeFileUtil::CopyOrMoveModeForDestination(dest_url,
+        storage::NativeFileUtil::CopyOrMoveModeForDestination(dest_url,
                                                               true /* copy */));
     created = true;
   }
   if (error != base::File::FILE_OK)
     return error;
   if (!created)
     return base::File::FILE_ERROR_FAILED;
 
   return CommitCreateFile(root, dest_local_path, db, dest_file_info);
 }
@@ skipping 26 matching lines @@
   return root.Append(data_path);
 }
 
 std::string ObfuscatedFileUtil::GetDirectoryDatabaseKey(
     const GURL& origin, const std::string& type_string) {
   if (type_string.empty()) {
     LOG(WARNING) << "Unknown filesystem type requested:" << type_string;
     return std::string();
   }
   // For isolated origin we just use a type string as a key.
-  return webkit_database::GetIdentifierFromOrigin(origin) +
-      type_string;
+  return storage::GetIdentifierFromOrigin(origin) + type_string;
 }
 
 // TODO(ericu): How to do the whole validation-without-creation thing?
 // We may not have quota even to create the database.
 // Ah, in that case don't even get here?
 // Still doesn't answer the quota issue, though.
 SandboxDirectoryDatabase* ObfuscatedFileUtil::GetDirectoryDatabase(
     const FileSystemURL& url, bool create) {
   std::string key = GetDirectoryDatabaseKey(
       url.origin(), CallGetTypeStringForURL(url));
@@ skipping 24 matching lines @@
     const GURL& origin, bool create, base::File::Error* error_code) {
   if (!InitOriginDatabase(origin, create)) {
     if (error_code) {
       *error_code = create ?
           base::File::FILE_ERROR_FAILED :
           base::File::FILE_ERROR_NOT_FOUND;
     }
     return base::FilePath();
   }
   base::FilePath directory_name;
-  std::string id = webkit_database::GetIdentifierFromOrigin(origin);
+  std::string id = storage::GetIdentifierFromOrigin(origin);
 
   bool exists_in_db = origin_database_->HasOriginPath(id);
   if (!exists_in_db && !create) {
     if (error_code)
       *error_code = base::File::FILE_ERROR_NOT_FOUND;
     return base::FilePath();
   }
   if (!origin_database_->GetPathForOrigin(id, &directory_name)) {
     if (error_code)
       *error_code = base::File::FILE_ERROR_FAILED;
@@ skipping 72 matching lines @@
 
   SandboxPrioritizedOriginDatabase* prioritized_origin_database =
       new SandboxPrioritizedOriginDatabase(file_system_directory_,
                                            env_override_);
   origin_database_.reset(prioritized_origin_database);
 
   if (origin_hint.is_empty() || !HasIsolatedStorage(origin_hint))
     return true;
 
   const std::string isolated_origin_string =
-      webkit_database::GetIdentifierFromOrigin(origin_hint);
+      storage::GetIdentifierFromOrigin(origin_hint);
 
   // TODO(kinuko): Deprecate this after a few release cycles, e.g. around M33.
   base::FilePath isolated_origin_dir = file_system_directory_.Append(
       SandboxIsolatedOriginDatabase::kObsoleteOriginDirectory);
   if (base::DirectoryExists(isolated_origin_dir) &&
       prioritized_origin_database->GetSandboxOriginDatabase()) {
     SandboxIsolatedOriginDatabase::MigrateBackFromObsoleteOriginDatabase(
         isolated_origin_string,
         file_system_directory_,
         prioritized_origin_database->GetSandboxOriginDatabase());
@@ skipping 112 matching lines @@
         &FileChangeObserver::OnModifyFile, MakeTuple(url));
   }
   return file.Pass();
 }
 
 bool ObfuscatedFileUtil::HasIsolatedStorage(const GURL& origin) {
   return special_storage_policy_.get() &&
       special_storage_policy_->HasIsolatedStorage(origin);
 }
 
-}  // namespace fileapi
+}  // namespace storage