Use OAuth2 token for sync

chrome/browser/sync/profile_sync_service.h

 // 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.
 
 #ifndef CHROME_BROWSER_SYNC_PROFILE_SYNC_SERVICE_H_
 #define CHROME_BROWSER_SYNC_PROFILE_SYNC_SERVICE_H_
 
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/gtest_prod_util.h"
 #include "base/location.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/observer_list.h"
 #include "base/string16.h"
 #include "base/time.h"
 #include "base/timer.h"
 #include "chrome/browser/invalidation/invalidation_frontend.h"
 #include "chrome/browser/invalidation/invalidator_storage.h"
+#include "chrome/browser/signin/oauth2_token_service.h"
 #include "chrome/browser/signin/signin_global_error.h"
 #include "chrome/browser/sync/backend_unrecoverable_error_handler.h"
 #include "chrome/browser/sync/glue/data_type_controller.h"
 #include "chrome/browser/sync/glue/data_type_encryption_handler.h"
 #include "chrome/browser/sync/glue/data_type_manager.h"
 #include "chrome/browser/sync/glue/data_type_manager_observer.h"
 #include "chrome/browser/sync/glue/failed_data_types_handler.h"
 #include "chrome/browser/sync/glue/sync_backend_host.h"
 #include "chrome/browser/sync/profile_sync_service_base.h"
 #include "chrome/browser/sync/profile_sync_service_observer.h"
 #include "chrome/browser/sync/sync_prefs.h"
 #include "components/browser_context_keyed_service/browser_context_keyed_service.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 #include "content/public/browser/notification_types.h"
 #include "google_apis/gaia/google_service_auth_error.h"
 #include "googleurl/src/gurl.h"
+#include "net/base/backoff_entry.h"
 #include "sync/internal_api/public/base/model_type.h"
 #include "sync/internal_api/public/engine/model_safe_worker.h"
 #include "sync/internal_api/public/sync_manager_factory.h"
 #include "sync/internal_api/public/util/experiments.h"
 #include "sync/internal_api/public/util/unrecoverable_error_handler.h"
 #include "sync/js/sync_js_controller.h"
 
 class Profile;
 class ProfileSyncComponentsFactory;
 class SigninManagerBase;
@@ skipping 106 matching lines @@
 //
 class ProfileSyncService : public ProfileSyncServiceBase,
                            public browser_sync::SyncFrontend,
                            public browser_sync::SyncPrefObserver,
                            public browser_sync::DataTypeManagerObserver,
                            public SigninGlobalError::AuthStatusProvider,
                            public syncer::UnrecoverableErrorHandler,
                            public content::NotificationObserver,
                            public BrowserContextKeyedService,
                            public invalidation::InvalidationFrontend,
