Implement SyncFileSystemService::GetFileSyncStatus method

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 "base/basictypes.h"
 #include "base/bind.h"
 #include "base/run_loop.h"
 #include "base/stl_util.h"
 #include "base/synchronization/waitable_event.h"
 #include "chrome/browser/sync_file_system/local_file_sync_service.h"
@@ skipping 26 matching lines @@
 using ::testing::StrictMock;
 using ::testing::_;
 
 namespace sync_file_system {
 
 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 <typename R>
 void AssignValueAndQuit(base::RunLoop* run_loop,
                         SyncStatusCode* status_out, R* value_out,
-                        SyncStatusCode status, const R& value) {
+                        SyncStatusCode status,
+                        typename AssignTrait<R>::ArgumentType value) {
   DCHECK(status_out);
   DCHECK(value_out);
   DCHECK(run_loop);
   *status_out = status;
   *value_out = value;
   run_loop->Quit();
 }
 
 // This is called on IO thread.
 void VerifyFileError(base::WaitableEvent* event,
@@ skipping 439 matching lines @@
   EXPECT_CALL(*mock_remote_service(), GetLocalChangeProcessor())
       .WillRepeatedly(Return(&local_change_processor));
 
   {
     InSequence sequence;
 
     // Return with SYNC_STATUS_FILE_BUSY once.
     EXPECT_CALL(*mock_remote_service(), ProcessRemoteChange(_, _))
         .WillOnce(MockSyncOperationCallback(fileapi::SYNC_STATUS_FILE_BUSY,
                                             kFile,
-                                            fileapi::SYNC_OPERATION_NONE))
-        .RetiresOnSaturation();
+                                            fileapi::SYNC_OPERATION_NONE));
 
     // ProcessRemoteChange should be called again when the becomes
     // not busy.
     EXPECT_CALL(*mock_remote_service(), ProcessRemoteChange(_, _))
         .WillOnce(InvokeWithoutArgs(&run_loop, &base::RunLoop::Quit));
   }
 
   // We might also see an activity for local sync as we're going to make
   // a local write operation on kFile.
   EXPECT_CALL(local_change_processor, ApplyLocalChange(_, _, _, kFile, _))
       .Times(AnyNumber());
 
   // This should trigger a remote sync.
   mock_remote_service()->NotifyRemoteChangeAvailable(1);
 
   // Start a local operation on the same file (to make it BUSY).
   base::WaitableEvent event(false, false);
   thread_helper_.io_task_runner()->PostTask(
       FROM_HERE, base::Bind(&fileapi::CannedSyncableFileSystem::DoCreateFile,
                             base::Unretained(file_system_.get()),
                             kFile, base::Bind(&VerifyFileError, &event)));
 
   run_loop.Run();
 
   mock_remote_service()->NotifyRemoteChangeAvailable(0);
 
   event.Wait();
 }
 
+TEST_F(SyncFileSystemServiceTest, GetFileSyncStatus) {
+  InitializeApp();
+
+  const FileSystemURL kFile(file_system_->URL("foo"));
+
+  fileapi::SyncStatusCode status;
+  fileapi::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_service_->GetFileSyncStatus(
+        kFile,
+        base::Bind(&AssignValueAndQuit<fileapi::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);
+  }
+
+  // 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_service_->GetFileSyncStatus(
+        kFile,
+        base::Bind(&AssignValueAndQuit<fileapi::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);
+  }
+
+  // 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_service_->GetFileSyncStatus(
+        kFile,
+        base::Bind(&AssignValueAndQuit<fileapi::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);
+  }
+
+  // 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_service_->GetFileSyncStatus(
+        kFile,
+        base::Bind(&AssignValueAndQuit<fileapi::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);
+  }
+}
+
 }  // namespace sync_file_system