[SyncFileSystem] Separate out ApplyLocalChange from DriveFileSyncService.

chrome/browser/sync_file_system/drive_file_sync_service.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 "chrome/browser/sync_file_system/drive_file_sync_service.h"
 
 #include <algorithm>
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/location.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_system.h"
 #include "chrome/browser/google_apis/drive_notification_manager.h"
 #include "chrome/browser/google_apis/drive_notification_manager_factory.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sync_file_system/conflict_resolution_policy.h"
 #include "chrome/browser/sync_file_system/drive/api_util.h"
+#include "chrome/browser/sync_file_system/drive/local_change_processor_delegate.h"
 #include "chrome/browser/sync_file_system/drive_file_sync_task_manager.h"
 #include "chrome/browser/sync_file_system/drive_file_sync_util.h"
 #include "chrome/browser/sync_file_system/drive_metadata_store.h"
 #include "chrome/browser/sync_file_system/file_status_observer.h"
 #include "chrome/browser/sync_file_system/remote_change_handler.h"
 #include "chrome/browser/sync_file_system/remote_change_processor.h"
 #include "chrome/browser/sync_file_system/remote_sync_operation_resolver.h"
 #include "chrome/browser/sync_file_system/sync_file_system.pb.h"
 #include "chrome/common/extensions/extension.h"
 #include "content/public/browser/browser_thread.h"
 #include "extensions/common/constants.h"
 #include "webkit/blob/scoped_file.h"
 #include "webkit/fileapi/file_system_url.h"
 #include "webkit/fileapi/file_system_util.h"
 #include "webkit/fileapi/syncable/sync_file_metadata.h"
 #include "webkit/fileapi/syncable/sync_file_type.h"
 #include "webkit/fileapi/syncable/syncable_file_system_util.h"
 
 using fileapi::FileSystemURL;
 
 namespace sync_file_system {
 
+typedef DriveFileSyncService::ConflictResolutionResult ConflictResolutionResult;
+
 namespace {
 
 const base::FilePath::CharType kTempDirName[] = FILE_PATH_LITERAL("tmp");
 const base::FilePath::CharType kSyncFileSystemDir[] =
     FILE_PATH_LITERAL("Sync FileSystem");
 const base::FilePath::CharType kSyncFileSystemDirDev[] =
     FILE_PATH_LITERAL("Sync FileSystem Dev");
 
 const base::FilePath::CharType* GetSyncFileSystemDir() {
   return IsSyncDirectoryOperationEnabled()
       ? kSyncFileSystemDirDev : kSyncFileSystemDir;
 }
 
 bool CreateTemporaryFile(const base::FilePath& dir_path,
                          webkit_blob::ScopedFile* temp_file) {
   base::FilePath temp_file_path;
   const bool success = file_util::CreateDirectory(dir_path) &&
       file_util::CreateTemporaryFileInDir(dir_path, &temp_file_path);
   if (!success)
     return success;
   *temp_file = webkit_blob::ScopedFile(
       temp_file_path,
       webkit_blob::ScopedFile::DELETE_ON_SCOPE_OUT,
       base::MessageLoopProxy::current());
   return success;
 }
 
 void EmptyStatusCallback(SyncStatusCode status) {}
 
-std::string PathToTitle(const base::FilePath& path) {
-  if (!IsSyncDirectoryOperationEnabled())
-    return path.AsUTF8Unsafe();
-
-  return fileapi::FilePathToString(
-      base::FilePath(fileapi::VirtualPath::GetNormalizedFilePath(path)));
-}
-
-base::FilePath TitleToPath(const std::string& title) {
-  if (!IsSyncDirectoryOperationEnabled())
-    return base::FilePath::FromUTF8Unsafe(title);
-
-  return fileapi::StringToFilePath(title).NormalizePathSeparators();
-}
-
-DriveMetadata::ResourceType SyncFileTypeToDriveMetadataResourceType(
-    SyncFileType file_type) {
-  DCHECK_NE(SYNC_FILE_TYPE_UNKNOWN, file_type);
-  switch (file_type) {
-    case SYNC_FILE_TYPE_UNKNOWN:
-      return DriveMetadata_ResourceType_RESOURCE_TYPE_FILE;
-    case SYNC_FILE_TYPE_FILE:
-      return DriveMetadata_ResourceType_RESOURCE_TYPE_FILE;
-    case SYNC_FILE_TYPE_DIRECTORY:
-      return DriveMetadata_ResourceType_RESOURCE_TYPE_FOLDER;
-  }
-  NOTREACHED();
-  return DriveMetadata_ResourceType_RESOURCE_TYPE_FILE;
-}
-
 void SyncFileCallbackAdapter(
     const SyncStatusCallback& status_callback,
     const SyncFileCallback& callback,
     SyncStatusCode status,
     const FileSystemURL& url) {
   status_callback.Run(status);
   callback.Run(status, url);
 }
 
 }  // namespace
@@ skipping 18 matching lines @@
       const RemoteChangeHandler::RemoteChange& remote_change,
       const SyncFileCallback& callback)
       : remote_change(remote_change),
         callback(callback),
         metadata_updated(false),
         sync_action(SYNC_ACTION_NONE),
         clear_local_changes(true) {
   }
 };
 
