[Sync] Fix namespaces for the browser_sync component.

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 43 matching lines @@
 #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 browser_sync {
-class BackendMigrator;
-}  // namespace browser_sync
-
 namespace sync_driver {
 class DataTypeManager;
 class DeviceInfoSyncService;
 class DeviceInfoTracker;
 class LocalDeviceInfoProvider;
 class SyncApiComponentFactory;
 class SyncClient;
 }  // namespace sync_driver
 
 namespace sync_driver_v2 {
@@ skipping 14 matching lines @@
 struct StatusCounters;
 struct SyncCredentials;
 struct UpdateCounters;
 struct UserShare;
 }  // namespace syncer
 
 namespace sync_pb {
 class EncryptedData;
 }  // namespace sync_pb
 
+namespace browser_sync {
+

[skym, 2016/09/22 17:25:59]

Should this newline be here?

[maxbogue, 2016/09/22 19:41:15]

Yes.

+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 70 matching lines @@
                            public sync_driver::SyncFrontend,
                            public sync_driver::SyncPrefObserver,
                            public sync_driver::DataTypeManagerObserver,
                            public syncer::UnrecoverableErrorHandler,
                            public KeyedService,
                            public OAuth2TokenService::Consumer,
                            public OAuth2TokenService::Observer,
                            public SigninManagerBase::Observer,
                            public GaiaCookieManagerService::Observer {
  public:
-  typedef browser_sync::SyncBackendHost::Status Status;
+  typedef 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 115 matching lines @@
   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(
-      browser_sync::ProtocolEventObserver* observer) override;
-  void RemoveProtocolEventObserver(
-      browser_sync::ProtocolEventObserver* observer) override;
+  void AddProtocolEventObserver(ProtocolEventObserver* observer) override;
+  void RemoveProtocolEventObserver(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);
@@ skipping 130 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.
-  browser_sync::BackendMigrator* GetBackendMigratorForTest();
+  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 130 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<browser_sync::SyncBackendHost> backend_;
+  std::unique_ptr<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 20 matching lines @@
     NOT_SIGNED_IN,            // There is no signed in user.
     NOT_REQUESTED,            // The user turned off sync.
     NOT_REQUESTED_NOT_SETUP,  // The user turned off sync and setup completed
                               // is false. Might indicate a stop-and-clear.
     NEEDS_CONFIRMATION,       // The user must confirm sync settings.
     IS_MANAGED,               // Sync is disallowed by enterprise policy.
     NOT_ALLOWED_BY_PLATFORM,  // Sync is disallowed by the platform.
     SYNC_INITIAL_STATE_LIMIT
   };
 
-  friend class ProfileSyncServicePasswordTest;
-  friend class SyncTest;
   friend class TestProfileSyncService;
-  FRIEND_TEST_ALL_PREFIXES(ProfileSyncServiceTest, InitialState);
 
   // Stops the sync engine. Does NOT set IsSyncRequested to false. Use
   // RequestStop for that. |data_fate| controls whether the local sync data is
   // deleted or kept when the engine shuts down.
   void StopImpl(SyncStopDataFate data_fate);
 
   // Update the last auth error and notify observers of error state.
   void UpdateAuthErrorState(const GoogleServiceAuthError& error);
 
   // Puts the backend's sync scheduler into NORMAL mode.
@@ skipping 184 matching lines @@
 
   // 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_;
 
   base::ObserverList<sync_driver::SyncServiceObserver> observers_;
-  base::ObserverList<browser_sync::ProtocolEventObserver>
-      protocol_event_observers_;
+  base::ObserverList<ProtocolEventObserver> protocol_event_observers_;
   base::ObserverList<syncer::TypeDebugInfoObserver> type_debug_info_observers_;
 
   std::set<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_;
@@ skipping 12 matching lines @@
   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<browser_sync::BackendMigrator> migrator_;
+  std::unique_ptr<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_;
 
   // Tracks the set of failed data types (those that encounter an error
   // or must delay loading for some reason).
@@ skipping 46 matching lines @@
   std::unique_ptr<sync_driver::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::NetworkResources> network_resources_;
 
   StartBehavior start_behavior_;
-  std::unique_ptr<browser_sync::StartupController> startup_controller_;
+  std::unique_ptr<StartupController> startup_controller_;
 
   // The full path to the sync data directory.
   base::FilePath directory_path_;
 
-  std::unique_ptr<browser_sync::SyncStoppedReporter> sync_stopped_reporter_;
+  std::unique_ptr<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 20 matching lines @@
   // This weak factory invalidates its issued pointers when Sync is disabled.
   base::WeakPtrFactory<ProfileSyncService> sync_enabled_weak_factory_;
 
   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_