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/local_to_remote_syncer.h" 6 7 #include <string> 8 #include <vector> 9 10 #include "base/callback.h" 11 #include "base/format_macros.h" 12 #include "base/location.h" 13 #include "base/logging.h" 14 #include "base/sequenced_task_runner.h" 15 #include "base/strings/stringprintf.h" 16 #include "base/task_runner_util.h" 17 #include "chrome/browser/drive/drive_api_util.h" 18 #include "chrome/browser/drive/drive_service_interface.h" 19 #include "chrome/browser/drive/drive_uploader.h" 20 #include "chrome/browser/sync_file_system/drive_backend/callback_helper.h" 21 #include "chrome/browser/sync_file_system/drive_backend/drive_backend_constants.h" 22 #include "chrome/browser/sync_file_system/drive_backend/drive_backend_util.h" 23 #include "chrome/browser/sync_file_system/drive_backend/folder_creator.h" 24 #include "chrome/browser/sync_file_system/drive_backend/metadata_database.h" 25 #include "chrome/browser/sync_file_system/drive_backend/metadata_database.pb.h" 26 #include "chrome/browser/sync_file_system/drive_backend/sync_engine_context.h" 27 #include "chrome/browser/sync_file_system/drive_backend/sync_task_manager.h" 28 #include "chrome/browser/sync_file_system/drive_backend/sync_task_token.h" 29 #include "chrome/browser/sync_file_system/logger.h" 30 #include "google_apis/drive/drive_api_parser.h" 31 #include "net/base/mime_util.h" 32 #include "storage/common/fileapi/file_system_util.h" 33 34 namespace sync_file_system { 35 namespace drive_backend { 36 37 namespace { 38 39 scoped_ptr<FileTracker> FindTrackerByID(MetadataDatabase* metadata_database, 40 int64 tracker_id) { 41 scoped_ptr<FileTracker> tracker(new FileTracker); 42 if (metadata_database->FindTrackerByTrackerID(tracker_id, tracker.get())) 43 return tracker.Pass(); 44 return scoped_ptr<FileTracker>(); 45 } 46 47 bool GetKnownChangeID(MetadataDatabase* metadata_database, 48 const std::string& file_id, 49 int64* change_id) { 50 FileMetadata remote_file_metadata; 51 if (!metadata_database->FindFileByFileID(file_id, &remote_file_metadata)) 52 return false; 53 *change_id = remote_file_metadata.details().change_id(); 54 return true; 55 } 56 57 bool IsLocalFileMissing(const SyncFileMetadata& local_metadata, 58 const FileChange& local_change) { 59 return local_metadata.file_type == SYNC_FILE_TYPE_UNKNOWN || 60 local_change.IsDelete(); 61 } 62 63 std::string GetMimeTypeFromTitle(const base::FilePath& title) { 64 base::FilePath::StringType extension = title.Extension(); 65 std::string mime_type; 66 if (extension.empty() || 67 !net::GetWellKnownMimeTypeFromExtension(extension.substr(1), &mime_type)) 68 return kMimeTypeOctetStream; 69 return mime_type; 70 } 71 72 } // namespace 73 74 LocalToRemoteSyncer::LocalToRemoteSyncer(SyncEngineContext* sync_context, 75 const SyncFileMetadata& local_metadata, 76 const FileChange& local_change, 77 const base::FilePath& local_path, 78 const storage::FileSystemURL& url) 79 : sync_context_(sync_context), 80 local_change_(local_change), 81 local_is_missing_(IsLocalFileMissing(local_metadata, local_change)), 82 local_path_(local_path), 83 url_(url), 84 sync_action_(SYNC_ACTION_NONE), 85 remote_file_change_id_(0), 86 retry_on_success_(false), 87 needs_remote_change_listing_(false), 88 weak_ptr_factory_(this) { 89 DCHECK(local_is_missing_ || 90 local_change.file_type() == local_metadata.file_type) 91 << local_change.DebugString() << " metadata:" << local_metadata.file_type; 92 } 93 94 LocalToRemoteSyncer::~LocalToRemoteSyncer() { 95 } 96 97 void LocalToRemoteSyncer::RunPreflight(scoped_ptr<SyncTaskToken> token) { 98 token->InitializeTaskLog("Local -> Remote"); 99 100 if (!IsContextReady()) { 101 token->RecordLog("Context not ready."); 102 SyncTaskManager::NotifyTaskDone(token.Pass(), SYNC_STATUS_FAILED); 103 return; 104 } 105 106 token->RecordLog(base::StringPrintf( 107 "Start: %s on %s@%s %s", 108 local_change_.DebugString().c_str(), 109 url_.path().AsUTF8Unsafe().c_str(), 110 url_.origin().host().c_str(), 111 local_is_missing_ ? "(missing)" : "")); 112 113 if (local_is_missing_ && !local_change_.IsDelete()) { 114 // Stray file, we can just return. 115 token->RecordLog("Missing file for non-delete change."); 116 SyncTaskManager::NotifyTaskDone(token.Pass(), SYNC_STATUS_OK); 117 return; 118 } 119 120 std::string app_id = url_.origin().host(); 121 base::FilePath path = url_.path(); 122 123 scoped_ptr<FileTracker> active_ancestor_tracker(new FileTracker); 124 base::FilePath active_ancestor_path; 125 if (!metadata_database()->FindNearestActiveAncestor( 126 app_id, path, 127 active_ancestor_tracker.get(), &active_ancestor_path)) { 128 // The app is disabled or not registered. 129 token->RecordLog("App is disabled or not registered"); 130 SyncTaskManager::NotifyTaskDone(token.Pass(), SYNC_STATUS_UNKNOWN_ORIGIN); 131 return; 132 } 133 DCHECK(active_ancestor_tracker->active()); 134 DCHECK(active_ancestor_tracker->has_synced_details()); 135 const FileDetails& active_ancestor_details = 136 active_ancestor_tracker->synced_details(); 137 138 // TODO(tzik): Consider handling 139 // active_ancestor_tracker->synced_details().missing() case. 140 141 DCHECK(active_ancestor_details.file_kind() == FILE_KIND_FILE || 142 active_ancestor_details.file_kind() == FILE_KIND_FOLDER); 143 144 base::FilePath missing_entries; 145 if (active_ancestor_path.empty()) { 146 missing_entries = path; 147 } else if (active_ancestor_path != path) { 148 if (!active_ancestor_path.AppendRelativePath(path, &missing_entries)) { 149 NOTREACHED(); 150 token->RecordLog(base::StringPrintf( 151 "Detected invalid ancestor: %s", 152 active_ancestor_path.value().c_str())); 153 SyncTaskManager::NotifyTaskDone(token.Pass(), SYNC_STATUS_FAILED); 154 return; 155 } 156 } 157 158 std::vector<base::FilePath::StringType> missing_components; 159 storage::VirtualPath::GetComponents(missing_entries, &missing_components); 160 161 if (!missing_components.empty()) { 162 if (local_is_missing_) { 163 token->RecordLog("Both local and remote are marked missing"); 164 // !IsDelete() but SYNC_FILE_TYPE_UNKNOWN could happen when a file is 165 // deleted by recursive deletion (which is not recorded by tracker) 166 // but there're remaining changes for the same file in the tracker. 167 168 // Local file is deleted and remote file is missing, already deleted or 169 // not yet synced. There is nothing to do for the file. 170 SyncTaskManager::NotifyTaskDone(token.Pass(), SYNC_STATUS_OK); 171 return; 172 } 173 } 174 175 if (missing_components.size() > 1) { 176 // The original target doesn't have remote file and parent. 177 // Try creating the parent first. 178 if (active_ancestor_details.file_kind() == FILE_KIND_FOLDER) { 179 remote_parent_folder_tracker_ = active_ancestor_tracker.Pass(); 180 target_path_ = active_ancestor_path.Append(missing_components[0]); 181 token->RecordLog("Detected missing parent folder."); 182 183 retry_on_success_ = true; 184 MoveToBackground(base::Bind(&LocalToRemoteSyncer::CreateRemoteFolder, 185 weak_ptr_factory_.GetWeakPtr()), 186 token.Pass()); 187 return; 188 } 189 190 DCHECK(active_ancestor_details.file_kind() == FILE_KIND_FILE); 191 remote_parent_folder_tracker_ = 192 FindTrackerByID(metadata_database(), 193 active_ancestor_tracker->parent_tracker_id()); 194 remote_file_tracker_ = active_ancestor_tracker.Pass(); 195 target_path_ = active_ancestor_path; 196 token->RecordLog("Detected non-folder file in its path."); 197 198 retry_on_success_ = true; 199 MoveToBackground(base::Bind(&LocalToRemoteSyncer::DeleteRemoteFile, 200 weak_ptr_factory_.GetWeakPtr()), 201 token.Pass()); 202 return; 203 } 204 205 if (missing_components.empty()) { 206 // The original target has remote active file/folder. 207 remote_parent_folder_tracker_ = 208 FindTrackerByID(metadata_database(), 209 active_ancestor_tracker->parent_tracker_id()); 210 remote_file_tracker_ = active_ancestor_tracker.Pass(); 211 target_path_ = url_.path(); 212 DCHECK(target_path_ == active_ancestor_path); 213 214 if (remote_file_tracker_->dirty()) { 215 token->RecordLog(base::StringPrintf( 216 "Detected conflicting dirty tracker:%" PRId64, 217 remote_file_tracker_->tracker_id())); 218 // Both local and remote file has pending modification. 219 HandleConflict(token.Pass()); 220 return; 221 } 222 223 // Non-conflicting file/folder update case. 224 HandleExistingRemoteFile(token.Pass()); 225 return; 226 } 227 228 DCHECK(local_change_.IsAddOrUpdate()); 229 DCHECK_EQ(1u, missing_components.size()); 230 // The original target has remote parent folder and doesn't have remote active 231 // file. 232 // Upload the file as a new file or create a folder. 233 remote_parent_folder_tracker_ = active_ancestor_tracker.Pass(); 234 target_path_ = url_.path(); 235 DCHECK(target_path_ == active_ancestor_path.Append(missing_components[0])); 236 if (local_change_.file_type() == SYNC_FILE_TYPE_FILE) { 237 token->RecordLog("Detected a new file."); 238 MoveToBackground(base::Bind(&LocalToRemoteSyncer::UploadNewFile, 239 weak_ptr_factory_.GetWeakPtr()), 240 token.Pass()); 241 return; 242 } 243 244 token->RecordLog("Detected a new folder."); 245 MoveToBackground(base::Bind(&LocalToRemoteSyncer::CreateRemoteFolder, 246 weak_ptr_factory_.GetWeakPtr()), 247 token.Pass()); 248 } 249 250 void LocalToRemoteSyncer::MoveToBackground(const Continuation& continuation, 251 scoped_ptr<SyncTaskToken> token) { 252 scoped_ptr<TaskBlocker> blocker(new TaskBlocker); 253 blocker->app_id = url_.origin().host(); 254 blocker->paths.push_back(target_path_); 255 256 if (remote_file_tracker_) { 257 if (!GetKnownChangeID(metadata_database(), 258 remote_file_tracker_->file_id(), 259 &remote_file_change_id_)) { 260 NOTREACHED(); 261 SyncCompleted(token.Pass(), SYNC_STATUS_FAILED); 262 return; 263 } 264 265 blocker->tracker_ids.push_back(remote_file_tracker_->tracker_id()); 266 blocker->file_ids.push_back(remote_file_tracker_->file_id()); 267 } 268 269 // Run current task as a background task with |blocker|. 270 // After the invocation of ContinueAsBackgroundTask 271 SyncTaskManager::UpdateTaskBlocker( 272 token.Pass(), blocker.Pass(), 273 base::Bind(&LocalToRemoteSyncer::ContinueAsBackgroundTask, 274 weak_ptr_factory_.GetWeakPtr(), 275 continuation)); 276 } 277 278 void LocalToRemoteSyncer::ContinueAsBackgroundTask( 279 const Continuation& continuation, 280 scoped_ptr<SyncTaskToken> token) { 281 // The SyncTask runs as a background task beyond this point. 282 // Note that any task can run between MoveToBackground() and 283 // ContinueAsBackgroundTask(), so we need to make sure other tasks didn't 284 // affect to the current LocalToRemoteSyncer task. 285 // 286 // - For RemoteToLocalSyncer, it doesn't actually run beyond 287 // PrepareForProcessRemoteChange() since it should be blocked in 288 // LocalFileSyncService. 289 // - For ListChangesTask, it may update FileMetatada together with |change_id| 290 // and may delete FileTracker. So, ensure |change_id| is not changed and 291 // check if FileTracker still exists. 292 // - For UninstallAppTask, it may also delete FileMetadata and FileTracker. 293 // Check if FileTracker still exists. 294 // - Others, SyncEngineInitializer and RegisterAppTask doesn't affect to 295 // LocalToRemoteSyncer. 296 if (remote_file_tracker_) { 297 int64 latest_change_id = 0; 298 if (!GetKnownChangeID(metadata_database(), 299 remote_file_tracker_->file_id(), 300 &latest_change_id) || 301 latest_change_id > remote_file_change_id_) { 302 SyncCompleted(token.Pass(), SYNC_STATUS_RETRY); 303 return; 304 } 305 306 if (!metadata_database()->FindTrackerByTrackerID( 307 remote_file_tracker_->tracker_id(), NULL)) { 308 SyncCompleted(token.Pass(), SYNC_STATUS_RETRY); 309 return; 310 } 311 } 312 313 continuation.Run(token.Pass()); 314 } 315 316 void LocalToRemoteSyncer::SyncCompleted(scoped_ptr<SyncTaskToken> token, 317 SyncStatusCode status) { 318 if (status == SYNC_STATUS_OK && retry_on_success_) 319 status = SYNC_STATUS_RETRY; 320 321 if (needs_remote_change_listing_) 322 status = SYNC_STATUS_FILE_BUSY; 323 324 token->RecordLog(base::StringPrintf( 325 "Finished: action=%s, status=%s for %s@%s", 326 SyncActionToString(sync_action_), 327 SyncStatusCodeToString(status), 328 target_path_.AsUTF8Unsafe().c_str(), 329 url_.origin().host().c_str())); 330 331 SyncTaskManager::NotifyTaskDone(token.Pass(), status); 332 } 333 334 void LocalToRemoteSyncer::HandleConflict(scoped_ptr<SyncTaskToken> token) { 335 DCHECK(remote_file_tracker_); 336 DCHECK(remote_file_tracker_->has_synced_details()); 337 DCHECK(remote_file_tracker_->active()); 338 DCHECK(remote_file_tracker_->dirty()); 339 340 if (local_is_missing_) { 341 SyncCompleted(token.Pass(), SYNC_STATUS_OK); 342 return; 343 } 344 345 if (local_change_.IsFile()) { 346 // Upload the conflicting file as a new file and let ConflictResolver 347 // resolve it. 348 MoveToBackground(base::Bind(&LocalToRemoteSyncer::UploadNewFile, 349 weak_ptr_factory_.GetWeakPtr()), 350 token.Pass()); 351 return; 352 } 353 354 DCHECK(local_change_.IsDirectory()); 355 // Check if we can reuse the remote folder. 356 FileMetadata remote_file_metadata; 357 if (!metadata_database()->FindFileByFileID( 358 remote_file_tracker_->file_id(), &remote_file_metadata)) { 359 NOTREACHED(); 360 MoveToBackground(base::Bind(&LocalToRemoteSyncer::CreateRemoteFolder, 361 weak_ptr_factory_.GetWeakPtr()), 362 token.Pass()); 363 return; 364 } 365 366 const FileDetails& remote_details = remote_file_metadata.details(); 367 base::FilePath title = storage::VirtualPath::BaseName(target_path_); 368 if (!remote_details.missing() && 369 remote_details.file_kind() == FILE_KIND_FOLDER && 370 remote_details.title() == title.AsUTF8Unsafe() && 371 HasFileAsParent(remote_details, 372 remote_parent_folder_tracker_->file_id())) { 373 MoveToBackground( 374 base::Bind(&LocalToRemoteSyncer::UpdateTrackerForReusedFolder, 375 weak_ptr_factory_.GetWeakPtr(), 376 remote_details), 377 token.Pass()); 378 return; 379 } 380 381 MoveToBackground(base::Bind(&LocalToRemoteSyncer::CreateRemoteFolder, 382 weak_ptr_factory_.GetWeakPtr()), 383 token.Pass()); 384 } 385 386 void LocalToRemoteSyncer::UpdateTrackerForReusedFolder( 387 const FileDetails& details, 388 scoped_ptr<SyncTaskToken> token) { 389 SyncStatusCode status = metadata_database()->UpdateTracker( 390 remote_file_tracker_->tracker_id(), details); 391 SyncCompleted(token.Pass(), status); 392 } 393 394 void LocalToRemoteSyncer::HandleExistingRemoteFile( 395 scoped_ptr<SyncTaskToken> token) { 396 DCHECK(remote_file_tracker_); 397 DCHECK(!remote_file_tracker_->dirty()); 398 DCHECK(remote_file_tracker_->active()); 399 DCHECK(remote_file_tracker_->has_synced_details()); 400 401 if (local_is_missing_) { 402 // Local file deletion for existing remote file. 403 MoveToBackground(base::Bind(&LocalToRemoteSyncer::DeleteRemoteFile, 404 weak_ptr_factory_.GetWeakPtr()), 405 token.Pass()); 406 return; 407 } 408 409 DCHECK(local_change_.IsAddOrUpdate()); 410 DCHECK(local_change_.IsFile() || local_change_.IsDirectory()); 411 412 const FileDetails& synced_details = remote_file_tracker_->synced_details(); 413 DCHECK(synced_details.file_kind() == FILE_KIND_FILE || 414 synced_details.file_kind() == FILE_KIND_FOLDER); 415 if (local_change_.IsFile()) { 416 if (synced_details.file_kind() == FILE_KIND_FILE) { 417 // Non-conflicting local file update to existing remote regular file. 418 MoveToBackground(base::Bind(&LocalToRemoteSyncer::UploadExistingFile, 419 weak_ptr_factory_.GetWeakPtr()), 420 token.Pass()); 421 return; 422 } 423 424 DCHECK_EQ(FILE_KIND_FOLDER, synced_details.file_kind()); 425 // Non-conflicting local file update to existing remote *folder*. 426 // Assuming this case as local folder deletion + local file creation, delete 427 // the remote folder and upload the file. 428 retry_on_success_ = true; 429 MoveToBackground(base::Bind(&LocalToRemoteSyncer::DeleteRemoteFile, 430 weak_ptr_factory_.GetWeakPtr()), 431 token.Pass()); 432 return; 433 } 434 435 DCHECK(local_change_.IsDirectory()); 436 if (synced_details.file_kind() == FILE_KIND_FILE) { 437 // Non-conflicting local folder creation to existing remote *file*. 438 // Assuming this case as local file deletion + local folder creation, delete 439 // the remote file and create a remote folder. 440 retry_on_success_ = true; 441 MoveToBackground(base::Bind(&LocalToRemoteSyncer::DeleteRemoteFile, 442 weak_ptr_factory_.GetWeakPtr()), 443 token.Pass()); 444 return; 445 } 446 447 // Non-conflicting local folder creation to existing remote folder. 448 DCHECK_EQ(FILE_KIND_FOLDER, synced_details.file_kind()); 449 SyncCompleted(token.Pass(), SYNC_STATUS_OK); 450 } 451 452 void LocalToRemoteSyncer::DeleteRemoteFile(scoped_ptr<SyncTaskToken> token) { 453 DCHECK(remote_file_tracker_); 454 DCHECK(remote_file_tracker_->has_synced_details()); 455 456 sync_action_ = SYNC_ACTION_DELETED; 457 drive_service()->DeleteResource( 458 remote_file_tracker_->file_id(), 459 remote_file_tracker_->synced_details().etag(), 460 base::Bind(&LocalToRemoteSyncer::DidDeleteRemoteFile, 461 weak_ptr_factory_.GetWeakPtr(), base::Passed(&token))); 462 } 463 464 void LocalToRemoteSyncer::DidDeleteRemoteFile( 465 scoped_ptr<SyncTaskToken> token, 466 google_apis::GDataErrorCode error) { 467 SyncStatusCode status = GDataErrorCodeToSyncStatusCode(error); 468 if (status != SYNC_STATUS_OK && 469 error != google_apis::HTTP_NOT_FOUND && 470 error != google_apis::HTTP_PRECONDITION && 471 error != google_apis::HTTP_CONFLICT) { 472 SyncCompleted(token.Pass(), status); 473 return; 474 } 475 476 // Handle NOT_FOUND case as SUCCESS case. 477 // For PRECONDITION / CONFLICT case, the remote file is modified since the 478 // last sync completed. As our policy for deletion-modification conflict 479 // resolution, ignore the local deletion. 480 if (status == SYNC_STATUS_OK || 481 error == google_apis::HTTP_NOT_FOUND) { 482 SyncStatusCode status = metadata_database()->UpdateByDeletedRemoteFile( 483 remote_file_tracker_->file_id()); 484 SyncCompleted(token.Pass(), status); 485 return; 486 } 487 488 SyncCompleted(token.Pass(), SYNC_STATUS_OK); 489 } 490 491 void LocalToRemoteSyncer::UploadExistingFile(scoped_ptr<SyncTaskToken> token) { 492 DCHECK(remote_file_tracker_); 493 DCHECK(remote_file_tracker_->has_synced_details()); 494 DCHECK(sync_context_->GetWorkerTaskRunner()->RunsTasksOnCurrentThread()); 495 496 const std::string local_file_md5 = drive::util::GetMd5Digest(local_path_); 497 if (local_file_md5 == remote_file_tracker_->synced_details().md5()) { 498 // Local file is not changed. 499 SyncCompleted(token.Pass(), SYNC_STATUS_OK); 500 return; 501 } 502 503 sync_action_ = SYNC_ACTION_UPDATED; 504 505 drive::DriveUploader::UploadExistingFileOptions options; 506 options.etag = remote_file_tracker_->synced_details().etag(); 507 drive_uploader()->UploadExistingFile( 508 remote_file_tracker_->file_id(), 509 local_path_, 510 "application/octet_stream", 511 options, 512 base::Bind(&LocalToRemoteSyncer::DidUploadExistingFile, 513 weak_ptr_factory_.GetWeakPtr(), base::Passed(&token)), 514 google_apis::ProgressCallback()); 515 } 516 517 void LocalToRemoteSyncer::DidUploadExistingFile( 518 scoped_ptr<SyncTaskToken> token, 519 google_apis::GDataErrorCode error, 520 const GURL&, 521 scoped_ptr<google_apis::FileResource> entry) { 522 if (error == google_apis::HTTP_PRECONDITION || 523 error == google_apis::HTTP_CONFLICT || 524 error == google_apis::HTTP_NOT_FOUND) { 525 // The remote file has unfetched remote change. Fetch latest metadata and 526 // update database with it. 527 // TODO(tzik): Consider adding local side low-priority dirtiness handling to 528 // handle this as ListChangesTask. 529 530 needs_remote_change_listing_ = true; 531 UpdateRemoteMetadata( 532 remote_file_tracker_->file_id(), 533 token.Pass()); 534 return; 535 } 536 537 SyncStatusCode status = GDataErrorCodeToSyncStatusCode(error); 538 if (status != SYNC_STATUS_OK) { 539 SyncCompleted(token.Pass(), status); 540 return; 541 } 542 543 if (!entry) { 544 NOTREACHED(); 545 SyncCompleted(token.Pass(), SYNC_STATUS_FAILED); 546 return; 547 } 548 549 DCHECK(entry); 550 status = metadata_database()->UpdateByFileResource(*entry); 551 if (status != SYNC_STATUS_OK) { 552 SyncCompleted(token.Pass(), status); 553 return; 554 } 555 556 FileMetadata file; 557 if (!metadata_database()->FindFileByFileID( 558 remote_file_tracker_->file_id(), &file)) { 559 NOTREACHED(); 560 SyncCompleted(token.Pass(), SYNC_STATUS_FAILED); 561 return; 562 } 563 564 const FileDetails& details = file.details(); 565 base::FilePath title = storage::VirtualPath::BaseName(target_path_); 566 if (!details.missing() && 567 details.file_kind() == FILE_KIND_FILE && 568 details.title() == title.AsUTF8Unsafe() && 569 HasFileAsParent(details, 570 remote_parent_folder_tracker_->file_id())) { 571 SyncStatusCode status = metadata_database()->UpdateTracker( 572 remote_file_tracker_->tracker_id(), file.details()); 573 SyncCompleted(token.Pass(), status); 574 return; 575 } 576 577 SyncCompleted(token.Pass(), SYNC_STATUS_RETRY); 578 } 579 580 void LocalToRemoteSyncer::UpdateRemoteMetadata( 581 const std::string& file_id, 582 scoped_ptr<SyncTaskToken> token) { 583 DCHECK(remote_file_tracker_); 584 585 drive_service()->GetFileResource( 586 file_id, 587 base::Bind(&LocalToRemoteSyncer::DidGetRemoteMetadata, 588 weak_ptr_factory_.GetWeakPtr(), 589 file_id, base::Passed(&token))); 590 } 591 592 void LocalToRemoteSyncer::DidGetRemoteMetadata( 593 const std::string& file_id, 594 scoped_ptr<SyncTaskToken> token, 595 google_apis::GDataErrorCode error, 596 scoped_ptr<google_apis::FileResource> entry) { 597 DCHECK(sync_context_->GetWorkerTaskRunner()->RunsTasksOnCurrentThread()); 598 599 if (error == google_apis::HTTP_NOT_FOUND) { 600 retry_on_success_ = true; 601 SyncStatusCode status = 602 metadata_database()->UpdateByDeletedRemoteFile(file_id); 603 SyncCompleted(token.Pass(), status); 604 return; 605 } 606 607 SyncStatusCode status = GDataErrorCodeToSyncStatusCode(error); 608 if (status != SYNC_STATUS_OK) { 609 SyncCompleted(token.Pass(), status); 610 return; 611 } 612 613 if (!entry) { 614 NOTREACHED(); 615 SyncCompleted(token.Pass(), SYNC_STATUS_FAILED); 616 return; 617 } 618 619 retry_on_success_ = true; 620 status = metadata_database()->UpdateByFileResource(*entry); 621 SyncCompleted(token.Pass(), status); 622 } 623 624 void LocalToRemoteSyncer::UploadNewFile(scoped_ptr<SyncTaskToken> token) { 625 DCHECK(remote_parent_folder_tracker_); 626 627 sync_action_ = SYNC_ACTION_ADDED; 628 base::FilePath title = storage::VirtualPath::BaseName(target_path_); 629 drive_uploader()->UploadNewFile( 630 remote_parent_folder_tracker_->file_id(), 631 local_path_, 632 title.AsUTF8Unsafe(), 633 GetMimeTypeFromTitle(title), 634 drive::DriveUploader::UploadNewFileOptions(), 635 base::Bind(&LocalToRemoteSyncer::DidUploadNewFile, 636 weak_ptr_factory_.GetWeakPtr(), 637 base::Passed(&token)), 638 google_apis::ProgressCallback()); 639 } 640 641 void LocalToRemoteSyncer::DidUploadNewFile( 642 scoped_ptr<SyncTaskToken> token, 643 google_apis::GDataErrorCode error, 644 const GURL& upload_location, 645 scoped_ptr<google_apis::FileResource> entry) { 646 if (error == google_apis::HTTP_NOT_FOUND) 647 needs_remote_change_listing_ = true; 648 649 SyncStatusCode status = GDataErrorCodeToSyncStatusCode(error); 650 if (status != SYNC_STATUS_OK) { 651 SyncCompleted(token.Pass(), status); 652 return; 653 } 654 655 if (!entry) { 656 NOTREACHED(); 657 SyncCompleted(token.Pass(), SYNC_STATUS_FAILED); 658 return; 659 } 660 661 status = metadata_database()->ReplaceActiveTrackerWithNewResource( 662 remote_parent_folder_tracker_->tracker_id(), *entry); 663 SyncCompleted(token.Pass(), status); 664 } 665 666 void LocalToRemoteSyncer::CreateRemoteFolder(scoped_ptr<SyncTaskToken> token) { 667 DCHECK(remote_parent_folder_tracker_); 668 669 base::FilePath title = storage::VirtualPath::BaseName(target_path_); 670 sync_action_ = SYNC_ACTION_ADDED; 671 672 DCHECK(!folder_creator_); 673 folder_creator_.reset(new FolderCreator( 674 drive_service(), metadata_database(), 675 remote_parent_folder_tracker_->file_id(), 676 title.AsUTF8Unsafe())); 677 folder_creator_->Run(base::Bind( 678 &LocalToRemoteSyncer::DidCreateRemoteFolder, 679 weak_ptr_factory_.GetWeakPtr(), 680 base::Passed(&token))); 681 } 682 683 void LocalToRemoteSyncer::DidCreateRemoteFolder( 684 scoped_ptr<SyncTaskToken> token, 685 const std::string& file_id, 686 SyncStatusCode status) { 687 if (status == SYNC_FILE_ERROR_NOT_FOUND) 688 needs_remote_change_listing_ = true; 689 690 scoped_ptr<FolderCreator> deleter = folder_creator_.Pass(); 691 if (status != SYNC_STATUS_OK) { 692 SyncCompleted(token.Pass(), status); 693 return; 694 } 695 696 status = SYNC_STATUS_FAILED; 697 MetadataDatabase::ActivationStatus activation_status = 698 metadata_database()->TryActivateTracker( 699 remote_parent_folder_tracker_->tracker_id(), 700 file_id, &status); 701 switch (activation_status) { 702 case MetadataDatabase::ACTIVATION_PENDING: 703 SyncCompleted(token.Pass(), status); 704 return; 705 case MetadataDatabase::ACTIVATION_FAILED_ANOTHER_ACTIVE_TRACKER: 706 // The activation failed due to another tracker that has another parent. 707 // Detach the folder from the current parent to avoid using this folder as 708 // active folder. 709 drive_service()->RemoveResourceFromDirectory( 710 remote_parent_folder_tracker_->file_id(), file_id, 711 base::Bind(&LocalToRemoteSyncer::DidDetachResourceForCreationConflict, 712 weak_ptr_factory_.GetWeakPtr(), base::Passed(&token))); 713 return; 714 } 715 716 NOTREACHED(); 717 SyncCompleted(token.Pass(), SYNC_STATUS_FAILED); 718 return; 719 } 720 721 void LocalToRemoteSyncer::DidDetachResourceForCreationConflict( 722 scoped_ptr<SyncTaskToken> token, 723 google_apis::GDataErrorCode error) { 724 SyncStatusCode status = GDataErrorCodeToSyncStatusCode(error); 725 if (status != SYNC_STATUS_OK) { 726 SyncCompleted(token.Pass(), status); 727 return; 728 } 729 730 SyncCompleted(token.Pass(), SYNC_STATUS_RETRY); 731 } 732 733 bool LocalToRemoteSyncer::IsContextReady() { 734 return sync_context_->GetDriveService() && 735 sync_context_->GetDriveUploader() && 736 sync_context_->GetMetadataDatabase(); 737 } 738 739 drive::DriveServiceInterface* LocalToRemoteSyncer::drive_service() { 740 set_used_network(true); 741 return sync_context_->GetDriveService(); 742 } 743 744 drive::DriveUploaderInterface* LocalToRemoteSyncer::drive_uploader() { 745 set_used_network(true); 746 return sync_context_->GetDriveUploader(); 747 } 748 749 MetadataDatabase* LocalToRemoteSyncer::metadata_database() { 750 return sync_context_->GetMetadataDatabase(); 751 } 752 753 } // namespace drive_backend 754 } // namespace sync_file_system 755
