SyncFS: Add resource type field into DriveMetadata

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 1120 matching lines @@
       sync_client_->UploadNewFile(
           origin_resource_id,
           local_file_path,
           url.path().AsUTF8Unsafe(),
           base::Bind(&DriveFileSyncService::DidUploadNewFileForLocalSync,
                     AsWeakPtr(), base::Passed(&param)));
       return;
     }
     case LOCAL_SYNC_OPERATION_UPDATE: {
       DCHECK(param->has_drive_metadata);
+      DCHECK_EQ(DriveMetadata::FILE, param->drive_metadata.type());

[kinuko, 2013/04/16 12:10:19]

It feels slightly weird to have these occasional DCHECKs while we don't have
actual code around.

[nhiroki, 2013/04/17 02:24:51]

Okay, recalled them for now.

       sync_client_->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: {
       DCHECK(param->has_drive_metadata);
@@ skipping 135 matching lines @@
     google_apis::GDataErrorCode error,
     const std::string& resource_id,
     const std::string& file_md5) {
   DCHECK(param);
   const FileSystemURL& url = param->url;
   if (error == 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::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;
   }
   FinalizeLocalSync(param->token.Pass(), param->callback,
                     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::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;
@@ skipping 742 matching lines @@
     return false;
   *change = found_path->second;
   return true;
 }
 
 void DriveFileSyncService::MarkConflict(
     const fileapi::FileSystemURL& url,
     DriveMetadata* drive_metadata,
     const SyncStatusCallback& callback) {
   DCHECK(drive_metadata);
+  // For now conflict involving directories should be resolved automatically.
+  // TODO(nhiroki): support manual conflict handling for directory operations.
+  // (http://crbug.com/231827)
+  DCHECK_EQ(DriveMetadata::FILE, drive_metadata->type());
+
   if (drive_metadata->resource_id().empty()) {
     // If the file does not have valid drive_metadata in the metadata store
     // we must have a pending remote change entry.
     RemoteChange remote_change;
     const bool has_remote_change =
         GetPendingChangeForFileSystemURL(url, &remote_change);
     DCHECK(has_remote_change);
     drive_metadata->set_resource_id(remote_change.resource_id);
     drive_metadata->set_md5_checksum(std::string());
   }
@@ skipping 357 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