Migrated sync_file_type and file_change from namespace fileapi to sync_file_system.

webkit/fileapi/syncable/local_file_sync_context_unittest.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/fileapi/syncable/local_file_sync_context.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/file_path.h"
@@ skipping 16 matching lines @@
 #include "webkit/fileapi/syncable/syncable_file_system_util.h"
 
 #define FPL FILE_PATH_LITERAL
 
 // 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.
 
+using sync_file_system::FileChange;
+using sync_file_system::FileChangeList;
+using sync_file_system::SyncFileType;
+
 namespace fileapi {
 
 namespace {
 const char kOrigin1[] = "http://example.com";
 const char kOrigin2[] = "http://chromium.org";
 const char kServiceName[] = "test";
 }
 
 class LocalFileSyncContextTest : public testing::Test {
  protected:
@@ skipping 253 matching lines @@
   ASSERT_EQ(1U, urls.size());
   EXPECT_TRUE(ContainsKey(urls, kURL2));
 
   SyncFileMetadata metadata;
   FileChangeList changes;
   EXPECT_EQ(SYNC_STATUS_OK, PrepareForSync(file_system1.file_system_context(),
                                            kURL1, &metadata, &changes));
   EXPECT_EQ(1U, changes.size());
   EXPECT_TRUE(changes.list().back().IsFile());
   EXPECT_TRUE(changes.list().back().IsAddOrUpdate());
-  EXPECT_EQ(SYNC_FILE_TYPE_FILE, metadata.file_type);
+  EXPECT_EQ(sync_file_system::SYNC_FILE_TYPE_FILE, metadata.file_type);
   EXPECT_EQ(0, metadata.size);
 
   changes.clear();
   EXPECT_EQ(SYNC_STATUS_OK, PrepareForSync(file_system2.file_system_context(),
                                            kURL2, &metadata, &changes));
   EXPECT_EQ(1U, changes.size());
   EXPECT_FALSE(changes.list().back().IsFile());
   EXPECT_TRUE(changes.list().back().IsAddOrUpdate());
-  EXPECT_EQ(SYNC_FILE_TYPE_DIRECTORY, metadata.file_type);
+  EXPECT_EQ(sync_file_system::SYNC_FILE_TYPE_DIRECTORY, metadata.file_type);
   EXPECT_EQ(0, metadata.size);
 
   sync_context_->ShutdownOnUIThread();
   sync_context_ = NULL;
 
   file_system1.TearDown();
   file_system2.TearDown();
 }
 
 TEST_F(LocalFileSyncContextTest, PrepareSyncWhileWriting) {
   CannedSyncableFileSystem file_system(GURL(kOrigin1), kServiceName,
                                        io_task_runner_, file_task_runner_);
   file_system.SetUp();
   sync_context_ = new LocalFileSyncContext(ui_task_runner_, io_task_runner_);
   EXPECT_EQ(SYNC_STATUS_OK,
             file_system.MaybeInitializeFileSystemContext(sync_context_));
 
   EXPECT_EQ(base::PLATFORM_FILE_OK, file_system.OpenFileSystem());
 
   const FileSystemURL kURL1(file_system.URL("foo"));
 
   // Creates a file in file_system.
   EXPECT_EQ(base::PLATFORM_FILE_OK, file_system.CreateFile(kURL1));
 
   // Kick file write on IO thread.
   StartModifyFileOnIOThread(&file_system, kURL1);
 
   // Until the operation finishes PrepareForSync should return BUSY error.
   SyncFileMetadata metadata;
-  metadata.file_type = SYNC_FILE_TYPE_UNKNOWN;
+  metadata.file_type = sync_file_system::SYNC_FILE_TYPE_UNKNOWN;
   FileChangeList changes;
   EXPECT_EQ(SYNC_STATUS_FILE_BUSY,
             PrepareForSync(file_system.file_system_context(),
                            kURL1, &metadata, &changes));
-  EXPECT_EQ(SYNC_FILE_TYPE_FILE, metadata.file_type);
+  EXPECT_EQ(sync_file_system::SYNC_FILE_TYPE_FILE, metadata.file_type);
 
   // Register PrepareForSync method to be invoked when kURL1 becomes
   // syncable. (Actually this may be done after all operations are done
   // on IO thread in this test.)
-  metadata.file_type = SYNC_FILE_TYPE_UNKNOWN;
+  metadata.file_type = sync_file_system::SYNC_FILE_TYPE_UNKNOWN;
   changes.clear();
   sync_context_->RegisterURLForWaitingSync(
       kURL1, GetPrepareForSyncClosure(file_system.file_system_context(),
                                       kURL1, &metadata, &changes));
 
   // Wait for the completion.
   EXPECT_EQ(base::PLATFORM_FILE_OK, WaitUntilModifyFileIsDone());
 
   // The PrepareForSync must have been started; wait until DidPrepareForSync
   // is done.
   MessageLoop::current()->Run();
   ASSERT_FALSE(has_inflight_prepare_for_sync_);
 
   // Now PrepareForSync should have run and returned OK.
   EXPECT_EQ(SYNC_STATUS_OK, status_);
   EXPECT_EQ(1U, changes.size());
   EXPECT_TRUE(changes.list().back().IsFile());
   EXPECT_TRUE(changes.list().back().IsAddOrUpdate());
-  EXPECT_EQ(SYNC_FILE_TYPE_FILE, metadata.file_type);
+  EXPECT_EQ(sync_file_system::SYNC_FILE_TYPE_FILE, metadata.file_type);
   EXPECT_EQ(1, metadata.size);
 
   sync_context_->ShutdownOnUIThread();
   sync_context_ = NULL;
   file_system.TearDown();
 }
 
 TEST_F(LocalFileSyncContextTest, ApplyRemoteChangeForDeletion) {
   CannedSyncableFileSystem file_system(GURL(kOrigin1), kServiceName,
                                        io_task_runner_, file_task_runner_);
@@ skipping 32 matching lines @@
   }
 
   // At this point the usage must be greater than the initial usage.
   int64 new_usage = -1;
   EXPECT_EQ(quota::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);
+                    sync_file_system::SYNC_FILE_TYPE_FILE);
   EXPECT_EQ(SYNC_STATUS_OK,
             ApplyRemoteChange(file_system.file_system_context(),
                               change, base::FilePath(), kFile,
-                              SYNC_FILE_TYPE_FILE));
+                              sync_file_system::SYNC_FILE_TYPE_FILE));
 
   // The implementation doesn't check file type for deletion, and it must be ok
   // even if we don't know if the deletion change was for a file or a directory.