-struct DriveFileSyncService::ApplyLocalChangeParam {
-  FileSystemURL url;
-  FileChange local_change;
-  base::FilePath local_path;
-  SyncFileMetadata local_metadata;
-  DriveMetadata drive_metadata;
-  bool has_drive_metadata;
-  SyncStatusCallback callback;
-
-  ApplyLocalChangeParam(const FileSystemURL& url,
-                        const FileChange& local_change,
-                        const base::FilePath& local_path,
-                        const SyncFileMetadata& local_metadata,
-                        const SyncStatusCallback& callback)
-      : url(url),
-        local_change(local_change),
-        local_path(local_path),
-        local_metadata(local_metadata),
-        has_drive_metadata(false),
-        callback(callback) {}
-};
-
 // DriveFileSyncService ------------------------------------------------------
 
 DriveFileSyncService::~DriveFileSyncService() {
   if (api_util_)
     api_util_->RemoveObserver(this);
 
   google_apis::DriveNotificationManager* drive_notification_manager =
       google_apis::DriveNotificationManagerFactory::GetForProfile(profile_);
   if (drive_notification_manager)
     drive_notification_manager->RemoveObserver(this);
@@ skipping 458 matching lines @@
       base::Bind(&DriveFileSyncService::DidPrepareForProcessRemoteChange,
                  AsWeakPtr(), base::Passed(&param)));
 }
 
 void DriveFileSyncService::DoApplyLocalChange(
     const FileChange& local_file_change,
     const base::FilePath& local_file_path,
     const SyncFileMetadata& local_file_metadata,
     const FileSystemURL& url,
     const SyncStatusCallback& callback) {
-  // TODO(nhiroki): support directory operations (http://crbug.com/161442).
-  DCHECK(IsSyncDirectoryOperationEnabled() ||
-         !local_file_change.IsDirectory());
-
   if (GetCurrentState() == REMOTE_SERVICE_DISABLED) {
     callback.Run(SYNC_STATUS_SYNC_DISABLED);
     return;
   }
 
   if (!metadata_store_->IsIncrementalSyncOrigin(url.origin()) &&
       !metadata_store_->IsBatchSyncOrigin(url.origin())) {
     // We may get called by LocalFileSyncService to sync local changes
     // for the origins that are disabled.
     DVLOG(1) << "Got request for stray origin: " << url.origin().spec();
     callback.Run(SYNC_STATUS_UNKNOWN_ORIGIN);
     return;
   }
 
-  DriveMetadata metadata;
-  const bool has_metadata =
-      (metadata_store_->ReadEntry(url, &metadata) == SYNC_STATUS_OK);
-
-  scoped_ptr<ApplyLocalChangeParam> param(new ApplyLocalChangeParam(
-      url, local_file_change, local_file_path, local_file_metadata, callback));
-  param->has_drive_metadata = has_metadata;
-  param->drive_metadata = metadata;
-  if (!has_metadata)
-    param->drive_metadata.set_md5_checksum(std::string());
-
-  EnsureOriginRootDirectory(
-      url.origin(),
-      base::Bind(&DriveFileSyncService::ApplyLocalChangeInternal,
-                 AsWeakPtr(), base::Passed(&param)));
+  DCHECK(!running_local_sync_task_);
+  running_local_sync_task_.reset(new drive::LocalChangeProcessorDelegate(
+      AsWeakPtr(), local_file_change, local_file_path,
+      local_file_metadata, url));
+  running_local_sync_task_->Run(base::Bind(
+      &DriveFileSyncService::DidApplyLocalChange, AsWeakPtr(), callback));
 }
 
 void DriveFileSyncService::UpdateRegisteredOrigins() {
   ExtensionService* extension_service =
       extensions::ExtensionSystem::Get(profile_)->extension_service();
   if (!extension_service)
     return;
 
   std::vector<GURL> origins;
   metadata_store_->GetAllOrigins(&origins);
@@ skipping 155 matching lines @@
   // Move |origin| to the incremental sync origin set if the origin has no file.
   if (metadata_store_->IsBatchSyncOrigin(origin) &&
       !remote_change_handler_.HasChangesForOrigin(origin)) {
     metadata_store_->MoveBatchSyncOriginToIncremental(origin);
   }
 
   may_have_unfetched_changes_ = true;
   callback.Run(SYNC_STATUS_OK);
 }
 
