Use SNAPSHOT sync mode for LocalSync

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"
 #include "chrome/browser/sync_file_system/sync_file_metadata.h"
 #include "chrome/browser/sync_file_system/sync_status_code.h"
 #include "chrome/browser/sync_file_system/syncable_file_system_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webkit/browser/blob/mock_blob_url_request_context.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 fileapi::FileSystemContext;
 using fileapi::FileSystemURL;
 using fileapi::FileSystemURLSet;
 
 // This tests LocalFileSyncContext behavior in multi-thread /
 // multi-file-system-context environment.
 // Basic combined tests (single-thread / single-file-system-context)
@@ skipping 11 matching lines @@
  protected:
   LocalFileSyncContextTest()
       : status_(SYNC_FILE_ERROR_FAILED),
         file_error_(base::PLATFORM_FILE_ERROR_FAILED),
         async_modify_finished_(false),
         has_inflight_prepare_for_sync_(false) {}
 
   virtual void SetUp() OVERRIDE {
     RegisterSyncableFileSystem();
 
+    ASSERT_TRUE(dir_.CreateUniqueTempDir());
+
     io_thread_.reset(new base::Thread("Thread_IO"));
     io_thread_->StartWithOptions(
         base::Thread::Options(base::MessageLoop::TYPE_IO, 0));
 
     file_thread_.reset(new base::Thread("Thread_File"));
     file_thread_->Start();
 
     ui_task_runner_ = base::MessageLoop::current()->message_loop_proxy();
     io_task_runner_ = io_thread_->message_loop_proxy();
     file_task_runner_ = file_thread_->message_loop_proxy();
   }
 
   virtual void TearDown() OVERRIDE {
     RevokeSyncableFileSystem();
     io_thread_->Stop();
     file_thread_->Stop();
   }
 
   void StartPrepareForSync(FileSystemContext* file_system_context,
                            const FileSystemURL& url,
+                           LocalFileSyncContext::SyncMode sync_mode,
                            SyncFileMetadata* metadata,
-                           FileChangeList* changes) {
+                           FileChangeList* changes,
+                           webkit_blob::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,
-        LocalFileSyncContext::SYNC_EXCLUSIVE,
+        sync_mode,
         base::Bind(&LocalFileSyncContextTest::DidPrepareForSync,
-                   base::Unretained(this), metadata, changes));
+                   base::Unretained(this), metadata, changes, snapshot));
   }
 
   SyncStatusCode PrepareForSync(FileSystemContext* file_system_context,
                                 const FileSystemURL& url,
+                                LocalFileSyncContext::SyncMode sync_mode,
                                 SyncFileMetadata* metadata,
-                                FileChangeList* changes) {
-    StartPrepareForSync(file_system_context, url, metadata, changes);
+                                FileChangeList* changes,
+                                webkit_blob::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,
-                                         SyncFileMetadata* metadata,
-                                         FileChangeList* changes) {
+  base::Closure GetPrepareForSyncClosure(
+      FileSystemContext* file_system_context,
+      const FileSystemURL& url,
+      LocalFileSyncContext::SyncMode sync_mode,
+      SyncFileMetadata* metadata,
+      FileChangeList* changes,
+      webkit_blob::ScopedFile* snapshot) {
     return base::Bind(&LocalFileSyncContextTest::StartPrepareForSync,
                       base::Unretained(this),
                       base::Unretained(file_system_context),
-                      url, metadata, changes);
+                      url, sync_mode, metadata, changes, snapshot);
   }
 
   void DidPrepareForSync(SyncFileMetadata* metadata_out,
                          FileChangeList* changes_out,
+                         webkit_blob::ScopedFile* snapshot_out,
                          SyncStatusCode status,
-                         const LocalFileSyncInfo& sync_file_info) {
+                         const LocalFileSyncInfo& sync_file_info,
+                         scoped_ptr<webkit_blob::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)
+      *snapshot_out = snapshot->Pass();
     base::MessageLoop::current()->Quit();
   }
 
   SyncStatusCode ApplyRemoteChange(FileSystemContext* file_system_context,
                                    const FileChange& change,
                                    const base::FilePath& local_path,
                                    const FileSystemURL& url,
                                    SyncFileType expected_file_type) {
     SCOPED_TRACE(testing::Message() << "ApplyChange for " <<
                  url.DebugString());
 
     // First we should call PrepareForSync to disable writing.
     SyncFileMetadata metadata;
     FileChangeList changes;
     EXPECT_EQ(SYNC_STATUS_OK,
-              PrepareForSync(file_system_context, url, &metadata, &changes));
+              PrepareForSync(file_system_context, url,
+                             LocalFileSyncContext::SYNC_EXCLUSIVE,
+                             &metadata, &changes, NULL));
     EXPECT_EQ(expected_file_type, metadata.file_type);
 
     status_ = SYNC_STATUS_UNKNOWN;
     sync_context_->ApplyRemoteChange(
         file_system_context, change, local_path, url,
         base::Bind(&LocalFileSyncContextTest::DidApplyRemoteChange,
                    base::Unretained(this)));
     base::MessageLoop::current()->Run();
     return status_;
   }
