[Sync] Fix namespaces for the browser_sync component.

components/browser_sync/profile_sync_service.cc

 // 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.
 
 #include "components/browser_sync/profile_sync_service.h"
 
 #include <stddef.h>
 
 #include <cstddef>
 #include <map>
@@ skipping 82 matching lines @@
 #include "components/version_info/version_info_values.h"
 #include "net/cookies/cookie_monster.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/l10n/time_format.h"
 
 #if defined(OS_ANDROID)
 #include "components/sync/core/read_transaction.h"
 #endif
 
-using browser_sync::SyncBackendHost;
 using sync_driver::ChangeProcessor;
 using sync_driver::DataTypeController;
 using sync_driver::DataTypeManager;
 using sync_driver::DataTypeStatusTable;
 using sync_driver::DeviceInfoSyncService;
 using sync_driver_v2::DeviceInfoService;
 using sync_sessions::SessionsSyncManager;
 using syncer::ModelType;
 using syncer::ModelTypeSet;
 using syncer::JsBackend;
 using syncer::JsController;
 using syncer::JsEventDetails;
 using syncer::JsEventHandler;
 using syncer::ModelSafeRoutingInfo;
 using syncer::SyncCredentials;
 using syncer::SyncProtocolError;
 using syncer::WeakHandle;
 using syncer_v2::ModelTypeStore;
 using syncer_v2::SharedModelTypeProcessor;
 
