Add SNAPSHOT sync mode to LocalFileSyncContext::PrepareForSync

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"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/message_loop/message_loop.h"
 #include "base/platform_file.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/threading/thread.h"
 #include "chrome/browser/sync_file_system/local/canned_syncable_file_system.h"
 #include "chrome/browser/sync_file_system/local/local_file_change_tracker.h"
 #include "chrome/browser/sync_file_system/local/sync_file_system_backend.h"
@@ skipping 58 matching lines @@
                            const FileSystemURL& url,
                            SyncFileMetadata* metadata,
                            FileChangeList* changes) {
     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,
+        LocalFileSyncContext::SYNC_EXCLUSIVE,
         base::Bind(&LocalFileSyncContextTest::DidPrepareForSync,
                    base::Unretained(this), metadata, changes));
   }
 
   SyncStatusCode PrepareForSync(FileSystemContext* file_system_context,
                                 const FileSystemURL& url,
                                 SyncFileMetadata* metadata,
                                 FileChangeList* changes) {
     StartPrepareForSync(file_system_context, url, metadata, changes);
     base::MessageLoop::current()->Run();
@@ skipping 83 matching lines @@
           FROM_HERE,
           base::Bind(&LocalFileSyncContextTest::DidModifyFile,
                      base::Unretained(this), error));
       return;
     }
     ASSERT_TRUE(ui_task_runner_->RunsTasksOnCurrentThread());
     file_error_ = error;
     async_modify_finished_ = true;
   }
 
+  void SimulateFinishSync(FileSystemContext* file_system_context,
+                          const FileSystemURL& url,
+                          SyncStatusCode status) {
+    sync_context_->CommitChangeStatusForURL(
+        file_system_context,
+        url,
+        status,
+        base::Bind(&LocalFileSyncContext::ClearSyncFlagForURL,
+                   sync_context_, url));
+    base::MessageLoop::current()->RunUntilIdle();
+  }
+
+  void PrepareForSync_Basic(LocalFileSyncContext::SyncMode sync_mode,
+                            SyncStatusCode simulate_sync_finish_status) {
+    CannedSyncableFileSystem file_system(GURL(kOrigin1),
+                                         io_task_runner_.get(),
+                                         file_task_runner_.get());
+    file_system.SetUp();
+    sync_context_ = new LocalFileSyncContext(
+        ui_task_runner_.get(), io_task_runner_.get());
+    ASSERT_EQ(SYNC_STATUS_OK,
+              file_system.MaybeInitializeFileSystemContext(
+                  sync_context_.get()));
+    ASSERT_EQ(base::PLATFORM_FILE_OK, file_system.OpenFileSystem());
+
+    const FileSystemURL kFile(file_system.URL("file"));
+    EXPECT_EQ(base::PLATFORM_FILE_OK, file_system.CreateFile(kFile));
+
+    SyncFileMetadata metadata;
+    FileChangeList changes;
+    EXPECT_EQ(SYNC_STATUS_OK,
+              PrepareForSync(file_system.file_system_context(), kFile,
+                             &metadata, &changes));
+    EXPECT_EQ(1U, changes.size());
+    EXPECT_TRUE(changes.list().back().IsFile());
+    EXPECT_TRUE(changes.list().back().IsAddOrUpdate());
+
+    // We should see the same set of changes.
+    file_system.GetChangesForURLInTracker(kFile, &changes);
+    EXPECT_EQ(1U, changes.size());
+    EXPECT_TRUE(changes.list().back().IsFile());
+    EXPECT_TRUE(changes.list().back().IsAddOrUpdate());
+
+    SimulateFinishSync(file_system.file_system_context(), kFile,
+                       simulate_sync_finish_status);
+
+    file_system.GetChangesForURLInTracker(kFile, &changes);
+    if (simulate_sync_finish_status == SYNC_STATUS_OK) {
+      // The change's cleared.
+      EXPECT_TRUE(changes.empty());
+    } else {
+      EXPECT_EQ(1U, changes.size());
+      EXPECT_TRUE(changes.list().back().IsFile());
+      EXPECT_TRUE(changes.list().back().IsAddOrUpdate());
+    }
+
+    sync_context_->ShutdownOnUIThread();
+    sync_context_ = NULL;
+
+    file_system.TearDown();
+  }
+
   ScopedEnableSyncFSDirectoryOperation enable_directory_operation_;
 
   // These need to remain until the very end.
   scoped_ptr<base::Thread> io_thread_;
   scoped_ptr<base::Thread> file_thread_;
   base::MessageLoop loop_;
 
   scoped_refptr<base::SingleThreadTaskRunner> io_task_runner_;
   scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner_;
   scoped_refptr<base::SingleThreadTaskRunner> file_task_runner_;
@@ skipping 128 matching lines @@
   EXPECT_EQ(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, PrepareSync_SyncSuccess_Exclusive) {
+  PrepareForSync_Basic(LocalFileSyncContext::SYNC_EXCLUSIVE,
+                       SYNC_STATUS_OK);
+}
+
+TEST_F(LocalFileSyncContextTest, PrepareSync_SyncSuccess_Snapshot) {
+  PrepareForSync_Basic(LocalFileSyncContext::SYNC_SNAPSHOT,
+                       SYNC_STATUS_OK);
+}
+
+TEST_F(LocalFileSyncContextTest, PrepareSync_SyncFailure_Exclusive) {
+  PrepareForSync_Basic(LocalFileSyncContext::SYNC_EXCLUSIVE,
+                       SYNC_STATUS_FAILED);
+}
+
+TEST_F(LocalFileSyncContextTest, PrepareSync_SyncFailure_Snapshot) {
+  PrepareForSync_Basic(LocalFileSyncContext::SYNC_SNAPSHOT,
+                       SYNC_STATUS_FAILED);
+}
+
 // LocalFileSyncContextTest.PrepareSyncWhileWriting is flaky on android.
 // http://crbug.com/239793
 #if defined(OS_ANDROID)
 #define MAYBE_PrepareSyncWhileWriting DISABLED_PrepareSyncWhileWriting
 #else
 #define MAYBE_PrepareSyncWhileWriting PrepareSyncWhileWriting
 #endif
 TEST_F(LocalFileSyncContextTest, MAYBE_PrepareSyncWhileWriting) {
   CannedSyncableFileSystem file_system(GURL(kOrigin1),
                                        io_task_runner_.get(),
@@ skipping 335 matching lines @@
 
   // Make sure kDir and kFile are created by ApplyRemoteChange.
   EXPECT_EQ(base::PLATFORM_FILE_OK, file_system.FileExists(kFile));
   EXPECT_EQ(base::PLATFORM_FILE_OK, file_system.DirectoryExists(kDir));
 
   sync_context_->ShutdownOnUIThread();
   file_system.TearDown();
 }
 
 }  // namespace sync_file_system