[Sync] Fix namespace for sync_driver component

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>
@@ skipping 44 matching lines @@
 class ProfileSyncComponentsFactory;
 class SupervisedUserSigninManagerWrapper;
 class SyncErrorController;
 
 namespace base {
 class CommandLine;
 };
 
 namespace browser_sync {
 class BackendMigrator;
-class ChangeProcessor;
-class DataTypeManager;
 class DeviceInfo;
 class FaviconCache;
 class JsController;
 class OpenTabsUIDelegate;
 
 namespace sessions {
 class SyncSessionSnapshot;
 }  // namespace sessions
 }  // namespace browser_sync
 
+namespace sync_driver {
+class ChangeProcessor;
+class DataTypeManager;
+}

[maxbogue, 2014/07/21 22:14:21]

// namespace sync_driver

[Nicolas Zea, 2014/07/21 22:23:31]

Done.

+
 namespace syncer {
 class BaseTransaction;
 class NetworkResources;
 struct CommitCounters;
 struct StatusCounters;
 struct SyncCredentials;
 struct UpdateCounters;
 struct UserShare;
 }  // namespace syncer
 
@@ skipping 80 matching lines @@
 //   SetSetupInProgress(false) should be called when configuration is complete.
 //   When SetSyncSetupCompleted() == false, but SetSetupInProgress(true) has
 //   been called, then the sync engine knows not to download any user data.
 //
 //   When initial sync is complete, the UI code should call
 //   SetSyncSetupCompleted() followed by SetSetupInProgress(false) - this will
 //   tell the sync engine that setup is completed and it can begin downloading
 //   data from the sync server.
 //
 class ProfileSyncService : public ProfileSyncServiceBase,
-                           public browser_sync::SyncFrontend,
+                           public sync_driver::SyncFrontend,
                            public sync_driver::SyncPrefObserver,
-                           public browser_sync::DataTypeManagerObserver,
+                           public sync_driver::DataTypeManagerObserver,
                            public syncer::UnrecoverableErrorHandler,
                            public KeyedService,
-                           public browser_sync::DataTypeEncryptionHandler,
+                           public sync_driver::DataTypeEncryptionHandler,
                            public OAuth2TokenService::Consumer,
                            public OAuth2TokenService::Observer,
                            public SessionsSyncManager::SyncInternalApiDelegate,
                            public SigninManagerBase::Observer {
  public:
   typedef browser_sync::SyncBackendHost::Status Status;
 
   // Status of sync server connection, sync token and token request.
   struct SyncTokenStatus {
     SyncTokenStatus();
@@ skipping 127 matching lines @@
 
   // 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);
+      sync_driver::DataTypeController* data_type_controller);
 
   // Registers a type whose sync storage will not be managed by the
   // ProfileSyncService.  It declares that this sync type may be activated at
   // some point in the future.  This function call does not enable or activate
   // the syncing of this type
   void RegisterNonBlockingType(syncer::ModelType type);
 
   // Called by a component that supports non-blocking sync when it is ready to
   // initialize its connection to the sync backend.
   //
@@ skipping 41 matching lines @@
   virtual void AddObserverForDeviceInfoChange(
       browser_sync::SyncedDeviceTracker::Observer* observer);
 
   // Removes the observer from device info notification.
   virtual void RemoveObserverForDeviceInfoChange(
       browser_sync::SyncedDeviceTracker::Observer* observer);
 
   // 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;
+    sync_driver::DataTypeController::StateMap* state_map) const;
 
   // Disables sync for user. Use ShowLoginDialog to enable.
   virtual void DisableForUser();
 
   // Disables sync for the user and prevents it from starting on next restart.
   virtual void StopSyncingPermanently();
 
   // SyncFrontend implementation.
   virtual void OnBackendInitialized(
       const syncer::WeakHandle<syncer::JsBackend>& js_backend,
@@ skipping 24 matching lines @@
   virtual void OnEncryptionComplete() OVERRIDE;
   virtual void OnMigrationNeededForTypes(
       syncer::ModelTypeSet types) OVERRIDE;
   virtual void OnExperimentsChanged(
       const syncer::Experiments& experiments) OVERRIDE;
   virtual void OnActionableError(
       const syncer::SyncProtocolError& error) OVERRIDE;
 
   // DataTypeManagerObserver implementation.
   virtual void OnConfigureDone(
-      const browser_sync::DataTypeManager::ConfigureResult& result) OVERRIDE;
+      const sync_driver::DataTypeManager::ConfigureResult& result) OVERRIDE;
   virtual void OnConfigureRetry() OVERRIDE;
   virtual void OnConfigureStart() OVERRIDE;
 
   // DataTypeEncryptionHandler implementation.
   virtual bool IsPassphraseRequired() const OVERRIDE;
   virtual syncer::ModelTypeSet GetEncryptedDataTypes() const OVERRIDE;
 
   // SigninManagerBase::Observer implementation.
   virtual void GoogleSigninSucceeded(const std::string& username,
                                      const std::string& password) OVERRIDE;