@@ skipping 54 matching lines @@
     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());
+        dir_.path(), 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));
+                             sync_mode, &metadata, &changes, NULL));
     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();
   }
 
+  void PrepareForSync_WriteDuringSync(
+      LocalFileSyncContext::SyncMode sync_mode) {
+    CannedSyncableFileSystem file_system(GURL(kOrigin1),
+                                         io_task_runner_.get(),
+                                         file_task_runner_.get());
+    file_system.SetUp();
+    sync_context_ = new LocalFileSyncContext(
+        dir_.path(), 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;
+    webkit_blob::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());
+
+    // Tracker keeps 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());
+
+    StartModifyFileOnIOThread(&file_system, kFile);
+
+    if (sync_mode == LocalFileSyncContext::SYNC_SNAPSHOT) {
+      // Write should succeed.
+      EXPECT_EQ(base::PLATFORM_FILE_OK, WaitUntilModifyFileIsDone());
+    } else {
+      base::MessageLoop::current()->RunUntilIdle();
+      EXPECT_FALSE(async_modify_finished_);
+    }
+
+    SimulateFinishSync(file_system.file_system_context(), kFile,
+                       SYNC_STATUS_OK);
+
+    EXPECT_EQ(base::PLATFORM_FILE_OK, WaitUntilModifyFileIsDone());
+
+    // Sync succeeded, but the other change that was made during or
+    // after sync is recorded.
+    file_system.GetChangesForURLInTracker(kFile, &changes);
+    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_;
 
+  base::ScopedTempDir dir_;
+
   // These need to remain until the very end.
   scoped_ptr<base::Thread> io_thread_;
   scoped_ptr<base::Thread> file_thread_;

[earthdok, 2013/09/17 12:39:26]

It looks like there's a race condition between the main message loop and one of
these real threads. Is there any reason why we can't replace the whole bunch
with content::TestBrowserThreadBundle? That would both ensure clean teardown and
get rid of a lot of boilerplate code.

   base::MessageLoop loop_;
 
   scoped_refptr<base::SingleThreadTaskRunner> io_task_runner_;
   scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner_;
   scoped_refptr<base::SingleThreadTaskRunner> file_task_runner_;
 
   scoped_refptr<LocalFileSyncContext> sync_context_;
 
   SyncStatusCode status_;
   base::PlatformFileError file_error_;
   bool async_modify_finished_;
   bool has_inflight_prepare_for_sync_;
 };
 
 TEST_F(LocalFileSyncContextTest, ConstructAndDestruct) {
   sync_context_ =
-      new LocalFileSyncContext(ui_task_runner_.get(), io_task_runner_.get());
+      new LocalFileSyncContext(
+          dir_.path(), ui_task_runner_.get(), io_task_runner_.get());
   sync_context_->ShutdownOnUIThread();
 }
 
 TEST_F(LocalFileSyncContextTest, InitializeFileSystemContext) {
   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());
+  sync_context_ = new LocalFileSyncContext(
+      dir_.path(), ui_task_runner_.get(), io_task_runner_.get());
 
   // Initializes file_system using |sync_context_|.
   EXPECT_EQ(SYNC_STATUS_OK,
             file_system.MaybeInitializeFileSystemContext(sync_context_.get()));
 
   // Make sure everything's set up for file_system to be able to handle
   // syncable file system operations.
   EXPECT_TRUE(file_system.backend()->sync_context() != NULL);
   EXPECT_TRUE(file_system.backend()->change_tracker() != NULL);
   EXPECT_EQ(sync_context_.get(), file_system.backend()->sync_context());
@@ skipping 23 matching lines @@
 TEST_F(LocalFileSyncContextTest, MultipleFileSystemContexts) {
   CannedSyncableFileSystem file_system1(GURL(kOrigin1),
                                         io_task_runner_.get(),
                                         file_task_runner_.get());
   CannedSyncableFileSystem file_system2(GURL(kOrigin2),
                                         io_task_runner_.get(),
                                         file_task_runner_.get());
   file_system1.SetUp();
   file_system2.SetUp();
 
-  sync_context_ =
-      new LocalFileSyncContext(ui_task_runner_.get(), io_task_runner_.get());
+  sync_context_ = new LocalFileSyncContext(
+      dir_.path(), ui_task_runner_.get(), io_task_runner_.get());
 
   // Initializes file_system1 and file_system2.
   EXPECT_EQ(SYNC_STATUS_OK,
             file_system1.MaybeInitializeFileSystemContext(sync_context_.get()));
   EXPECT_EQ(SYNC_STATUS_OK,
             file_system2.MaybeInitializeFileSystemContext(sync_context_.get()));
 
   EXPECT_EQ(base::PLATFORM_FILE_OK, file_system1.OpenFileSystem());
   EXPECT_EQ(base::PLATFORM_FILE_OK, file_system2.OpenFileSystem());
 
@@ skipping 26 matching lines @@
   // file_system2's tracker now must have the change for kURL2.
   urls.clear();
   file_system2.GetChangedURLsInTracker(&urls);
   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));
