New authorization framework for sync. ...

chrome/browser/sync/profile_sync_service.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_PROFILE_SYNC_SERVICE_H_
 #define CHROME_BROWSER_SYNC_PROFILE_SYNC_SERVICE_H_
 #pragma once
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/gtest_prod_util.h"
 #include "base/observer_list.h"
 #include "base/scoped_ptr.h"
 #include "base/string16.h"
 #include "base/time.h"
 #include "chrome/browser/prefs/pref_member.h"
+#include "chrome/browser/sync/engine/syncapi.h"
 #include "chrome/browser/sync/glue/data_type_controller.h"
 #include "chrome/browser/sync/glue/data_type_manager.h"
 #include "chrome/browser/sync/glue/session_model_associator.h"
 #include "chrome/browser/sync/glue/sync_backend_host.h"
 #include "chrome/browser/sync/notification_method.h"
 #include "chrome/browser/sync/profile_sync_service_observer.h"
+#include "chrome/browser/sync/signin_manager.h"
 #include "chrome/browser/sync/sync_setup_wizard.h"
 #include "chrome/browser/sync/syncable/model_type.h"
 #include "chrome/browser/sync/unrecoverable_error_handler.h"
 #include "chrome/common/net/gaia/google_service_auth_error.h"
 #include "chrome/common/notification_observer.h"
 #include "chrome/common/notification_registrar.h"
 #include "googleurl/src/gurl.h"
 
 class NotificationDetails;
 class NotificationSource;
 class NotificationType;
 class Profile;
 class ProfileSyncFactory;
+class TokenMigrator;
 
 // ProfileSyncService is the layer between browser subsystems like bookmarks,
 // and the sync backend.  Each subsystem is logically thought of as being
 // a sync datatype.
 //
 // Individual datatypes can, at any point, be in a variety of stages of being
 // "enabled".  Here are some specific terms for concepts used in this class:
 //
 //   'Registered' (feature suppression for a datatype)
 //
@@ skipping 60 matching lines @@
     MAX_SYNC_EVENT_CODE
   };
 
   // Default sync server URL.
   static const char* kSyncServerUrl;
   // Sync server URL for dev channel users
   static const char* kDevServerUrl;
 
   ProfileSyncService(ProfileSyncFactory* factory_,
                      Profile* profile,
-                     bool bootstrap_sync_authentication);
+                     const std::string& cros_user);
   virtual ~ProfileSyncService();
 
   // Initializes the object. This should be called every time an object of this
   // class is constructed.
   void Initialize();
 
+  void RegisterAuthNotifications();
+
+  // Return whether all sync tokens are loaded and
+  // available for the backend to start up.
+  bool AreCredentialsAvailable();
+
+  // Loads credentials migrated from the old user settings db.
+  void LoadMigratedCredentials(const std::string& username,
+                               const std::string& token);
+
   // 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
   // null.
   browser_sync::SessionModelAssociator* GetSessionModelAssociator();
 
   // Fills state_map with a map of current data types that are possible to
   // sync, as well as their states.
   void GetDataTypeControllerStates(
     browser_sync::DataTypeController::StateMap* state_map) const;
 
-  // Enables/disables sync for user.
-  virtual void EnableForUser(gfx::NativeWindow parent_window);
+  // Disables sync for user. Use ShowLoginDialog to enable.
   virtual void DisableForUser();
 
   // Whether sync is enabled by user or not.
   virtual bool HasSyncSetupCompleted() const;
   void SetSyncSetupCompleted();
 
   // SyncFrontend implementation.
   virtual void OnBackendInitialized();
   virtual void OnSyncCycleCompleted();
   virtual void OnAuthError();
   virtual void OnStopSyncingPermanently();
 
   // Called when a user enters credentials through UI.
   virtual void OnUserSubmittedAuth(const std::string& username,
                                    const std::string& password,
                                    const std::string& captcha);
 
+  // Update the last auth error and notify observers of error state.
+  void UpdateAuthErrorState(const GoogleServiceAuthError& error);
+
   // Called when a user chooses which data types to sync as part of the sync
   // setup wizard.  |sync_everything| represents whether they chose the
   // "keep everything synced" option; if true, |chosen_types| will be ignored
   // and all data types will be synced.  |sync_everything| means "sync all
   // current and future data types."
   virtual void OnUserChoseDatatypes(bool sync_everything,
       const syncable::ModelTypeSet& chosen_types);
 
   // Called when a user cancels any setup dialog (login, etc).
   virtual void OnUserCancelledDialog();
