[Sync FileSystem] Implement directory supported RESOLVE_TO_LOCAL to LocalSync.

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 1085 matching lines @@
       // The file is already conflicted.
       HandleConflictForLocalSync(param.Pass());
       return;
     case LOCAL_SYNC_OPERATION_NONE:
       FinalizeLocalSync(param->token.Pass(), callback, SYNC_STATUS_OK);
       return;
     case LOCAL_SYNC_OPERATION_CONFLICT:
       HandleConflictForLocalSync(param.Pass());
       return;
     case LOCAL_SYNC_OPERATION_RESOLVE_TO_LOCAL:
-      // TODO(nhiroki): support directory operations (http://crbug.com/161442).
-      NOTREACHED();
-      FinalizeLocalSync(param->token.Pass(),
-                        param->callback,
-                        SYNC_STATUS_FAILED);
+      sync_client_->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());
       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: {
       FinalizeLocalSync(param->token.Pass(), callback, SYNC_STATUS_FAILED);
       return;
     }
   }
   NOTREACHED();
   FinalizeLocalSync(param->token.Pass(), callback, 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);
+    SyncStatusCode status = GDataErrorCodeToSyncStatusCodeWrapper(error);
+    FinalizeLocalSync(param->token.Pass(), param->callback, status);
+    return;
+  }
+
+  DCHECK_NE(SYNC_FILE_TYPE_UNKNOWN, param->local_metadata.file_type);
+  if (param->local_metadata.file_type == SYNC_FILE_TYPE_FILE) {
+    sync_client_->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);
+  sync_client_->CreateDirectory(
+      origin_resource_id,
+      PathToTitle(url.path()),
+      base::Bind(&DriveFileSyncService::DidCreateDirectoryForLocalSync,
+                 AsWeakPtr(), base::Passed(&param)));
+}
+
 void DriveFileSyncService::DidApplyLocalChange(
     scoped_ptr<ApplyLocalChangeParam> param,
     const google_apis::GDataErrorCode error,
     SyncStatusCode status) {
   if (status == SYNC_STATUS_OK) {
     RemoveRemoteChange(param->url);
     status = GDataErrorCodeToSyncStatusCodeWrapper(error);
   }
   FinalizeLocalSync(param->token.Pass(), param->callback, status);
 }
@@ skipping 1169 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