[SyncFS] Support late authentication

chrome/browser/sync_file_system/drive_backend/sync_engine.cc

 // Copyright 2013 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_backend/sync_engine.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/metrics/histogram.h"
@@ skipping 152 matching lines @@
     obj_ptr->DetachFromSequence();
     deleter.Run();
   }
 }
 
 }  // namespace
 
 scoped_ptr<SyncEngine> SyncEngine::CreateForBrowserContext(
     content::BrowserContext* context,
     TaskLogger* task_logger) {
-  scoped_refptr<base::SequencedWorkerPool> worker_pool(
-      content::BrowserThread::GetBlockingPool());
+  scoped_refptr<base::SequencedWorkerPool> worker_pool =
+      content::BrowserThread::GetBlockingPool();
 
   scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner =
       base::MessageLoopProxy::current();
   // TODO(peria): Create another task runner to manage SyncWorker.
   scoped_refptr<base::SequencedTaskRunner> worker_task_runner =
       base::MessageLoopProxy::current();
   scoped_refptr<base::SequencedTaskRunner> file_task_runner =
       worker_pool->GetSequencedTaskRunnerWithShutdownBehavior(
           worker_pool->GetSequenceToken(),
           base::SequencedWorkerPool::SKIP_ON_SHUTDOWN);
@@ skipping 37 matching lines @@
   DCHECK(factories);
   factories->insert(drive::DriveNotificationManagerFactory::GetInstance());
   factories->insert(SigninManagerFactory::GetInstance());
   factories->insert(
       extensions::ExtensionsBrowserClient::Get()->GetExtensionSystemFactory());
   factories->insert(ProfileOAuth2TokenServiceFactory::GetInstance());
 }
 
 SyncEngine::~SyncEngine() {
   Reset();
+
+  net::NetworkChangeNotifier::RemoveNetworkChangeObserver(this);
+  if (signin_manager_)
+    signin_manager_->RemoveObserver(this);
+  if (notification_manager_)
+    notification_manager_->RemoveObserver(this);
 }
 
 void SyncEngine::Reset() {
-  if (notification_manager_)
-    notification_manager_->RemoveObserver(this);
   if (drive_service_)
     drive_service_->RemoveObserver(this);
-  net::NetworkChangeNotifier::RemoveNetworkChangeObserver(this);
 
   DeleteSoon(FROM_HERE, worker_task_runner_, worker_observer_.Pass());
   DeleteSoon(FROM_HERE, worker_task_runner_, sync_worker_.Pass());
   DeleteSoon(FROM_HERE, worker_task_runner_,
              remote_change_processor_on_worker_.Pass());
 
   drive_service_wrapper_.reset();
   drive_service_.reset();
   drive_uploader_wrapper_.reset();
   drive_uploader_.reset();
   remote_change_processor_wrapper_.reset();
   callback_tracker_.AbortAll();
 }
 
 void SyncEngine::Initialize() {
   Reset();
 
+  if (!signin_manager_ ||
+      signin_manager_->GetAuthenticatedAccountId().empty())
+    return;
+
   scoped_ptr<drive::DriveServiceInterface> drive_service(
       new drive::DriveAPIService(
           token_service_,
           request_context_,
           drive_task_runner_,
           GURL(google_apis::DriveApiUrlGenerator::kBaseUrlForProduction),
           GURL(google_apis::DriveApiUrlGenerator::
                kBaseDownloadUrlForProduction),
           GURL(google_apis::GDataWapiUrlGenerator::kBaseUrlForProduction),
           std::string() /* custom_user_agent */));
@@ skipping 60 matching lines @@
   sync_worker_ = worker.PassAs<SyncWorkerInterface>();
 
   if (remote_change_processor_)
     SetRemoteChangeProcessor(remote_change_processor_);
 
   worker_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&SyncWorkerInterface::Initialize,
                  base::Unretained(sync_worker_.get())));
 
-  if (notification_manager_)
-    notification_manager_->AddObserver(this);
   drive_service_->AddObserver(this);
