Handle errors on the initialization of SyncFileSystemService

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 18 matching lines @@
 
 namespace {
 
 // Run the given join_callback when all the callbacks created by this runner
 // are run, or may dispatch it earlier if we get an error in any of the sub
 // callbacks.
 class SharedCallbackRunner
     : public base::RefCounted<SharedCallbackRunner>,
       public base::NonThreadSafe {
  public:
-  SharedCallbackRunner(const SyncStatusCallback& join_callback)
+  explicit SharedCallbackRunner(const SyncStatusCallback& join_callback)
       : join_callback_(join_callback),
         num_shared_callbacks_(0) {}
 
+  SyncStatusCallback CreateCallback() {
+    ++num_shared_callbacks_;
+    return base::Bind(&SharedCallbackRunner::Done, this);
+  }
+
   template <typename R>
   base::Callback<void(SyncStatusCode, const R& in)>
   CreateAssignAndRunCallback(R* out) {
     ++num_shared_callbacks_;
     return base::Bind(&SharedCallbackRunner::AssignAndRun<R>, this, out);
   }
 
  private:
   virtual ~SharedCallbackRunner() {}
   friend class base::RefCounted<SharedCallbackRunner>;
 
   template <typename R>
   void AssignAndRun(R* out, SyncStatusCode status, const R& in) {
     DCHECK(out);
     DCHECK_GT(num_shared_callbacks_, 0);
     if (join_callback_.is_null())
       return;
     *out = in;
+    Done(status);
+  }
+
+  void Done(SyncStatusCode status) {
     if (status != fileapi::SYNC_STATUS_OK) {
       join_callback_.Run(status);
       join_callback_.Reset();
       return;
     }
     if (--num_shared_callbacks_ > 0)
       return;
     join_callback_.Run(status);
     join_callback_.Reset();
   }
@@ skipping 50 matching lines @@
     const SyncStatusCallback& callback) {
   DCHECK(local_file_service_);
   DCHECK(app_origin == app_origin.GetOrigin());
 
   bool inserted = initialized_app_origins_.insert(app_origin).second;
   if (!inserted) {
     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);
+      app_origin, service_name, file_system_context,
+      callback_runner->CreateCallback());
 
   if (remote_file_service_) {
-    // TODO(tzik): Handle errors in the completion callback.
     remote_file_service_->RegisterOriginForTrackingChanges(
-        app_origin, fileapi::SyncStatusCallback());
+        app_origin, callback_runner->CreateCallback());
   }
 }
 
 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());
 
@@ skipping 126 matching lines @@
 
   if (mock_remote_file_service_)
     remote_file_service = mock_remote_file_service_.Pass();
 
   service->Initialize(local_file_service.Pass(),
                       remote_file_service.Pass());
   return service;
 }
 
 }  // namespace sync_file_system