New authorization framework for sync. ...

chrome/browser/sync/glue/sync_backend_host.h

 // 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.
 
 #ifndef CHROME_BROWSER_SYNC_GLUE_SYNC_BACKEND_HOST_H_
 #define CHROME_BROWSER_SYNC_GLUE_SYNC_BACKEND_HOST_H_
 #pragma once
 
 #include <map>
 #include <string>
 #include <vector>
 
 #include "base/file_path.h"
 #include "base/lock.h"
 #include "base/message_loop.h"
 #include "base/ref_counted.h"
 #include "base/thread.h"
 #include "base/timer.h"
+#include "base/utf_string_conversions.h"
 #include "chrome/browser/sync/notification_method.h"
 #include "chrome/browser/sync/engine/syncapi.h"
 #include "chrome/browser/sync/engine/model_safe_worker.h"
 #include "chrome/browser/sync/glue/data_type_controller.h"
 #include "chrome/browser/sync/glue/ui_model_worker.h"
 #include "chrome/browser/sync/syncable/model_type.h"
 #include "chrome/common/net/gaia/google_service_auth_error.h"
 #include "chrome/common/net/url_request_context_getter.h"
 #include "googleurl/src/gurl.h"
 
@@ skipping 65 matching lines @@
   SyncBackendHost();
   ~SyncBackendHost();
 
   // Called on |frontend_loop_| to kick off asynchronous initialization.
   // As a fallback when no cached auth information is available, try to
   // bootstrap authentication using |lsid|, if it isn't empty.
   // Optionally delete the Sync Data folder (if it's corrupt).
   void Initialize(const GURL& service_url,
                   const syncable::ModelTypeSet& types,
                   URLRequestContextGetter* baseline_context_getter,
-                  const std::string& lsid,
+                  const sync_api::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);
 
-  // Called on |frontend_loop_| to kick off asynchronous authentication.
-  void Authenticate(const std::string& username, const std::string& password,
-                    const std::string& captcha);
+  // Called from |frontend_loop| to update SyncCredentials.
+  void UpdateCredentials(const sync_api::SyncCredentials& credentials);
 
   // This starts the SyncerThread running a Syncer object to communicate with
   // sync servers.  Until this is called, no changes will leave or enter this
   // browser from the cloud / sync servers.
   // Called on |frontend_loop_|.
   virtual void StartSyncingWithServer();
 
   // Called on |frontend_loop_| to asynchronously set the passphrase.
   void SetPassphrase(const std::string& passphrase);
 
@@ skipping 76 matching lines @@
         int change_count);
     virtual void OnSyncCycleCompleted(
         const sessions::SyncSessionSnapshot* snapshot);
     virtual void OnInitializationComplete();
     virtual void OnAuthError(const GoogleServiceAuthError& auth_error);
     virtual void OnPassphraseRequired();
     virtual void OnPassphraseAccepted(const std::string& bootstrap_token);
     virtual void OnPaused();
     virtual void OnResumed();
     virtual void OnStopSyncingPermanently();
+    virtual void OnUpdatedToken(const std::string& token);
 
     struct DoInitializeOptions {
       DoInitializeOptions(
           const GURL& service_url,
-          bool attempt_last_user_authentication,
           sync_api::HttpPostProviderFactory* http_bridge_factory,
-          sync_api::HttpPostProviderFactory* auth_http_bridge_factory,
-          const std::string& lsid,
+          const sync_api::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,
           std::string restored_key_for_bootstrapping)
           : service_url(service_url),
-            attempt_last_user_authentication(attempt_last_user_authentication),
             http_bridge_factory(http_bridge_factory),
-            auth_http_bridge_factory(auth_http_bridge_factory),
-            lsid(lsid),
+            credentials(credentials),
             delete_sync_data_folder(delete_sync_data_folder),
-            invalidate_sync_login(invalidate_sync_login),
-            invalidate_sync_xmpp_login(invalidate_sync_xmpp_login),
             use_chrome_async_socket(use_chrome_async_socket),
             try_ssltcp_first(try_ssltcp_first),
             notification_method(notification_method),
             restored_key_for_bootstrapping(restored_key_for_bootstrapping) {}
 
       GURL service_url;
       bool attempt_last_user_authentication;
       sync_api::HttpPostProviderFactory* http_bridge_factory;
-      sync_api::HttpPostProviderFactory* auth_http_bridge_factory;
+      sync_api::SyncCredentials credentials;
       std::string lsid;
       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;
       std::string restored_key_for_bootstrapping;
     };
 
     // Note:
     //
     // The Do* methods are the various entry points from our SyncBackendHost.
     // It calls us on a dedicated thread to actually perform synchronous
     // (and potentially blocking) syncapi operations.
     //
     // Called on the SyncBackendHost core_thread_ to perform initialization
     // of the syncapi on behalf of SyncBackendHost::Initialize.
     void DoInitialize(const DoInitializeOptions& options);
 
