Home | History | Annotate | Download | only in drive_backend_v1 
      1 // Copyright 2013 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "chrome/browser/sync_file_system/drive_backend_v1/local_sync_delegate.h"
      6 
      7 #include "base/bind.h"
      8 #include "base/callback.h"
      9 #include "chrome/browser/sync_file_system/conflict_resolution_resolver.h"
     10 #include "chrome/browser/sync_file_system/drive_backend_v1/api_util.h"
     11 #include "chrome/browser/sync_file_system/drive_backend_v1/drive_metadata_store.h"
     12 #include "chrome/browser/sync_file_system/logger.h"
     13 #include "chrome/browser/sync_file_system/syncable_file_system_util.h"
     14 
     15 namespace sync_file_system {
     16 namespace drive_backend {
     17 
     18 LocalSyncDelegate::LocalSyncDelegate(
     19     DriveFileSyncService* sync_service,
     20     const FileChange& local_change,
     21     const base::FilePath& local_path,
     22     const SyncFileMetadata& local_metadata,
     23     const fileapi::FileSystemURL& url)
     24     : sync_service_(sync_service),
     25       operation_(SYNC_OPERATION_NONE),
     26       url_(url),
     27       local_change_(local_change),
     28       local_path_(local_path),
     29       local_metadata_(local_metadata),
     30       has_drive_metadata_(false),
     31       has_remote_change_(false),
     32       weak_factory_(this) {}
     33 
     34 LocalSyncDelegate::~LocalSyncDelegate() {}
     35 
     36 void LocalSyncDelegate::Run(const SyncStatusCallback& callback) {
     37   // TODO(nhiroki): support directory operations (http://crbug.com/161442).
     38   DCHECK(IsSyncFSDirectoryOperationEnabled() || !local_change_.IsDirectory());
     39   operation_ = SYNC_OPERATION_NONE;
     40 
     41   has_drive_metadata_ =
     42       metadata_store()->ReadEntry(url_, &drive_metadata_) == SYNC_STATUS_OK;
     43 
     44   if (!has_drive_metadata_)
     45     drive_metadata_.set_md5_checksum(std::string());
     46 
     47   sync_service_->EnsureOriginRootDirectory(
     48       url_.origin(),
     49       base::Bind(&LocalSyncDelegate::DidGetOriginRoot,
     50                  weak_factory_.GetWeakPtr(),
     51                  callback));
     52 }
     53 
     54 void LocalSyncDelegate::DidGetOriginRoot(
     55     const SyncStatusCallback& callback,
     56     SyncStatusCode status,
     57     const std::string& origin_resource_id) {
     58   if (status != SYNC_STATUS_OK) {
     59     callback.Run(status);
     60     return;
     61   }
     62 
     63   origin_resource_id_ = origin_resource_id;
     64 
     65   has_remote_change_ =
     66       remote_change_handler()->GetChangeForURL(url_, &remote_change_);
     67   if (has_remote_change_ && drive_metadata_.resource_id().empty())
     68     drive_metadata_.set_resource_id(remote_change_.resource_id);
     69 
     70   SyncFileType remote_file_type =
     71       has_remote_change_ ? remote_change_.change.file_type() :
     72       has_drive_metadata_ ?
     73           DriveFileSyncService::DriveMetadataResourceTypeToSyncFileType(
     74               drive_metadata_.type())
     75       : SYNC_FILE_TYPE_UNKNOWN;
     76 
     77   DCHECK_EQ(SYNC_OPERATION_NONE, operation_);
     78   operation_ = LocalSyncOperationResolver::Resolve(
     79       local_change_,
     80       has_remote_change_ ? &remote_change_.change : NULL,
     81       has_drive_metadata_ ? &drive_metadata_ : NULL);
     82 
     83   util::Log(logging::LOG_VERBOSE, FROM_HERE,
     84             "ApplyLocalChange for %s local_change:%s ===> %s",
     85             url_.DebugString().c_str(),
     86             local_change_.DebugString().c_str(),
     87             SyncOperationTypeToString(operation_));
     88 
     89   switch (operation_) {
     90     case SYNC_OPERATION_ADD_FILE:
     91       UploadNewFile(callback);
     92       return;
     93     case SYNC_OPERATION_ADD_DIRECTORY:
     94       CreateDirectory(callback);
     95       return;
     96     case SYNC_OPERATION_UPDATE_FILE:
     97       UploadExistingFile(callback);
     98       return;
     99     case SYNC_OPERATION_DELETE:
    100       Delete(callback);
    101       return;
    102     case SYNC_OPERATION_NONE:
    103       callback.Run(SYNC_STATUS_OK);
    104       return;
    105     case SYNC_OPERATION_CONFLICT:
    106       HandleConflict(callback);
    107       return;
    108     case SYNC_OPERATION_RESOLVE_TO_LOCAL:
    109       ResolveToLocal(callback);
    110       return;
    111     case SYNC_OPERATION_RESOLVE_TO_REMOTE:
    112       ResolveToRemote(callback, remote_file_type);
    113       return;
    114     case SYNC_OPERATION_DELETE_METADATA:
    115       DeleteMetadata(base::Bind(
    116           &LocalSyncDelegate::DidApplyLocalChange,
    117           weak_factory_.GetWeakPtr(), callback, google_apis::HTTP_SUCCESS));
    118       return;
    119     case SYNC_OPERATION_FAIL: {
    120       callback.Run(SYNC_STATUS_FAILED);
    121       return;
    122     }
    123   }
    124   NOTREACHED();
    125   callback.Run(SYNC_STATUS_FAILED);
    126 }
    127 
    128 void LocalSyncDelegate::UploadNewFile(const SyncStatusCallback& callback) {
    129   api_util()->UploadNewFile(
    130       origin_resource_id_,
    131       local_path_,
    132       DriveFileSyncService::PathToTitle(url_.path()),
    133       base::Bind(&LocalSyncDelegate::DidUploadNewFile,
    134                  weak_factory_.GetWeakPtr(), callback));
    135 }
    136 
    137 void LocalSyncDelegate::DidUploadNewFile(
    138     const SyncStatusCallback& callback,
    139     google_apis::GDataErrorCode error,
    140     const std::string& resource_id,
    141     const std::string& md5) {
    142   switch (error) {
    143     case google_apis::HTTP_CREATED:
    144       UpdateMetadata(
    145           resource_id, md5, DriveMetadata::RESOURCE_TYPE_FILE,
    146           base::Bind(&LocalSyncDelegate::DidApplyLocalChange,
    147                      weak_factory_.GetWeakPtr(), callback, error));
    148       sync_service_->NotifyObserversFileStatusChanged(
    149           url_,
    150           SYNC_FILE_STATUS_SYNCED,
    151           SYNC_ACTION_ADDED,
    152           SYNC_DIRECTION_LOCAL_TO_REMOTE);
    153       return;
    154     case google_apis::HTTP_CONFLICT:
    155       HandleCreationConflict(resource_id, DriveMetadata::RESOURCE_TYPE_FILE,
    156                              callback);
    157       return;
    158     default:
    159       callback.Run(GDataErrorCodeToSyncStatusCodeWrapper(error));
    160   }
    161 }
    162 
    163 void LocalSyncDelegate::CreateDirectory(const SyncStatusCallback& callback) {
    164   DCHECK(IsSyncFSDirectoryOperationEnabled());
    165   api_util()->CreateDirectory(
    166       origin_resource_id_,
    167       DriveFileSyncService::PathToTitle(url_.path()),
    168       base::Bind(&LocalSyncDelegate::DidCreateDirectory,
    169                  weak_factory_.GetWeakPtr(), callback));
    170 }
    171 
    172 void LocalSyncDelegate::DidCreateDirectory(
    173     const SyncStatusCallback& callback,
    174     google_apis::GDataErrorCode error,
    175     const std::string& resource_id) {
    176   switch (error) {
    177     case google_apis::HTTP_SUCCESS:
    178     case google_apis::HTTP_CREATED: {
    179       UpdateMetadata(
    180           resource_id, std::string(), DriveMetadata::RESOURCE_TYPE_FOLDER,
    181           base::Bind(&LocalSyncDelegate::DidApplyLocalChange,
    182                      weak_factory_.GetWeakPtr(), callback, error));
    183       sync_service_->NotifyObserversFileStatusChanged(
    184           url_,
    185           SYNC_FILE_STATUS_SYNCED,
    186           SYNC_ACTION_ADDED,
    187           SYNC_DIRECTION_LOCAL_TO_REMOTE);
    188       return;
    189     }
    190 
    191     case google_apis::HTTP_CONFLICT:
    192       // There were conflicts and a file was left.
    193       // TODO(kinuko): Handle the latter case (http://crbug.com/237090).
    194       // Fall-through
    195 
    196     default:
    197       callback.Run(GDataErrorCodeToSyncStatusCodeWrapper(error));
    198   }
    199 }
    200 
    201 void LocalSyncDelegate::UploadExistingFile(const SyncStatusCallback& callback) {
    202   DCHECK(has_drive_metadata_);
    203   if (drive_metadata_.resource_id().empty()) {
    204     UploadNewFile(callback);
    205     return;
    206   }
    207 
    208   api_util()->UploadExistingFile(
    209       drive_metadata_.resource_id(),
    210       drive_metadata_.md5_checksum(),
    211       local_path_,
    212       base::Bind(&LocalSyncDelegate::DidUploadExistingFile,
    213                  weak_factory_.GetWeakPtr(), callback));
    214 }
    215 
    216 void LocalSyncDelegate::DidUploadExistingFile(
    217     const SyncStatusCallback& callback,
    218     google_apis::GDataErrorCode error,
    219     const std::string& resource_id,
    220     const std::string& md5) {
    221   DCHECK(has_drive_metadata_);
    222   switch (error) {
    223     case google_apis::HTTP_SUCCESS:
    224       UpdateMetadata(
    225           resource_id, md5, DriveMetadata::RESOURCE_TYPE_FILE,
    226           base::Bind(&LocalSyncDelegate::DidApplyLocalChange,
    227                      weak_factory_.GetWeakPtr(), callback, error));
    228       sync_service_->NotifyObserversFileStatusChanged(
    229           url_,
    230           SYNC_FILE_STATUS_SYNCED,
    231           SYNC_ACTION_UPDATED,
    232           SYNC_DIRECTION_LOCAL_TO_REMOTE);
    233       return;
    234     case google_apis::HTTP_CONFLICT:
    235       HandleConflict(callback);
    236       return;
    237     case google_apis::HTTP_NOT_MODIFIED:
    238       DidApplyLocalChange(callback,
    239                           google_apis::HTTP_SUCCESS, SYNC_STATUS_OK);
    240       return;
    241     case google_apis::HTTP_NOT_FOUND:
    242       UploadNewFile(callback);
    243       return;
    244     default: {
    245       const SyncStatusCode status =
    246           GDataErrorCodeToSyncStatusCodeWrapper(error);
    247       DCHECK_NE(SYNC_STATUS_OK, status);
    248       callback.Run(status);
    249       return;
    250     }
    251   }
    252 }
    253 
    254 void LocalSyncDelegate::Delete(const SyncStatusCallback& callback) {
    255   if (!has_drive_metadata_) {
    256     callback.Run(SYNC_STATUS_OK);
    257     return;
    258   }
    259 
    260   if (drive_metadata_.resource_id().empty()) {
    261     DidDelete(callback, google_apis::HTTP_NOT_FOUND);
    262     return;
    263   }
    264 
    265   api_util()->DeleteFile(
    266       drive_metadata_.resource_id(),
    267       drive_metadata_.md5_checksum(),
    268       base::Bind(&LocalSyncDelegate::DidDelete,
    269                  weak_factory_.GetWeakPtr(), callback));
    270 }
    271 
    272 void LocalSyncDelegate::DidDelete(
    273     const SyncStatusCallback& callback,
    274     google_apis::GDataErrorCode error) {
    275   DCHECK(has_drive_metadata_);
    276 
    277   switch (error) {
    278     case google_apis::HTTP_SUCCESS:
    279     case google_apis::HTTP_NOT_FOUND:
    280       DeleteMetadata(base::Bind(
    281           &LocalSyncDelegate::DidApplyLocalChange,
    282           weak_factory_.GetWeakPtr(), callback, google_apis::HTTP_SUCCESS));
    283       sync_service_->NotifyObserversFileStatusChanged(
    284           url_,
    285           SYNC_FILE_STATUS_SYNCED,
    286           SYNC_ACTION_DELETED,
    287           SYNC_DIRECTION_LOCAL_TO_REMOTE);
    288       return;
    289     case google_apis::HTTP_PRECONDITION:
    290     case google_apis::HTTP_CONFLICT:
    291       // Delete |drive_metadata| on the conflict case.
    292       // Conflicted remote change should be applied as a future remote change.
    293       DeleteMetadata(base::Bind(
    294           &LocalSyncDelegate::DidDeleteMetadataForDeletionConflict,
    295           weak_factory_.GetWeakPtr(), callback));
    296       sync_service_->NotifyObserversFileStatusChanged(
    297           url_,
    298           SYNC_FILE_STATUS_SYNCED,
    299           SYNC_ACTION_DELETED,
    300           SYNC_DIRECTION_LOCAL_TO_REMOTE);
    301       return;
    302     default: {
    303       const SyncStatusCode status =
    304           GDataErrorCodeToSyncStatusCodeWrapper(error);
    305       DCHECK_NE(SYNC_STATUS_OK, status);
    306       callback.Run(status);
    307       return;
    308     }
    309   }
    310 }
    311 
    312 void LocalSyncDelegate::DidDeleteMetadataForDeletionConflict(
    313     const SyncStatusCallback& callback,
    314     SyncStatusCode status) {
    315   callback.Run(SYNC_STATUS_OK);
    316 }
    317 
    318 void LocalSyncDelegate::ResolveToLocal(const SyncStatusCallback& callback) {
    319   if (drive_metadata_.resource_id().empty()) {
    320     DidDeleteFileToResolveToLocal(callback, google_apis::HTTP_NOT_FOUND);
    321     return;
    322   }
    323 
    324   api_util()->DeleteFile(
    325       drive_metadata_.resource_id(),
    326       drive_metadata_.md5_checksum(),
    327       base::Bind(
    328           &LocalSyncDelegate::DidDeleteFileToResolveToLocal,
    329           weak_factory_.GetWeakPtr(), callback));
    330 }
    331 
    332 void LocalSyncDelegate::DidDeleteFileToResolveToLocal(
    333     const SyncStatusCallback& callback,
    334     google_apis::GDataErrorCode error) {
    335   if (error != google_apis::HTTP_SUCCESS &&
    336       error != google_apis::HTTP_NOT_FOUND) {
    337     callback.Run(GDataErrorCodeToSyncStatusCodeWrapper(error));
    338     return;
    339   }
    340 
    341   DCHECK_NE(SYNC_FILE_TYPE_UNKNOWN, local_metadata_.file_type);
    342   if (local_metadata_.file_type == SYNC_FILE_TYPE_FILE) {
    343     UploadNewFile(callback);
    344     return;
    345   }
    346 
    347   DCHECK(IsSyncFSDirectoryOperationEnabled());
    348   DCHECK_EQ(SYNC_FILE_TYPE_DIRECTORY, local_metadata_.file_type);
    349   CreateDirectory(callback);
    350 }
    351 
    352 void LocalSyncDelegate::ResolveToRemote(
    353     const SyncStatusCallback& callback,
    354     SyncFileType remote_file_type) {
    355   // Mark the file as to-be-fetched.
    356   DCHECK(!drive_metadata_.resource_id().empty());
    357 
    358   SetMetadataToBeFetched(
    359       DriveFileSyncService::SyncFileTypeToDriveMetadataResourceType(
    360           remote_file_type),
    361       base::Bind(&LocalSyncDelegate::DidResolveToRemote,
    362                  weak_factory_.GetWeakPtr(), callback));
    363   // The synced notification will be dispatched when the remote file is
    364   // downloaded.
    365 }
    366 
    367 void LocalSyncDelegate::DidResolveToRemote(
    368     const SyncStatusCallback& callback,
    369     SyncStatusCode status) {
    370   DCHECK(has_drive_metadata_);
    371   if (status != SYNC_STATUS_OK) {
    372     callback.Run(status);
    373     return;
    374   }
    375 
    376   SyncFileType file_type = SYNC_FILE_TYPE_FILE;
    377   if (drive_metadata_.type() == DriveMetadata::RESOURCE_TYPE_FOLDER)
    378     file_type = SYNC_FILE_TYPE_DIRECTORY;
    379   sync_service_->AppendFetchChange(
    380       url_.origin(), url_.path(), drive_metadata_.resource_id(), file_type);
    381   callback.Run(status);
    382 }
    383 
    384 void LocalSyncDelegate::DidApplyLocalChange(
    385     const SyncStatusCallback& callback,
    386     const google_apis::GDataErrorCode error,
    387     SyncStatusCode status) {
    388   if ((operation_ == SYNC_OPERATION_DELETE ||
    389        operation_ == SYNC_OPERATION_DELETE_METADATA) &&
    390       (status == SYNC_FILE_ERROR_NOT_FOUND ||
    391        status == SYNC_DATABASE_ERROR_NOT_FOUND)) {
    392     status = SYNC_STATUS_OK;
    393   }
    394 
    395   if (status == SYNC_STATUS_OK) {
    396     remote_change_handler()->RemoveChangeForURL(url_);
    397     status = GDataErrorCodeToSyncStatusCodeWrapper(error);
    398   }
    399   callback.Run(status);
    400 }
    401 
    402 void LocalSyncDelegate::UpdateMetadata(
    403     const std::string& resource_id,
    404     const std::string& md5,
    405     DriveMetadata::ResourceType type,
    406     const SyncStatusCallback& callback) {
    407   has_drive_metadata_ = true;
    408   drive_metadata_.set_resource_id(resource_id);
    409   drive_metadata_.set_md5_checksum(md5);
    410   drive_metadata_.set_conflicted(false);
    411   drive_metadata_.set_to_be_fetched(false);
    412   drive_metadata_.set_type(type);
    413   metadata_store()->UpdateEntry(url_, drive_metadata_, callback);
    414 }
    415 
    416 void LocalSyncDelegate::ResetMetadataForStartOver(
    417     const SyncStatusCallback& callback) {
    418   has_drive_metadata_ = true;
    419   DCHECK(!drive_metadata_.resource_id().empty());
    420   drive_metadata_.set_md5_checksum(std::string());
    421   drive_metadata_.set_conflicted(false);
    422   drive_metadata_.set_to_be_fetched(false);
    423   metadata_store()->UpdateEntry(url_, drive_metadata_, callback);
    424 }
    425 
    426 void LocalSyncDelegate::SetMetadataToBeFetched(
    427     DriveMetadata::ResourceType type,
    428     const SyncStatusCallback& callback) {
    429   has_drive_metadata_ = true;
    430   drive_metadata_.set_md5_checksum(std::string());
    431   drive_metadata_.set_conflicted(false);
    432   drive_metadata_.set_to_be_fetched(true);
    433   drive_metadata_.set_type(type);
    434   metadata_store()->UpdateEntry(url_, drive_metadata_, callback);
    435 }
    436 
    437 void LocalSyncDelegate::DeleteMetadata(const SyncStatusCallback& callback) {
    438   metadata_store()->DeleteEntry(url_, callback);
    439 }
    440 
    441 void LocalSyncDelegate::HandleCreationConflict(
    442     const std::string& resource_id,
    443     DriveMetadata::ResourceType type,
    444     const SyncStatusCallback& callback) {
    445   // File-file conflict is found.
    446   // Populates a fake drive_metadata and set has_drive_metadata = true.
    447   // In HandleConflictLocalSync:
    448   // - If conflict_resolution is manual, we'll change conflicted to true
    449   //   and save the metadata.
    450   // - Otherwise we'll save the metadata with empty md5 and will start
    451   //   over local sync as UploadExistingFile.
    452   drive_metadata_.set_resource_id(resource_id);
    453   drive_metadata_.set_md5_checksum(std::string());
    454   drive_metadata_.set_conflicted(false);
    455   drive_metadata_.set_to_be_fetched(false);
    456   drive_metadata_.set_type(type);
    457   has_drive_metadata_ = true;
    458   HandleConflict(callback);
    459 }
    460 
    461 void LocalSyncDelegate::HandleConflict(const SyncStatusCallback& callback) {
    462   DCHECK(!drive_metadata_.resource_id().empty());
    463   api_util()->GetResourceEntry(
    464       drive_metadata_.resource_id(),
    465       base::Bind(
    466           &LocalSyncDelegate::DidGetEntryForConflictResolution,
    467           weak_factory_.GetWeakPtr(), callback));
    468 }
    469 
    470 void LocalSyncDelegate::DidGetEntryForConflictResolution(
    471     const SyncStatusCallback& callback,
    472     google_apis::GDataErrorCode error,
    473     scoped_ptr<google_apis::ResourceEntry> entry) {
    474   SyncFileType remote_file_type = SYNC_FILE_TYPE_UNKNOWN;
    475   ConflictResolution resolution = CONFLICT_RESOLUTION_UNKNOWN;
    476 
    477   if (error != google_apis::HTTP_SUCCESS ||
    478       entry->updated_time().is_null()) {
    479     resolution = CONFLICT_RESOLUTION_LOCAL_WIN;
    480   } else {
    481     SyncFileType local_file_type = local_metadata_.file_type;
    482     base::Time local_modification_time = local_metadata_.last_modified;
    483     base::Time remote_modification_time = entry->updated_time();
    484     if (entry->is_file())
    485       remote_file_type = SYNC_FILE_TYPE_FILE;
    486     else if (entry->is_folder())
    487       remote_file_type = SYNC_FILE_TYPE_DIRECTORY;
    488     else
    489       remote_file_type = SYNC_FILE_TYPE_UNKNOWN;
    490 
    491     resolution = conflict_resolution_resolver()->Resolve(
    492         local_file_type, local_modification_time,
    493         remote_file_type, remote_modification_time);
    494   }
    495 
    496   switch (resolution) {
    497     case CONFLICT_RESOLUTION_MARK_CONFLICT:
    498       HandleManualResolutionCase(callback);
    499       return;
    500     case CONFLICT_RESOLUTION_LOCAL_WIN:
    501       HandleLocalWinCase(callback);
    502       return;
    503     case CONFLICT_RESOLUTION_REMOTE_WIN:
    504       HandleRemoteWinCase(callback, remote_file_type);
    505       return;
    506     case CONFLICT_RESOLUTION_UNKNOWN:
    507       NOTREACHED();
    508   }
    509   NOTREACHED();
    510   callback.Run(SYNC_STATUS_FAILED);
    511 }
    512 
    513 void LocalSyncDelegate::HandleManualResolutionCase(
    514     const SyncStatusCallback& callback) {
    515   if (drive_metadata_.conflicted()) {
    516     callback.Run(SYNC_STATUS_HAS_CONFLICT);
    517     return;
    518   }
    519 
    520   has_drive_metadata_ = true;
    521   sync_service_->MarkConflict(
    522       url_, &drive_metadata_,
    523       base::Bind(&LocalSyncDelegate::DidMarkConflict,
    524                  weak_factory_.GetWeakPtr(), callback));
    525 }
    526 
    527 void LocalSyncDelegate::DidMarkConflict(
    528     const SyncStatusCallback& callback,
    529     SyncStatusCode status) {
    530   DidApplyLocalChange(callback, google_apis::HTTP_CONFLICT, status);
    531 }
    532 
    533 void LocalSyncDelegate::HandleLocalWinCase(
    534     const SyncStatusCallback& callback) {
    535   util::Log(logging::LOG_VERBOSE, FROM_HERE,
    536             "Resolving conflict for local sync: %s: LOCAL WIN",
    537             url_.DebugString().c_str());
    538 
    539   DCHECK(!drive_metadata_.resource_id().empty());
    540   if (!has_drive_metadata_) {
    541     StartOver(callback, SYNC_STATUS_OK);
    542     return;
    543   }
    544 
    545   ResetMetadataForStartOver(base::Bind(&LocalSyncDelegate::StartOver,
    546                                        weak_factory_.GetWeakPtr(), callback));
    547 }
    548 
    549 void LocalSyncDelegate::HandleRemoteWinCase(
    550     const SyncStatusCallback& callback,
    551     SyncFileType remote_file_type) {
    552   util::Log(logging::LOG_VERBOSE, FROM_HERE,
    553             "Resolving conflict for local sync: %s: REMOTE WIN",
    554             url_.DebugString().c_str());
    555   ResolveToRemote(callback, remote_file_type);
    556 }
    557 
    558 void LocalSyncDelegate::StartOver(const SyncStatusCallback& callback,
    559                                   SyncStatusCode status) {
    560   if (status != SYNC_STATUS_OK) {
    561     callback.Run(status);
    562     return;
    563   }
    564 
    565   remote_change_handler()->RemoveChangeForURL(url_);
    566 
    567   // Return the control back to the sync service once.
    568   callback.Run(SYNC_STATUS_RETRY);
    569 }
    570 
    571 SyncStatusCode
    572 LocalSyncDelegate::GDataErrorCodeToSyncStatusCodeWrapper(
    573     google_apis::GDataErrorCode error) {
    574   return sync_service_->GDataErrorCodeToSyncStatusCodeWrapper(error);
    575 }
    576 
    577 DriveMetadataStore* LocalSyncDelegate::metadata_store() {
    578   return sync_service_->metadata_store_.get();
    579 }
    580 
    581 APIUtilInterface* LocalSyncDelegate::api_util() {
    582   return sync_service_->api_util_.get();
    583 }
    584 
    585 RemoteChangeHandler* LocalSyncDelegate::remote_change_handler() {
    586   return &sync_service_->remote_change_handler_;
    587 }
    588 
    589 ConflictResolutionResolver* LocalSyncDelegate::conflict_resolution_resolver() {
    590   return &sync_service_->conflict_resolution_resolver_;
    591 }
    592 
    593 }  // namespace drive_backend
    594 }  // namespace sync_file_system
    595