-                           public browser_sync::DataTypeEncryptionHandler {
+                           public browser_sync::DataTypeEncryptionHandler,
+                           public OAuth2TokenService::Consumer {
  public:
   typedef browser_sync::SyncBackendHost::Status Status;
 
   enum SyncEventCodes  {
     MIN_SYNC_EVENT_CODE = 0,
 
     // Events starting the sync service.
     START_FROM_NTP = 1,      // Sync was started from the ad in NTP
     START_FROM_WRENCH = 2,   // Sync was started from the Wrench menu.
     START_FROM_OPTIONS = 3,  // Sync was started from Wrench->Options.
@@ skipping 64 matching lines @@
 
   void RegisterAuthNotifications();
 
   // Returns true if sync is enabled/not suppressed and the user is logged in.
   // (being logged in does not mean that tokens are available - tokens may
   // be missing because they have not loaded yet, or because they were deleted
   // due to http://crbug.com/121755).
   // Virtual to enable mocking in tests.
   virtual bool IsSyncEnabledAndLoggedIn();
 
-  // Return whether all sync tokens are loaded and available for the backend to
-  // start up. Virtual to enable mocking in tests.
-  virtual bool IsSyncTokenAvailable();
+  // Return whether OAuth2 refresh token is loaded and available for the backend
+  // to start up. Virtual to enable mocking in tests.
+  virtual bool IsOAuthRefreshTokenAvailable();
 
   // Registers a data type controller with the sync service.  This
   // makes the data type controller available for use, it does not
   // enable or activate the synchronization of the data type (see
   // ActivateDataType).  Takes ownership of the pointer.
   void RegisterDataTypeController(
       browser_sync::DataTypeController* data_type_controller);
 
   // Returns the session model associator associated with this type, but only if
   // the associator is running.  If it is doing anything else, it will return
@@ skipping 340 matching lines @@
       syncer::InvalidationHandler* handler,
       const syncer::ObjectIdSet& ids) OVERRIDE;
   virtual void UnregisterInvalidationHandler(
       syncer::InvalidationHandler* handler) OVERRIDE;
   virtual void AcknowledgeInvalidation(
       const invalidation::ObjectId& id,
       const syncer::AckHandle& ack_handle) OVERRIDE;
 
   virtual syncer::InvalidatorState GetInvalidatorState() const OVERRIDE;
 
+  // OAuth2TokenService::Consumer implementation
+  virtual void OnGetTokenSuccess(
+      const OAuth2TokenService::Request* request,
+      const std::string& access_token,
+      const base::Time& expiration_time) OVERRIDE;
+  virtual void OnGetTokenFailure(
+      const OAuth2TokenService::Request* request,
+      const GoogleServiceAuthError& error) OVERRIDE;
+
   // BrowserContextKeyedService implementation.  This must be called exactly
   // once (before this object is destroyed).
   virtual void Shutdown() OVERRIDE;
 
   // Simulate an incoming notification for the given id and payload.
   void EmitInvalidationForTest(
       const invalidation::ObjectId& id,
       const std::string& payload);
 
   // Called when a datatype (SyncableService) has a need for sync to start
@@ skipping 90 matching lines @@
   // because OnPassphraseAccepted() was called, or because we've gotten a
   // OnPassphraseRequired() but no data types are enabled).
   void ResolvePassphraseRequired();
 
   // During initial signin, ProfileSyncService caches the user's signin
   // passphrase so it can be used to encrypt/decrypt data after sync starts up.
   // This routine is invoked once the backend has started up to use the
   // cached passphrase and clear it out when it is done.
   void ConsumeCachedPassphraseIfPossible();
 
+  // RequestAccessToken initiates RPC to request downscoped access token from
+  // refresh token. This happens when TokenService loads OAuth2 login token and
+  // when sync server returns AUTH_ERROR which indicates it is time to refresh
+  // token.
+  virtual void RequestAccessToken();
+
   // If |delete_sync_data_folder| is true, then this method will delete all
   // previous "Sync Data" folders. (useful if the folder is partial/corrupt).
   void InitializeBackend(bool delete_sync_data_folder);
 
   // Initializes the various settings from the command line.
   void InitSettings();
 
   // Sets the last synced time to the current time.
   void UpdateLastSyncedTime();
 
@@ skipping 198 matching lines @@
   // Dispatches invalidations to handlers.  Set in Initialize() and
   // unset in Shutdown().
   scoped_ptr<syncer::InvalidatorRegistrar> invalidator_registrar_;
   // Queues any acknowledgements received while the backend is uninitialized.
   AckHandleReplayQueue ack_replay_queue_;
 
   // Sync's internal debug info listener. Used to record datatype configuration
   // and association information.
   syncer::WeakHandle<syncer::DataTypeDebugInfoListener> debug_info_listener_;
 
+  // Specifies whenever to use oauth2 access token or ClientLogin token in
+  // communications with sync and xmpp servers.
+  // TODO(pavely): Remove once android is converted to oauth2 tokens.
+  bool use_oauth2_token_;
+
+  // ProfileSyncService needs to remember access token in order to invalidate it
+  // with OAuth2TokenService.
+  std::string access_token_;
+
+  // ProfileSyncService needs to hold reference to access_token_request_ for
+  // the duration of request in order to receive callbacks.
+  scoped_ptr<OAuth2TokenService::Request> access_token_request_;
+
+  // If RequestAccessToken fails with transient error then retry requesting
+  // access token with exponential backoff.
+  base::OneShotTimer<ProfileSyncService> request_access_token_retry_timer_;
+  net::BackoffEntry request_access_token_backoff_;
+
   DISALLOW_COPY_AND_ASSIGN(ProfileSyncService);
 };
 
 bool ShouldShowActionOnUI(
     const syncer::SyncProtocolError& error);
 
 
 #endif  // CHROME_BROWSER_SYNC_PROFILE_SYNC_SERVICE_H_