[Sync] Move //components/sync to the syncer namespace.

components/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 COMPONENTS_BROWSER_SYNC_PROFILE_SYNC_SERVICE_H_
 #define COMPONENTS_BROWSER_SYNC_PROFILE_SYNC_SERVICE_H_
 
 #include <memory>
 #include <set>
 #include <string>
@@ skipping 40 matching lines @@
 #include "components/sync/js/sync_js_controller.h"
 #include "components/version_info/version_info.h"
 #include "google_apis/gaia/google_service_auth_error.h"
 #include "google_apis/gaia/oauth2_token_service.h"
 #include "net/base/backoff_entry.h"
 #include "url/gurl.h"
 
 class Profile;
 class ProfileOAuth2TokenService;
 class SigninManagerWrapper;
-class SyncErrorController;
-class SyncTypePreferenceProvider;
 
-namespace sync_driver {
-class DataTypeManager;
-class DeviceInfoSyncService;
-class DeviceInfoTracker;
-class LocalDeviceInfoProvider;
-class SyncApiComponentFactory;
-class SyncClient;
-}  // namespace sync_driver
-
-namespace sync_driver_v2 {
-class DeviceInfoService;
-}
+namespace sync_pb {
+class EncryptedData;
+}  // namespace sync_pb
 
 namespace sync_sessions {
 class FaviconCache;
 class OpenTabsUIDelegate;
 class SessionsSyncManager;
 }  // namespace sync_sessions
 
 namespace syncer {
+class BackendMigrator;
 class BaseTransaction;
+class DataTypeManager;
+class DeviceInfoService;
+class DeviceInfoSyncService;
+class DeviceInfoTracker;
+class LocalDeviceInfoProvider;
 class NetworkResources;
+class SyncApiComponentFactory;
+class SyncClient;
+class SyncErrorController;
+class SyncTypePreferenceProvider;
 class TypeDebugInfoObserver;
 struct CommitCounters;
 struct StatusCounters;
 struct SyncCredentials;
 struct UpdateCounters;
 struct UserShare;
 }  // namespace syncer
 
