SyncFS: Introduce RemoteSyncOperationResolver for directory operation support

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/debug/trace_event.h"
 #include "base/file_util.h"
 #include "base/location.h"
 #include "base/memory/weak_ptr.h"
 #include "base/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_file_sync_client.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_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/fileapi/file_system_url.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;
@@ skipping 1441 matching lines @@
 
   bool missing_db_entry = (status != SYNC_STATUS_OK);
   if (missing_db_entry) {
     param->drive_metadata.set_resource_id(param->remote_change.resource_id);
     param->drive_metadata.set_md5_checksum(std::string());
     param->drive_metadata.set_conflicted(false);
     param->drive_metadata.set_to_be_fetched(false);
   }
   bool missing_local_file = (metadata.file_type == SYNC_FILE_TYPE_UNKNOWN);
 
-  RemoteSyncOperationType operation =
-      ResolveRemoteSyncOperationType(remote_file_change, param.get(),
-                                     local_changes, missing_local_file);
+  RemoteSyncOperationResolver::RemoteSyncOperationType operation =
+      RemoteSyncOperationResolver::Resolve(remote_file_change,
+                                           local_changes,
+                                           param->local_metadata.file_type,
+                                           param->drive_metadata.conflicted());
 
   DVLOG(1) << "ProcessRemoteChange for " << url.DebugString()
            << (param->drive_metadata.conflicted() ? " (conflicted)" : " ")
            << (missing_local_file ? " (missing local file)" : " ")
            << " remote_change: " << remote_file_change.DebugString()
            << " ==> operation: " << operation;
 
   switch (operation) {
-    case REMOTE_SYNC_OPERATION_ADD_FILE:
+    case RemoteSyncOperationResolver::REMOTE_SYNC_OPERATION_ADD_FILE:
       param->sync_action = SYNC_ACTION_ADDED;
       DownloadForRemoteSync(param.Pass());
       return;
-    case REMOTE_SYNC_OPERATION_UPDATE_FILE:
+    case RemoteSyncOperationResolver::REMOTE_SYNC_OPERATION_ADD_DIRECTORY:
+      // TODO(nhiroki): support directory operations (http://crbug.com/161442).
+      NOTIMPLEMENTED();
+      AbortRemoteSync(param.Pass(), SYNC_STATUS_FAILED);
+      return;
+    case RemoteSyncOperationResolver::REMOTE_SYNC_OPERATION_UPDATE_FILE:
       param->sync_action = SYNC_ACTION_UPDATED;
       DownloadForRemoteSync(param.Pass());
       return;
-    case REMOTE_SYNC_OPERATION_DELETE_FILE: {
+    case RemoteSyncOperationResolver::REMOTE_SYNC_OPERATION_DELETE_FILE: {
       param->sync_action = SYNC_ACTION_DELETED;
       const FileChange& file_change = remote_file_change;
       remote_change_processor_->ApplyRemoteChange(
           file_change, base::FilePath(), url,
           base::Bind(&DriveFileSyncService::DidApplyRemoteChange, AsWeakPtr(),
                      base::Passed(&param)));
       return;
     }
-    case REMOTE_SYNC_OPERATION_NONE:
+    case RemoteSyncOperationResolver::REMOTE_SYNC_OPERATION_DELETE_DIRECTORY:
+      // TODO(nhiroki): support directory operations (http://crbug.com/161442).
+      NOTIMPLEMENTED();
+      AbortRemoteSync(param.Pass(), SYNC_STATUS_FAILED);
+      return;
+    case RemoteSyncOperationResolver::REMOTE_SYNC_OPERATION_NONE:
       param->sync_action = SYNC_ACTION_NONE;
       CompleteRemoteSync(param.Pass(), SYNC_STATUS_OK);
       return;
-    case REMOTE_SYNC_OPERATION_CONFLICT:
+    case RemoteSyncOperationResolver::REMOTE_SYNC_OPERATION_CONFLICT:
       HandleConflictForRemoteSync(param.Pass(), base::Time(), SYNC_STATUS_OK);
       return;
-    case REMOTE_SYNC_OPERATION_RESOLVE_TO_LOCAL:
+    case RemoteSyncOperationResolver::REMOTE_SYNC_OPERATION_RESOLVE_TO_LOCAL:
       ResolveConflictToLocalForRemoteSync(param.Pass());
       return;
-    case REMOTE_SYNC_OPERATION_RESOLVE_TO_REMOTE: {
+    case RemoteSyncOperationResolver::REMOTE_SYNC_OPERATION_RESOLVE_TO_REMOTE: {
       const FileSystemURL& url = param->remote_change.url;
       param->drive_metadata.set_conflicted(false);
       param->drive_metadata.set_to_be_fetched(true);
       metadata_store_->UpdateEntry(
           url, drive_metadata, base::Bind(&EmptyStatusCallback));
       param->sync_action = SYNC_ACTION_ADDED;
       DownloadForRemoteSync(param.Pass());
       return;
     }
-    case REMOTE_SYNC_OPERATION_DELETE_METADATA:
+    case RemoteSyncOperationResolver::REMOTE_SYNC_OPERATION_DELETE_METADATA:
       param->sync_action = SYNC_ACTION_NONE;
       if (missing_db_entry)
         CompleteRemoteSync(param.Pass(), SYNC_STATUS_OK);
       else
         DeleteMetadataForRemoteSync(param.Pass());
       return;
-    case REMOTE_SYNC_OPERATION_FAIL:
+    case RemoteSyncOperationResolver::REMOTE_SYNC_OPERATION_FAIL:
       AbortRemoteSync(param.Pass(), SYNC_STATUS_FAILED);
       return;
   }
   NOTREACHED();
   AbortRemoteSync(param.Pass(), SYNC_STATUS_FAILED);
 }
 
-DriveFileSyncService::RemoteSyncOperationType
-DriveFileSyncService::ResolveRemoteSyncOperationType(
-    const FileChange& remote_file_change,
-    ProcessRemoteChangeParam* param,
-    const FileChangeList& local_changes,
-    bool missing_local_file) {
-  if (param->drive_metadata.conflicted()) {
-    switch (remote_file_change.change()) {
-      case FileChange::FILE_CHANGE_ADD_OR_UPDATE:
-        return missing_local_file ? REMOTE_SYNC_OPERATION_RESOLVE_TO_REMOTE
-                                  : REMOTE_SYNC_OPERATION_CONFLICT;
-      case FileChange::FILE_CHANGE_DELETE:
-        return missing_local_file ? REMOTE_SYNC_OPERATION_DELETE_METADATA
-                                  : REMOTE_SYNC_OPERATION_RESOLVE_TO_LOCAL;
-    }
-  }
-
-  if (remote_file_change.IsAddOrUpdate()) {
-    if (local_changes.empty())
-      return missing_local_file ? REMOTE_SYNC_OPERATION_ADD_FILE
-                                : REMOTE_SYNC_OPERATION_UPDATE_FILE;
-    switch (local_changes.list().back().change()) {
-      case FileChange::FILE_CHANGE_ADD_OR_UPDATE:
-        return REMOTE_SYNC_OPERATION_CONFLICT;
-      case FileChange::FILE_CHANGE_DELETE:
-        return REMOTE_SYNC_OPERATION_ADD_FILE;
-    }
-  }
-
-  DCHECK(remote_file_change.IsDelete());
-  if (local_changes.empty())
-    return missing_local_file ? REMOTE_SYNC_OPERATION_DELETE_METADATA
-                              : REMOTE_SYNC_OPERATION_DELETE_FILE;
-  switch (local_changes.list().back().change()) {
-    case FileChange::FILE_CHANGE_ADD_OR_UPDATE:
-      return REMOTE_SYNC_OPERATION_NONE;
-    case FileChange::FILE_CHANGE_DELETE:
-      return REMOTE_SYNC_OPERATION_DELETE_METADATA;
-  }
-  NOTREACHED();
-  return REMOTE_SYNC_OPERATION_FAIL;
-}
-
 void DriveFileSyncService::DidResolveConflictToLocalChange(
     scoped_ptr<ProcessRemoteChangeParam> param,
     SyncStatusCode status) {
   if (status != SYNC_STATUS_OK) {
     DCHECK_NE(SYNC_STATUS_HAS_CONFLICT, status);
     AbortRemoteSync(param.Pass(), status);
     return;
   }
 
   const FileSystemURL& url = param->remote_change.url;
@@ skipping 340 matching lines @@
     return false;
 
   // Drop any change if the change has unknown resource id.
   if (!remote_resource_id.empty() &&
       !local_resource_id.empty() &&
       remote_resource_id != local_resource_id)
     return false;
 
   FileChange file_change(CreateFileChange(is_deleted));
 
+  if (is_deleted) {
+    // Determine a file type of the deleted change by local metadata.
+    if (!remote_resource_id.empty() &&
+        !local_resource_id.empty() &&
+        remote_resource_id == local_resource_id) {
+      DCHECK_EQ(DriveMetadata::RESOURCE_TYPE_FILE, metadata.type());
+      file_change = FileChange(FileChange::FILE_CHANGE_DELETE,
+                               SYNC_FILE_TYPE_FILE);
+    }
+  }
+
   if (is_deleted && has_db_entry) {
     metadata.set_resource_id(std::string());
     metadata_store_->UpdateEntry(url, metadata,
                                  base::Bind(&EmptyStatusCallback));
   }
 
   // Do not return in this block. These changes should be done together.
   {
     if (overridden_queue_item != pending_changes_.end())
       pending_changes_.erase(overridden_queue_item);
@@ skipping 391 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