sync: final pieces to sync deferred initialization

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/scoped_vector.h"
 #include "base/memory/weak_ptr.h"
 #include "base/observer_list.h"
 #include "base/strings/string16.h"
 #include "base/time/time.h"
 #include "base/timer/timer.h"
 #include "chrome/browser/sync/backend_unrecoverable_error_handler.h"
 #include "chrome/browser/sync/glue/sync_backend_host.h"
 #include "chrome/browser/sync/glue/synced_device_tracker.h"
 #include "chrome/browser/sync/profile_sync_service_base.h"
 #include "chrome/browser/sync/profile_sync_service_observer.h"
 #include "chrome/browser/sync/sessions2/sessions_sync_manager.h"
+#include "chrome/browser/sync/startup_controller.h"
 #include "chrome/browser/sync/sync_prefs.h"
 #include "components/browser_context_keyed_service/browser_context_keyed_service.h"
 #include "components/sync_driver/data_type_controller.h"
 #include "components/sync_driver/data_type_encryption_handler.h"
 #include "components/sync_driver/data_type_manager.h"
 #include "components/sync_driver/data_type_manager_observer.h"
 #include "components/sync_driver/failed_data_types_handler.h"
 #include "components/sync_driver/sync_frontend.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
@@ skipping 180 matching lines @@
                                             // types and clicking OK.
     // Events resulting in the stoppage of sync service.
     STOP_FROM_OPTIONS = 20,  // Sync was stopped from Wrench->Options.
     STOP_FROM_ADVANCED_DIALOG = 21,  // Sync was stopped via advanced settings.
 
     // Miscellaneous events caused by sync service.
 
     MAX_SYNC_EVENT_CODE
   };
 
-  // Defines the type of behavior the sync engine should use. If configured for
-  // AUTO_START, the sync engine will automatically call SetSyncSetupCompleted()
-  // and start downloading data types as soon as sync credentials are available
-  // (a signed-in username and a "chromiumsync" token).
-  // If configured for MANUAL_START, sync will not start until the user
-  // completes sync setup, at which point the UI makes an explicit call to
-  // SetSyncSetupCompleted().
-  enum StartBehavior {
-    AUTO_START,
-    MANUAL_START,
-  };
-
   // Used to specify the kind of passphrase with which sync data is encrypted.
   enum PassphraseType {
     IMPLICIT,  // The user did not provide a custom passphrase for encryption.
                // We implicitly use the GAIA password in such cases.
     EXPLICIT,  // The user selected the "use custom passphrase" radio button
                // during sync setup and provided a passphrase.
   };
 
   enum SyncStatusSummary {
     UNRECOVERABLE_ERROR,
     NOT_ENABLED,
     SETUP_INCOMPLETE,
     DATATYPES_NOT_INITIALIZED,
     INITIALIZED,
     UNKNOWN_ERROR,
   };
 
   // Default sync server URL.
   static const char* kSyncServerUrl;
   // Sync server URL for dev channel users
   static const char* kDevServerUrl;
 
   // Takes ownership of |factory| and |signin_wrapper|.
-  ProfileSyncService(ProfileSyncComponentsFactory* factory,
-                     Profile* profile,
-                     ManagedUserSigninManagerWrapper* signin_wrapper,
-                     ProfileOAuth2TokenService* oauth2_token_service,
-                     StartBehavior start_behavior);
+  ProfileSyncService(
+      ProfileSyncComponentsFactory* factory,
+      Profile* profile,
+      ManagedUserSigninManagerWrapper* signin_wrapper,
+      ProfileOAuth2TokenService* oauth2_token_service,
+      browser_sync::ProfileSyncServiceStartBehavior start_behavior);
   virtual ~ProfileSyncService();
 
   // Initializes the object. This must be called at most once, and
   // immediately after an object of this class is constructed.
   void Initialize();
 
   virtual void SetSyncSetupCompleted();
 
   // ProfileSyncServiceBase implementation.
   virtual bool HasSyncSetupCompleted() const OVERRIDE;
   virtual bool ShouldPushChanges() OVERRIDE;
   virtual syncer::ModelTypeSet GetActiveDataTypes() const OVERRIDE;
   virtual void AddObserver(ProfileSyncServiceBase::Observer* observer) OVERRIDE;
   virtual void RemoveObserver(
       ProfileSyncServiceBase::Observer* observer) OVERRIDE;
   virtual bool HasObserver(
       ProfileSyncServiceBase::Observer* observer) const OVERRIDE;
 
   void RegisterAuthNotifications();
   void UnregisterAuthNotifications();
 
   // 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.
