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

chrome/browser/sync_file_system/local/local_file_sync_context_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 "chrome/browser/sync_file_system/local/local_file_sync_context.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 14 matching lines @@
 #include "third_party/leveldatabase/src/helpers/memenv/memenv.h"
 #include "third_party/leveldatabase/src/include/leveldb/env.h"
 #include "webkit/browser/fileapi/file_system_context.h"
 #include "webkit/browser/fileapi/file_system_operation_runner.h"
 #include "webkit/browser/fileapi/isolated_context.h"
 #include "webkit/common/blob/scoped_file.h"
 
 #define FPL FILE_PATH_LITERAL
 
 using content::BrowserThread;
-using fileapi::FileSystemContext;
-using fileapi::FileSystemURL;
-using fileapi::FileSystemURLSet;
+using storage::FileSystemContext;
+using storage::FileSystemURL;
+using storage::FileSystemURLSet;
 
 // This tests LocalFileSyncContext behavior in multi-thread /
 // multi-file-system-context environment.
 // Basic combined tests (single-thread / single-file-system-context)
 // that involve LocalFileSyncContext are also in
 // syncable_file_system_unittests.cc.
 
 namespace sync_file_system {
 
 namespace {
@@ skipping 26 matching lines @@
 
   virtual void TearDown() OVERRIDE {
     RevokeSyncableFileSystem();
   }
 
   void StartPrepareForSync(FileSystemContext* file_system_context,
                            const FileSystemURL& url,
                            LocalFileSyncContext::SyncMode sync_mode,
                            SyncFileMetadata* metadata,
                            FileChangeList* changes,
-                           webkit_blob::ScopedFile* snapshot) {
+                           storage::ScopedFile* snapshot) {
     ASSERT_TRUE(changes != NULL);
     ASSERT_FALSE(has_inflight_prepare_for_sync_);
     status_ = SYNC_STATUS_UNKNOWN;
     has_inflight_prepare_for_sync_ = true;
     sync_context_->PrepareForSync(
         file_system_context,
         url,
         sync_mode,
         base::Bind(&LocalFileSyncContextTest::DidPrepareForSync,
                    base::Unretained(this), metadata, changes, snapshot));
   }
 
   SyncStatusCode PrepareForSync(FileSystemContext* file_system_context,
                                 const FileSystemURL& url,
                                 LocalFileSyncContext::SyncMode sync_mode,
                                 SyncFileMetadata* metadata,
                                 FileChangeList* changes,
-                                webkit_blob::ScopedFile* snapshot) {
+                                storage::ScopedFile* snapshot) {
     StartPrepareForSync(file_system_context, url, sync_mode,
                         metadata, changes, snapshot);
     base::MessageLoop::current()->Run();
     return status_;
   }
 
   base::Closure GetPrepareForSyncClosure(
       FileSystemContext* file_system_context,
       const FileSystemURL& url,
       LocalFileSyncContext::SyncMode sync_mode,
       SyncFileMetadata* metadata,
       FileChangeList* changes,
-      webkit_blob::ScopedFile* snapshot) {
+      storage::ScopedFile* snapshot) {
     return base::Bind(&LocalFileSyncContextTest::StartPrepareForSync,
                       base::Unretained(this),
                       base::Unretained(file_system_context),
                       url, sync_mode, metadata, changes, snapshot);
   }
 
   void DidPrepareForSync(SyncFileMetadata* metadata_out,
                          FileChangeList* changes_out,
-                         webkit_blob::ScopedFile* snapshot_out,
+                         storage::ScopedFile* snapshot_out,
                          SyncStatusCode status,
                          const LocalFileSyncInfo& sync_file_info,
-                         webkit_blob::ScopedFile snapshot) {
+                         storage::ScopedFile snapshot) {
     ASSERT_TRUE(ui_task_runner_->RunsTasksOnCurrentThread());
     has_inflight_prepare_for_sync_ = false;
     status_ = status;
     *metadata_out = sync_file_info.metadata;
     *changes_out = sync_file_info.changes;
     if (snapshot_out)
       *snapshot_out = snapshot.Pass();
     base::MessageLoop::current()->Quit();
   }
 
@@ skipping 154 matching lines @@
     ASSERT_EQ(SYNC_STATUS_OK,
               file_system.MaybeInitializeFileSystemContext(
                   sync_context_.get()));
     ASSERT_EQ(base::File::FILE_OK, file_system.OpenFileSystem());
 
     const FileSystemURL kFile(file_system.URL("file"));
     EXPECT_EQ(base::File::FILE_OK, file_system.CreateFile(kFile));
 
     SyncFileMetadata metadata;
     FileChangeList changes;
-    webkit_blob::ScopedFile snapshot;
+    storage::ScopedFile snapshot;
     EXPECT_EQ(SYNC_STATUS_OK,
               PrepareForSync(file_system.file_system_context(), kFile,
                              sync_mode, &metadata, &changes, &snapshot));
     EXPECT_EQ(1U, changes.size());
     EXPECT_TRUE(changes.list().back().IsFile());
     EXPECT_TRUE(changes.list().back().IsAddOrUpdate());
 
     EXPECT_EQ(sync_mode == LocalFileSyncContext::SYNC_SNAPSHOT,
               !snapshot.path().empty());
 
@@ skipping 292 matching lines @@
   sync_context_ = new LocalFileSyncContext(
       dir_.path(), in_memory_env_.get(),
       ui_task_runner_.get(), io_task_runner_.get());
   ASSERT_EQ(SYNC_STATUS_OK,
             file_system.MaybeInitializeFileSystemContext(sync_context_.get()));
   ASSERT_EQ(base::File::FILE_OK, file_system.OpenFileSystem());
 
   // Record the initial usage (likely 0).
   int64 initial_usage = -1;
   int64 quota = -1;
-  EXPECT_EQ(quota::kQuotaStatusOk,
+  EXPECT_EQ(storage::kQuotaStatusOk,
             file_system.GetUsageAndQuota(&initial_usage, &quota));
 
   // Create a file and directory in the file_system.
   const FileSystemURL kFile(file_system.URL("file"));
   const FileSystemURL kDir(file_system.URL("dir"));
   const FileSystemURL kChild(file_system.URL("dir/child"));
 
   EXPECT_EQ(base::File::FILE_OK, file_system.CreateFile(kFile));
   EXPECT_EQ(base::File::FILE_OK, file_system.CreateDirectory(kDir));
   EXPECT_EQ(base::File::FILE_OK, file_system.CreateFile(kChild));
 
   // file_system's change tracker must have recorded the creation.
   FileSystemURLSet urls;
   file_system.GetChangedURLsInTracker(&urls);
   ASSERT_EQ(3U, urls.size());
   ASSERT_TRUE(ContainsKey(urls, kFile));
   ASSERT_TRUE(ContainsKey(urls, kDir));
   ASSERT_TRUE(ContainsKey(urls, kChild));
   for (FileSystemURLSet::iterator iter = urls.begin();
        iter != urls.end(); ++iter) {
     file_system.ClearChangeForURLInTracker(*iter);
   }
 
   // At this point the usage must be greater than the initial usage.
   int64 new_usage = -1;
-  EXPECT_EQ(quota::kQuotaStatusOk,
+  EXPECT_EQ(storage::kQuotaStatusOk,
             file_system.GetUsageAndQuota(&new_usage, &quota));
   EXPECT_GT(new_usage, initial_usage);
 
   // Now let's apply remote deletion changes.
   FileChange change(FileChange::FILE_CHANGE_DELETE,
                     SYNC_FILE_TYPE_FILE);
   EXPECT_EQ(SYNC_STATUS_OK,
             ApplyRemoteChange(file_system.file_system_context(),
                               change, base::FilePath(), kFile,
                               SYNC_FILE_TYPE_FILE));
@@ skipping 15 matching lines @@
   EXPECT_EQ(base::File::FILE_ERROR_NOT_FOUND,
             file_system.FileExists(kChild));
 
   // The changes applied by ApplyRemoteChange should not be recorded in
   // the change tracker.
   urls.clear();
   file_system.GetChangedURLsInTracker(&urls);
   EXPECT_TRUE(urls.empty());
 
   // The quota usage data must have reflected the deletion.
-  EXPECT_EQ(quota::kQuotaStatusOk,
+  EXPECT_EQ(storage::kQuotaStatusOk,
             file_system.GetUsageAndQuota(&new_usage, &quota));
   EXPECT_EQ(new_usage, initial_usage);
 
   sync_context_->ShutdownOnUIThread();
   sync_context_ = NULL;
   file_system.TearDown();
 }
 
 TEST_F(LocalFileSyncContextTest, ApplyRemoteChangeForDeletion_ForRoot) {
   CannedSyncableFileSystem file_system(GURL(kOrigin1),
                                        in_memory_env_.get(),
                                        io_task_runner_.get(),
                                        file_task_runner_.get());
   file_system.SetUp(CannedSyncableFileSystem::QUOTA_ENABLED);
 
   sync_context_ = new LocalFileSyncContext(
       dir_.path(), in_memory_env_.get(),
       ui_task_runner_.get(), io_task_runner_.get());
   ASSERT_EQ(SYNC_STATUS_OK,
             file_system.MaybeInitializeFileSystemContext(sync_context_.get()));
   ASSERT_EQ(base::File::FILE_OK, file_system.OpenFileSystem());
 
   // Record the initial usage (likely 0).
   int64 initial_usage = -1;
   int64 quota = -1;
-  EXPECT_EQ(quota::kQuotaStatusOk,
+  EXPECT_EQ(storage::kQuotaStatusOk,
             file_system.GetUsageAndQuota(&initial_usage, &quota));
 
   // Create a file and directory in the file_system.
   const FileSystemURL kFile(file_system.URL("file"));
   const FileSystemURL kDir(file_system.URL("dir"));
   const FileSystemURL kChild(file_system.URL("dir/child"));
 
   EXPECT_EQ(base::File::FILE_OK, file_system.CreateFile(kFile));
   EXPECT_EQ(base::File::FILE_OK, file_system.CreateDirectory(kDir));
   EXPECT_EQ(base::File::FILE_OK, file_system.CreateFile(kChild));
 
   // At this point the usage must be greater than the initial usage.
   int64 new_usage = -1;
-  EXPECT_EQ(quota::kQuotaStatusOk,
+  EXPECT_EQ(storage::kQuotaStatusOk,
             file_system.GetUsageAndQuota(&new_usage, &quota));
   EXPECT_GT(new_usage, initial_usage);
 
   const FileSystemURL kRoot(file_system.URL(""));
 
   // Now let's apply remote deletion changes for the root.
   FileChange change(FileChange::FILE_CHANGE_DELETE, SYNC_FILE_TYPE_DIRECTORY);
   EXPECT_EQ(SYNC_STATUS_OK,
             ApplyRemoteChange(file_system.file_system_context(),
                               change, base::FilePath(), kRoot,
                               SYNC_FILE_TYPE_DIRECTORY));
 
   // Check the directory/files are deleted successfully.
   EXPECT_EQ(base::File::FILE_ERROR_NOT_FOUND,
             file_system.FileExists(kFile));
   EXPECT_EQ(base::File::FILE_ERROR_NOT_FOUND,
             file_system.DirectoryExists(kDir));
   EXPECT_EQ(base::File::FILE_ERROR_NOT_FOUND,
             file_system.FileExists(kChild));
 
   // All changes made for the previous creation must have been also reset.
   FileSystemURLSet urls;
   file_system.GetChangedURLsInTracker(&urls);
   EXPECT_TRUE(urls.empty());
 
   // The quota usage data must have reflected the deletion.
-  EXPECT_EQ(quota::kQuotaStatusOk,
+  EXPECT_EQ(storage::kQuotaStatusOk,
             file_system.GetUsageAndQuota(&new_usage, &quota));
   EXPECT_EQ(new_usage, initial_usage);
 
   sync_context_->ShutdownOnUIThread();
   sync_context_ = NULL;
   file_system.TearDown();
 }
 
 TEST_F(LocalFileSyncContextTest, ApplyRemoteChangeForAddOrUpdate) {
   base::ScopedTempDir temp_dir;
@@ skipping 45 matching lines @@
   ASSERT_EQ(static_cast<int>(arraysize(kTestFileData1) - 1),
             base::WriteFile(kFilePath1, kTestFileData1,
                             arraysize(kTestFileData1) - 1));
   ASSERT_EQ(static_cast<int>(arraysize(kTestFileData2) - 1),
             base::WriteFile(kFilePath2, kTestFileData2,
                             arraysize(kTestFileData2) - 1));
 
   // Record the usage.
   int64 usage = -1, new_usage = -1;
   int64 quota = -1;
-  EXPECT_EQ(quota::kQuotaStatusOk,
+  EXPECT_EQ(storage::kQuotaStatusOk,
             file_system.GetUsageAndQuota(&usage, &quota));
 
   // Here in the local filesystem we have:
   //  * kFile1 with kTestFileData0
   //
   // In the remote side let's assume we have:
   //  * kFile1 with kTestFileData1
   //  * kFile2 with kTestFileData2
   //  * kDir
   //
   // By calling ApplyChange's:
   //  * kFile1 will be updated to have kTestFileData1
   //  * kFile2 will be created
   //  * kDir will be created
 
   // Apply the remote change to kFile1 (which will update the file).
   FileChange change(FileChange::FILE_CHANGE_ADD_OR_UPDATE,
                     SYNC_FILE_TYPE_FILE);
   EXPECT_EQ(SYNC_STATUS_OK,
             ApplyRemoteChange(file_system.file_system_context(),
                               change, kFilePath1, kFile1,
                               SYNC_FILE_TYPE_FILE));
 
   // Check if the usage has been increased by (kTestFileData1 - kTestFileData0).
   const int updated_size =
       arraysize(kTestFileData1) - arraysize(kTestFileData0);
-  EXPECT_EQ(quota::kQuotaStatusOk,
+  EXPECT_EQ(storage::kQuotaStatusOk,
             file_system.GetUsageAndQuota(&new_usage, &quota));
   EXPECT_EQ(updated_size, new_usage - usage);
 
   // Apply remote changes to kFile2 and kDir (should create a file and
   // directory respectively).
   // They are non-existent yet so their expected file type (the last
   // parameter of ApplyRemoteChange) are
   // SYNC_FILE_TYPE_UNKNOWN.
   change = FileChange(FileChange::FILE_CHANGE_ADD_OR_UPDATE,
                       SYNC_FILE_TYPE_FILE);
@@ skipping 26 matching lines @@
   EXPECT_EQ(SYNC_STATUS_OK,
             ApplyRemoteChange(file_system.file_system_context(),
                               change,
                               kFilePath1,
                               kDir,
                               SYNC_FILE_TYPE_FILE));
 
   // Creating a file/directory must have increased the usage more than
   // the size of kTestFileData2.
   new_usage = usage;
-  EXPECT_EQ(quota::kQuotaStatusOk,
+  EXPECT_EQ(storage::kQuotaStatusOk,
             file_system.GetUsageAndQuota(&new_usage, &quota));
   EXPECT_GT(new_usage,
             static_cast<int64>(usage + arraysize(kTestFileData2) - 1));
 
   // The changes applied by ApplyRemoteChange should not be recorded in
   // the change tracker.
   urls.clear();
   file_system.GetChangedURLsInTracker(&urls);
   EXPECT_TRUE(urls.empty());
 
@@ skipping 55 matching lines @@
 
   // Make sure kDir and kFile are created by ApplyRemoteChange.
   EXPECT_EQ(base::File::FILE_OK, file_system.FileExists(kFile));
   EXPECT_EQ(base::File::FILE_OK, file_system.DirectoryExists(kDir));
 
   sync_context_->ShutdownOnUIThread();
   file_system.TearDown();
 }
 
 }  // namespace sync_file_system