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>
 
@@ skipping 1485 matching lines @@
            << (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:
       param->sync_action = SYNC_ACTION_ADDED;
       DownloadForRemoteSync(param.Pass());
       return;
+    case REMOTE_SYNC_OPERATION_ADD_DIRECTORY:
+      // TODO(nhiroki): support directory operations (http://crbug.com/161442).
+      NOTIMPLEMENTED();
+      AbortRemoteSync(param.Pass(), SYNC_STATUS_FAILED);
+      return;
     case REMOTE_SYNC_OPERATION_UPDATE_FILE:
       param->sync_action = SYNC_ACTION_UPDATED;
       DownloadForRemoteSync(param.Pass());
       return;
     case 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_DELETE_DIRECTORY:
+      // TODO(nhiroki): support directory operations (http://crbug.com/161442).
+      NOTIMPLEMENTED();
+      AbortRemoteSync(param.Pass(), SYNC_STATUS_FAILED);
+      return;
     case REMOTE_SYNC_OPERATION_NONE:
       param->sync_action = SYNC_ACTION_NONE;
       CompleteRemoteSync(param.Pass(), SYNC_STATUS_OK);
       return;
     case REMOTE_SYNC_OPERATION_CONFLICT:
       HandleConflictForRemoteSync(param.Pass(), base::Time(), SYNC_STATUS_OK);
       return;
     case REMOTE_SYNC_OPERATION_RESOLVE_TO_LOCAL:
       ResolveConflictToLocalForRemoteSync(param.Pass());
       return;
@@ skipping 20 matching lines @@
   }
   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) {

[kinuko, 2013/04/24 02:32:32]

It looks this doesn't need entire ProcessRemoteChangeParam but only need
local_file_type and is_conflicting flag.

I think this method could be separated out from this class and can have its own
unittest.
And then we can verify this logic solely not by inline-comments but in a full
matrix test?

[kinuko, 2013/04/24 02:42:29]

If this takes too much your time it'd be still nicer to add a unittest for this
method.

[nhiroki, 2013/04/24 13:29:05]

Done.

-  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:
+  SyncFileType local_file_type = param->local_metadata.file_type;
+
+  if (remote_file_change.IsAddOrUpdateFile()) {
+    if (param->drive_metadata.conflicted()) {
+      //
+      // (LocalFile) + (LocalChange)        -> (OperationType)
+      // None        + Delete               -> RESOLVE_TO_REMOTE
+      // File        + None/AddOrUpdateFile -> CONFLICT
+      // Dir         + None/AddDir          -> RESOLVE_TO_LOCAL
+      //
+      switch (local_file_type) {
+        case SYNC_FILE_TYPE_UNKNOWN:
+          DCHECK(!local_changes.empty() &&
+                 local_changes.list().back().IsDelete());
+          return REMOTE_SYNC_OPERATION_RESOLVE_TO_REMOTE;
+        case SYNC_FILE_TYPE_FILE:
+          DCHECK(local_changes.empty() ||
+                 local_changes.list().back().IsAddOrUpdateFile());
+          return REMOTE_SYNC_OPERATION_CONFLICT;
+        case SYNC_FILE_TYPE_DIRECTORY:
+          DCHECK(local_changes.empty() ||
+                 local_changes.list().back().IsAddDirectory());
+          return REMOTE_SYNC_OPERATION_RESOLVE_TO_LOCAL;
+      }
+    }
+
+    //
+    // (LocalFile) + (LocalChange)   -> (OperationType)
+    // None        + None/Delete     -> ADD_FILE
+    // File        + None            -> UPDATE_FILE
+    // File        + AddOrUpdateFile -> CONFLICT
+    // Dir         + None/AddDir     -> RESOLVE_TO_LOCAL
+    //
+    switch (local_file_type) {
+      case SYNC_FILE_TYPE_UNKNOWN:
+        DCHECK(local_changes.empty() || local_changes.list().back().IsDelete());
+        return REMOTE_SYNC_OPERATION_ADD_FILE;
+      case SYNC_FILE_TYPE_FILE:
+        if (local_changes.empty())
+          return REMOTE_SYNC_OPERATION_UPDATE_FILE;
+        DCHECK(local_changes.list().back().IsAddOrUpdateFile());
         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;
+      case SYNC_FILE_TYPE_DIRECTORY:
+        DCHECK(local_changes.empty() ||
+               local_changes.list().back().IsAddDirectory());
+        return REMOTE_SYNC_OPERATION_RESOLVE_TO_LOCAL;
+    }
+  }
+
+  if (remote_file_change.IsDeleteFile()) {
+    if (param->drive_metadata.conflicted()) {
+      //
+      // (LocalFile) + (LocalChange)        -> (OperationType)
+      // None        + *                    -> DELETE_METADATA
+      // File        + None/AddOrUpdateFile -> RESOLVE_TO_LOCAL
+      // Dir         + None/AddDir          -> RESOLVE_TO_LOCAL
+      //
+      switch (local_file_type) {
+        case SYNC_FILE_TYPE_UNKNOWN:
+          return REMOTE_SYNC_OPERATION_DELETE_METADATA;
+        case SYNC_FILE_TYPE_FILE:
+          DCHECK(local_changes.empty() ||
+                 local_changes.list().back().IsAddOrUpdateFile());
+          return REMOTE_SYNC_OPERATION_RESOLVE_TO_LOCAL;
+        case SYNC_FILE_TYPE_DIRECTORY:
+          DCHECK(local_changes.empty() ||
+                 local_changes.list().back().IsAddDirectory());
+          return REMOTE_SYNC_OPERATION_RESOLVE_TO_LOCAL;
+      }
+    }
+
+    //
+    // (LocalFile) + (LocalChange)     -> (OperationType)
+    // None        + *                 -> DELETE_METADATA
+    // File        + None              -> DELETE_FILE
+    // File        + AddOrUpdateFile   -> NONE
+    // Dir         + None/AddDirectory -> NONE
+    //
+    switch (local_file_type) {
+      case SYNC_FILE_TYPE_UNKNOWN:
+          return REMOTE_SYNC_OPERATION_DELETE_METADATA;
+      case SYNC_FILE_TYPE_FILE:
+        if (local_changes.empty())
+          return REMOTE_SYNC_OPERATION_DELETE_FILE;
+        DCHECK(local_changes.list().back().IsAddOrUpdateFile());
+        return REMOTE_SYNC_OPERATION_NONE;
+      case SYNC_FILE_TYPE_DIRECTORY:
+        DCHECK(local_changes.empty() ||
+               local_changes.list().back().IsAddDirectory());
+        return REMOTE_SYNC_OPERATION_NONE;
+    }
+  }
+
+  if (remote_file_change.IsAddDirectory()) {
+    if (param->drive_metadata.conflicted()) {
+      //
+      // (LocalFile) + (LocalChange)        -> (OperationType)
+      // None        + Delete               -> RESOLVE_TO_REMOTE
+      // File        + None/AddOrUpdateFile -> RESOLVE_TO_REMOTE
+      // Dir         + AddDir               -> RESOLVE_TO_LOCAL
+      //
+      switch (local_file_type) {
+        case SYNC_FILE_TYPE_UNKNOWN:
+          if (!local_changes.empty() && local_changes.list().back().IsDelete())
+            return REMOTE_SYNC_OPERATION_RESOLVE_TO_REMOTE;
+          break;
+        case SYNC_FILE_TYPE_FILE:
+          if (local_changes.empty())
+            return REMOTE_SYNC_OPERATION_RESOLVE_TO_REMOTE;
+          if (local_changes.list().back().IsAddDirectory())
+            return REMOTE_SYNC_OPERATION_RESOLVE_TO_REMOTE;
+          break;
+        case SYNC_FILE_TYPE_DIRECTORY:
+          if (!local_changes.empty() &&
+              local_changes.list().back().IsAddDirectory())
+            return REMOTE_SYNC_OPERATION_RESOLVE_TO_LOCAL;
+          break;
+      }
+      NOTREACHED();
+      return REMOTE_SYNC_OPERATION_FAIL;
+    }
+
+    //
+    // (LocalFile) + (LocalChange)        -> (OperationType)
+    // None        + None                 -> ADD_DIR
+    // None        + Delete               -> RESOLVE_TO_REMOTE
+    // File        + None/AddOrUpdateFile -> RESOLVE_TO_REMOTE
+    // Dir         + None/AddDir          -> NONE
+    //
+    switch (local_file_type) {
+      case SYNC_FILE_TYPE_UNKNOWN:
+        if (local_changes.empty())
+          return REMOTE_SYNC_OPERATION_ADD_DIRECTORY;
+        DCHECK(local_changes.list().back().IsDelete());
+        return REMOTE_SYNC_OPERATION_RESOLVE_TO_REMOTE;
+      case SYNC_FILE_TYPE_FILE:
+        DCHECK(local_changes.empty() ||
+               local_changes.list().back().IsAddOrUpdateFile());
+        return REMOTE_SYNC_OPERATION_RESOLVE_TO_REMOTE;
+      case SYNC_FILE_TYPE_DIRECTORY:
+        DCHECK(local_changes.empty() ||
+               local_changes.list().back().IsAddDirectory());
+        return REMOTE_SYNC_OPERATION_NONE;
+    }
+    NOTREACHED();
+    return REMOTE_SYNC_OPERATION_FAIL;
+  }
+
+  if (remote_file_change.IsDeleteDirectory()) {
+    if (param->drive_metadata.conflicted()) {
+      //
+      // (LocalFile) + (LocalChange)        -> (OperationType)
+      // None        + *                    -> DELETE_METADATA
+      // File        + None/AddOrUpdateFile -> RESOLVE_TO_LOCAL
+      // Dir         + None                 -> DELETE_DIRECTORY
+      // Dir         + AddDir               -> RESOLVE_TO_LOCAL
+      //
+      switch (local_file_type) {
+        case SYNC_FILE_TYPE_UNKNOWN:
+          return REMOTE_SYNC_OPERATION_DELETE_METADATA;
+        case SYNC_FILE_TYPE_FILE:
+          DCHECK(local_changes.empty() ||
+                 local_changes.list().back().IsAddOrUpdateFile());
+          return REMOTE_SYNC_OPERATION_RESOLVE_TO_LOCAL;
+        case SYNC_FILE_TYPE_DIRECTORY:
+          DCHECK(local_changes.empty() ||
+                 local_changes.list().back().IsAddDirectory());
+          return REMOTE_SYNC_OPERATION_RESOLVE_TO_LOCAL;
+      }
+    }
+
+    //
+    // (LocalFile) + (LocalChange)        -> (OperationType)
+    // None        + None/Delete          -> NONE
+    // File        + None/AddOrUpdateFile -> RESOLVE_TO_LOCAL
+    // Dir         + None                 -> DELETE_DIRECTORY
+    // Dir         + AddDir               -> RESOLVE_TO_LOCAL
+    //
+    switch (local_file_type) {
+      case SYNC_FILE_TYPE_UNKNOWN:
+        DCHECK(local_changes.empty() ||
+               local_changes.list().back().IsDelete());
+        return REMOTE_SYNC_OPERATION_NONE;
+      case SYNC_FILE_TYPE_FILE:
+        DCHECK(local_changes.empty() ||
+               local_changes.list().back().IsAddOrUpdateFile());
+        return REMOTE_SYNC_OPERATION_RESOLVE_TO_LOCAL;
+      case SYNC_FILE_TYPE_DIRECTORY:
+        if (local_changes.empty())
+          return REMOTE_SYNC_OPERATION_DELETE_DIRECTORY;
+        DCHECK(local_changes.list().back().IsAddDirectory());
+        return REMOTE_SYNC_OPERATION_RESOLVE_TO_LOCAL;
+    }
+  }
+
+  DCHECK(remote_file_change.IsTypeUnknown());
+  return REMOTE_SYNC_OPERATION_NONE;
 }
 
 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;
   }
@@ skipping 342 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