+  // TODO(tim): Remove this? Nothing in ProfileSyncService uses it, and outside
+  // callers use a seemingly arbitrary / redundant / bug prone combination of
+  // this method, IsSyncAccessible, and others.
   virtual bool IsSyncEnabledAndLoggedIn();
 
   // 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.
@@ skipping 329 matching lines @@
   // Returns true if we are currently set to encrypt all the sync data. Note:
   // this is based on the cryptographer's settings, so if the user has recently
   // requested encryption to be turned on, this may not be true yet. For that,
   // encryption_pending() must be checked.
   virtual bool EncryptEverythingEnabled() const;
 
   // Returns true if the syncer is waiting for new datatypes to be encrypted.
   virtual bool encryption_pending() const;
 
   const GURL& sync_service_url() const { return sync_service_url_; }
-  bool auto_start_enabled() const { return auto_start_enabled_; }
   SigninManagerBase* signin() const;
-  bool setup_in_progress() const { return setup_in_progress_; }
+
+  // Used by tests.
+  bool auto_start_enabled() const;
+  bool setup_in_progress() const;
 
   // Stops the sync backend and sets the flag for suppressing sync startup.
   void StopAndSuppress();
 
   // Resets the flag for suppressing sync startup and starts the sync backend.
   virtual void UnsuppressAndStart();
 
   // Marks all currently registered types as "acknowledged" so we won't prompt
   // the user about them any more.
   void AcknowledgeSyncedTypes();
@@ skipping 122 matching lines @@
   FRIEND_TEST_ALL_PREFIXES(ProfileSyncServiceTest, InitialState);
 
   // Update the last auth error and notify observers of error state.
   void UpdateAuthErrorState(const GoogleServiceAuthError& error);
 
   // Detects and attempts to recover from a previous improper datatype
   // configuration where Keep Everything Synced and the preferred types were
   // not correctly set.
   void TrySyncDatatypePrefRecovery();
 
-  // Starts up sync if it is not suppressed and preconditions are met.
-  // Called from Initialize() and UnsuppressAndStart().
-  void TryStart();
-
   // Puts the backend's sync scheduler into NORMAL mode.
   // Called when configuration is complete.
   void StartSyncingWithServer();
 
   // Called when we've determined that we don't need a passphrase (either
   // 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
@@ skipping 18 matching lines @@
   // Sets the last synced time to the current time.
   void UpdateLastSyncedTime();
 
   void NotifyObservers();
   void NotifySyncCycleCompleted();
 
   void ClearStaleErrors();
 
   void ClearUnrecoverableError();
 
-  enum StartUpDeferredOption {
-    STARTUP_BACKEND_DEFERRED,
-    STARTUP_IMMEDIATE
-  };
-  void StartUp(StartUpDeferredOption deferred_option);
-
   // Starts up the backend sync components.
   void StartUpSlowBackendComponents();
 
   // About-flags experiment names for datatypes that aren't enabled by default
   // yet.
   static std::string GetExperimentNameForDataType(
       syncer::ModelType data_type);
 
   // Create and register a new datatype controller.
   void RegisterNewDataType(syncer::ModelType data_type);
@@ skipping 18 matching lines @@
   void RefreshSpareBootstrapToken(const std::string& passphrase);
 #endif
 
   // Internal unrecoverable error handler. Used to track error reason via
   // Sync.UnrecoverableErrors histogram.
   void OnInternalUnrecoverableError(const tracked_objects::Location& from_here,
                                     const std::string& message,
                                     bool delete_sync_database,
                                     UnrecoverableErrorReason reason);
 
-  // Returns the username (in form of an email address) that should be used in
-  // the credentials.
-  std::string GetEffectiveUsername();
-
-  // Returns the account ID to use to get tokens.
-  std::string GetAccountIdToUse();
-
  // Factory used to create various dependent objects.
   scoped_ptr<ProfileSyncComponentsFactory> factory_;
 
   // The profile whose data we are synchronizing.
   Profile* profile_;
 
   // The class that handles getting, setting, and persisting sync
   // preferences.
   browser_sync::SyncPrefs sync_prefs_;
 
   // 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_;
 