-  net::NetworkChangeNotifier::AddNetworkChangeObserver(this);
 
   service_state_ = REMOTE_SERVICE_TEMPORARY_UNAVAILABLE;
   SetSyncEnabled(sync_enabled_);
   OnNetworkChanged(net::NetworkChangeNotifier::GetConnectionType());
 }
 
 void SyncEngine::AddServiceObserver(SyncServiceObserver* observer) {
   service_observers_.AddObserver(observer);
 }
 
 void SyncEngine::AddFileStatusObserver(FileStatusObserver* observer) {
   file_status_observers_.AddObserver(observer);
 }
 
 void SyncEngine::RegisterOrigin(const GURL& origin,
                                 const SyncStatusCallback& callback) {
+  if (!sync_worker_) {
+    // TODO(tzik): Record |origin| and retry the registration after late
+    // sign-in.  Then, return SYNC_STATUS_OK.
+    if (!signin_manager_ ||
+        signin_manager_->GetAuthenticatedAccountId().empty())
+      callback.Run(SYNC_STATUS_AUTHENTICATION_FAILED);
+    else
+      callback.Run(SYNC_STATUS_ABORT);
+    return;
+  }
+
   SyncStatusCallback relayed_callback = RelayCallbackToCurrentThread(
       FROM_HERE, base::Bind(&DidRegisterOrigin, base::TimeTicks::Now(),
                             TrackCallback(callback)));
 
   worker_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&SyncWorkerInterface::RegisterOrigin,
                  base::Unretained(sync_worker_.get()),
                  origin, relayed_callback));
 }
 
 void SyncEngine::EnableOrigin(
     const GURL& origin, const SyncStatusCallback& callback) {
+  if (!sync_worker_) {
+    // It's safe to return OK immediately since this is also checked in
+    // SyncWorker initialization.
+    callback.Run(SYNC_STATUS_OK);
+    return;
+  }
+
   SyncStatusCallback relayed_callback = RelayCallbackToCurrentThread(
       FROM_HERE, TrackCallback(callback));
 
   worker_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&SyncWorkerInterface::EnableOrigin,
                  base::Unretained(sync_worker_.get()),
                  origin, relayed_callback));
 }
 
 void SyncEngine::DisableOrigin(
     const GURL& origin, const SyncStatusCallback& callback) {
+  if (!sync_worker_) {
+    // It's safe to return OK immediately since this is also checked in
+    // SyncWorker initialization.
+    callback.Run(SYNC_STATUS_OK);
+    return;
+  }
+
   SyncStatusCallback relayed_callback = RelayCallbackToCurrentThread(
       FROM_HERE, TrackCallback(callback));
 
   worker_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&SyncWorkerInterface::DisableOrigin,
                  base::Unretained(sync_worker_.get()),
                  origin,
                  relayed_callback));
 }
 
 void SyncEngine::UninstallOrigin(
     const GURL& origin,
     UninstallFlag flag,
     const SyncStatusCallback& callback) {
+  if (!sync_worker_) {
+    // It's safe to return OK immediately since this is also checked in
+    // SyncWorker initialization.
+    callback.Run(SYNC_STATUS_OK);
+    return;
+  }
+
   SyncStatusCallback relayed_callback = RelayCallbackToCurrentThread(
       FROM_HERE, TrackCallback(callback));
   worker_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&SyncWorkerInterface::UninstallOrigin,
                  base::Unretained(sync_worker_.get()),
                  origin, flag, relayed_callback));
 }
 
 void SyncEngine::ProcessRemoteChange(const SyncFileCallback& callback) {
+  base::Closure abort_closure =
+      base::Bind(callback, SYNC_STATUS_ABORT, fileapi::FileSystemURL());
+
+  if (!sync_worker_) {
+    abort_closure.Run();
+    return;
+  }
+
   SyncFileCallback tracked_callback = callback_tracker_.Register(
-      base::Bind(callback, SYNC_STATUS_ABORT, fileapi::FileSystemURL()),
-      callback);
+      abort_closure, callback);
   SyncFileCallback relayed_callback = RelayCallbackToCurrentThread(
       FROM_HERE, tracked_callback);
   worker_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&SyncWorkerInterface::ProcessRemoteChange,
                  base::Unretained(sync_worker_.get()),
                  relayed_callback));
 }
 
 void SyncEngine::SetRemoteChangeProcessor(RemoteChangeProcessor* processor) {
   remote_change_processor_ = processor;
+
+  if (!sync_worker_)
+    return;
+
   remote_change_processor_wrapper_.reset(
       new RemoteChangeProcessorWrapper(processor));
 
   remote_change_processor_on_worker_.reset(new RemoteChangeProcessorOnWorker(
       remote_change_processor_wrapper_->AsWeakPtr(),
       ui_task_runner_, worker_task_runner_));
 
   worker_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&SyncWorkerInterface::SetRemoteChangeProcessor,
                  base::Unretained(sync_worker_.get()),
                  remote_change_processor_on_worker_.get()));
 }
 
 LocalChangeProcessor* SyncEngine::GetLocalChangeProcessor() {
   return this;
 }
 
 RemoteServiceState SyncEngine::GetCurrentState() const {
   return service_state_;
 }
 
 void SyncEngine::GetOriginStatusMap(const StatusMapCallback& callback) {
+  base::Closure abort_closure =
+      base::Bind(callback, base::Passed(scoped_ptr<OriginStatusMap>()));
+
+  if (!sync_worker_) {
+    abort_closure.Run();
+    return;
+  }
+
   StatusMapCallback tracked_callback =
-      callback_tracker_.Register(
-          base::Bind(callback, base::Passed(scoped_ptr<OriginStatusMap>())),
-          callback);
-
+      callback_tracker_.Register(abort_closure, callback);
   StatusMapCallback relayed_callback =
       RelayCallbackToCurrentThread(FROM_HERE, tracked_callback);
 
   worker_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&SyncWorkerInterface::GetOriginStatusMap,
                  base::Unretained(sync_worker_.get()),
                  relayed_callback));
 }
 
 void SyncEngine::DumpFiles(const GURL& origin,
                            const ListCallback& callback) {
+  base::Closure abort_closure =
+      base::Bind(callback, base::Passed(scoped_ptr<base::ListValue>()));
+
+  if (!sync_worker_) {
+    abort_closure.Run();
+    return;
+  }
+
   ListCallback tracked_callback =
-      callback_tracker_.Register(
-          base::Bind(callback, base::Passed(scoped_ptr<base::ListValue>())),
-          callback);
+      callback_tracker_.Register(abort_closure, callback);
 
   PostTaskAndReplyWithResult(
       worker_task_runner_,
       FROM_HERE,
       base::Bind(&SyncWorkerInterface::DumpFiles,
                  base::Unretained(sync_worker_.get()),
                  origin),
       tracked_callback);
 }
 
 void SyncEngine::DumpDatabase(const ListCallback& callback) {
+  base::Closure abort_closure =
+      base::Bind(callback, base::Passed(scoped_ptr<base::ListValue>()));
+
+  if (!sync_worker_) {
+    abort_closure.Run();
+    return;
+  }
+
   ListCallback tracked_callback =
-      callback_tracker_.Register(
-          base::Bind(callback, base::Passed(scoped_ptr<base::ListValue>())),
-          callback);
+      callback_tracker_.Register(abort_closure, callback);
 
   PostTaskAndReplyWithResult(
       worker_task_runner_,
       FROM_HERE,
       base::Bind(&SyncWorkerInterface::DumpDatabase,
                  base::Unretained(sync_worker_.get())),
       tracked_callback);
 }
 
 void SyncEngine::SetSyncEnabled(bool sync_enabled) {
   sync_enabled_ = sync_enabled;
+
+  if (!sync_worker_)
+    return;
+
   worker_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&SyncWorkerInterface::SetSyncEnabled,
                  base::Unretained(sync_worker_.get()),
                  sync_enabled));
 }
 
 void SyncEngine::PromoteDemotedChanges() {
+  if (!sync_worker_)
+    return;
+
   worker_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&SyncWorkerInterface::PromoteDemotedChanges,
                  base::Unretained(sync_worker_.get())));
 }
 
 void SyncEngine::ApplyLocalChange(
     const FileChange& local_change,
     const base::FilePath& local_path,
     const SyncFileMetadata& local_metadata,
     const fileapi::FileSystemURL& url,
     const SyncStatusCallback& callback) {
+  if (!sync_worker_) {
+    callback.Run(SYNC_STATUS_ABORT);
+    return;
+  }
+
   SyncStatusCallback relayed_callback = RelayCallbackToCurrentThread(
       FROM_HERE, TrackCallback(callback));
   worker_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&SyncWorkerInterface::ApplyLocalChange,
                  base::Unretained(sync_worker_.get()),
                  local_change,
                  local_path,
                  local_metadata,
                  url,
                  relayed_callback));
 }
 
 void SyncEngine::OnNotificationReceived() {
+  if (!sync_worker_)
+    return;
+
   worker_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&SyncWorkerInterface::OnNotificationReceived,
                  base::Unretained(sync_worker_.get())));
 }
 
 void SyncEngine::OnPushNotificationEnabled(bool) {}
 
 void SyncEngine::OnReadyToSendRequests() {
-  // TODO(tzik): Drop current Syncworker and replace with new one.
-
-  const std::string account_id =
-      signin_manager_ ? signin_manager_->GetAuthenticatedAccountId() : "";
+  if (!sync_worker_)
+    return;
 
   worker_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&SyncWorkerInterface::OnReadyToSendRequests,
-                 base::Unretained(sync_worker_.get()),
-                 account_id));
+                 base::Unretained(sync_worker_.get())));
 }
 
 void SyncEngine::OnRefreshTokenInvalid() {
+  if (!sync_worker_)
+    return;
+
   worker_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&SyncWorkerInterface::OnRefreshTokenInvalid,
                  base::Unretained(sync_worker_.get())));
 }
 
 void SyncEngine::OnNetworkChanged(
     net::NetworkChangeNotifier::ConnectionType type) {
+  if (!sync_worker_)
+    return;
+
   worker_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&SyncWorkerInterface::OnNetworkChanged,
                  base::Unretained(sync_worker_.get()),
                  type));
 }
 