@@ skipping 260 matching lines @@
 
   // Marks all currently registered types as "acknowledged" so we won't prompt
   // the user about them any more.
   void AcknowledgeSyncedTypes();
 
   SyncErrorController* sync_error_controller() {
     return sync_error_controller_.get();
   }
 
   // TODO(sync): This is only used in tests.  Can we remove it?
-  const browser_sync::FailedDataTypesHandler& failed_data_types_handler() const;
+  const sync_driver::FailedDataTypesHandler& failed_data_types_handler() const;
 
-  browser_sync::DataTypeManager::ConfigureStatus configure_status() {
+  sync_driver::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 62 matching lines @@
   // Shuts down the backend sync components.
   // |option| indicates if syncing is being disabled or not, and whether
   // to claim ownership of sync thread from backend.
   void ShutdownImpl(browser_sync::SyncBackendHost::ShutdownOption option);
 
   // Return SyncCredentials from the OAuth2TokenService.
   syncer::SyncCredentials GetCredentials();
 
   virtual syncer::WeakHandle<syncer::JsEventHandler> GetJsEventHandler();
 
-  const browser_sync::DataTypeController::TypeMap&
+  const sync_driver::DataTypeController::TypeMap&
       directory_data_type_controllers() {
     return directory_data_type_controllers_;
   }
 
   // Helper method for managing encryption UI.
   bool IsEncryptedDatatypeEnabled() const;
 
   // Helper for OnUnrecoverableError.
   // TODO(tim): Use an enum for |delete_sync_database| here, in ShutdownImpl,
   // and in SyncBackendHost::Shutdown.
@@ skipping 171 matching lines @@
   // 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 for directory types.
-  browser_sync::DataTypeController::TypeMap directory_data_type_controllers_;
+  sync_driver::DataTypeController::TypeMap directory_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 scoped_ptr<SupervisedUserSigninManagerWrapper> 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 directory data types.
-  scoped_ptr<browser_sync::DataTypeManager> directory_data_type_manager_;
+  scoped_ptr<sync_driver::DataTypeManager> directory_data_type_manager_;
 
   // Manager for the non-blocking data types.
-  browser_sync::NonBlockingDataTypeManager non_blocking_data_type_manager_;
+  sync_driver::NonBlockingDataTypeManager non_blocking_data_type_manager_;
 
   ObserverList<ProfileSyncServiceBase::Observer> observers_;
   ObserverList<browser_sync::ProtocolEventObserver> protocol_event_observers_;
   ObserverList<syncer::TypeDebugInfoObserver> type_debug_info_observers_;
 
   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.
@@ skipping 21 matching lines @@
 
   // 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.
   scoped_ptr<SyncErrorController> sync_error_controller_;
 
   // 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_;
+  sync_driver::FailedDataTypesHandler failed_data_types_handler_;
 
-  browser_sync::DataTypeManager::ConfigureStatus configure_status_;
+  sync_driver::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 59 matching lines @@
   scoped_ptr<base::Time> last_backup_time_;
 
   DISALLOW_COPY_AND_ASSIGN(ProfileSyncService);
 };
 
 bool ShouldShowActionOnUI(
     const syncer::SyncProtocolError& error);
 
 
 #endif  // CHROME_BROWSER_SYNC_PROFILE_SYNC_SERVICE_H_