[Sync] Move ModelType and related classes to 'syncer' namespace

chrome/browser/sync/glue/sync_backend_host.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 "build/build_config.h"
 
 #include "chrome/browser/sync/glue/sync_backend_host.h"
 
 #include <algorithm>
 #include <map>
@@ skipping 80 matching lines @@
       syncer::ConnectionStatus status) OVERRIDE;
   virtual void OnPassphraseRequired(
       syncer::PassphraseRequiredReason reason,
       const sync_pb::EncryptedData& pending_keys) OVERRIDE;
   virtual void OnPassphraseAccepted() OVERRIDE;
   virtual void OnBootstrapTokenUpdated(
       const std::string& bootstrap_token) OVERRIDE;
   virtual void OnStopSyncingPermanently() OVERRIDE;
   virtual void OnUpdatedToken(const std::string& token) OVERRIDE;
   virtual void OnEncryptedTypesChanged(
-      syncable::ModelTypeSet encrypted_types,
+      syncer::ModelTypeSet encrypted_types,
       bool encrypt_everything) OVERRIDE;
   virtual void OnEncryptionComplete() OVERRIDE;
   virtual void OnActionableError(
       const syncer::SyncProtocolError& sync_error) OVERRIDE;
 
   // Note:
   //
   // The Do* methods are the various entry points from our
   // SyncBackendHost.  They are all called on the sync thread to
   // actually perform synchronous (and potentially blocking) syncapi
   // operations.
   //
   // Called to perform initialization of the syncapi on behalf of
   // SyncBackendHost::Initialize.
   void DoInitialize(const DoInitializeOptions& options);
 
   // Called to perform credential update on behalf of
   // SyncBackendHost::UpdateCredentials
   void DoUpdateCredentials(const syncer::SyncCredentials& credentials);
 
   // Called when the user disables or enables a sync type.
-  void DoUpdateEnabledTypes(const syncable::ModelTypeSet& enabled_types);
+  void DoUpdateEnabledTypes(const syncer::ModelTypeSet& enabled_types);
 
   // Called to tell the syncapi to start syncing (generally after
   // initialization and authentication).
   void DoStartSyncing(const syncer::ModelSafeRoutingInfo& routing_info);
 
   // Called to cleanup disabled types.
   void DoRequestCleanupDisabledTypes(
       const syncer::ModelSafeRoutingInfo& routing_info);
 
   // Called to set the passphrase for encryption.
@@ skipping 20 matching lines @@
   //    to run and make use of cached pointers to various components
   //    owned implicitly by us.
   // 3) Destroy this Core. That will delete syncapi components in a
   //    safe order because the thread that was using them has exited
   //    (in step 2).
   void DoStopSyncManagerForShutdown(const base::Closure& closure);
   void DoShutdown(bool stopping_sync);
 
   virtual void DoRequestConfig(
       const syncer::ModelSafeRoutingInfo& routing_info,
-      syncable::ModelTypeSet types_to_config,
+      syncer::ModelTypeSet types_to_config,
       syncer::ConfigureReason reason);
 
   // Start the configuration mode.  |callback| is called on the sync
   // thread.
   virtual void DoStartConfiguration(const base::Closure& callback);
 
   // Set the base request context to use when making HTTP calls.
   // This method will add a reference to the context to persist it
   // on the IO thread. Must be removed from IO thread.
 