@@ skipping 149 matching lines @@
   // Starts up the backend sync components.
   void StartUp();
   // Shuts down the backend sync components.
   // |sync_disabled| indicates if syncing is being disabled or not.
   void Shutdown(bool sync_disabled);
 
   // Methods to register and remove preferences.
   void RegisterPreferences();
   void ClearPreferences();
 
+  // Return SyncCredentials from the TokenService.
+  sync_api::SyncCredentials GetCredentials();
+
   // Test need to override this to create backends that allow setting up
   // initial conditions, such as populating sync nodes.
   virtual void CreateBackend();
 
   const browser_sync::DataTypeController::TypeMap& data_type_controllers() {
     return data_type_controllers_;
   }
 
-  // We keep track of the last auth error observed so we can cover up the first
-  // "expected" auth failure from observers.
-  // TODO(timsteele): Same as expecting_first_run_auth_needed_event_. Remove
-  // this!
+  // The wizard will try to read the auth state out of the profile sync
+  // service using this member. Captcha and error state are reflected.
   GoogleServiceAuthError last_auth_error_;
 
   // Our asynchronous backend to communicate with sync components living on
   // other threads.
   scoped_ptr<browser_sync::SyncBackendHost> backend_;
 
   // Cache of the last name the client attempted to authenticate.
   std::string last_attempted_user_email_;
 
  private:
@@ skipping 22 matching lines @@
 
   // Time at which error UI is presented for the new tab page.
   base::TimeTicks auth_error_time_;
 
   // Factory used to create various dependent objects.
   ProfileSyncFactory* factory_;
 
   // The profile whose data we are synchronizing.
   Profile* profile_;
 
-  // True if the profile sync service should attempt to use an LSID
-  // cookie for authentication.  This is typically set to true in
-  // ChromiumOS since we want to use the system level authentication
-  // for sync.
-  bool bootstrap_sync_authentication_;
+  // Email for the ChromiumOS user, if we're running under ChromiumOS.
+  std::string cros_user_;
 
   // TODO(ncarter): Put this in a profile, once there is UI for it.
   // This specifies where to find the sync server.
   GURL sync_service_url_;
 
   // The last time we detected a successful transition from SYNCING state.
   // Our backend notifies us whenever we should take a new snapshot.
   base::Time last_synced_time_;
 
   // List of available data type controllers.
   browser_sync::DataTypeController::TypeMap data_type_controllers_;
 
   // Whether the SyncBackendHost has been initialized.
   bool backend_initialized_;
 
-  // Set to true when the user first enables sync, and we are waiting for
-  // syncapi to give us the green light on providing credentials for the first
-  // time. It is set back to false as soon as we get this message, and is
-  // false all other times so we don't have to persist this value as it will
-  // get initialized to false.
-  // TODO(timsteele): Remove this by way of starting the wizard when enabling
-  // sync *before* initializing the backend. syncapi will need to change, but
-  // it means we don't have to wait for the first AuthError; if we ever get
-  // one, it is actually an error and this bool isn't needed.
-  bool expecting_first_run_auth_needed_event_;
-
   // Various pieces of UI query this value to determine if they should show
   // an "Authenticating.." type of message.  We are the only central place
   // all auth attempts funnel through, so it makes sense to provide this.
   // As its name suggests, this should NOT be used for anything other than UI.
   bool is_auth_in_progress_;
 
   SyncSetupWizard wizard_;
 
+  // Encapsulates user signin with TokenService.
+  SigninManager signin_;
+
   // True if an unrecoverable error (e.g. violation of an assumed invariant)
   // occurred during syncer operation.  This value should be checked before
   // doing any work that might corrupt things further.
   bool unrecoverable_error_detected_;
 
   // A message sent when an unrecoverable error occurred.
   std::string unrecoverable_error_message_;
   scoped_ptr<tracked_objects::Location> unrecoverable_error_location_;
 
   // Whether to use the (new, untested) Chrome-socket-based
@@ skipping 15 matching lines @@
 
   // The preference that controls whether sync is under control by configuration
   // management.
   BooleanPrefMember pref_sync_managed_;
 
   // This allows us to gracefully handle an ABORTED return code from the
   // DataTypeManager in the event that the server informed us to cease and
   // desist syncing immediately.
   bool expect_sync_configuration_aborted_;
 
+  scoped_ptr<TokenMigrator> token_migrator_;
+
   DISALLOW_COPY_AND_ASSIGN(ProfileSyncService);
 };
 
 #endif  // CHROME_BROWSER_SYNC_PROFILE_SYNC_SERVICE_H_