-namespace sync_pb {
-class EncryptedData;
-}  // namespace sync_pb
-
 namespace browser_sync {
 
-class BackendMigrator;
-
 // 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)
 //
 //      When a datatype is registered, the user has the option of syncing it.
@@ skipping 59 matching lines @@
 //    * GetSetupInProgressHandle()
 //
 //   SetFirstSetupComplete() should be called once the user has finished setting
 //   up sync at least once on their account. GetSetupInProgressHandle() should
 //   be called while the user is actively configuring their account. The handle
 //   should be deleted once configuration is complete.
 //
 //   Once first setup has completed and there are no outstanding
 //   setup-in-progress handles, CanConfigureDataTypes() will return true and
 //   datatype configuration can begin.
-class ProfileSyncService : public sync_driver::SyncService,
-                           public sync_driver::SyncFrontend,
-                           public sync_driver::SyncPrefObserver,
-                           public sync_driver::DataTypeManagerObserver,
+class ProfileSyncService : public syncer::SyncService,
+                           public syncer::SyncFrontend,
+                           public syncer::SyncPrefObserver,
+                           public syncer::DataTypeManagerObserver,
                            public syncer::UnrecoverableErrorHandler,
                            public KeyedService,
                            public OAuth2TokenService::Consumer,
                            public OAuth2TokenService::Observer,
                            public SigninManagerBase::Observer,
                            public GaiaCookieManagerService::Observer {
  public:
-  typedef SyncBackendHost::Status Status;
+  typedef syncer::SyncBackendHost::Status Status;
   typedef base::Callback<bool(void)> PlatformSyncAllowedProvider;
 
   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.
     START_FROM_BOOKMARK_MANAGER = 4,  // Sync was started from Bookmark manager.
@@ skipping 33 matching lines @@
 
   // Bundles the arguments for ProfileSyncService construction. This is a
   // movable struct. Because of the non-POD data members, it needs out-of-line
   // constructors, so in particular the move constructor needs to be
   // explicitly defined.
   struct InitParams {
     InitParams();
     ~InitParams();
     InitParams(InitParams&& other);  // NOLINT
 
-    std::unique_ptr<sync_driver::SyncClient> sync_client;
+    std::unique_ptr<syncer::SyncClient> sync_client;
     std::unique_ptr<SigninManagerWrapper> signin_wrapper;
     ProfileOAuth2TokenService* oauth2_token_service = nullptr;
     GaiaCookieManagerService* gaia_cookie_manager_service = nullptr;
     StartBehavior start_behavior = MANUAL_START;
     syncer::NetworkTimeUpdateCallback network_time_update_callback;
     base::FilePath base_directory;
     scoped_refptr<net::URLRequestContextGetter> url_request_context;
     std::string debug_identifier;
     version_info::Channel channel = version_info::Channel::UNKNOWN;
     scoped_refptr<base::SingleThreadTaskRunner> db_thread;
     scoped_refptr<base::SingleThreadTaskRunner> file_thread;
     base::SequencedWorkerPool* blocking_pool = nullptr;
 
    private:
     DISALLOW_COPY_AND_ASSIGN(InitParams);
   };
 
   explicit ProfileSyncService(InitParams init_params);
 
   ~ProfileSyncService() override;
 
   // Initializes the object. This must be called at most once, and
   // immediately after an object of this class is constructed.
   void Initialize();
 
-  // sync_driver::SyncService implementation
+  // syncer::SyncService implementation
   bool IsFirstSetupComplete() const override;
   bool IsSyncAllowed() const override;
   bool IsSyncActive() const override;
   void TriggerRefresh(const syncer::ModelTypeSet& types) override;
   void OnDataTypeRequestsSyncStartup(syncer::ModelType type) override;
   bool CanSyncStart() const override;
   void RequestStop(SyncStopDataFate data_fate) override;
   void RequestStart() override;
   syncer::ModelTypeSet GetActiveDataTypes() const override;
-  sync_driver::SyncClient* GetSyncClient() const override;
+  syncer::SyncClient* GetSyncClient() const override;
   syncer::ModelTypeSet GetPreferredDataTypes() const override;
   void OnUserChoseDatatypes(bool sync_everything,
                             syncer::ModelTypeSet chosen_types) override;
   void SetFirstSetupComplete() override;
   bool IsFirstSetupInProgress() const override;
-  std::unique_ptr<sync_driver::SyncSetupInProgressHandle>
-  GetSetupInProgressHandle() override;
+  std::unique_ptr<syncer::SyncSetupInProgressHandle> GetSetupInProgressHandle()
+      override;
   bool IsSetupInProgress() const override;
   bool ConfigurationDone() const override;
   const GoogleServiceAuthError& GetAuthError() const override;
   bool HasUnrecoverableError() const override;
   bool IsBackendInitialized() const override;
   sync_sessions::OpenTabsUIDelegate* GetOpenTabsUIDelegate() override;
   bool IsPassphraseRequiredForDecryption() const override;
   base::Time GetExplicitPassphraseTime() const override;
   bool IsUsingSecondaryPassphrase() const override;
   void EnableEncryptEverything() override;
   bool IsEncryptEverythingEnabled() const override;
   void SetEncryptionPassphrase(const std::string& passphrase,
                                PassphraseType type) override;
   bool SetDecryptionPassphrase(const std::string& passphrase) override
       WARN_UNUSED_RESULT;
   bool IsCryptographerReady(
       const syncer::BaseTransaction* trans) const override;
   syncer::UserShare* GetUserShare() const override;
-  sync_driver::LocalDeviceInfoProvider* GetLocalDeviceInfoProvider()
-      const override;
-  void AddObserver(sync_driver::SyncServiceObserver* observer) override;
-  void RemoveObserver(sync_driver::SyncServiceObserver* observer) override;
-  bool HasObserver(
-      const sync_driver::SyncServiceObserver* observer) const override;
-  void RegisterDataTypeController(
-      std::unique_ptr<sync_driver::DataTypeController> data_type_controller)
-      override;
+  syncer::LocalDeviceInfoProvider* GetLocalDeviceInfoProvider() const override;
+  void AddObserver(syncer::SyncServiceObserver* observer) override;
+  void RemoveObserver(syncer::SyncServiceObserver* observer) override;
+  bool HasObserver(const syncer::SyncServiceObserver* observer) const override;
+  void RegisterDataTypeController(std::unique_ptr<syncer::DataTypeController>
+                                      data_type_controller) override;
   void ReenableDatatype(syncer::ModelType type) override;
   SyncTokenStatus GetSyncTokenStatus() const override;
   std::string QuerySyncStatusSummaryString() override;
   bool QueryDetailedSyncStatus(syncer::SyncStatus* result) override;
   base::string16 GetLastSyncedTimeString() const override;
   std::string GetBackendInitializationStateString() const override;
   syncer::SyncCycleSnapshot GetLastCycleSnapshot() const override;
   base::Value* GetTypeStatusMap() const override;
   const GURL& sync_service_url() const override;
   std::string unrecoverable_error_message() const override;
   tracked_objects::Location unrecoverable_error_location() const override;
-  void AddProtocolEventObserver(ProtocolEventObserver* observer) override;
-  void RemoveProtocolEventObserver(ProtocolEventObserver* observer) override;
+  void AddProtocolEventObserver(
+      syncer::ProtocolEventObserver* observer) override;
+  void RemoveProtocolEventObserver(
+      syncer::ProtocolEventObserver* observer) override;
   void AddTypeDebugInfoObserver(
       syncer::TypeDebugInfoObserver* observer) override;
   void RemoveTypeDebugInfoObserver(
       syncer::TypeDebugInfoObserver* observer) override;
   base::WeakPtr<syncer::JsController> GetJsController() override;
   void GetAllNodes(const base::Callback<void(std::unique_ptr<base::ListValue>)>&
                        callback) override;
 
   // Add a sync type preference provider. Each provider may only be added once.
-  void AddPreferenceProvider(SyncTypePreferenceProvider* provider);
+  void AddPreferenceProvider(syncer::SyncTypePreferenceProvider* provider);
   // Remove a sync type preference provider. May only be called for providers
   // that have been added. Providers must not remove themselves while being
   // called back.
-  void RemovePreferenceProvider(SyncTypePreferenceProvider* provider);
+  void RemovePreferenceProvider(syncer::SyncTypePreferenceProvider* provider);
   // Check whether a given sync type preference provider has been added.
-  bool HasPreferenceProvider(SyncTypePreferenceProvider* provider) const;
+  bool HasPreferenceProvider(
+      syncer::SyncTypePreferenceProvider* provider) const;
 
   void RegisterAuthNotifications();
   void UnregisterAuthNotifications();
 
   // Returns the SyncableService for syncer::SESSIONS.
   virtual syncer::SyncableService* GetSessionsSyncableService();
 
   // Returns the SyncableService for syncer::DEVICE_INFO.
   virtual syncer::SyncableService* GetDeviceInfoSyncableService();
 
   // Returns the ModelTypeService for syncer::DEVICE_INFO.
-  virtual syncer_v2::ModelTypeService* GetDeviceInfoService();
+  virtual syncer::ModelTypeService* GetDeviceInfoService();
 
   // Returns synced devices tracker.
-  virtual sync_driver::DeviceInfoTracker* GetDeviceInfoTracker() const;
+  virtual syncer::DeviceInfoTracker* GetDeviceInfoTracker() const;
 
   // Fills state_map with a map of current data types that are possible to
   // sync, as well as their states.
   void GetDataTypeControllerStates(
-      sync_driver::DataTypeController::StateMap* state_map) const;
+      syncer::DataTypeController::StateMap* state_map) const;
 
   // Called when asynchronous session restore has completed.
   void OnSessionRestoreComplete();
 
   // SyncFrontend implementation.
   void OnBackendInitialized(
       const syncer::WeakHandle<syncer::JsBackend>& js_backend,
       const syncer::WeakHandle<syncer::DataTypeDebugInfoListener>&
           debug_info_listener,
       const std::string& cache_guid,
@@ skipping 18 matching lines @@
                                bool encrypt_everything) override;
   void OnEncryptionComplete() override;
   void OnMigrationNeededForTypes(syncer::ModelTypeSet types) override;
   void OnExperimentsChanged(const syncer::Experiments& experiments) override;
   void OnActionableError(const syncer::SyncProtocolError& error) override;
   void OnLocalSetPassphraseEncryption(
       const syncer::SyncEncryptionHandler::NigoriState& nigori_state) override;
 
   // DataTypeManagerObserver implementation.
   void OnConfigureDone(
-      const sync_driver::DataTypeManager::ConfigureResult& result) override;
+      const syncer::DataTypeManager::ConfigureResult& result) override;
   void OnConfigureStart() override;
 
   // DataTypeEncryptionHandler implementation.
   bool IsPassphraseRequired() const override;
   syncer::ModelTypeSet GetEncryptedDataTypes() const override;
 
   // SigninManagerBase::Observer implementation.
   void GoogleSigninSucceeded(const std::string& account_id,
                              const std::string& username,
                              const std::string& password) override;
