SyncFileSystem: Register origin only after the local-side initialization finishes successfully

chrome/browser/sync_file_system/sync_file_system_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/sync_file_system_service.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/stl_util.h"
@@ skipping 140 matching lines @@
 
   DVLOG(1) << "InitializeForApp: " << app_origin.spec();
 
   if (initialized_app_origins_.find(app_origin) !=
       initialized_app_origins_.end()) {
     DVLOG(1) << "The app is already initialized: " << app_origin.spec();
     callback.Run(fileapi::SYNC_STATUS_OK);
     return;
   }
 
-  scoped_refptr<SharedCallbackRunner> callback_runner(
-      new SharedCallbackRunner(callback));
-
   local_file_service_->MaybeInitializeFileSystemContext(
       app_origin, service_name, file_system_context,
-      callback_runner->CreateCallback());
-  remote_file_service_->RegisterOriginForTrackingChanges(
-      app_origin,
-      base::Bind(&SyncFileSystemService::DidRegisterOrigin,
-                 AsWeakPtr(), app_origin,
-                 callback_runner->CreateCallback()));
+      base::Bind(&SyncFileSystemService::DidInitializeFileSystem,
+                 AsWeakPtr(), app_origin, callback));
 }
 
 void SyncFileSystemService::GetConflictFiles(
     const GURL& app_origin,
     const std::string& service_name,
     const fileapi::SyncFileSetCallback& callback) {
   DCHECK(remote_file_service_);
   DCHECK(app_origin == app_origin.GetOrigin());
 
   if (!ContainsKey(initialized_app_origins_, app_origin)) {
@@ skipping 81 matching lines @@
     SyncStatusCode status) {
   DCHECK(local_metadata);
   DCHECK(remote_metadata);
   fileapi::ConflictFileInfo info;
   info.url = url;
   info.local_metadata = *local_metadata;
   info.remote_metadata = *remote_metadata;
   callback.Run(status, info);
 }
 
+void SyncFileSystemService::DidInitializeFileSystem(
+    const GURL& app_origin,
+    const fileapi::SyncStatusCallback& callback,
+    fileapi::SyncStatusCode status) {
+  DVLOG(1) << "DidInitializeFileSystem: " << app_origin.spec() << " " << status;
+
+  if (status != fileapi::SYNC_STATUS_OK) {
+    callback.Run(status);
+    return;
+  }
+
+  // Local side of initialization for the app is done.
+  // Continue on initializing the remote side.
+  remote_file_service_->RegisterOriginForTrackingChanges(
+      app_origin,
+      base::Bind(&SyncFileSystemService::DidRegisterOrigin,
+                 AsWeakPtr(), app_origin, callback));
+}
+
 void SyncFileSystemService::DidRegisterOrigin(
     const GURL& app_origin,
     const fileapi::SyncStatusCallback& callback,
     fileapi::SyncStatusCode status) {
   DVLOG(1) << "DidRegisterOrigin: " << app_origin.spec() << " " << status;
 
   if (status == fileapi::SYNC_STATUS_OK)
     initialized_app_origins_.insert(app_origin);
 
   callback.Run(status);
@@ skipping 189 matching lines @@
     remote_file_service = mock_remote_file_service_.Pass();
   else
     remote_file_service.reset(new DriveFileSyncService(profile));
 
   service->Initialize(local_file_service.Pass(),
                       remote_file_service.Pass());
   return service;
 }
 
 }  // namespace sync_file_system