-    // Called on our SyncBackendHost's core_thread_ to perform authentication
-    // on behalf of SyncBackendHost::Authenticate.
-    void DoAuthenticate(const std::string& username,
-                        const std::string& password,
-                        const std::string& captcha);
+    // Called on our SyncBackendHost's core_thread_ to perform credential
+    // update on behalf of SyncBackendHost::UpdateCredentials
+    void DoUpdateCredentials(const sync_api::SyncCredentials& credentials);
 
     // Called on the SyncBackendHost core_thread_ to tell the syncapi to start
     // syncing (generally after initialization and authentication).
     void DoStartSyncing();
 
     // Called on the SyncBackendHost core_thread_ to nudge/pause/resume the
     // syncer.
     void DoRequestNudge();
     void DoRequestPause();
     void DoRequestResume();
@@ skipping 23 matching lines @@
     // time sync is enabled for a user (to prevent accidentally reusing old
     // sync databases), as well as shutdown when you're no longer syncing.
     void DeleteSyncDataFolder();
 
 #if defined(UNIT_TEST)
     // Special form of initialization that does not try and authenticate the
     // last known user (since it will fail in test mode) and does some extra
     // setup to nudge the syncapi into a useable state.
     void DoInitializeForTest(const std::wstring& test_user,
                              sync_api::HttpPostProviderFactory* factory,
-                             sync_api::HttpPostProviderFactory* auth_factory,
                              bool delete_sync_data_folder,
                              NotificationMethod notification_method) {
-      DoInitialize(DoInitializeOptions(GURL(), false, factory, auth_factory,
-                                       std::string(), delete_sync_data_folder,
-                                       false, false, false, false,
-                                       notification_method, ""));
-        syncapi_->SetupForTestMode(test_user);
+      // Construct dummy credentials for test.
+      sync_api::SyncCredentials credentials;
+      credentials.email = WideToUTF8(test_user);
+      credentials.sync_token = "token";
+      DoInitialize(DoInitializeOptions(GURL(), factory,
+                                       credentials,
+                                       delete_sync_data_folder, false, false,
+                                       notification_method, std::string()));
+      syncapi_->SetupForTestMode(test_user);
     }
 #endif
 
    private:
     friend class base::RefCountedThreadSafe<SyncBackendHost::Core>;
     friend class SyncBackendHostForProfileSyncTest;
 
     ~Core();
 
     // Sends a SYNC_PAUSED notification to the notification service on
@@ skipping 22 matching lines @@
     // frontend UI components.
     void HandleAuthErrorEventOnFrontendLoop(
         const GoogleServiceAuthError& new_auth_error);
 
     // Invoked when a passphrase is required to decrypt a set of Nigori keys.
     void NotifyPassphraseRequired();
 
     // Invoked when the passphrase provided by the user has been accepted.
     void NotifyPassphraseAccepted(const std::string& bootstrap_token);
 
+    // Invoked when an updated token is available from the sync server.
+    void NotifyUpdatedToken(const std::string& token);
+
     // Called from Core::OnSyncCycleCompleted to handle updating frontend
     // thread components.
     void HandleSyncCycleCompletedOnFrontendLoop(
         sessions::SyncSessionSnapshot* snapshot);
 
     void HandleStopSyncingPermanentlyOnFrontendLoop();
 
     // Called from Core::OnInitializationComplete to handle updating
     // frontend thread components.
     void HandleInitalizationCompletedOnFrontendLoop();
 
     // Return true if a model lives on the current thread.
     bool IsCurrentThreadSafeForModel(syncable::ModelType model_type);
 
+    // True if credentials are ready for sync use.
+    bool CredentialsAvailable();
+
     // Our parent SyncBackendHost
     SyncBackendHost* host_;
 
     // The timer used to periodically call SaveChanges.
     base::RepeatingTimer<Core> save_changes_timer_;
 
     // The top-level syncapi entry point.
     scoped_ptr<sync_api::SyncManager> syncapi_;
 
     DISALLOW_COPY_AND_ASSIGN(Core);
@@ skipping 97 matching lines @@
 
   // Whether we've processed the initialization complete callback.
   bool syncapi_initialized_;
 
   DISALLOW_COPY_AND_ASSIGN(SyncBackendHost);
 };
 
 }  // namespace browser_sync
 
 #endif  // CHROME_BROWSER_SYNC_GLUE_SYNC_BACKEND_HOST_H_