Migrated sync_file_status, sync_action and sync_direction from fileapi:: namespace to sync_file_sys…

chrome/browser/sync_file_system/sync_file_system_service_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 <vector>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/run_loop.h"
 #include "base/stl_util.h"
@@ skipping 32 matching lines @@
 
 namespace {
 
 const char kOrigin[] = "http://example.com";
 const char kServiceName[] = "test";
 
 template <typename R> struct AssignTrait {
   typedef const R& ArgumentType;
 };
 
-template <> struct AssignTrait<fileapi::SyncFileStatus> {
-  typedef fileapi::SyncFileStatus ArgumentType;
+template <> struct AssignTrait<SyncFileStatus> {
+  typedef SyncFileStatus ArgumentType;
 };
 
 template <typename R>
 void AssignValueAndQuit(base::RunLoop* run_loop,
                         SyncStatusCode* status_out, R* value_out,
                         SyncStatusCode status,
                         typename AssignTrait<R>::ArgumentType value) {
   DCHECK(status_out);
   DCHECK(value_out);
   DCHECK(run_loop);
@@ skipping 16 matching lines @@
  public:
   MockSyncEventObserver() {}
   virtual ~MockSyncEventObserver() {}
 
   MOCK_METHOD3(OnSyncStateUpdated,
                void(const GURL& app_origin,
                     SyncServiceState state,
                     const std::string& description));
   MOCK_METHOD4(OnFileSynced,
                void(const fileapi::FileSystemURL& url,
-                    fileapi::SyncFileStatus status,
-                    fileapi::SyncAction action,
-                    fileapi::SyncDirection direction));
+                    SyncFileStatus status,
+                    SyncAction action,
+                    SyncDirection direction));
 };
 
 ACTION_P3(NotifyStateAndCallback,
           mock_remote_service, service_state, operation_status) {
   mock_remote_service->NotifyRemoteServiceStateUpdated(
       service_state, "Test event.");
   base::MessageLoopProxy::current()->PostTask(
       FROM_HERE, base::Bind(arg1, operation_status));
 }
 
@@ skipping 308 matching lines @@
 
   event.Wait();
 }
 
 TEST_F(SyncFileSystemServiceTest, GetFileSyncStatus) {
   InitializeApp();
 
   const FileSystemURL kFile(file_system_->URL("foo"));
 
   fileapi::SyncStatusCode status;
-  fileapi::SyncFileStatus sync_file_status;
+  SyncFileStatus sync_file_status;
 
   // 1. The file is not in conflicting nor in pending change state.
   {
     base::RunLoop run_loop;
     EXPECT_CALL(*mock_remote_service(), IsConflicting(kFile))
         .WillOnce(Return(false));
 
     status = fileapi::SYNC_STATUS_UNKNOWN;
-    sync_file_status = fileapi::SYNC_FILE_STATUS_UNKNOWN;
+    sync_file_status = SYNC_FILE_STATUS_UNKNOWN;
     sync_service_->GetFileSyncStatus(
         kFile,
-        base::Bind(&AssignValueAndQuit<fileapi::SyncFileStatus>,
+        base::Bind(&AssignValueAndQuit<SyncFileStatus>,
                    &run_loop, &status, &sync_file_status));
     run_loop.Run();
 
     EXPECT_EQ(fileapi::SYNC_STATUS_OK, status);
-    EXPECT_EQ(fileapi::SYNC_FILE_STATUS_SYNCED, sync_file_status);
+    EXPECT_EQ(SYNC_FILE_STATUS_SYNCED, sync_file_status);
   }
 
   // 2. Conflicting case.
   {
     base::RunLoop run_loop;
     EXPECT_CALL(*mock_remote_service(), IsConflicting(kFile))
         .WillOnce(Return(true));
 
     status = fileapi::SYNC_STATUS_UNKNOWN;
-    sync_file_status = fileapi::SYNC_FILE_STATUS_UNKNOWN;
+    sync_file_status = SYNC_FILE_STATUS_UNKNOWN;
     sync_service_->GetFileSyncStatus(
         kFile,
-        base::Bind(&AssignValueAndQuit<fileapi::SyncFileStatus>,
+        base::Bind(&AssignValueAndQuit<SyncFileStatus>,
                    &run_loop, &status, &sync_file_status));
     run_loop.Run();
 
     EXPECT_EQ(fileapi::SYNC_STATUS_OK, status);
-    EXPECT_EQ(fileapi::SYNC_FILE_STATUS_CONFLICTING, sync_file_status);
+    EXPECT_EQ(SYNC_FILE_STATUS_CONFLICTING, sync_file_status);
   }
 
   // 3. The file has pending local changes.
   {
     EXPECT_EQ(base::PLATFORM_FILE_OK, file_system_->CreateFile(kFile));
 
     base::RunLoop run_loop;
     EXPECT_CALL(*mock_remote_service(), IsConflicting(kFile))
         .WillOnce(Return(false));
 
     status = fileapi::SYNC_STATUS_UNKNOWN;
-    sync_file_status = fileapi::SYNC_FILE_STATUS_UNKNOWN;
+    sync_file_status = SYNC_FILE_STATUS_UNKNOWN;
     sync_service_->GetFileSyncStatus(
         kFile,
-        base::Bind(&AssignValueAndQuit<fileapi::SyncFileStatus>,
+        base::Bind(&AssignValueAndQuit<SyncFileStatus>,
                    &run_loop, &status, &sync_file_status));
     run_loop.Run();
 
     EXPECT_EQ(fileapi::SYNC_STATUS_OK, status);
-    EXPECT_EQ(fileapi::SYNC_FILE_STATUS_HAS_PENDING_CHANGES, sync_file_status);
+    EXPECT_EQ(SYNC_FILE_STATUS_HAS_PENDING_CHANGES, sync_file_status);
   }
 
   // 4. The file has a conflict and pending local changes. In this case
   // we return SYNC_FILE_STATUS_CONFLICTING.
   {
     EXPECT_EQ(base::PLATFORM_FILE_OK, file_system_->TruncateFile(kFile, 1U));
 
     base::RunLoop run_loop;
     EXPECT_CALL(*mock_remote_service(), IsConflicting(kFile))
         .WillOnce(Return(true));
 
     status = fileapi::SYNC_STATUS_UNKNOWN;
-    sync_file_status = fileapi::SYNC_FILE_STATUS_UNKNOWN;
+    sync_file_status = SYNC_FILE_STATUS_UNKNOWN;
     sync_service_->GetFileSyncStatus(
         kFile,
-        base::Bind(&AssignValueAndQuit<fileapi::SyncFileStatus>,
+        base::Bind(&AssignValueAndQuit<SyncFileStatus>,
                    &run_loop, &status, &sync_file_status));
     run_loop.Run();
 
     EXPECT_EQ(fileapi::SYNC_STATUS_OK, status);
-    EXPECT_EQ(fileapi::SYNC_FILE_STATUS_CONFLICTING, sync_file_status);
+    EXPECT_EQ(SYNC_FILE_STATUS_CONFLICTING, sync_file_status);
   }
 }
 
 }  // namespace sync_file_system