DriveFileSyncService listens to OnAuthenticated event to recover from unavailable state

chrome/browser/sync_file_system/drive_file_sync_client.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_client.h"
 
 #include <sstream>
 
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
@@ skipping 52 matching lines @@
   return NULL;
 }
 
 }  // namespace
 
 DriveFileSyncClient::DriveFileSyncClient(Profile* profile) {
   drive_service_.reset(new google_apis::GDataWapiService(
       GURL(google_apis::GDataWapiUrlGenerator::kBaseUrlForProduction),
       "" /* custom_user_agent */));
   drive_service_->Initialize(profile);
+  drive_service_->AddObserver(this);
 
   drive_uploader_.reset(new google_apis::DriveUploader(drive_service_.get()));
 }
 
 scoped_ptr<DriveFileSyncClient> DriveFileSyncClient::CreateForTesting(
     Profile* profile,
     scoped_ptr<google_apis::DriveServiceInterface> drive_service,
     scoped_ptr<google_apis::DriveUploaderInterface> drive_uploader) {
   return make_scoped_ptr(new DriveFileSyncClient(
       profile, drive_service.Pass(), drive_uploader.Pass()));
 }
 
 DriveFileSyncClient::DriveFileSyncClient(
     Profile* profile,
     scoped_ptr<google_apis::DriveServiceInterface> drive_service,
     scoped_ptr<google_apis::DriveUploaderInterface> drive_uploader) {
   drive_service_ = drive_service.Pass();
   drive_service_->Initialize(profile);
+  drive_service_->AddObserver(this);
 
   drive_uploader_ = drive_uploader.Pass();
 }
 
 DriveFileSyncClient::~DriveFileSyncClient() {
   DCHECK(CalledOnValidThread());
+  drive_service_->RemoveObserver(this);
   drive_service_->CancelAll();
 }
 
+void DriveFileSyncClient::AddObserver(DriveFileSyncClientObserver* observer) {
+  DCHECK(CalledOnValidThread());
+  observers_.AddObserver(observer);
+}
+
+void DriveFileSyncClient::RemoveObserver(
+    DriveFileSyncClientObserver* observer) {
+  DCHECK(CalledOnValidThread());
+  observers_.RemoveObserver(observer);
+}
+
 void DriveFileSyncClient::GetDriveDirectoryForSyncRoot(
     const ResourceIdCallback& callback) {
   DCHECK(CalledOnValidThread());
 
   std::string directory_name(kSyncRootDirectoryName);
   SearchFilesInDirectory(
       kRootResourceId,
       FormatTitleQuery(directory_name),
       base::Bind(&DriveFileSyncClient::DidGetDirectory, AsWeakPtr(),
                  kRootResourceId, directory_name, callback));
@@ skipping 252 matching lines @@
 std::string DriveFileSyncClient::OriginToDirectoryTitle(const GURL& origin) {
   DCHECK(origin.SchemeIs(extensions::kExtensionScheme));
   return origin.host();
 }
 
 // static
 GURL DriveFileSyncClient::DirectoryTitleToOrigin(const std::string& title) {
   return extensions::Extension::GetBaseURLFromExtensionId(title);
 }
 
+void DriveFileSyncClient::OnReadyToPerformOperations() {
+  DCHECK(CalledOnValidThread());
+  FOR_EACH_OBSERVER(DriveFileSyncClientObserver, observers_, OnAuthenticated());
+}
+
 void DriveFileSyncClient::DidGetDocumentFeedData(
     const DocumentFeedCallback& callback,
     google_apis::GDataErrorCode error,
     scoped_ptr<base::Value> data) {
   DCHECK(CalledOnValidThread());
 
   if (error != google_apis::HTTP_SUCCESS) {
     callback.Run(error, scoped_ptr<google_apis::DocumentFeed>());
     return;
   }
@@ skipping 229 matching lines @@
 }
 
 void DriveFileSyncClient::DidDeleteFile(
     const GDataErrorCallback& callback,
     google_apis::GDataErrorCode error) {
   DCHECK(CalledOnValidThread());
   callback.Run(error);
 }
 
 }  // namespace sync_file_system