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

content/browser/fileapi/obfuscated_file_util_unittest.cc

 // Copyright 2013 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 <set>
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/file_util.h"
@@ skipping 17 matching lines @@
 #include "webkit/browser/fileapi/obfuscated_file_util.h"
 #include "webkit/browser/fileapi/sandbox_directory_database.h"
 #include "webkit/browser/fileapi/sandbox_file_system_backend_delegate.h"
 #include "webkit/browser/fileapi/sandbox_isolated_origin_database.h"
 #include "webkit/browser/fileapi/sandbox_origin_database.h"
 #include "webkit/browser/quota/quota_manager.h"
 #include "webkit/common/database/database_identifier.h"
 #include "webkit/common/quota/quota_types.h"
 
 using content::AsyncFileTestHelper;
-using fileapi::FileSystemContext;
-using fileapi::FileSystemOperation;
-using fileapi::FileSystemOperationContext;
-using fileapi::FileSystemURL;
-using fileapi::ObfuscatedFileUtil;
-using fileapi::SandboxDirectoryDatabase;
-using fileapi::SandboxIsolatedOriginDatabase;
-using fileapi::kFileSystemTypeTemporary;
-using fileapi::kFileSystemTypePersistent;
+using storage::FileSystemContext;
+using storage::FileSystemOperation;
+using storage::FileSystemOperationContext;
+using storage::FileSystemURL;
+using storage::ObfuscatedFileUtil;
+using storage::SandboxDirectoryDatabase;
+using storage::SandboxIsolatedOriginDatabase;
+using storage::kFileSystemTypeTemporary;
+using storage::kFileSystemTypePersistent;
 
 namespace content {
 
 namespace {
 
 bool FileExists(const base::FilePath& path) {
   return base::PathExists(path) && !base::DirectoryExists(path);
 }
 
 int64 GetSize(const base::FilePath& path) {
@@ skipping 57 matching lines @@
 FileSystemURL FileSystemURLAppendUTF8(
     const FileSystemURL& url, const std::string& child) {
   return FileSystemURL::CreateForTest(
       url.origin(),
       url.mount_type(),
       url.virtual_path().Append(base::FilePath::FromUTF8Unsafe(child)));
 }
 
 FileSystemURL FileSystemURLDirName(const FileSystemURL& url) {
   return FileSystemURL::CreateForTest(
-      url.origin(), url.mount_type(),
-      fileapi::VirtualPath::DirName(url.virtual_path()));
+      url.origin(),
+      url.mount_type(),
+      storage::VirtualPath::DirName(url.virtual_path()));
 }
 
-std::string GetTypeString(fileapi::FileSystemType type) {
-  return fileapi::SandboxFileSystemBackendDelegate::GetTypeString(type);
+std::string GetTypeString(storage::FileSystemType type) {
+  return storage::SandboxFileSystemBackendDelegate::GetTypeString(type);
 }
 
 bool HasFileSystemType(ObfuscatedFileUtil::AbstractOriginEnumerator* enumerator,
-                       fileapi::FileSystemType type) {
+                       storage::FileSystemType type) {
   return enumerator->HasTypeDirectory(GetTypeString(type));
 }
 
 }  // namespace
 
 // TODO(ericu): The vast majority of this and the other FSFU subclass tests
 // could theoretically be shared.  It would basically be a FSFU interface
 // compliance test, and only the subclass-specific bits that look into the
 // implementation would need to be written per-subclass.
 class ObfuscatedFileUtilTest : public testing::Test {
  public:
   ObfuscatedFileUtilTest()
       : origin_(GURL("http://www.example.com")),
-        type_(fileapi::kFileSystemTypeTemporary),
+        type_(storage::kFileSystemTypeTemporary),
         weak_factory_(this),
         sandbox_file_system_(origin_, type_),
-        quota_status_(quota::kQuotaStatusUnknown),
-        usage_(-1) {
-  }
+        quota_status_(storage::kQuotaStatusUnknown),
+        usage_(-1) {}
 
   virtual void SetUp() {
     ASSERT_TRUE(data_dir_.CreateUniqueTempDir());
 
     storage_policy_ = new MockSpecialStoragePolicy();
 
     quota_manager_ =
-        new quota::QuotaManager(false /* is_incognito */,
-                                data_dir_.path(),
-                                base::MessageLoopProxy::current().get(),
-                                base::MessageLoopProxy::current().get(),
-                                storage_policy_.get());
+        new storage::QuotaManager(false /* is_incognito */,
+                                  data_dir_.path(),
+                                  base::MessageLoopProxy::current().get(),
+                                  base::MessageLoopProxy::current().get(),
+                                  storage_policy_.get());
 
     // Every time we create a new sandbox_file_system helper,
     // it creates another context, which creates another path manager,
     // another sandbox_backend, and another OFU.
     // We need to pass in the context to skip all that.
     file_system_context_ = CreateFileSystemContextForTesting(
         quota_manager_->proxy(),
         data_dir_.path());
 
     sandbox_file_system_.SetUp(file_system_context_.get());
 
-    change_observers_ = fileapi::MockFileChangeObserver::CreateList(
-        &change_observer_);
+    change_observers_ =
+        storage::MockFileChangeObserver::CreateList(&change_observer_);
   }
 
   virtual void TearDown() {
     quota_manager_ = NULL;
     sandbox_file_system_.TearDown();
   }
 
   scoped_ptr<FileSystemOperationContext> LimitedContext(
       int64 allowed_bytes_growth) {
     scoped_ptr<FileSystemOperationContext> context(
@@ skipping 13 matching lines @@
     if (file_system)
       context = file_system->NewOperationContext();
     else
       context = sandbox_file_system_.NewOperationContext();
     // Setting allowed_bytes_growth big enough for all tests.
     context->set_allowed_bytes_growth(1024 * 1024);
     context->set_change_observers(change_observers());
     return context;
   }
 
-  const fileapi::ChangeObserverList& change_observers() const {
+  const storage::ChangeObserverList& change_observers() const {
     return change_observers_;
   }
 
-  fileapi::MockFileChangeObserver* change_observer() {
+  storage::MockFileChangeObserver* change_observer() {
     return &change_observer_;
   }
 
   // This can only be used after SetUp has run and created file_system_context_
   // and obfuscated_file_util_.
   // Use this for tests which need to run in multiple origins; we need a test
   // helper per origin.
-  SandboxFileSystemTestHelper* NewFileSystem(
-      const GURL& origin, fileapi::FileSystemType type) {
+  SandboxFileSystemTestHelper* NewFileSystem(const GURL& origin,
+                                             storage::FileSystemType type) {
     SandboxFileSystemTestHelper* file_system =
         new SandboxFileSystemTestHelper(origin, type);
 
     file_system->SetUp(file_system_context_.get());
     return file_system;
   }
 
   scoped_ptr<ObfuscatedFileUtil> CreateObfuscatedFileUtil(
-      quota::SpecialStoragePolicy* storage_policy) {
+      storage::SpecialStoragePolicy* storage_policy) {
     return scoped_ptr<ObfuscatedFileUtil>(
       ObfuscatedFileUtil::CreateForTesting(
           storage_policy, data_dir_path(), NULL,
           base::MessageLoopProxy::current().get()));
   }
 
   ObfuscatedFileUtil* ofu() {
     return static_cast<ObfuscatedFileUtil*>(sandbox_file_system_.file_util());
   }
 
   const base::FilePath& test_directory() const {
     return data_dir_.path();
   }
 
   const GURL& origin() const {
     return origin_;
   }
 
-  fileapi::FileSystemType type() const {
-    return type_;
-  }
+  storage::FileSystemType type() const { return type_; }
 
   std::string type_string() const {
     return GetTypeString(type_);
   }
 
   int64 ComputeTotalFileSize() {
     return sandbox_file_system_.ComputeCurrentOriginUsage() -
         sandbox_file_system_.ComputeCurrentDirectoryDatabaseUsage();
   }
 
   void GetUsageFromQuotaManager() {
     int64 quota = -1;
     quota_status_ =
         AsyncFileTestHelper::GetUsageAndQuota(quota_manager_.get(),
                                               origin(),
                                               sandbox_file_system_.type(),
                                               &usage_,
                                               &quota);
-    EXPECT_EQ(quota::kQuotaStatusOk, quota_status_);
+    EXPECT_EQ(storage::kQuotaStatusOk, quota_status_);
   }
 
   void RevokeUsageCache() {
     quota_manager_->ResetUsageTracker(sandbox_file_system_.storage_type());
     usage_cache()->Delete(sandbox_file_system_.GetUsageCachePath());
   }
 
   int64 SizeByQuotaUtil() {
     return sandbox_file_system_.GetCachedOriginUsage();
   }
@@ skipping 12 matching lines @@
     base::File::Error error = ofu()->GetFileInfo(
         context.get(), url, &file_info, &platform_path);
     return error == base::File::FILE_OK;
   }
 
   bool DirectoryExists(const FileSystemURL& url) {
     return AsyncFileTestHelper::DirectoryExists(file_system_context(), url);
   }
 
   int64 usage() const { return usage_; }
-  fileapi::FileSystemUsageCache* usage_cache() {
+  storage::FileSystemUsageCache* usage_cache() {
     return sandbox_file_system_.usage_cache();
   }
 
   FileSystemURL CreateURLFromUTF8(const std::string& path) {
     return sandbox_file_system_.CreateURLFromUTF8(path);
   }
 
   int64 PathCost(const FileSystemURL& url) {
     return ObfuscatedFileUtil::ComputeFilePathCost(url.path());
   }
@@ skipping 116 matching lines @@
     int64 usage = sandbox_file_system_.GetCachedOriginUsage();
     return scoped_ptr<UsageVerifyHelper>(new UsageVerifyHelper(
         LimitedContext(requested_growth - 1), &sandbox_file_system_, usage));
   }
 
   void FillTestDirectory(
       const FileSystemURL& root_url,
       std::set<base::FilePath::StringType>* files,
       std::set<base::FilePath::StringType>* directories) {
     scoped_ptr<FileSystemOperationContext> context;
-    std::vector<fileapi::DirectoryEntry> entries;
+    std::vector<storage::DirectoryEntry> entries;
     EXPECT_EQ(base::File::FILE_OK,
               AsyncFileTestHelper::ReadDirectory(file_system_context(),
                                                  root_url, &entries));
     EXPECT_EQ(0UL, entries.size());
 
     files->clear();
     files->insert(FILE_PATH_LITERAL("first"));
     files->insert(FILE_PATH_LITERAL("second"));
     files->insert(FILE_PATH_LITERAL("third"));
     directories->clear();
@@ skipping 21 matching lines @@
     }
     ValidateTestDirectory(root_url, *files, *directories);
   }
 
   void TestReadDirectoryHelper(const FileSystemURL& root_url) {
     std::set<base::FilePath::StringType> files;
     std::set<base::FilePath::StringType> directories;
     FillTestDirectory(root_url, &files, &directories);
 
     scoped_ptr<FileSystemOperationContext> context;
-    std::vector<fileapi::DirectoryEntry> entries;
+    std::vector<storage::DirectoryEntry> entries;
     context.reset(NewContext(NULL));
     EXPECT_EQ(base::File::FILE_OK,
               AsyncFileTestHelper::ReadDirectory(
                   file_system_context(), root_url, &entries));
-    std::vector<fileapi::DirectoryEntry>::iterator entry_iter;
+    std::vector<storage::DirectoryEntry>::iterator entry_iter;
     EXPECT_EQ(files.size() + directories.size(), entries.size());
     EXPECT_TRUE(change_observer()->HasNoChange());
     for (entry_iter = entries.begin(); entry_iter != entries.end();
         ++entry_iter) {
-      const fileapi::DirectoryEntry& entry = *entry_iter;
+      const storage::DirectoryEntry& entry = *entry_iter;
       std::set<base::FilePath::StringType>::iterator iter =
           files.find(entry.name);
       if (iter != files.end()) {
         EXPECT_FALSE(entry.is_directory);
         files.erase(iter);
         continue;
       }
       iter = directories.find(entry.name);
       EXPECT_FALSE(directories.end() == iter);
       EXPECT_TRUE(entry.is_directory);
@@ skipping 232 matching lines @@
     ASSERT_EQ(db, db2);
   }
 
   void MigrationBackFromIsolatedTestBody() {
     std::string kFakeDirectoryData("0123456789");
     base::FilePath old_directory_db_path;
 
     // Initialize the directory with one origin using
     // SandboxIsolatedOriginDatabase.
     {
-      std::string origin_string =
-          webkit_database::GetIdentifierFromOrigin(origin_);
+      std::string origin_string = storage::GetIdentifierFromOrigin(origin_);
       SandboxIsolatedOriginDatabase database_old(
           origin_string, data_dir_path(),
           base::FilePath(
               SandboxIsolatedOriginDatabase::kObsoleteOriginDirectory));
       base::FilePath path;
       EXPECT_TRUE(database_old.GetPathForOrigin(origin_string, &path));
       EXPECT_FALSE(path.empty());
 
       // Populate the origin directory with some fake data.
       old_directory_db_path = data_dir_path().Append(path);
@@ skipping 34 matching lines @@
   }
 
   const base::FilePath& data_dir_path() const {
     return data_dir_.path();
   }
 
  protected:
   base::ScopedTempDir data_dir_;
   base::MessageLoop message_loop_;
   scoped_refptr<MockSpecialStoragePolicy> storage_policy_;
-  scoped_refptr<quota::QuotaManager> quota_manager_;
+  scoped_refptr<storage::QuotaManager> quota_manager_;
   scoped_refptr<FileSystemContext> file_system_context_;
   GURL origin_;
-  fileapi::FileSystemType type_;
+  storage::FileSystemType type_;
   base::WeakPtrFactory<ObfuscatedFileUtilTest> weak_factory_;
   SandboxFileSystemTestHelper sandbox_file_system_;
-  quota::QuotaStatusCode quota_status_;
+  storage::QuotaStatusCode quota_status_;
   int64 usage_;
-  fileapi::MockFileChangeObserver change_observer_;
-  fileapi::ChangeObserverList change_observers_;
+  storage::MockFileChangeObserver change_observer_;
+  storage::ChangeObserverList change_observers_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ObfuscatedFileUtilTest);
 };
 
 TEST_F(ObfuscatedFileUtilTest, TestCreateAndDeleteFile) {
   FileSystemURL url = CreateURLFromUTF8("fake/file");
   scoped_ptr<FileSystemOperationContext> context(NewContext(NULL));
   int file_flags = base::File::FLAG_CREATE | base::File::FLAG_WRITE;
 
@@ skipping 386 matching lines @@
 
 TEST_F(ObfuscatedFileUtilTest, TestReadDirectoryOnFile) {
   FileSystemURL url = CreateURLFromUTF8("file");
   scoped_ptr<FileSystemOperationContext> context(NewContext(NULL));
 
   bool created = false;
   ASSERT_EQ(base::File::FILE_OK,
             ofu()->EnsureFileExists(context.get(), url, &created));
   ASSERT_TRUE(created);
 
-  std::vector<fileapi::DirectoryEntry> entries;
+  std::vector<storage::DirectoryEntry> entries;
   EXPECT_EQ(base::File::FILE_ERROR_NOT_A_DIRECTORY,
             AsyncFileTestHelper::ReadDirectory(file_system_context(), url,
                                                &entries));
 
   EXPECT_TRUE(ofu()->IsDirectoryEmpty(context.get(), url));
 }
 
 TEST_F(ObfuscatedFileUtilTest, TestTouch) {
   FileSystemURL url = CreateURLFromUTF8("file");
   scoped_ptr<FileSystemOperationContext> context(NewContext(NULL));
@@ skipping 557 matching lines @@
   scoped_ptr<FileSystemOperationContext> context;
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kPath); ++i) {
     bool created = false;
     context.reset(NewContext(NULL));
     EXPECT_EQ(base::File::FILE_OK,
               ofu()->EnsureFileExists(context.get(), kPath[i], &created));
     EXPECT_TRUE(created);
   }
 
-  std::vector<fileapi::DirectoryEntry> entries;
+  std::vector<storage::DirectoryEntry> entries;
   EXPECT_EQ(base::File::FILE_OK,
             AsyncFileTestHelper::ReadDirectory(
                 file_system_context(), empty_path, &entries));
   EXPECT_EQ(3u, entries.size());
 
   base::FilePath local_path;
   EXPECT_EQ(base::File::FILE_OK,
             ofu()->GetLocalFilePath(context.get(), kPath[0], &local_path));
   EXPECT_TRUE(base::DeleteFile(local_path, false));
 
@@ skipping 224 matching lines @@
             ofu()->GetLocalFilePath(context.get(), url1, &file_path));
   EXPECT_FALSE(file_path.empty());
 
   context.reset(NewContext(NULL));
   EXPECT_EQ(base::File::FILE_OK,
             ofu()->Touch(context.get(), url1,
                          base::Time::Now() + base::TimeDelta::FromHours(1),
                          base::Time()));
 
   context.reset(NewContext(NULL));
-  scoped_ptr<fileapi::FileSystemFileUtil::AbstractFileEnumerator> file_enum(
+  scoped_ptr<storage::FileSystemFileUtil::AbstractFileEnumerator> file_enum(
       ofu()->CreateFileEnumerator(context.get(), dir, false));
 
   int count = 0;
   base::FilePath file_path_each;
   while (!(file_path_each = file_enum->Next()).empty()) {
     context.reset(NewContext(NULL));
     base::File::Info file_info;
     base::FilePath file_path;
     EXPECT_EQ(base::File::FILE_OK,
               ofu()->GetFileInfo(context.get(),
@@ skipping 393 matching lines @@
                                    false /* exclusive */,
                                    true /* recursive */));
   ASSERT_EQ(base::File::FILE_ERROR_NOT_A_DIRECTORY,
             ofu()->CreateDirectory(UnlimitedContext().get(),
                                    path_in_file_in_file,
                                    false /* exclusive */,
                                    true /* recursive */));
 }
 
 }  // namespace content