@@ skipping 184 matching lines @@
     const scoped_refptr<net::URLRequestContextGetter>& getter) {
   return new syncer::HttpBridgeFactory(getter, MakeUserAgentForSyncApi());
 }
 
 }  // namespace
 
 void SyncBackendHost::Initialize(
     SyncFrontend* frontend,
     const syncer::WeakHandle<syncer::JsEventHandler>& event_handler,
     const GURL& sync_service_url,
-    syncable::ModelTypeSet initial_types,
+    syncer::ModelTypeSet initial_types,
     const SyncCredentials& credentials,
     bool delete_sync_data_folder,
     syncer::UnrecoverableErrorHandler* unrecoverable_error_handler,
     syncer::ReportUnrecoverableErrorFunction
         report_unrecoverable_error_function) {
   if (!sync_thread_.Start())
     return;
 
   frontend_ = frontend;
   DCHECK(frontend);
 
-  syncable::ModelTypeSet initial_types_with_nigori(initial_types);
+  syncer::ModelTypeSet initial_types_with_nigori(initial_types);
   CHECK(sync_prefs_.get());
   if (sync_prefs_->HasSyncSetupCompleted()) {
-    initial_types_with_nigori.Put(syncable::NIGORI);
+    initial_types_with_nigori.Put(syncer::NIGORI);
   }
 
   registrar_.reset(new SyncBackendRegistrar(initial_types_with_nigori,
                                             name_,
                                             profile_,
                                             sync_thread_.message_loop()));
   syncer::ModelSafeRoutingInfo routing_info;
   std::vector<syncer::ModelSafeWorker*> workers;
   registrar_->GetModelSafeRoutingInfo(&routing_info);
   registrar_->GetWorkers(&workers);
@@ skipping 21 matching lines @@
 
 void SyncBackendHost::UpdateCredentials(const SyncCredentials& credentials) {
   sync_thread_.message_loop()->PostTask(FROM_HERE,
       base::Bind(&SyncBackendHost::Core::DoUpdateCredentials, core_.get(),
                  credentials));
 }
 
 void SyncBackendHost::StartSyncingWithServer() {
   SDVLOG(1) << "SyncBackendHost::StartSyncingWithServer called.";
 
- syncer::ModelSafeRoutingInfo routing_info;
+  syncer::ModelSafeRoutingInfo routing_info;
   registrar_->GetModelSafeRoutingInfo(&routing_info);
 
   sync_thread_.message_loop()->PostTask(FROM_HERE,
       base::Bind(&SyncBackendHost::Core::DoStartSyncing,
                  core_.get(), routing_info));
 }
 
 void SyncBackendHost::SetEncryptionPassphrase(const std::string& passphrase,
                                               bool is_explicit) {
   if (!IsNigoriEnabled()) {
@@ skipping 142 matching lines @@
   UMA_HISTOGRAM_TIMES("Sync.Shutdown.StopSyncThreadTime",
                       stop_sync_thread_time);
 
   registrar_.reset();
   frontend_ = NULL;
   core_ = NULL;  // Releases reference to core_.
 }
 
 void SyncBackendHost::ConfigureDataTypes(
     syncer::ConfigureReason reason,
-    syncable::ModelTypeSet types_to_add,
-    syncable::ModelTypeSet types_to_remove,
+    syncer::ModelTypeSet types_to_add,
+    syncer::ModelTypeSet types_to_remove,
     NigoriState nigori_state,
-    base::Callback<void(syncable::ModelTypeSet)> ready_task,
+    base::Callback<void(syncer::ModelTypeSet)> ready_task,
     base::Callback<void()> retry_callback) {
-  syncable::ModelTypeSet types_to_add_with_nigori = types_to_add;
-  syncable::ModelTypeSet types_to_remove_with_nigori = types_to_remove;
+  syncer::ModelTypeSet types_to_add_with_nigori = types_to_add;
+  syncer::ModelTypeSet types_to_remove_with_nigori = types_to_remove;
   if (nigori_state == WITH_NIGORI) {
-    types_to_add_with_nigori.Put(syncable::NIGORI);
-    types_to_remove_with_nigori.Remove(syncable::NIGORI);
+    types_to_add_with_nigori.Put(syncer::NIGORI);
+    types_to_remove_with_nigori.Remove(syncer::NIGORI);
   } else {
-    types_to_add_with_nigori.Remove(syncable::NIGORI);
-    types_to_remove_with_nigori.Put(syncable::NIGORI);
+    types_to_add_with_nigori.Remove(syncer::NIGORI);
+    types_to_remove_with_nigori.Put(syncer::NIGORI);
   }
   // Only one configure is allowed at a time.
   DCHECK(!pending_config_mode_state_.get());
   DCHECK(!pending_download_state_.get());
   DCHECK_GT(initialization_state_, NOT_INITIALIZED);
 
   pending_config_mode_state_.reset(new PendingConfigureDataTypesState());
   pending_config_mode_state_->ready_task = ready_task;
   pending_config_mode_state_->types_to_add = types_to_add_with_nigori;
   pending_config_mode_state_->added_types =
       registrar_->ConfigureDataTypes(types_to_add_with_nigori,
                                      types_to_remove_with_nigori);
   pending_config_mode_state_->reason = reason;
   pending_config_mode_state_->retry_callback = retry_callback;
 
   // Cleanup disabled types before starting configuration so that
   // callers can assume that the data types are cleaned up once
   // configuration is done.
   if (!types_to_remove_with_nigori.Empty()) {
-   syncer::ModelSafeRoutingInfo routing_info;
+    syncer::ModelSafeRoutingInfo routing_info;
     registrar_->GetModelSafeRoutingInfo(&routing_info);
     sync_thread_.message_loop()->PostTask(
         FROM_HERE,
         base::Bind(&SyncBackendHost::Core::DoRequestCleanupDisabledTypes,
                    core_.get(),
                    routing_info));
   }
 
   StartConfiguration(
       base::Bind(&SyncBackendHost::Core::FinishConfigureDataTypes,
                  core_.get()));
 }
 
 void SyncBackendHost::StartConfiguration(const base::Closure& callback) {
   // Put syncer in the config mode. DTM will put us in normal mode once it is
   // done. This is to ensure we dont do a normal sync when we are doing model
   // association.
   sync_thread_.message_loop()->PostTask(FROM_HERE, base::Bind(
       &SyncBackendHost::Core::DoStartConfiguration, core_.get(), callback));
 }
 
 void SyncBackendHost::EnableEncryptEverything() {
   sync_thread_.message_loop()->PostTask(FROM_HERE,
      base::Bind(&SyncBackendHost::Core::DoEnableEncryptEverything,
                 core_.get()));
 }
 
 void SyncBackendHost::ActivateDataType(
-    syncable::ModelType type, syncer::ModelSafeGroup group,
+    syncer::ModelType type, syncer::ModelSafeGroup group,
     ChangeProcessor* change_processor) {
   registrar_->ActivateDataType(type, group, change_processor, GetUserShare());
 }
 
-void SyncBackendHost::DeactivateDataType(syncable::ModelType type) {
+void SyncBackendHost::DeactivateDataType(syncer::ModelType type) {
   registrar_->DeactivateDataType(type);
 }
 
 syncer::UserShare* SyncBackendHost::GetUserShare() const {
   DCHECK(initialized());
   return core_->sync_manager()->GetUserShare();
 }
 
 SyncBackendHost::Status SyncBackendHost::GetDetailedStatus() {
   DCHECK(initialized());
@@ skipping 21 matching lines @@
   return IsNigoriEnabled() &&
       core_->sync_manager()->IsUsingExplicitPassphrase();
 }
 
 bool SyncBackendHost::IsCryptographerReady(
     const syncer::BaseTransaction* trans) const {
   return initialized() && trans->GetCryptographer()->is_ready();
 }
 
 void SyncBackendHost::GetModelSafeRoutingInfo(
-   syncer::ModelSafeRoutingInfo* out) const {
+    syncer::ModelSafeRoutingInfo* out) const {
   if (initialized()) {
     CHECK(registrar_.get());
     registrar_->GetModelSafeRoutingInfo(out);
   } else {
     NOTREACHED();
   }
 }
 
 void SyncBackendHost::InitCore(const DoInitializeOptions& options) {
   sync_thread_.message_loop()->PostTask(FROM_HERE,
       base::Bind(&SyncBackendHost::Core::DoInitialize, core_.get(), options));
 }
 
 void SyncBackendHost::HandleSyncCycleCompletedOnFrontendLoop(
     const SyncSessionSnapshot& snapshot) {
   if (!frontend_)
     return;
   DCHECK_EQ(MessageLoop::current(), frontend_loop_);
 
   last_snapshot_ = snapshot;
 
   SDVLOG(1) << "Got snapshot " << snapshot.ToString();
 
-  const syncable::ModelTypeSet to_migrate =
+  const syncer::ModelTypeSet to_migrate =
       snapshot.model_neutral_state().types_needing_local_migration;
   if (!to_migrate.Empty())
     frontend_->OnMigrationNeededForTypes(to_migrate);
 
   // Process any changes to the datatypes we're syncing.
   // TODO(sync): add support for removing types.
   if (initialized())
     AddExperimentalTypes();
 
   // If we are waiting for a configuration change, check here to see
   // if this sync cycle has initialized all of the types we've been
   // waiting for.
   if (pending_download_state_.get()) {
-    const syncable::ModelTypeSet types_to_add =
+    const syncer::ModelTypeSet types_to_add =
         pending_download_state_->types_to_add;
-    const syncable::ModelTypeSet added_types =
+    const syncer::ModelTypeSet added_types =
         pending_download_state_->added_types;
     DCHECK(types_to_add.HasAll(added_types));
-    const syncable::ModelTypeSet initial_sync_ended =
+    const syncer::ModelTypeSet initial_sync_ended =
         snapshot.initial_sync_ended();
-    const syncable::ModelTypeSet failed_configuration_types =
+    const syncer::ModelTypeSet failed_configuration_types =
         Difference(added_types, initial_sync_ended);
     SDVLOG(1)
         << "Added types: "
-        << syncable::ModelTypeSetToString(added_types)
+        << syncer::ModelTypeSetToString(added_types)
         << ", configured types: "
-        << syncable::ModelTypeSetToString(initial_sync_ended)
+        << syncer::ModelTypeSetToString(initial_sync_ended)
         << ", failed configuration types: "
-        << syncable::ModelTypeSetToString(failed_configuration_types);
+        << syncer::ModelTypeSetToString(failed_configuration_types);
 
     if (!failed_configuration_types.Empty() &&
         snapshot.retry_scheduled()) {
       // Inform the caller that download failed but we are retrying.
       if (!pending_download_state_->retry_in_progress) {
         pending_download_state_->retry_callback.Run();
         pending_download_state_->retry_in_progress = true;
       }
       // Nothing more to do.
       return;
@@ skipping 22 matching lines @@
   //
   // In the case of additions, on the next sync cycle, the syncer should
   // notice that the routing info has changed and start the process of
   // downloading updates for newly added data types.  Once this is
   // complete, the configure_state_.ready_task_ is run via an
   // OnInitializationComplete notification.
 
   SDVLOG(1) << "Syncer in config mode. SBH executing "
             << "FinishConfigureDataTypesOnFrontendLoop";
 
-
- syncer::ModelSafeRoutingInfo routing_info;
+  syncer::ModelSafeRoutingInfo routing_info;
   registrar_->GetModelSafeRoutingInfo(&routing_info);
-  const syncable::ModelTypeSet enabled_types =
-      GetRoutingInfoTypes(routing_info);
+  const syncer::ModelTypeSet enabled_types = GetRoutingInfoTypes(routing_info);
 
   // Update |chrome_sync_notification_bridge_|'s enabled types here as it has
   // to happen on the UI thread.
   chrome_sync_notification_bridge_.UpdateEnabledTypes(enabled_types);
 
   if (pending_config_mode_state_->added_types.Empty() &&
       !core_->sync_manager()->InitialSyncEndedTypes().HasAll(enabled_types)) {
 
     // TODO(tim): Log / UMA / count this somehow?
     // Add only the types with empty progress markers. Note: it is possible
     // that some types have their initial_sync_ended be false but with non
     // empty progress marker. Which is ok as the rest of the changes would
     // be downloaded on a regular nudge and initial_sync_ended should be set
     // to true. However this is a very corner case. So it is not explicitly
     // handled.
     pending_config_mode_state_->added_types =
         syncer::GetTypesWithEmptyProgressMarkerToken(enabled_types,
                                                        GetUserShare());
   }
 
   // If we've added types, we always want to request a nudge/config (even if
   // the initial sync is ended), in case we could not decrypt the data.
   if (pending_config_mode_state_->added_types.Empty()) {
     SDVLOG(1) << "No new types added; calling ready_task directly";
     // No new types - just notify the caller that the types are available.
-    const syncable::ModelTypeSet failed_configuration_types;
+    const syncer::ModelTypeSet failed_configuration_types;
     pending_config_mode_state_->ready_task.Run(failed_configuration_types);
   } else {
     pending_download_state_.reset(pending_config_mode_state_.release());
 
     // Always configure nigori if it's enabled.
-    syncable::ModelTypeSet types_to_config =
-        pending_download_state_->added_types;
+    syncer::ModelTypeSet types_to_config = pending_download_state_->added_types;
     if (IsNigoriEnabled()) {
       // Note: Nigori is the only type that gets added with a nonempty
       // progress marker during config. If the server returns a migration
       // error then we will go into unrecoverable error. We dont handle it
       // explicitly because server might help us out here by not sending a
       // migraiton error for nigori during config.
-      types_to_config.Put(syncable::NIGORI);
+      types_to_config.Put(syncer::NIGORI);
     }
     SDVLOG(1) << "Types "
-              << syncable::ModelTypeSetToString(types_to_config)
+              << syncer::ModelTypeSetToString(types_to_config)
               << " added; calling DoRequestConfig";
-   syncer::ModelSafeRoutingInfo routing_info;
+    syncer::ModelSafeRoutingInfo routing_info;
     registrar_->GetModelSafeRoutingInfo(&routing_info);
     sync_thread_.message_loop()->PostTask(FROM_HERE,
          base::Bind(&SyncBackendHost::Core::DoRequestConfig,
                     core_.get(),
                     routing_info,
                     types_to_config,
                     pending_download_state_->reason));
   }
 
   pending_config_mode_state_.reset();
@@ skipping 151 matching lines @@
 void SyncBackendHost::Core::OnUpdatedToken(const std::string& token) {
   if (!sync_loop_)
     return;
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   host_.Call(
       FROM_HERE,
       &SyncBackendHost::NotifyUpdatedToken, token);
 }
 
 void SyncBackendHost::Core::OnEncryptedTypesChanged(
-    syncable::ModelTypeSet encrypted_types,
+    syncer::ModelTypeSet encrypted_types,
     bool encrypt_everything) {
   if (!sync_loop_)
     return;
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   // NOTE: We're in a transaction.
   host_.Call(
       FROM_HERE,
       &SyncBackendHost::NotifyEncryptedTypesChanged,
       encrypted_types, encrypt_everything);
 }
@@ skipping 76 matching lines @@
   }
 }
 
 void SyncBackendHost::Core::DoUpdateCredentials(
     const SyncCredentials& credentials) {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   sync_manager_->UpdateCredentials(credentials);
 }
 
 void SyncBackendHost::Core::DoUpdateEnabledTypes(
-    const syncable::ModelTypeSet& enabled_types) {
+    const syncer::ModelTypeSet& enabled_types) {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   sync_manager_->UpdateEnabledTypes(enabled_types);
 }
 
 void SyncBackendHost::Core::DoStartSyncing(
     const syncer::ModelSafeRoutingInfo& routing_info) {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   sync_manager_->StartSyncingNormally(routing_info);
 }
 
@@ skipping 49 matching lines @@
   if (sync_disabled)
     DeleteSyncDataFolder();
 
   sync_loop_ = NULL;
 
   host_.Reset();
 }
 
 void SyncBackendHost::Core::DoRequestConfig(
     const syncer::ModelSafeRoutingInfo& routing_info,
-    syncable::ModelTypeSet types_to_config,
+    syncer::ModelTypeSet types_to_config,
     syncer::ConfigureReason reason) {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   sync_manager_->RequestConfig(routing_info, types_to_config, reason);
 }
 
 void SyncBackendHost::Core::DoStartConfiguration(
     const base::Closure& callback) {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   sync_manager_->StartConfigurationMode(callback);
 }
@@ skipping 71 matching lines @@
       initialization_state_ < DOWNLOADING_NIGORI) {
     initialization_state_ = DOWNLOADING_NIGORI;
   }
 
   // Run initialization state machine.
   switch (initialization_state_) {
     case NOT_INITIALIZED:
       initialization_state_ = DOWNLOADING_NIGORI;
       ConfigureDataTypes(
           syncer::CONFIGURE_REASON_NEW_CLIENT,
-          syncable::ModelTypeSet(),
-          syncable::ModelTypeSet(),
+          syncer::ModelTypeSet(),
+          syncer::ModelTypeSet(),
           WITH_NIGORI,
           // Calls back into this function.
           base::Bind(
               &SyncBackendHost::
                   HandleNigoriConfigurationCompletedOnFrontendLoop,
               weak_ptr_factory_.GetWeakPtr(), js_backend),
           base::Bind(&SyncBackendHost::OnNigoriDownloadRetry,
                      weak_ptr_factory_.GetWeakPtr()));
       break;
     case DOWNLOADING_NIGORI:
@@ skipping 72 matching lines @@
 void SyncBackendHost::NotifyUpdatedToken(const std::string& token) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   TokenAvailableDetails details(GaiaConstants::kSyncService, token);
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_TOKEN_UPDATED,
       content::Source<Profile>(profile_),
       content::Details<const TokenAvailableDetails>(&details));
 }
 
 void SyncBackendHost::NotifyEncryptedTypesChanged(
-    syncable::ModelTypeSet encrypted_types,
+    syncer::ModelTypeSet encrypted_types,
     bool encrypt_everything) {
   if (!frontend_)
     return;
 
   DCHECK_EQ(MessageLoop::current(), frontend_loop_);
   frontend_->OnEncryptedTypesChanged(
       encrypted_types, encrypt_everything);
 }
 
 void SyncBackendHost::NotifyEncryptionComplete() {
@@ skipping 15 matching lines @@
   if (!frontend_)
     return;
 
   DCHECK_EQ(MessageLoop::current(), frontend_loop_);
 
   frontend_->OnConnectionStatusChange(status);
 }
 
 void SyncBackendHost::HandleNigoriConfigurationCompletedOnFrontendLoop(
     const syncer::WeakHandle<syncer::JsBackend>& js_backend,
-    const syncable::ModelTypeSet failed_configuration_types) {
+    const syncer::ModelTypeSet failed_configuration_types) {
   HandleInitializationCompletedOnFrontendLoop(
       js_backend, failed_configuration_types.Empty());
 }
 
 namespace {
 
 // Needed because MessageLoop::PostTask is overloaded.
 void PostClosure(MessageLoop* message_loop,
                  const tracked_objects::Location& from_here,
                  const base::Closure& callback) {
@@ skipping 11 matching lines @@
       FROM_HERE,
       base::Bind(&SyncBackendHost::Core::DoRefreshNigori,
                  core_.get(), sync_thread_done_callback));
 }
 
 #undef SDVLOG
 
 #undef SLOG
 
 }  // namespace browser_sync