-void DriveFileSyncService::ApplyLocalChangeInternal(
-    scoped_ptr<ApplyLocalChangeParam> param,
-    SyncStatusCode status,
-    const std::string& origin_resource_id) {
-  if (status != SYNC_STATUS_OK) {
-    param->callback.Run(status);
-    return;
+ConflictResolutionResult DriveFileSyncService::ResolveConflictForLocalSync(
+    SyncFileType local_file_type,
+    const base::Time& local_updated_time,
+    SyncFileType remote_file_type,
+    const base::Time& remote_updated_time) {
+  // Currently we always prioritize directories over files regardless of
+  // conflict resolution policy.
+  if (remote_file_type == SYNC_FILE_TYPE_DIRECTORY)
+    return CONFLICT_RESOLUTION_REMOTE_WIN;
+
+  if (conflict_resolution_ == CONFLICT_RESOLUTION_MANUAL)
+    return CONFLICT_RESOLUTION_MARK_CONFLICT;
+
+  DCHECK_EQ(CONFLICT_RESOLUTION_LAST_WRITE_WIN, conflict_resolution_);
+  if (local_updated_time >= remote_updated_time ||
+      remote_file_type == SYNC_FILE_TYPE_UNKNOWN) {
+    return CONFLICT_RESOLUTION_LOCAL_WIN;
   }
 
-  const FileSystemURL& url = param->url;
-  const FileChange& local_file_change = param->local_change;
-  const base::FilePath& local_file_path = param->local_path;
-  DriveMetadata& drive_metadata = param->drive_metadata;
-  const SyncStatusCallback& callback = param->callback;
-
-  RemoteChangeHandler::RemoteChange remote_change;
-  const bool has_remote_change =
-      remote_change_handler_.GetChangeForURL(url, &remote_change);
-  if (has_remote_change && param->drive_metadata.resource_id().empty())
-    param->drive_metadata.set_resource_id(remote_change.resource_id);
-
-  LocalSyncOperationType operation =
-      LocalSyncOperationResolver::Resolve(
-          local_file_change,
-          has_remote_change ? &remote_change.change : NULL,
-          param->has_drive_metadata ? &drive_metadata : NULL);
-
-  DVLOG(1) << "ApplyLocalChange for " << url.DebugString()
-           << " local_change:" << local_file_change.DebugString()
-           << " ==> operation:" << operation;
-
-  switch (operation) {
-    case LOCAL_SYNC_OPERATION_ADD_FILE:
-      api_util_->UploadNewFile(
-          origin_resource_id,
-          local_file_path,
-          PathToTitle(url.path()),
-          base::Bind(&DriveFileSyncService::DidUploadNewFileForLocalSync,
-                     AsWeakPtr(),
-                     base::Passed(&param)));
-      return;
-    case LOCAL_SYNC_OPERATION_ADD_DIRECTORY:
-      DCHECK(IsSyncDirectoryOperationEnabled());
-      api_util_->CreateDirectory(
-          origin_resource_id,
-          PathToTitle(url.path()),
-          base::Bind(&DriveFileSyncService::DidCreateDirectoryForLocalSync,
-                     AsWeakPtr(),
-                     base::Passed(&param)));
-      return;
-    case LOCAL_SYNC_OPERATION_UPDATE_FILE:
-      DCHECK(param->has_drive_metadata);
-      api_util_->UploadExistingFile(
-          drive_metadata.resource_id(),
-          drive_metadata.md5_checksum(),
-          local_file_path,
-          base::Bind(&DriveFileSyncService::DidUploadExistingFileForLocalSync,
-                     AsWeakPtr(),
-                     base::Passed(&param)));
-      return;
-    case LOCAL_SYNC_OPERATION_DELETE_FILE:
-      DCHECK(param->has_drive_metadata);
-      api_util_->DeleteFile(
-          drive_metadata.resource_id(),
-          drive_metadata.md5_checksum(),
-          base::Bind(&DriveFileSyncService::DidDeleteFileForLocalSync,
-                     AsWeakPtr(),
-                     base::Passed(&param)));
-      return;
-    case LOCAL_SYNC_OPERATION_DELETE_DIRECTORY:
-      DCHECK(IsSyncDirectoryOperationEnabled());
-      DCHECK(param->has_drive_metadata);
-      // This does not handle recursive directory deletion
-      // (which should not happen other than after a restart).
-      api_util_->DeleteFile(
-          drive_metadata.resource_id(),
-          std::string(),  // empty etag
-          base::Bind(&DriveFileSyncService::DidDeleteFileForLocalSync,
-                     AsWeakPtr(),
-                     base::Passed(&param)));
-      return;
-    case LOCAL_SYNC_OPERATION_NONE:
-      callback.Run(SYNC_STATUS_OK);
-      return;
-    case LOCAL_SYNC_OPERATION_CONFLICT:
-      HandleConflictForLocalSync(param.Pass());
-      return;
-    case LOCAL_SYNC_OPERATION_RESOLVE_TO_LOCAL:
-      api_util_->DeleteFile(
-          drive_metadata.resource_id(),
-          drive_metadata.md5_checksum(),
-          base::Bind(
-              &DriveFileSyncService::DidDeleteForResolveToLocalForLocalSync,
-              AsWeakPtr(),
-              origin_resource_id,
-              local_file_path,
-              url,
-              base::Passed(&param)));
-      return;
-    case LOCAL_SYNC_OPERATION_RESOLVE_TO_REMOTE:
-      ResolveConflictToRemoteForLocalSync(
-          param.Pass(),
-          remote_change.change.file_type());
-      return;
-    case LOCAL_SYNC_OPERATION_DELETE_METADATA:
-      metadata_store_->DeleteEntry(
-          url,
-          base::Bind(&DriveFileSyncService::DidApplyLocalChange,
-                     AsWeakPtr(), base::Passed(&param),
-                     google_apis::HTTP_SUCCESS));
-      return;
-    case LOCAL_SYNC_OPERATION_FAIL: {
-      callback.Run(SYNC_STATUS_FAILED);
-      return;
-    }
-  }
-  NOTREACHED();
-  callback.Run(SYNC_STATUS_FAILED);
-}
-
-void DriveFileSyncService::DidDeleteForResolveToLocalForLocalSync(
-    const std::string& origin_resource_id,
-    const base::FilePath& local_file_path,
-    const fileapi::FileSystemURL& url,
-    scoped_ptr<ApplyLocalChangeParam> param,
-    google_apis::GDataErrorCode error) {
-  if (error != google_apis::HTTP_SUCCESS &&
-      error != google_apis::HTTP_NOT_FOUND) {
-    RemoveRemoteChange(param->url);
-    param->callback.Run(GDataErrorCodeToSyncStatusCodeWrapper(error));
-    return;
-  }
-
-  DCHECK_NE(SYNC_FILE_TYPE_UNKNOWN, param->local_metadata.file_type);
-  if (param->local_metadata.file_type == SYNC_FILE_TYPE_FILE) {
-    api_util_->UploadNewFile(
-        origin_resource_id,
-        local_file_path,
-        PathToTitle(url.path()),
-        base::Bind(&DriveFileSyncService::DidUploadNewFileForLocalSync,
-                   AsWeakPtr(),
-                   base::Passed(&param)));
-    return;
-  }
-
-  DCHECK(IsSyncDirectoryOperationEnabled());
-  DCHECK_EQ(SYNC_FILE_TYPE_DIRECTORY, param->local_metadata.file_type);
-  api_util_->CreateDirectory(
-      origin_resource_id,
-      PathToTitle(url.path()),
-      base::Bind(&DriveFileSyncService::DidCreateDirectoryForLocalSync,
-                 AsWeakPtr(),
-                 base::Passed(&param)));
+  return CONFLICT_RESOLUTION_REMOTE_WIN;
 }
 
 void DriveFileSyncService::DidApplyLocalChange(
-    scoped_ptr<ApplyLocalChangeParam> param,
-    const google_apis::GDataErrorCode error,
+    const SyncStatusCallback& callback,
     SyncStatusCode status) {
-  if (status == SYNC_STATUS_OK) {
-    RemoveRemoteChange(param->url);
-    status = GDataErrorCodeToSyncStatusCodeWrapper(error);
-  }
-  param->callback.Run(status);
-}
-
-void DriveFileSyncService::DidResolveConflictToRemoteChange(
-    scoped_ptr<ApplyLocalChangeParam> param,
-    SyncStatusCode status) {
-  DCHECK(param->has_drive_metadata);
-  if (status != SYNC_STATUS_OK) {
-    param->callback.Run(status);
-    return;
-  }
-
-  SyncFileType file_type = SYNC_FILE_TYPE_FILE;
-  if (param->drive_metadata.type() == DriveMetadata::RESOURCE_TYPE_FOLDER)
-    file_type = SYNC_FILE_TYPE_DIRECTORY;
-  AppendFetchChange(param->url.origin(), param->url.path(),
-                    param->drive_metadata.resource_id(),
-                    file_type);
-  param->callback.Run(status);
-}
-
-void DriveFileSyncService::DidUploadNewFileForLocalSync(
-    scoped_ptr<ApplyLocalChangeParam> param,
-    google_apis::GDataErrorCode error,
-    const std::string& resource_id,
-    const std::string& file_md5) {
-  DCHECK(param);
-  const FileSystemURL& url = param->url;
-  switch (error) {
-    case google_apis::HTTP_CREATED: {
-      param->drive_metadata.set_resource_id(resource_id);
-      param->drive_metadata.set_md5_checksum(file_md5);
-      param->drive_metadata.set_conflicted(false);
-      param->drive_metadata.set_to_be_fetched(false);
-      param->drive_metadata.set_type(DriveMetadata::RESOURCE_TYPE_FILE);
-      const DriveMetadata& metadata = param->drive_metadata;
-      metadata_store_->UpdateEntry(
-          url, metadata,
-          base::Bind(&DriveFileSyncService::DidApplyLocalChange,
-                     AsWeakPtr(), base::Passed(&param), error));
-      NotifyObserversFileStatusChanged(url,
-                                       SYNC_FILE_STATUS_SYNCED,
-                                       SYNC_ACTION_ADDED,
-                                       SYNC_DIRECTION_LOCAL_TO_REMOTE);
-      return;
-    }
-    case google_apis::HTTP_CONFLICT:
-      // File-file conflict is found.
-      // Populates a fake drive_metadata and set has_drive_metadata = true.
-      // In HandleConflictLocalSync:
-      // - If conflict_resolution is manual, we'll change conflicted to true
-      //   and save the metadata.
-      // - Otherwise we'll save the metadata with empty md5 and will start
-      //   over local sync as UploadExistingFile.
-      param->drive_metadata.set_resource_id(resource_id);
-      param->drive_metadata.set_md5_checksum(std::string());
-      param->drive_metadata.set_conflicted(false);
-      param->drive_metadata.set_to_be_fetched(false);
-      param->drive_metadata.set_type(DriveMetadata::RESOURCE_TYPE_FILE);
-      param->has_drive_metadata = true;
-      HandleConflictForLocalSync(param.Pass());
-      return;
-
-    default:
-      param->callback.Run(GDataErrorCodeToSyncStatusCodeWrapper(error));
-  }
-}
-
-void DriveFileSyncService::DidCreateDirectoryForLocalSync(
-    scoped_ptr<ApplyLocalChangeParam> param,
-    google_apis::GDataErrorCode error,
-    const std::string& resource_id) {
-  DCHECK(param);
-  const FileSystemURL& url = param->url;
-  switch (error) {
-    case google_apis::HTTP_SUCCESS:
-    case google_apis::HTTP_CREATED: {
-      param->drive_metadata.set_resource_id(resource_id);
-      param->drive_metadata.set_md5_checksum(std::string());
-      param->drive_metadata.set_conflicted(false);
-      param->drive_metadata.set_to_be_fetched(false);
-      param->drive_metadata.set_type(DriveMetadata::RESOURCE_TYPE_FOLDER);
-      const DriveMetadata& metadata = param->drive_metadata;
-      metadata_store_->UpdateEntry(
-          url, metadata,
-          base::Bind(&DriveFileSyncService::DidApplyLocalChange,
-                     AsWeakPtr(), base::Passed(&param), error));
-      NotifyObserversFileStatusChanged(url,
-                                       SYNC_FILE_STATUS_SYNCED,
-                                       SYNC_ACTION_ADDED,
-                                       SYNC_DIRECTION_LOCAL_TO_REMOTE);
-      return;
-    }
-
-    case google_apis::HTTP_CONFLICT:
-      // There were conflicts and a file was left.
-      // TODO(kinuko): Handle the latter case (http://crbug.com/237090).
-      // Fall-through
-
-    default:
-      param->callback.Run(GDataErrorCodeToSyncStatusCodeWrapper(error));
-  }
-}
-
-void DriveFileSyncService::DidUploadExistingFileForLocalSync(
-    scoped_ptr<ApplyLocalChangeParam> param,
-    google_apis::GDataErrorCode error,
-    const std::string& resource_id,
-    const std::string& file_md5) {
-  DCHECK(param);
-  DCHECK(param->has_drive_metadata);
-  const FileSystemURL& url = param->url;
-  switch (error) {
-    case google_apis::HTTP_SUCCESS: {
-      param->drive_metadata.set_resource_id(resource_id);
-      param->drive_metadata.set_md5_checksum(file_md5);
-      param->drive_metadata.set_conflicted(false);
-      param->drive_metadata.set_to_be_fetched(false);
-      param->drive_metadata.set_type(DriveMetadata::RESOURCE_TYPE_FILE);
-      const DriveMetadata& metadata = param->drive_metadata;
-      metadata_store_->UpdateEntry(
-          url, metadata,
-          base::Bind(&DriveFileSyncService::DidApplyLocalChange,
-                     AsWeakPtr(), base::Passed(&param), error));
-      NotifyObserversFileStatusChanged(url,
-                                       SYNC_FILE_STATUS_SYNCED,
-                                       SYNC_ACTION_UPDATED,
-                                       SYNC_DIRECTION_LOCAL_TO_REMOTE);
-      return;
-    }
-    case google_apis::HTTP_CONFLICT: {
-      HandleConflictForLocalSync(param.Pass());
-      return;
-    }
-    case google_apis::HTTP_NOT_MODIFIED: {
-      DidApplyLocalChange(param.Pass(),
-                          google_apis::HTTP_SUCCESS, SYNC_STATUS_OK);
-      return;
-    }
-    case google_apis::HTTP_NOT_FOUND: {
-      const base::FilePath& local_file_path = param->local_path;
-      api_util_->UploadNewFile(
-          metadata_store_->GetResourceIdForOrigin(url.origin()),
-          local_file_path,
-          PathToTitle(url.path()),
-          base::Bind(&DriveFileSyncService::DidUploadNewFileForLocalSync,
-                     AsWeakPtr(),
-                     base::Passed(&param)));
-      return;
-    }
-    default: {
-      const SyncStatusCode status =
-          GDataErrorCodeToSyncStatusCodeWrapper(error);
-      DCHECK_NE(SYNC_STATUS_OK, status);
-      param->callback.Run(status);
-      return;
-    }
-  }
-}
-
-void DriveFileSyncService::DidDeleteFileForLocalSync(
-    scoped_ptr<ApplyLocalChangeParam> param,
-    google_apis::GDataErrorCode error) {
-  DCHECK(param);
-  DCHECK(param->has_drive_metadata);
-  const FileSystemURL& url = param->url;
-  switch (error) {
-    // Regardless of whether the deletion has succeeded (HTTP_SUCCESS) or
-    // has failed with ETag conflict error (HTTP_PRECONDITION or HTTP_CONFLICT)
-    // we should just delete the drive_metadata.
-    // In the former case the file should be just gone now, and
-    // in the latter case the remote change will be applied in a future
-    // remote sync.
-    case google_apis::HTTP_SUCCESS:
-    case google_apis::HTTP_PRECONDITION:
-    case google_apis::HTTP_CONFLICT:
-      metadata_store_->DeleteEntry(
-          url,
-          base::Bind(&DriveFileSyncService::DidApplyLocalChange,
-                     AsWeakPtr(), base::Passed(&param), error));
-      NotifyObserversFileStatusChanged(url,
-                                       SYNC_FILE_STATUS_SYNCED,
-                                       SYNC_ACTION_DELETED,
-                                       SYNC_DIRECTION_LOCAL_TO_REMOTE);
-      return;
-    case google_apis::HTTP_NOT_FOUND:
-      DidApplyLocalChange(param.Pass(),
-                          google_apis::HTTP_SUCCESS, SYNC_STATUS_OK);
-      return;
-    default: {
-      const SyncStatusCode status =
-          GDataErrorCodeToSyncStatusCodeWrapper(error);
-      DCHECK_NE(SYNC_STATUS_OK, status);
-      param->callback.Run(status);
-      return;
-    }
-  }
-}
-
-void DriveFileSyncService::HandleConflictForLocalSync(
-    scoped_ptr<ApplyLocalChangeParam> param) {
-  DCHECK(param);
-  DriveMetadata& drive_metadata = param->drive_metadata;
-  DCHECK(!drive_metadata.resource_id().empty());
-
-  api_util_->GetResourceEntry(
-      drive_metadata.resource_id(),
-      base::Bind(
-          &DriveFileSyncService::DidGetRemoteFileMetadataForRemoteUpdatedTime,
-          AsWeakPtr(),
-          base::Bind(&DriveFileSyncService::ResolveConflictForLocalSync,
-                     AsWeakPtr(),
-                     base::Passed(&param))));
-}
-
-void DriveFileSyncService::ResolveConflictForLocalSync(
-    scoped_ptr<ApplyLocalChangeParam> param,
-    const base::Time& remote_updated_time,
-    SyncFileType remote_file_type,
-    SyncStatusCode status) {
-  DCHECK(param);
-  const FileSystemURL& url = param->url;
-  DriveMetadata& drive_metadata = param->drive_metadata;
-  SyncFileMetadata& local_metadata = param->local_metadata;
-  if (status != SYNC_STATUS_OK) {
-    param->callback.Run(status);
-    return;
-  }
-
-  // Currently we always prioritize directories over files regardless of
-  // conflict resolution policy.
-  DCHECK(param->local_change.IsFile());
-  if (remote_file_type == SYNC_FILE_TYPE_DIRECTORY) {
-    ResolveConflictToRemoteForLocalSync(param.Pass(), SYNC_FILE_TYPE_DIRECTORY);
-    return;
-  }
-
-  if (conflict_resolution_ == CONFLICT_RESOLUTION_MANUAL) {
-    if (drive_metadata.conflicted()) {
-      // It's already conflicting; no need to update metadata.
-      param->callback.Run(SYNC_STATUS_FAILED);
-      return;
-    }
-    MarkConflict(url, &drive_metadata,
-                 base::Bind(&DriveFileSyncService::DidApplyLocalChange,
-                            AsWeakPtr(), base::Passed(&param),
-                            google_apis::HTTP_CONFLICT));
-    return;
-  }
-
-  DCHECK_EQ(CONFLICT_RESOLUTION_LAST_WRITE_WIN, conflict_resolution_);
-
-  if (local_metadata.last_modified >= remote_updated_time ||
-      remote_file_type == SYNC_FILE_TYPE_UNKNOWN) {
-    // Local win case.
-    DVLOG(1) << "Resolving conflict for local sync:"
-             << url.DebugString() << ": LOCAL WIN";
-    if (!param->has_drive_metadata) {
-      StartOverLocalSync(param.Pass(), SYNC_STATUS_OK);
-      return;
-    }
-    // Make sure we reset the conflict flag and start over the local sync
-    // with empty remote changes.
-    DCHECK(!drive_metadata.resource_id().empty());
-    drive_metadata.set_md5_checksum(std::string());
-    drive_metadata.set_conflicted(false);
-    drive_metadata.set_to_be_fetched(false);
-    drive_metadata.set_type(
-        SyncFileTypeToDriveMetadataResourceType(SYNC_FILE_TYPE_FILE));
-    metadata_store_->UpdateEntry(
-        url, drive_metadata,
-        base::Bind(&DriveFileSyncService::StartOverLocalSync, AsWeakPtr(),
-                   base::Passed(&param)));
-    return;
-  }
-  // Remote win case.
-  DVLOG(1) << "Resolving conflict for local sync:"
-           << url.DebugString() << ": REMOTE WIN";
-  ResolveConflictToRemoteForLocalSync(param.Pass(), SYNC_FILE_TYPE_FILE);
-}
-
-void DriveFileSyncService::ResolveConflictToRemoteForLocalSync(
-    scoped_ptr<ApplyLocalChangeParam> param,
-    SyncFileType remote_file_type) {
-  DCHECK(param);
-  const FileSystemURL& url = param->url;
-  DriveMetadata& drive_metadata = param->drive_metadata;
-  // Mark the file as to-be-fetched.
-  DCHECK(!drive_metadata.resource_id().empty());
-  drive_metadata.set_conflicted(false);
-  drive_metadata.set_to_be_fetched(true);
-  drive_metadata.set_type(
-      SyncFileTypeToDriveMetadataResourceType(remote_file_type));
-  param->has_drive_metadata = true;
-  metadata_store_->UpdateEntry(
-      url, drive_metadata,
-      base::Bind(&DriveFileSyncService::DidResolveConflictToRemoteChange,
-                 AsWeakPtr(), base::Passed(&param)));
-  // The synced notification will be dispatched when the remote file is
-  // downloaded.
-}
-
-void DriveFileSyncService::StartOverLocalSync(
-    scoped_ptr<ApplyLocalChangeParam> param,
-    SyncStatusCode status) {
-  DCHECK(param);
-  if (status != SYNC_STATUS_OK) {
-    param->callback.Run(status);
-    return;
-  }
-  RemoveRemoteChange(param->url);
-  DoApplyLocalChange(
-      param->local_change, param->local_path, param->local_metadata,
-      param->url, param->callback);
+  running_local_sync_task_.reset();
+  callback.Run(status);
 }
 
 void DriveFileSyncService::DidPrepareForProcessRemoteChange(
     scoped_ptr<ProcessRemoteChangeParam> param,
     SyncStatusCode status,
     const SyncFileMetadata& metadata,
     const FileChangeList& local_changes) {
   if (status != SYNC_STATUS_OK) {
     AbortRemoteSync(param.Pass(), status);
     return;
@@ skipping 639 matching lines @@
 
   MaybeStartFetchChanges();
 }
 
 void DriveFileSyncService::NotifyLastOperationStatus(
     SyncStatusCode sync_status,
     google_apis::GDataErrorCode gdata_error) {
   UpdateServiceStateFromLastOperationStatus(sync_status, gdata_error);
 }
 
+// static
+std::string DriveFileSyncService::PathToTitle(const base::FilePath& path) {
+  if (!IsSyncDirectoryOperationEnabled())
+    return path.AsUTF8Unsafe();
+
+  return fileapi::FilePathToString(
+      base::FilePath(fileapi::VirtualPath::GetNormalizedFilePath(path)));
+}
+
+// static
+base::FilePath DriveFileSyncService::TitleToPath(const std::string& title) {
+  if (!IsSyncDirectoryOperationEnabled())
+    return base::FilePath::FromUTF8Unsafe(title);
+
+  return fileapi::StringToFilePath(title).NormalizePathSeparators();
+}
+
+// static
+DriveMetadata::ResourceType
+DriveFileSyncService::SyncFileTypeToDriveMetadataResourceType(

[kinuko, 2013/05/16 13:37:37]

nit: maybe we can factor out these util methods into a separate class later. (No
need to do it in this CL)

[tzik, 2013/05/17 05:14:10]

Done.

+    SyncFileType file_type) {
+  DCHECK_NE(SYNC_FILE_TYPE_UNKNOWN, file_type);
+  switch (file_type) {
+    case SYNC_FILE_TYPE_UNKNOWN:
+      return DriveMetadata_ResourceType_RESOURCE_TYPE_FILE;
+    case SYNC_FILE_TYPE_FILE:
+      return DriveMetadata_ResourceType_RESOURCE_TYPE_FILE;
+    case SYNC_FILE_TYPE_DIRECTORY:
+      return DriveMetadata_ResourceType_RESOURCE_TYPE_FOLDER;
+  }
+  NOTREACHED();
+  return DriveMetadata_ResourceType_RESOURCE_TYPE_FILE;
+}
+
 void DriveFileSyncService::FetchChangesForIncrementalSync(
     const SyncStatusCallback& callback) {
   DCHECK(may_have_unfetched_changes_);
   DCHECK(pending_batch_sync_origins_.empty());
   DCHECK(!metadata_store_->incremental_sync_origins().empty());
 
   DVLOG(1) << "FetchChangesForIncrementalSync (start_changestamp:"
            << (largest_fetched_changestamp_ + 1) << ")";
 
   api_util_->ListChanges(
@@ skipping 184 matching lines @@
       pending_batch_sync_origins_.insert(origin);
   }
   callback.Run(status, resource_id);
 }
 
 std::string DriveFileSyncService::sync_root_resource_id() {
   return metadata_store_->sync_root_directory();
 }
 
 }  // namespace sync_file_system