+                           LocalFileSyncContext::SYNC_EXCLUSIVE,
+                           &metadata, &changes, NULL));
   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(0, metadata.size);
 
   changes.clear();
   EXPECT_EQ(SYNC_STATUS_OK,
             PrepareForSync(file_system2.file_system_context(), kURL2,
-                           &metadata, &changes));
+                           LocalFileSyncContext::SYNC_EXCLUSIVE,
+                           &metadata, &changes, NULL));
   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(0, metadata.size);
 
   sync_context_->ShutdownOnUIThread();
   sync_context_ = NULL;
 
   file_system1.TearDown();
@@ skipping 13 matching lines @@
 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);
 }
 
+TEST_F(LocalFileSyncContextTest, PrepareSync_WriteDuringSync_Exclusive) {
+  PrepareForSync_WriteDuringSync(LocalFileSyncContext::SYNC_EXCLUSIVE);
+}
+
+TEST_F(LocalFileSyncContextTest, PrepareSync_WriteDuringSync_Snapshot) {
+  PrepareForSync_WriteDuringSync(LocalFileSyncContext::SYNC_SNAPSHOT);
+}
+
 // 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(),
                                        file_task_runner_.get());
   file_system.SetUp();
-  sync_context_ =
-      new LocalFileSyncContext(ui_task_runner_.get(), io_task_runner_.get());
+  sync_context_ = new LocalFileSyncContext(
+      dir_.path(), ui_task_runner_.get(), io_task_runner_.get());
   EXPECT_EQ(SYNC_STATUS_OK,
             file_system.MaybeInitializeFileSystemContext(sync_context_.get()));
 
   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;
   FileChangeList changes;
   EXPECT_EQ(SYNC_STATUS_FILE_BUSY,
-            PrepareForSync(file_system.file_system_context(),
-                           kURL1, &metadata, &changes));
+            PrepareForSync(file_system.file_system_context(), kURL1,
+                           LocalFileSyncContext::SYNC_EXCLUSIVE,
+                           &metadata, &changes, NULL));
   EXPECT_EQ(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;
   changes.clear();
   sync_context_->RegisterURLForWaitingSync(
-      kURL1, GetPrepareForSyncClosure(file_system.file_system_context(),
-                                      kURL1, &metadata, &changes));
+      kURL1, GetPrepareForSyncClosure(file_system.file_system_context(), kURL1,
+                                      LocalFileSyncContext::SYNC_EXCLUSIVE,
+                                      &metadata, &changes, NULL));
 
   // Wait for the completion.
   EXPECT_EQ(base::PLATFORM_FILE_OK, WaitUntilModifyFileIsDone());
 
   // The PrepareForSync must have been started; wait until DidPrepareForSync
   // is done.
   base::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(1, metadata.size);
 
   sync_context_->ShutdownOnUIThread();
   sync_context_ = NULL;
   file_system.TearDown();
 }
 
 TEST_F(LocalFileSyncContextTest, ApplyRemoteChangeForDeletion) {
   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());
+  sync_context_ = new LocalFileSyncContext(
+      dir_.path(), 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());
 
   // Record the initial usage (likely 0).
   int64 initial_usage = -1;
   int64 quota = -1;
   EXPECT_EQ(quota::kQuotaStatusOk,
             file_system.GetUsageAndQuota(&initial_usage, &quota));
 
@@ skipping 67 matching lines @@
 
 TEST_F(LocalFileSyncContextTest, ApplyRemoteChangeForAddOrUpdate) {
   base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
 
   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());
+  sync_context_ = new LocalFileSyncContext(
+      dir_.path(), 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 kFile1(file_system.URL("file1"));
   const FileSystemURL kFile2(file_system.URL("file2"));
   const FileSystemURL kDir(file_system.URL("dir"));
 
   const char kTestFileData0[] = "0123456789";
   const char kTestFileData1[] = "Lorem ipsum!";
@@ skipping 127 matching lines @@
 
 TEST_F(LocalFileSyncContextTest, ApplyRemoteChangeForAddOrUpdate_NoParent) {
   base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
 
   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());
+  sync_context_ = new LocalFileSyncContext(
+      dir_.path(), 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 char kTestFileData[] = "Lorem ipsum!";
   const FileSystemURL kDir(file_system.URL("dir"));
   const FileSystemURL kFile(file_system.URL("dir/file"));
 
   // Either kDir or kFile not exist yet.
   EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_FOUND, file_system.FileExists(kDir));
@@ skipping 23 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