+namespace browser_sync {
+
 typedef GoogleServiceAuthError AuthError;
 
 const char kSyncUnrecoverableErrorHistogram[] = "Sync.UnrecoverableErrors";
 
 const net::BackoffEntry::Policy kRequestAccessTokenBackoffPolicy = {
     // Number of initial errors (in sequence) to ignore before applying
     // exponential back-off rules.
     0,
 
     // Initial delay for exponential back-off in ms.
@@ skipping 129 matching lines @@
 
 bool ProfileSyncService::CanSyncStart() const {
   return IsSyncAllowed() && IsSyncRequested() && IsSignedIn();
 }
 
 void ProfileSyncService::Initialize() {
   sync_client_->Initialize();
 
   // We don't pass StartupController an Unretained reference to future-proof
   // against the controller impl changing to post tasks.
-  startup_controller_.reset(new browser_sync::StartupController(
+  startup_controller_.reset(new StartupController(
       &sync_prefs_,
       base::Bind(&ProfileSyncService::CanBackendStart, base::Unretained(this)),
       base::Bind(&ProfileSyncService::StartUpSlowBackendComponents,
                  weak_factory_.GetWeakPtr())));
   std::unique_ptr<sync_sessions::LocalSessionEventRouter> router(
       sync_client_->GetSyncSessionsClient()->GetLocalSessionEventRouter());
   local_device_ = sync_client_->GetSyncApiComponentFactory()
                       ->CreateLocalDeviceInfoProvider();
-  sync_stopped_reporter_.reset(new browser_sync::SyncStoppedReporter(
+  sync_stopped_reporter_.reset(new SyncStoppedReporter(
       sync_service_url_, local_device_->GetSyncUserAgent(),
-      url_request_context_,
-      browser_sync::SyncStoppedReporter::ResultCallback()));
+      url_request_context_, SyncStoppedReporter::ResultCallback()));
   sessions_sync_manager_.reset(new SessionsSyncManager(
       sync_client_->GetSyncSessionsClient(), &sync_prefs_, local_device_.get(),
       std::move(router),
       base::Bind(&ProfileSyncService::NotifyForeignSessionUpdated,
                  sync_enabled_weak_factory_.GetWeakPtr()),
       base::Bind(&ProfileSyncService::TriggerRefresh,
                  sync_enabled_weak_factory_.GetWeakPtr(),
                  syncer::ModelTypeSet(syncer::SESSIONS))));
 
   if (base::FeatureList::IsEnabled(switches::kSyncUSSDeviceInfo)) {
@@ skipping 221 matching lines @@
                      base::Unretained(network_resources_.get()),
                      url_request_context_, network_time_update_callback_);
 
   backend_->Initialize(
       this, std::move(sync_thread_), db_thread_, file_thread_,
       GetJsEventHandler(), sync_service_url_, local_device_->GetSyncUserAgent(),
       credentials, delete_stale_data,
       std::unique_ptr<syncer::SyncManagerFactory>(
           new syncer::SyncManagerFactory()),
       MakeWeakHandle(sync_enabled_weak_factory_.GetWeakPtr()),
-      base::Bind(browser_sync::ChromeReportUnrecoverableError, channel_),
+      base::Bind(ChromeReportUnrecoverableError, channel_),
       http_post_provider_factory_getter, std::move(saved_nigori_state_));
 }
 
 bool ProfileSyncService::IsEncryptedDatatypeEnabled() const {
   if (encryption_pending())
     return true;
   const syncer::ModelTypeSet preferred_types = GetPreferredDataTypes();
   const syncer::ModelTypeSet encrypted_types = GetEncryptedDataTypes();
   DCHECK(encrypted_types.Has(syncer::PASSWORDS));
   return !Intersection(preferred_types, encrypted_types).Empty();
 }
 
 void ProfileSyncService::OnProtocolEvent(const syncer::ProtocolEvent& event) {
-  FOR_EACH_OBSERVER(browser_sync::ProtocolEventObserver,
-                    protocol_event_observers_, OnProtocolEvent(event));
+  FOR_EACH_OBSERVER(ProtocolEventObserver, protocol_event_observers_,
+                    OnProtocolEvent(event));
 }
 
 void ProfileSyncService::OnDirectoryTypeCommitCounterUpdated(
     syncer::ModelType type,
     const syncer::CommitCounters& counters) {
   FOR_EACH_OBSERVER(syncer::TypeDebugInfoObserver, type_debug_info_observers_,
                     OnCommitCountersUpdated(type, counters));
 }
 
 void ProfileSyncService::OnDirectoryTypeUpdateCounterUpdated(
@@ skipping 827 matching lines @@
   // enabled, and yet we still think we require a passphrase for decryption.
   DCHECK(
       !(IsPassphraseRequiredForDecryption() && !IsEncryptedDatatypeEnabled()));
 
   // This must be done before we start syncing with the server to avoid
   // sending unencrypted data up on a first time sync.
   if (encryption_pending_)
     backend_->EnableEncryptEverything();
   NotifyObservers();
 
-  if (migrator_.get() &&
-      migrator_->state() != browser_sync::BackendMigrator::IDLE) {
+  if (migrator_.get() && migrator_->state() != BackendMigrator::IDLE) {
     // Migration in progress.  Let the migrator know we just finished
     // configuring something.  It will be up to the migrator to call
     // StartSyncingWithServer() if migration is now finished.
     migrator_->OnConfigureDone(result);
     return;
   }
 
   if (catch_up_configure_in_progress_) {
     catch_up_configure_in_progress_ = false;
     ClearAndRestartSyncForPassphraseEncryption();
@@ skipping 353 matching lines @@
 
   bool restart = false;
   if (!data_type_manager_) {
     restart = true;
     data_type_manager_.reset(
         sync_client_->GetSyncApiComponentFactory()->CreateDataTypeManager(
             debug_info_listener_, &data_type_controllers_, this, backend_.get(),
             this));
 
     // We create the migrator at the same time.
-    migrator_.reset(new browser_sync::BackendMigrator(
+    migrator_.reset(new BackendMigrator(
         debug_identifier_, GetUserShare(), this, data_type_manager_.get(),
         base::Bind(&ProfileSyncService::StartSyncingWithServer,
                    base::Unretained(this))));
   }
 
   syncer::ModelTypeSet types;
   syncer::ConfigureReason reason = syncer::CONFIGURE_REASON_UNKNOWN;
   types = GetPreferredDataTypes();
   if (restart) {
     // Datatype downloads on restart are generally due to newly supported
@@ skipping 25 matching lines @@
 }
 
 bool ProfileSyncService::HasUnsyncedItems() const {
   if (HasSyncingBackend() && backend_initialized_) {
     return backend_->HasUnsyncedItems();
   }
   NOTREACHED();
   return false;
 }
 
-browser_sync::BackendMigrator* ProfileSyncService::GetBackendMigratorForTest() {
+BackendMigrator* ProfileSyncService::GetBackendMigratorForTest() {
   return migrator_.get();
 }
 
 void ProfileSyncService::GetModelSafeRoutingInfo(
     syncer::ModelSafeRoutingInfo* out) const {
   if (backend_.get() && backend_initialized_) {
     backend_->GetModelSafeRoutingInfo(out);
   } else {
     NOTREACHED();
   }
@@ skipping 287 matching lines @@
     sync_driver::SyncServiceObserver* observer) {
   observers_.AddObserver(observer);
 }
 
 void ProfileSyncService::RemoveObserver(
     sync_driver::SyncServiceObserver* observer) {
   observers_.RemoveObserver(observer);
 }
 
 void ProfileSyncService::AddProtocolEventObserver(
-    browser_sync::ProtocolEventObserver* observer) {
+    ProtocolEventObserver* observer) {
   protocol_event_observers_.AddObserver(observer);
   if (HasSyncingBackend()) {
     backend_->RequestBufferedProtocolEventsAndEnableForwarding();
   }
 }
 
 void ProfileSyncService::RemoveProtocolEventObserver(
-    browser_sync::ProtocolEventObserver* observer) {
+    ProtocolEventObserver* observer) {
   protocol_event_observers_.RemoveObserver(observer);
   if (HasSyncingBackend() &&
       !protocol_event_observers_.might_have_observers()) {
     backend_->DisableProtocolEventForwarding();
   }
 }
 
 void ProfileSyncService::AddTypeDebugInfoObserver(
     syncer::TypeDebugInfoObserver* type_debug_info_observer) {
   type_debug_info_observers_.AddObserver(type_debug_info_observer);
@@ skipping 365 matching lines @@
   if (--outstanding_setup_in_progress_handles_ != 0)
     return;
 
   DCHECK(startup_controller_->IsSetupInProgress());
   startup_controller_->SetSetupInProgress(false);
 
   if (IsBackendInitialized())
     ReconfigureDatatypeManager();
   NotifyObservers();
 }
+
+}  // namespace browser_sync