+void SyncEngine::GoogleSigninFailed(const GoogleServiceAuthError& error) {
+  Reset();
+  UpdateServiceState(REMOTE_SERVICE_AUTHENTICATION_REQUIRED,
+                     "Failed to sign in.");
+}
+
+void SyncEngine::GoogleSigninSucceeded(const std::string& username,
+                                       const std::string& password) {
+  Initialize();
+}
+
+void SyncEngine::GoogleSignedOut(const std::string& username) {
+  Reset();
+  UpdateServiceState(REMOTE_SERVICE_AUTHENTICATION_REQUIRED,
+                     "User signed out.");
+}
+
 SyncEngine::SyncEngine(
     base::SingleThreadTaskRunner* ui_task_runner,
     base::SequencedTaskRunner* worker_task_runner,
     base::SequencedTaskRunner* file_task_runner,
     base::SequencedTaskRunner* drive_task_runner,
     const base::FilePath& sync_file_system_dir,
     TaskLogger* task_logger,
     drive::DriveNotificationManager* notification_manager,
     ExtensionServiceInterface* extension_service,
     SigninManagerBase* signin_manager,
@@ skipping 10 matching lines @@
       extension_service_(extension_service),
       signin_manager_(signin_manager),
       token_service_(token_service),
       request_context_(request_context),
       remote_change_processor_(NULL),
       service_state_(REMOTE_SERVICE_TEMPORARY_UNAVAILABLE),
       sync_enabled_(false),
       env_override_(env_override),
       weak_ptr_factory_(this) {
   DCHECK(sync_file_system_dir_.IsAbsolute());
+  if (notification_manager_)
+    notification_manager_->AddObserver(this);
+  if (signin_manager_)
+    signin_manager_->AddObserver(this);
+  net::NetworkChangeNotifier::AddNetworkChangeObserver(this);
 }
 
 void SyncEngine::OnPendingFileListUpdated(int item_count) {
   FOR_EACH_OBSERVER(
-      Observer,
+      SyncServiceObserver,
       service_observers_,
       OnRemoteChangeQueueUpdated(item_count));
 }
 
 void SyncEngine::OnFileStatusChanged(const fileapi::FileSystemURL& url,
                                      SyncFileStatus file_status,
                                      SyncAction sync_action,
                                      SyncDirection direction) {
   FOR_EACH_OBSERVER(FileStatusObserver,
                     file_status_observers_,
                     OnFileStatusChanged(
                         url, file_status, sync_action, direction));
 }
 
 void SyncEngine::UpdateServiceState(RemoteServiceState state,
                                     const std::string& description) {
   service_state_ = state;
 
   FOR_EACH_OBSERVER(
-      Observer, service_observers_,
+      SyncServiceObserver, service_observers_,
       OnRemoteServiceStateUpdated(state, description));
 }
 
 SyncStatusCallback SyncEngine::TrackCallback(
     const SyncStatusCallback& callback) {
   return callback_tracker_.Register(
       base::Bind(callback, SYNC_STATUS_ABORT),
       callback);
 }
 
 }  // namespace drive_backend
 }  // namespace sync_file_system