Use SNAPSHOT sync mode for LocalSync

chrome/browser/sync_file_system/local/local_file_sync_context.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 "base/bind.h"
+#include "base/file_util.h"
 #include "base/location.h"
 #include "base/platform_file.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/task_runner_util.h"
 #include "chrome/browser/sync_file_system/file_change.h"
 #include "chrome/browser/sync_file_system/local/local_file_change_tracker.h"
 #include "chrome/browser/sync_file_system/local/local_origin_change_observer.h"
 #include "chrome/browser/sync_file_system/local/sync_file_system_backend.h"
 #include "chrome/browser/sync_file_system/local/syncable_file_operation_runner.h"
 #include "chrome/browser/sync_file_system/sync_file_metadata.h"
 #include "chrome/browser/sync_file_system/syncable_file_system_util.h"
 #include "webkit/browser/fileapi/file_system_context.h"
 #include "webkit/browser/fileapi/file_system_file_util.h"
 #include "webkit/browser/fileapi/file_system_operation_context.h"
 #include "webkit/browser/fileapi/file_system_operation_runner.h"
+#include "webkit/common/blob/scoped_file.h"
 #include "webkit/common/fileapi/file_system_util.h"
 
 using fileapi::FileSystemContext;
 using fileapi::FileSystemFileUtil;
 using fileapi::FileSystemOperation;
 using fileapi::FileSystemOperationContext;
 using fileapi::FileSystemURL;
 
 namespace sync_file_system {
 
 namespace {
 
 const int kMaxConcurrentSyncableOperation = 3;
 const int kNotifyChangesDurationInSec = 1;
 const int kMaxURLsToFetchForLocalSync = 5;
 
+const base::FilePath::CharType kSnapshotDir[] = FILE_PATH_LITERAL("snapshots");
+
 }  // namespace
 
 LocalFileSyncContext::LocalFileSyncContext(
+    const base::FilePath& base_path,
     base::SingleThreadTaskRunner* ui_task_runner,
     base::SingleThreadTaskRunner* io_task_runner)
-    : ui_task_runner_(ui_task_runner),
+    : local_base_path_(base_path.Append(FILE_PATH_LITERAL("local"))),
+      ui_task_runner_(ui_task_runner),
       io_task_runner_(io_task_runner),
       shutdown_on_ui_(false),
       mock_notify_changes_duration_in_sec_(-1) {
   DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
 }
 
 void LocalFileSyncContext::MaybeInitializeFileSystemContext(
     const GURL& source_url,
     FileSystemContext* file_system_context,
     const SyncStatusCallback& callback) {
@@ skipping 96 matching lines @@
 
   if (sync_finish_status == SYNC_STATUS_OK ||
       sync_finish_status == SYNC_STATUS_HAS_CONFLICT) {
     // Commit the in-memory mirror change.
     backend->change_tracker()->ResetToMirrorAndCommitChangesForURL(url);
   } else {
     // Abort in-memory mirror change.
     backend->change_tracker()->RemoveMirrorAndCommitChangesForURL(url);
   }
 
+  // We've been keeping it in writing mode, so clear the writing counter
+  // to unblock sync activities.
+  io_task_runner_->PostTask(
+      FROM_HERE, base::Bind(&LocalFileSyncContext::EndWritingOnIOThread,
+                            this, url));
+
   // Call the completion callback on UI thread.
   ui_task_runner_->PostTask(FROM_HERE, done_callback);
 }
 
 void LocalFileSyncContext::ClearSyncFlagForURL(const FileSystemURL& url) {
   // This is initially called on UI thread and to be relayed to IO thread.
   io_task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&LocalFileSyncContext::EnableWritingOnIOThread,
-                 this, url, true /* may_have_updates */));
+      base::Bind(&LocalFileSyncContext::ClearSyncFlagOnIOThread,
+                 this, url, false /* keep_url_in_writing */));
 }
 
 void LocalFileSyncContext::PrepareForSync(
     FileSystemContext* file_system_context,
     const FileSystemURL& url,
     SyncMode sync_mode,
     const LocalFileSyncInfoCallback& callback) {
   // This is initially called on UI thread and to be relayed to IO thread.
   if (!io_task_runner_->RunsTasksOnCurrentThread()) {
     DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
@@ skipping 363 matching lines @@
   if (status != SYNC_STATUS_OK)
     return status;
 
   // Get all origins that have pending changes.
   std::deque<FileSystemURL> urls;
   (*tracker_ptr)->GetNextChangedURLs(&urls, 0);
   for (std::deque<FileSystemURL>::iterator iter = urls.begin();
        iter != urls.end(); ++iter) {
     origins_with_changes->insert(iter->origin());
   }
+
+  // Creates snapshot directory.
+  file_util::CreateDirectory(local_base_path_.Append(kSnapshotDir));
+
   return status;
 }
 
 void LocalFileSyncContext::DidInitializeChangeTrackerOnIOThread(
     scoped_ptr<LocalFileChangeTracker>* tracker_ptr,
     const GURL& source_url,
     FileSystemContext* file_system_context,
     std::set<GURL>* origins_with_changes,
     SyncStatusCode status) {
   DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
@@ skipping 63 matching lines @@
 }
 
 void LocalFileSyncContext::TryPrepareForLocalSync(
     FileSystemContext* file_system_context,
     std::deque<FileSystemURL>* urls,
     const LocalFileSyncInfoCallback& callback) {
   DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
   DCHECK(urls);
 
   if (shutdown_on_ui_) {
-    callback.Run(SYNC_STATUS_ABORT, LocalFileSyncInfo());
+    callback.Run(SYNC_STATUS_ABORT, LocalFileSyncInfo(),
+                 scoped_ptr<webkit_blob::ScopedFile>());
     return;
   }
 
   if (urls->empty()) {
-    callback.Run(SYNC_STATUS_NO_CHANGE_TO_SYNC,
-                 LocalFileSyncInfo());
+    callback.Run(SYNC_STATUS_NO_CHANGE_TO_SYNC, LocalFileSyncInfo(),
+                 scoped_ptr<webkit_blob::ScopedFile>());
     return;
   }
 
   const FileSystemURL url = urls->front();
   urls->pop_front();
   std::deque<FileSystemURL>* remaining = new std::deque<FileSystemURL>;
   remaining->swap(*urls);
 
-  // TODO(kinuko): Call PrepareForSync with SYNC_SNAPSHOT when it becomes ready.
   PrepareForSync(
-      file_system_context, url, SYNC_EXCLUSIVE,
+      file_system_context, url, SYNC_SNAPSHOT,
       base::Bind(&LocalFileSyncContext::DidTryPrepareForLocalSync,
                  this, make_scoped_refptr(file_system_context),
                  base::Owned(remaining), callback));
 }
 
 void LocalFileSyncContext::DidTryPrepareForLocalSync(
     FileSystemContext* file_system_context,
     std::deque<FileSystemURL>* remaining_urls,
     const LocalFileSyncInfoCallback& callback,
     SyncStatusCode status,
-    const LocalFileSyncInfo& sync_file_info) {
+    const LocalFileSyncInfo& sync_file_info,
+    scoped_ptr<webkit_blob::ScopedFile> snapshot) {
   DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
   if (status != SYNC_STATUS_FILE_BUSY) {
-    callback.Run(status, sync_file_info);
+    callback.Run(status, sync_file_info, snapshot.Pass());
     return;
   }
   // Recursively call TryPrepareForLocalSync with remaining_urls.
   TryPrepareForLocalSync(file_system_context, remaining_urls, callback);
 }
 
 void LocalFileSyncContext::DidGetWritingStatusForSync(
     FileSystemContext* file_system_context,
     SyncStatusCode status,
     const FileSystemURL& url,
     SyncMode sync_mode,
     const LocalFileSyncInfoCallback& callback) {
   // This gets called on UI thread and relays the task on FILE thread.
   DCHECK(file_system_context);
   if (!file_system_context->default_file_task_runner()->
           RunsTasksOnCurrentThread()) {
     DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
     if (shutdown_on_ui_) {
-      callback.Run(SYNC_STATUS_ABORT, LocalFileSyncInfo());
+      callback.Run(SYNC_STATUS_ABORT, LocalFileSyncInfo(),
+                   scoped_ptr<webkit_blob::ScopedFile>());
       return;
     }
     file_system_context->default_file_task_runner()->PostTask(
         FROM_HERE,
         base::Bind(&LocalFileSyncContext::DidGetWritingStatusForSync,
                    this, make_scoped_refptr(file_system_context),
                    status, url, sync_mode, callback));
     return;
   }
 
   SyncFileSystemBackend* backend =
       SyncFileSystemBackend::GetBackend(file_system_context);
   DCHECK(backend);
   DCHECK(backend->change_tracker());
   FileChangeList changes;
   backend->change_tracker()->GetChangesForURL(url, &changes);
 
   base::FilePath platform_path;
   base::PlatformFileInfo file_info;
   FileSystemFileUtil* file_util =
       file_system_context->sandbox_delegate()->sync_file_util();
   DCHECK(file_util);
 
   base::PlatformFileError file_error = file_util->GetFileInfo(
       make_scoped_ptr(
           new FileSystemOperationContext(file_system_context)).get(),
       url,
       &file_info,
       &platform_path);
+
+  scoped_ptr<webkit_blob::ScopedFile> snapshot;
   if (file_error == base::PLATFORM_FILE_OK && sync_mode == SYNC_SNAPSHOT) {
-    // TODO(kinuko): creates a snapshot file.
+    base::FilePath snapshot_path;
+    file_util::CreateTemporaryFileInDir(local_base_path_.Append(kSnapshotDir),
+                                        &snapshot_path);
+    if (base::CopyFile(platform_path, snapshot_path)) {
+      platform_path = snapshot_path;
+      snapshot.reset(new webkit_blob::ScopedFile(
+          snapshot_path,
+          webkit_blob::ScopedFile::DELETE_ON_SCOPE_OUT,
+          file_system_context->default_file_task_runner()));
+    }
   }
+
   if (status == SYNC_STATUS_OK &&
       file_error != base::PLATFORM_FILE_OK &&
       file_error != base::PLATFORM_FILE_ERROR_NOT_FOUND)
     status = PlatformFileErrorToSyncStatusCode(file_error);
 
   DCHECK(!file_info.is_symbolic_link);
 
   SyncFileType file_type = SYNC_FILE_TYPE_FILE;
   if (file_error == base::PLATFORM_FILE_ERROR_NOT_FOUND)
     file_type = SYNC_FILE_TYPE_UNKNOWN;
   else if (file_info.is_directory)
     file_type = SYNC_FILE_TYPE_DIRECTORY;
 
-  // TODO(kinuko): returns the snapshot file path if snapshot is available.
   LocalFileSyncInfo sync_file_info;
   sync_file_info.url = url;
   sync_file_info.local_file_path = platform_path;
   sync_file_info.metadata.file_type = file_type;
   sync_file_info.metadata.size = file_info.size;
   sync_file_info.metadata.last_modified = file_info.last_modified;
   sync_file_info.changes = changes;
 
   if (status == SYNC_STATUS_OK) {
     if (!changes.empty()) {
       // Now we create an empty mirror change record for URL (and we record
       // changes to both mirror and original records during sync), so that
       // we can reset to the mirror when the sync succeeds.
       backend->change_tracker()->CreateFreshMirrorForURL(url);
     }
 
     // 'Unlock' the file if sync_mode is not SYNC_EXCLUSIVE.
+    // (But keep it in writing status so that no other sync starts on
+    // the same URL)
     if (sync_mode != SYNC_EXCLUSIVE) {
       io_task_runner_->PostTask(
           FROM_HERE,
-          base::Bind(&LocalFileSyncContext::EnableWritingOnIOThread,
-                    this, url, false /* may_have_updates */));
+          base::Bind(&LocalFileSyncContext::ClearSyncFlagOnIOThread,
+                     this, url, true /* keep_url_in_writing */));
     }
   }
 
   ui_task_runner_->PostTask(FROM_HERE,
-                            base::Bind(callback, status, sync_file_info));
+                            base::Bind(callback, status, sync_file_info,
+                                       base::Passed(&snapshot)));
 }
 