@@ skipping 55 matching lines @@
   // TODO(akalin): These two functions are used only by
   // ProfileSyncServiceHarness.  Figure out a different way to expose
   // this info to that class, and remove these functions.
 
   // Returns whether or not the underlying sync engine has made any
   // local changes to items that have not yet been synced with the
   // server.
   bool HasUnsyncedItems() const;
 
   // Used by ProfileSyncServiceHarness.  May return NULL.
-  BackendMigrator* GetBackendMigratorForTest();
+  syncer::BackendMigrator* GetBackendMigratorForTest();
 
   // Used by tests to inspect interaction with OAuth2TokenService.
   bool IsRetryingAccessTokenFetchForTest() const;
 
   // Used by tests to inspect the OAuth2 access tokens used by PSS.
   std::string GetAccessTokenForTest() const;
 
   // TODO(sync): This is only used in tests.  Can we remove it?
   void GetModelSafeRoutingInfo(syncer::ModelSafeRoutingInfo* out) const;
 
@@ skipping 31 matching lines @@
   virtual bool IsEncryptEverythingAllowed() const;
 
   // Sets whether encrypting all the sync data is allowed or not.
   virtual void SetEncryptEverythingAllowed(bool allowed);
 
   // Returns true if the syncer is waiting for new datatypes to be encrypted.
   virtual bool encryption_pending() const;
 
   SigninManagerBase* signin() const;
 