-  // The time that StartUp() is called.  This member is zero if StartUp() has
-  // never been called, and is reset to zero once OnBackendInitialized() is
-  // called.
-  base::Time start_up_time_;
-
-  // Whether we have received a signal from a SyncableService requesting that
-  // sync starts as soon as possible.
-  // TODO(tim): Move this and other TryStart related logic + state to separate
-  // class. Bug 80149.
-  bool data_type_requested_sync_startup_;
-
   // The time that OnConfigureStart is called. This member is zero if
   // OnConfigureStart has not yet been called, and is reset to zero once
   // OnConfigureDone is called.
   base::Time sync_configure_start_time_;
 
   // Indicates if this is the first time sync is being configured.  This value
   // is equal to !HasSyncSetupCompleted() at the time of OnBackendInitialized().
   bool is_first_time_sync_configure_;
 
   // List of available data type controllers.
@@ skipping 45 matching lines @@
   syncer::ModelTypeSet encrypted_types_;
 
   // Whether we want to encrypt everything.
   bool encrypt_everything_;
 
   // Whether we're waiting for an attempt to encryption all sync data to
   // complete. We track this at this layer in order to allow the user to cancel
   // if they e.g. don't remember their explicit passphrase.
   bool encryption_pending_;
 
-  // If true, we want to automatically start sync signin whenever we have
-  // credentials (user doesn't need to go through the startup flow). This is
-  // typically enabled on platforms (like ChromeOS) that have their own
-  // distinct signin flow.
-  const bool auto_start_enabled_;
-
   scoped_ptr<browser_sync::BackendMigrator> migrator_;
 
   // This is the last |SyncProtocolError| we received from the server that had
   // an action set on it.
   syncer::SyncProtocolError last_actionable_error_;
 
   // This is used to show sync errors in the wrench menu.
   scoped_ptr<SyncGlobalError> sync_global_error_;
 
   // Tracks the set of failed data types (those that encounter an error
   // or must delay loading for some reason).
   browser_sync::FailedDataTypesHandler failed_data_types_handler_;
 
   browser_sync::DataTypeManager::ConfigureStatus configure_status_;
 
-  // If |true|, there is setup UI visible so we should not start downloading
-  // data types.
-  bool setup_in_progress_;
-
   // The set of currently enabled sync experiments.
   syncer::Experiments current_experiments_;
 
   // Sync's internal debug info listener. Used to record datatype configuration
   // and association information.
   syncer::WeakHandle<syncer::DataTypeDebugInfoListener> debug_info_listener_;
 
   // A thread where all the sync operations happen.
   // OWNERSHIP Notes:
   //     * Created when backend starts for the first time.
@@ skipping 12 matching lines @@
   // 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_;
 
   base::WeakPtrFactory<ProfileSyncService> weak_factory_;
 
+  // We don't use |weak_factory_| for the StartupController because the weak
+  // ptrs should be bound to the lifetime of ProfileSyncService and not to the
+  // [Initialize -> sync disabled/shutdown] lifetime.  We don't pass
+  // StartupController an Unretained reference to future-proof against
+  // the controller impl changing to post tasks. Therefore, we have a separate
+  // factory.
+  base::WeakPtrFactory<ProfileSyncService> startup_controller_weak_factory_;
+
   // States related to sync token and connection.
   base::Time connection_status_update_time_;
   syncer::ConnectionStatus connection_status_;
   base::Time token_request_time_;
   base::Time token_receive_time_;
   GoogleServiceAuthError last_get_token_error_;
   base::Time next_token_request_time_;
 
   scoped_ptr<SessionsSyncManager> sessions_sync_manager_;
 
   scoped_ptr<syncer::NetworkResources> network_resources_;
 
+  browser_sync::StartupController startup_controller_;
+
   DISALLOW_COPY_AND_ASSIGN(ProfileSyncService);
 };
 
 bool ShouldShowActionOnUI(
     const syncer::SyncProtocolError& error);
 
 
 #endif  // CHROME_BROWSER_SYNC_PROFILE_SYNC_SERVICE_H_