-void LocalFileSyncContext::EnableWritingOnIOThread(
+void LocalFileSyncContext::ClearSyncFlagOnIOThread(
     const FileSystemURL& url,
-    bool may_have_updates) {
+    bool keep_url_in_writing) {
   DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
   if (!sync_status()) {
     // The service might have been shut down.
     return;
   }
   sync_status()->EndSyncing(url);
 
-  if (!may_have_updates)
+  if (keep_url_in_writing) {
+    // The caller will hold shared lock on this one.
+    sync_status()->StartWriting(url);
     return;
+  }
 
   // Since a sync has finished the number of changes must have been updated.
   origins_with_pending_changes_.insert(url.origin());
   ScheduleNotifyChangesUpdatedOnIOThread();
 }
 
+void LocalFileSyncContext::EndWritingOnIOThread(
+    const FileSystemURL& url) {
+  DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
+  if (!sync_status()) {
+    // The service might have been shut down.
+    return;
+  }
+  sync_status()->EndWriting(url);
+}
+
 void LocalFileSyncContext::DidApplyRemoteChange(
     const FileSystemURL& url,
     const SyncStatusCallback& callback_on_ui,
     base::PlatformFileError file_error) {
   DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
   ui_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(callback_on_ui,
                  PlatformFileErrorToSyncStatusCode(file_error)));
-  EnableWritingOnIOThread(url, true /* may_have_updates */);
+  ClearSyncFlagOnIOThread(url, false /* keep_url_in_writing */);
 }
 
 void LocalFileSyncContext::DidGetFileMetadata(
     const SyncFileMetadataCallback& callback,
     base::PlatformFileError file_error,
     const base::PlatformFileInfo& file_info) {
   DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
   SyncFileMetadata metadata;
   if (file_error == base::PLATFORM_FILE_OK) {
     metadata.file_type = file_info.is_directory ?
@@ skipping 25 matching lines @@
     return;
   }
 
   FileSystemURL url_for_sync = CreateSyncableFileSystemURLForSync(
       file_system_context, dest_url);
   file_system_context->operation_runner()->CopyInForeignFile(
       local_path, url_for_sync, callback);
 }
 
 }  // namespace sync_file_system