New authorization framework for sync. ...

chrome/browser/sync/glue/sync_backend_host.cc

 // Copyright (c) 2010 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 "build/build_config.h"
 
 #include <algorithm>
 
 #include "base/file_util.h"
 #include "base/task.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/chrome_thread.h"
+#include "chrome/browser/net/gaia/token_service.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profile.h"
 #include "chrome/browser/sync/engine/syncapi.h"
 #include "chrome/browser/sync/glue/change_processor.h"
 #include "chrome/browser/sync/glue/database_model_worker.h"
 #include "chrome/browser/sync/glue/history_model_worker.h"
 #include "chrome/browser/sync/glue/sync_backend_host.h"
 #include "chrome/browser/sync/glue/http_bridge.h"
 #include "chrome/browser/sync/glue/password_model_worker.h"
 #include "chrome/browser/sync/sessions/session_state.h"
 #include "chrome/common/chrome_version_info.h"
+#include "chrome/common/net/gaia/gaia_constants.h"
 #include "chrome/common/notification_service.h"
 #include "chrome/common/notification_type.h"
 #include "chrome/common/pref_names.h"
 #include "webkit/glue/webkit_glue.h"
 
 static const int kSaveChangesIntervalSeconds = 10;
-static const char kGaiaServiceId[] = "chromiumsync";
-static const char kGaiaSourceForChrome[] = "ChromiumBrowser";
 static const FilePath::CharType kSyncDataFolderName[] =
     FILE_PATH_LITERAL("Sync Data");
 
 using browser_sync::DataTypeController;