-  SyncErrorController* sync_error_controller() {
+  syncer::SyncErrorController* sync_error_controller() {
     return sync_error_controller_.get();
   }
 
   // TODO(sync): This is only used in tests.  Can we remove it?
-  const sync_driver::DataTypeStatusTable& data_type_status_table() const;
+  const syncer::DataTypeStatusTable& data_type_status_table() const;
 
-  sync_driver::DataTypeManager::ConfigureStatus configure_status() {
+  syncer::DataTypeManager::ConfigureStatus configure_status() {
     return configure_status_;
   }
 
   // If true, the ProfileSyncService has detected that a new GAIA signin has
   // succeeded, and is waiting for initialization to complete. This is used by
   // the UI to differentiate between a new auth error (encountered as part of
   // the initialization process) and a pre-existing auth error that just hasn't
   // been cleared yet. Virtual for testing purposes.
   virtual bool waiting_for_auth() const;
 
@@ skipping 71 matching lines @@
                                 const std::string& message,
                                 bool delete_sync_database);
 
   // This is a cache of the last authentication response we received from the
   // sync server. The UI queries this to display appropriate messaging to the
   // user.
   GoogleServiceAuthError last_auth_error_;
 
   // Our asynchronous backend to communicate with sync components living on
   // other threads.
-  std::unique_ptr<SyncBackendHost> backend_;
+  std::unique_ptr<syncer::SyncBackendHost> backend_;
 
   // Was the last SYNC_PASSPHRASE_REQUIRED notification sent because it
   // was required for encryption, decryption with a cached passphrase, or
   // because a new passphrase is required?
   syncer::PassphraseRequiredReason passphrase_required_reason_;
 
  private:
   enum UnrecoverableErrorReason {
     ERROR_REASON_UNSET,
     ERROR_REASON_SYNCER,
@@ skipping 153 matching lines @@
   void OnClearServerDataDone();
 
   // True if setup has been completed at least once and is not in progress.
   bool CanConfigureDataTypes() const;
 
   // Called when a SetupInProgressHandle issued by this instance is destroyed.
   virtual void OnSetupInProgressHandleDestroyed();
 
   // This profile's SyncClient, which abstracts away non-Sync dependencies and
   // the Sync API component factory.
-  std::unique_ptr<sync_driver::SyncClient> sync_client_;
+  std::unique_ptr<syncer::SyncClient> sync_client_;
 
   // The class that handles getting, setting, and persisting sync
   // preferences.
-  sync_driver::SyncPrefs sync_prefs_;
+  syncer::SyncPrefs sync_prefs_;
 
   // TODO(ncarter): Put this in a profile, once there is UI for it.
   // This specifies where to find the sync server.
   const GURL sync_service_url_;
 
   // 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_;
 
@@ skipping 20 matching lines @@
 
   // Indicates if this is the first time sync is being configured.  This value
   // is equal to !IsFirstSetupComplete() at the time of OnBackendInitialized().
   bool is_first_time_sync_configure_;
 
   // Number of UIs currently configuring the Sync service. When this number
   // is decremented back to zero, Sync setup is marked no longer in progress.
   int outstanding_setup_in_progress_handles_ = 0;
 
   // List of available data type controllers.
-  sync_driver::DataTypeController::TypeMap data_type_controllers_;
+  syncer::DataTypeController::TypeMap data_type_controllers_;
 
   // Whether the SyncBackendHost has been initialized.
   bool backend_initialized_;
 
   // Set when sync receives DISABLED_BY_ADMIN error from server. Prevents
   // ProfileSyncService from starting backend till browser restarted or user
   // signed out.
   bool sync_disabled_by_admin_;
 
   // Set to true if a signin has completed but we're still waiting for the
   // backend to refresh its credentials.
   bool is_auth_in_progress_;
 
   // Encapsulates user signin - used to set/get the user's authenticated
   // email address.
   const std::unique_ptr<SigninManagerWrapper> signin_;
 
   // Information describing an unrecoverable error.
   UnrecoverableErrorReason unrecoverable_error_reason_;
   std::string unrecoverable_error_message_;
   tracked_objects::Location unrecoverable_error_location_;
 
   // Manages the start and stop of the data types.
-  std::unique_ptr<sync_driver::DataTypeManager> data_type_manager_;
+  std::unique_ptr<syncer::DataTypeManager> data_type_manager_;
 
-  base::ObserverList<sync_driver::SyncServiceObserver> observers_;
-  base::ObserverList<ProtocolEventObserver> protocol_event_observers_;
+  base::ObserverList<syncer::SyncServiceObserver> observers_;
+  base::ObserverList<syncer::ProtocolEventObserver> protocol_event_observers_;
   base::ObserverList<syncer::TypeDebugInfoObserver> type_debug_info_observers_;
 
-  std::set<SyncTypePreferenceProvider*> preference_providers_;
+  std::set<syncer::SyncTypePreferenceProvider*> preference_providers_;
 
   syncer::SyncJsController sync_js_controller_;
 
   // 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_;
 
   // Sometimes we need to temporarily hold on to a passphrase because we don't
   // yet have a backend to send it to.  This happens during initialization as
   // we don't StartUp until we have a valid token, which happens after valid
   // credentials were provided.
   std::string cached_passphrase_;
 
   // The current set of encrypted types.  Always a superset of
   // syncer::Cryptographer::SensitiveTypes().
   syncer::ModelTypeSet encrypted_types_;
 
   // Whether encrypting everything is allowed.
   bool encrypt_everything_allowed_;
 
   // 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_;
 
-  std::unique_ptr<BackendMigrator> migrator_;
+  std::unique_ptr<syncer::BackendMigrator> migrator_;
 
   // This is the last |SyncProtocolError| we received from the server that had
   // an action set on it.
   syncer::SyncProtocolError last_actionable_error_;
 
   // Exposes sync errors to the UI.
-  std::unique_ptr<SyncErrorController> sync_error_controller_;
+  std::unique_ptr<syncer::SyncErrorController> sync_error_controller_;
 
   // Tracks the set of failed data types (those that encounter an error
   // or must delay loading for some reason).
-  sync_driver::DataTypeStatusTable data_type_status_table_;
+  syncer::DataTypeStatusTable data_type_status_table_;
 
-  sync_driver::DataTypeManager::ConfigureStatus configure_status_;
+  syncer::DataTypeManager::ConfigureStatus configure_status_;
 
   // 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:
@@ skipping 23 matching lines @@
   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_;
 
   // The gaia cookie manager. Used for monitoring cookie jar changes to detect
   // when the user signs out of the content area.
   GaiaCookieManagerService* const gaia_cookie_manager_service_;
 
-  std::unique_ptr<sync_driver::LocalDeviceInfoProvider> local_device_;
+  std::unique_ptr<syncer::LocalDeviceInfoProvider> local_device_;
 
   // Locally owned SyncableService and ModelTypeService implementations.
   std::unique_ptr<sync_sessions::SessionsSyncManager> sessions_sync_manager_;
-  std::unique_ptr<sync_driver::DeviceInfoSyncService> device_info_sync_service_;
-  std::unique_ptr<sync_driver_v2::DeviceInfoService> device_info_service_;
+  std::unique_ptr<syncer::DeviceInfoSyncService> device_info_sync_service_;
+  std::unique_ptr<syncer::DeviceInfoService> device_info_service_;
 
   std::unique_ptr<syncer::NetworkResources> network_resources_;
 
   StartBehavior start_behavior_;
-  std::unique_ptr<StartupController> startup_controller_;
+  std::unique_ptr<syncer::StartupController> startup_controller_;
 
   // The full path to the sync data directory.
   base::FilePath directory_path_;
 
-  std::unique_ptr<SyncStoppedReporter> sync_stopped_reporter_;
+  std::unique_ptr<syncer::SyncStoppedReporter> sync_stopped_reporter_;
 
   // Listens for the system being under memory pressure.
   std::unique_ptr<base::MemoryPressureListener> memory_pressure_listener_;
 
   // Nigori state after user switching to custom passphrase, saved until
   // transition steps complete. It will be injected into new backend after sync
   // restart.
   std::unique_ptr<syncer::SyncEncryptionHandler::NigoriState>
       saved_nigori_state_;
 
@@ skipping 23 matching lines @@
   base::WeakPtrFactory<ProfileSyncService> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ProfileSyncService);
 };
 
 bool ShouldShowActionOnUI(const syncer::SyncProtocolError& error);
 
 }  // namespace browser_sync
 
 #endif  // COMPONENTS_BROWSER_SYNC_PROFILE_SYNC_SERVICE_H_