-  change = FileChange(FileChange::FILE_CHANGE_DELETE, SYNC_FILE_TYPE_UNKNOWN);
+  change = FileChange(FileChange::FILE_CHANGE_DELETE,
+                      sync_file_system::SYNC_FILE_TYPE_UNKNOWN);
   EXPECT_EQ(SYNC_STATUS_OK,
             ApplyRemoteChange(file_system.file_system_context(),
                               change, base::FilePath(), kDir,
-                              SYNC_FILE_TYPE_DIRECTORY));
+                              sync_file_system::SYNC_FILE_TYPE_DIRECTORY));
 
   // Check the directory/files are deleted successfully.
   EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_FOUND,
             file_system.FileExists(kFile));
   EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_FOUND,
             file_system.DirectoryExists(kDir));
   EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_FOUND,
             file_system.FileExists(kChild));
 
   // The changes applied by ApplyRemoteChange should not be recorded in
@@ skipping 76 matching lines @@
   //  * 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);
+                    sync_file_system::SYNC_FILE_TYPE_FILE);
   EXPECT_EQ(SYNC_STATUS_OK,
             ApplyRemoteChange(file_system.file_system_context(),
                               change, kFilePath1, kFile1,
-                              SYNC_FILE_TYPE_FILE));
+                              sync_file_system::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,
             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.
+  // parameter of ApplyRemoteChange) are
+  // sync_file_system::SYNC_FILE_TYPE_UNKNOWN.
   change = FileChange(FileChange::FILE_CHANGE_ADD_OR_UPDATE,
                       SYNC_FILE_TYPE_FILE);
   EXPECT_EQ(SYNC_STATUS_OK,
             ApplyRemoteChange(file_system.file_system_context(),
                               change, kFilePath2, kFile2,
-                              SYNC_FILE_TYPE_UNKNOWN));
+                              sync_file_system::SYNC_FILE_TYPE_UNKNOWN));
 
   change = FileChange(FileChange::FILE_CHANGE_ADD_OR_UPDATE,
-                      SYNC_FILE_TYPE_DIRECTORY);
+                      sync_file_system::SYNC_FILE_TYPE_DIRECTORY);
   EXPECT_EQ(SYNC_STATUS_OK,
             ApplyRemoteChange(file_system.file_system_context(),
                               change, base::FilePath(), kDir,
-                              SYNC_FILE_TYPE_UNKNOWN));
+                              sync_file_system::SYNC_FILE_TYPE_UNKNOWN));
 
   // This should not happen, but calling ApplyRemoteChange
   // with wrong file type will result in error.
   change = FileChange(FileChange::FILE_CHANGE_ADD_OR_UPDATE,
                       SYNC_FILE_TYPE_FILE);
   EXPECT_NE(SYNC_STATUS_OK,
             ApplyRemoteChange(file_system.file_system_context(),
                               change, kFilePath1, kDir,
-                              SYNC_FILE_TYPE_DIRECTORY));
+                              sync_file_system::SYNC_FILE_TYPE_DIRECTORY));
 
   // Creating a file/directory must have increased the usage more than
   // the size of kTestFileData2.
   new_usage = usage;
   EXPECT_EQ(quota::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());
 
   // Make sure all three files/directory exist.
   EXPECT_EQ(base::PLATFORM_FILE_OK, file_system.FileExists(kFile1));
   EXPECT_EQ(base::PLATFORM_FILE_OK, file_system.FileExists(kFile2));
   EXPECT_EQ(base::PLATFORM_FILE_OK, file_system.DirectoryExists(kDir));
 
   sync_context_->ShutdownOnUIThread();
   file_system.TearDown();
 }
 
 }  // namespace fileapi