+typedef TokenService::TokenAvailableDetails TokenAvailableDetails;
 
 typedef GoogleServiceAuthError AuthError;
 
 namespace browser_sync {
 
 using sessions::SyncSessionSnapshot;
+using sync_api::SyncCredentials;
 
 SyncBackendHost::SyncBackendHost(
     SyncFrontend* frontend,
     Profile* profile,
     const FilePath& profile_path,
     const DataTypeController::TypeMap& data_type_controllers)
     : core_thread_("Chrome_SyncCoreThread"),
       frontend_loop_(MessageLoop::current()),
       profile_(profile),
       frontend_(frontend),
@@ skipping 16 matching lines @@
 
 SyncBackendHost::~SyncBackendHost() {
   DCHECK(!core_ && !frontend_) << "Must call Shutdown before destructor.";
   DCHECK(registrar_.workers.empty());
 }
 
 void SyncBackendHost::Initialize(
     const GURL& sync_service_url,
     const syncable::ModelTypeSet& types,
     URLRequestContextGetter* baseline_context_getter,
-    const std::string& lsid,
+    const SyncCredentials& credentials,
     bool delete_sync_data_folder,
-    bool invalidate_sync_login,
-    bool invalidate_sync_xmpp_login,
     bool use_chrome_async_socket,
     bool try_ssltcp_first,
     NotificationMethod notification_method) {
   if (!core_thread_.Start())
     return;
 
   // Create a worker for the UI thread and route bookmark changes to it.
   // TODO(tim): Pull this into a method to reuse.  For now we don't even
   // need to lock because we init before the syncapi exists and we tear down
   // after the syncapi is destroyed.  Make sure to NULL-check workers_ indices
@@ skipping 11 matching lines @@
 
   // Any datatypes that we want the syncer to pull down must
   // be in the routing_info map.  We set them to group passive, meaning that
   // updates will be applied, but not dispatched to the UI thread yet.
   for (syncable::ModelTypeSet::const_iterator it = types.begin();
       it != types.end(); ++it) {
     registrar_.routing_info[(*it)] = GROUP_PASSIVE;
   }
 
   InitCore(Core::DoInitializeOptions(
-      sync_service_url, lsid.empty(),
+      sync_service_url,
       MakeHttpBridgeFactory(baseline_context_getter),
-      MakeHttpBridgeFactory(baseline_context_getter),
-      lsid,
+      credentials,
       delete_sync_data_folder,
-      invalidate_sync_login,
-      invalidate_sync_xmpp_login,
       use_chrome_async_socket,
       try_ssltcp_first,
       notification_method,
       RestoreEncryptionBootstrapToken()));
 }
 
 void SyncBackendHost::PersistEncryptionBootstrapToken(
     const std::string& token) {
   PrefService* prefs = profile_->GetPrefs();
 
@@ skipping 11 matching lines @@
     URLRequestContextGetter* getter) {
   return new HttpBridgeFactory(getter);
 }
 
 void SyncBackendHost::InitCore(const Core::DoInitializeOptions& options) {
   core_thread_.message_loop()->PostTask(FROM_HERE,
       NewRunnableMethod(core_.get(), &SyncBackendHost::Core::DoInitialize,
                         options));
 }
 
-void SyncBackendHost::Authenticate(const std::string& username,
-                                   const std::string& password,
-                                   const std::string& captcha) {
+void SyncBackendHost::UpdateCredentials(const SyncCredentials& credentials) {
   core_thread_.message_loop()->PostTask(FROM_HERE,
-      NewRunnableMethod(core_.get(), &SyncBackendHost::Core::DoAuthenticate,
-                        username, password, captcha));
+      NewRunnableMethod(core_.get(),
+                        &SyncBackendHost::Core::DoUpdateCredentials,
+                        credentials));
 }
 
 void SyncBackendHost::StartSyncingWithServer() {
   core_thread_.message_loop()->PostTask(FROM_HERE,
       NewRunnableMethod(core_.get(), &SyncBackendHost::Core::DoStartSyncing));
 }
 
 void SyncBackendHost::SetPassphrase(const std::string& passphrase) {
   core_thread_.message_loop()->PostTask(FROM_HERE,
       NewRunnableMethod(core_.get(), &SyncBackendHost::Core::DoSetPassphrase,
@@ skipping 170 matching lines @@
 
 void SyncBackendHost::Core::NotifyPassphraseAccepted(
     const std::string& bootstrap_token) {
   host_->PersistEncryptionBootstrapToken(bootstrap_token);
   NotificationService::current()->Notify(
       NotificationType::SYNC_PASSPHRASE_ACCEPTED,
       NotificationService::AllSources(),
       NotificationService::NoDetails());
 }
 
+void SyncBackendHost::Core::NotifyUpdatedToken(const std::string& token) {
+  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
+  TokenAvailableDetails details(GaiaConstants::kSyncService, token);
+  NotificationService::current()->Notify(
+      NotificationType::TOKEN_UPDATED,
+      NotificationService::AllSources(),
+      Details<const TokenAvailableDetails>(&details));
+}
+
 SyncBackendHost::UserShareHandle SyncBackendHost::GetUserShareHandle() const {
   DCHECK(syncapi_initialized_);
   return core_->syncapi()->GetUserShare();
 }
 
 SyncBackendHost::Status SyncBackendHost::GetDetailedStatus() {
   DCHECK(syncapi_initialized_);
   return core_->syncapi()->GetDetailedStatus();
 }
 
@@ skipping 68 matching lines @@
   if (!version_info.IsOfficialBuild())
     user_agent += "-devel";
   return user_agent;
 }
 
 void SyncBackendHost::Core::DoInitialize(const DoInitializeOptions& options) {
   DCHECK(MessageLoop::current() == host_->core_thread_.message_loop());
 
   // Blow away the partial or corrupt sync data folder before doing any more
   // initialization, if necessary.
-  if (options.delete_sync_data_folder)
+  if (options.delete_sync_data_folder) {
     DeleteSyncDataFolder();
+  }
 
   // Make sure that the directory exists before initializing the backend.
   // If it already exists, this will do no harm.
   bool success = file_util::CreateDirectory(host_->sync_data_folder_path());
   DCHECK(success);
 
   syncapi_->SetObserver(this);
   const FilePath& path_str = host_->sync_data_folder_path();
   success = syncapi_->Init(path_str,
       (options.service_url.host() + options.service_url.path()).c_str(),
       options.service_url.EffectiveIntPort(),
-      kGaiaServiceId,
-      kGaiaSourceForChrome,
       options.service_url.SchemeIsSecure(),
       options.http_bridge_factory,
-      options.auth_http_bridge_factory,
       host_,  // ModelSafeWorkerRegistrar.
-      options.attempt_last_user_authentication,
-      options.invalidate_sync_login,
-      options.invalidate_sync_xmpp_login,
       MakeUserAgentForSyncapi().c_str(),
-      options.lsid.c_str(),
+      options.credentials,
       options.use_chrome_async_socket,
       options.try_ssltcp_first,
       options.notification_method,
       options.restored_key_for_bootstrapping);
   DCHECK(success) << "Syncapi initialization failed!";
 }
 
-void SyncBackendHost::Core::DoAuthenticate(const std::string& username,
-                                           const std::string& password,
-                                           const std::string& captcha) {
+void SyncBackendHost::Core::DoUpdateCredentials(
+    const SyncCredentials& credentials) {
   DCHECK(MessageLoop::current() == host_->core_thread_.message_loop());
-  syncapi_->Authenticate(username.c_str(), password.c_str(), captcha.c_str());
+  syncapi_->UpdateCredentials(credentials);
 }
 
 void SyncBackendHost::Core::DoStartSyncing() {
   DCHECK(MessageLoop::current() == host_->core_thread_.message_loop());
   syncapi_->StartSyncing();
 }
 
 void SyncBackendHost::Core::DoSetPassphrase(const std::string& passphrase) {
   DCHECK(MessageLoop::current() == host_->core_thread_.message_loop());
   syncapi_->SetPassphrase(passphrase);
@@ skipping 136 matching lines @@
   browser_sync::ModelSafeGroup group = routing_it->second;
   WorkerMap::const_iterator worker_it = host_->registrar_.workers.find(group);
   if (worker_it == host_->registrar_.workers.end())
     return false;
   ModelSafeWorker* worker = worker_it->second;
   return worker->CurrentThreadIsWorkThread();
 }
 
 
 void SyncBackendHost::Core::OnAuthError(const AuthError& auth_error) {
-  // We could be on SyncEngine_AuthWatcherThread.  Post to our core loop so
-  // we can modify state.
+  // Post to our core loop so we can modify state. Could be on another thread.
   host_->frontend_loop_->PostTask(FROM_HERE,
       NewRunnableMethod(this, &Core::HandleAuthErrorEventOnFrontendLoop,
       auth_error));
 }
 
 void SyncBackendHost::Core::OnPassphraseRequired() {
   host_->frontend_loop_->PostTask(FROM_HERE,
       NewRunnableMethod(this, &Core::NotifyPassphraseRequired));
 }
 
@@ skipping 14 matching lines @@
   host_->frontend_loop_->PostTask(
       FROM_HERE,
       NewRunnableMethod(this, &Core::NotifyResumed));
 }
 
 void SyncBackendHost::Core::OnStopSyncingPermanently() {
   host_->frontend_loop_->PostTask(FROM_HERE, NewRunnableMethod(this,
       &Core::HandleStopSyncingPermanentlyOnFrontendLoop));
 }
 
+void SyncBackendHost::Core::OnUpdatedToken(const std::string& token) {
+  host_->frontend_loop_->PostTask(FROM_HERE, NewRunnableMethod(this,
+      &Core::NotifyUpdatedToken, token));
+}
+
 void SyncBackendHost::Core::HandleStopSyncingPermanentlyOnFrontendLoop() {
   if (!host_ || !host_->frontend_)
     return;
   host_->frontend_->OnStopSyncingPermanently();
 }
 
 void SyncBackendHost::Core::HandleAuthErrorEventOnFrontendLoop(
     const GoogleServiceAuthError& new_auth_error) {
   if (!host_ || !host_->frontend_)
     return;
@@ skipping 27 matching lines @@
 }
 
 void SyncBackendHost::Core::DeleteSyncDataFolder() {
   if (file_util::DirectoryExists(host_->sync_data_folder_path())) {
     if (!file_util::Delete(host_->sync_data_folder_path(), true))
       LOG(DFATAL) << "Could not delete the Sync Data folder.";
   }
 }
 
 }  // namespace browser_sync