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

chrome/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 "chrome/browser/sync/profile_sync_service.h"
 
 #include <cstddef>
 #include <map>
 #include <set>
 #include <utility>
@@ skipping 50 matching lines @@
 #include "sync/internal_api/public/util/experiments.h"
 #include "sync/js/js_arg_list.h"
 #include "sync/js/js_event_details.h"
 #include "sync/util/cryptographer.h"
 #include "ui/base/l10n/l10n_util.h"
 
 using browser_sync::ChangeProcessor;
 using browser_sync::DataTypeController;
 using browser_sync::DataTypeManager;
 using browser_sync::SyncBackendHost;
-using syncable::ModelType;
-using syncable::ModelTypeSet;
+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;
 
 typedef GoogleServiceAuthError AuthError;
@@ skipping 172 matching lines @@
 
 void ProfileSyncService::RegisterDataTypeController(
     DataTypeController* data_type_controller) {
   DCHECK_EQ(data_type_controllers_.count(data_type_controller->type()), 0U);
   data_type_controllers_[data_type_controller->type()] =
       data_type_controller;
 }
 
 browser_sync::SessionModelAssociator*
     ProfileSyncService::GetSessionModelAssociator() {
-  if (data_type_controllers_.find(syncable::SESSIONS) ==
+  if (data_type_controllers_.find(syncer::SESSIONS) ==
       data_type_controllers_.end() ||
-      data_type_controllers_.find(syncable::SESSIONS)->second->state() !=
+      data_type_controllers_.find(syncer::SESSIONS)->second->state() !=
       DataTypeController::RUNNING) {
     return NULL;
   }
   return static_cast<browser_sync::SessionDataTypeController*>(
       data_type_controllers_.find(
-      syncable::SESSIONS)->second.get())->GetModelAssociator();
+      syncer::SESSIONS)->second.get())->GetModelAssociator();
 }
 
 void ProfileSyncService::GetDataTypeControllerStates(
   browser_sync::DataTypeController::StateMap* state_map) const {
     for (browser_sync::DataTypeController::TypeMap::const_iterator iter =
          data_type_controllers_.begin(); iter != data_type_controllers_.end();
          ++iter)
       (*state_map)[iter->first] = iter->second.get()->state();
 }
 
@@ skipping 34 matching lines @@
   }
   return credentials;
 }
 
 void ProfileSyncService::InitializeBackend(bool delete_stale_data) {
   if (!backend_.get()) {
     NOTREACHED();
     return;
   }
 
-  syncable::ModelTypeSet initial_types;
+  syncer::ModelTypeSet initial_types;
   // If sync setup hasn't finished, we don't want to initialize routing info
   // for any data types so that we don't download updates for types that the
   // user chooses not to sync on the first DownloadUpdatesCommand.
   if (HasSyncSetupCompleted()) {
     initial_types = GetPreferredDataTypes();
   }
 
   SyncCredentials credentials = GetCredentials();
 
   scoped_refptr<net::URLRequestContextGetter> request_context_getter(
@@ skipping 20 matching lines @@
 void ProfileSyncService::CreateBackend() {
   backend_.reset(
       new SyncBackendHost(profile_->GetDebugName(),
                           profile_, sync_prefs_.AsWeakPtr(),
                           invalidator_storage_.AsWeakPtr()));
 }
 
 bool ProfileSyncService::IsEncryptedDatatypeEnabled() const {
   if (encryption_pending())
     return true;
-  const syncable::ModelTypeSet preferred_types = GetPreferredDataTypes();
-  const syncable::ModelTypeSet encrypted_types = GetEncryptedDataTypes();
-  DCHECK(encrypted_types.Has(syncable::PASSWORDS));
+  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::OnSyncConfigureDone(
     DataTypeManager::ConfigureResult result) {
   if (failed_datatypes_handler_.UpdateFailedDatatypes(result.failed_data_types,
           FailedDatatypesHandler::STARTUP)) {
     ReconfigureDatatypeManager();
   }
 }
@@ skipping 175 matching lines @@
 }
 
 void ProfileSyncService::ClearUnrecoverableError() {
   unrecoverable_error_reason_ = ERROR_REASON_UNSET;
   unrecoverable_error_message_.clear();
   unrecoverable_error_location_ = tracked_objects::Location();
 }
 
 // static
 std::string ProfileSyncService::GetExperimentNameForDataType(
-    syncable::ModelType data_type) {
+    syncer::ModelType data_type) {
   switch (data_type) {
-    case syncable::SESSIONS:
+    case syncer::SESSIONS:
       return "sync-tabs";
     default:
       break;
   }
   NOTREACHED();
   return "";
 }
 
-void ProfileSyncService::RegisterNewDataType(syncable::ModelType data_type) {
+void ProfileSyncService::RegisterNewDataType(syncer::ModelType data_type) {
   if (data_type_controllers_.count(data_type) > 0)
     return;
   NOTREACHED();
 }
 
 // An invariant has been violated.  Transition to an error state where we try
 // to do as little work as possible, to avoid further corruption or crashes.
 void ProfileSyncService::OnUnrecoverableError(
     const tracked_objects::Location& from_here,
     const std::string& message) {
@@ skipping 21 matching lines @@
       << "Unrecoverable error detected at " << location
       << " -- ProfileSyncService unusable: " << message;
 
   // Shut all data types down.
   MessageLoop::current()->PostTask(FROM_HERE,
       base::Bind(&ProfileSyncService::ShutdownImpl, weak_factory_.GetWeakPtr(),
                  delete_sync_database));
 }
 
 void ProfileSyncService::DisableBrokenDatatype(
-    syncable::ModelType type,
+    syncer::ModelType type,
     const tracked_objects::Location& from_here,
     std::string message) {
   // First deactivate the type so that no further server changes are
   // passed onto the change processor.
   DeactivateDataType(type);
 
   syncer::SyncError error(from_here, message, type);
 
   std::list<syncer::SyncError> errors;
   errors.push_back(error);
@@ skipping 86 matching lines @@
   // OnBackendInitialized() to ensure the new datatypes are available at sync
   // setup. As a result, the migrator won't exist yet. This is fine because for
   // first time sync cases we're only concerned with making the datatype
   // available.
   if (migrator_.get() &&
       migrator_->state() != browser_sync::BackendMigrator::IDLE) {
     DVLOG(1) << "Dropping OnExperimentsChanged due to migrator busy.";
     return;
   }
 
-  const syncable::ModelTypeSet registered_types = GetRegisteredDataTypes();
-  syncable::ModelTypeSet to_add;
-  const syncable::ModelTypeSet to_register =
+  const syncer::ModelTypeSet registered_types = GetRegisteredDataTypes();
+  syncer::ModelTypeSet to_add;
+  const syncer::ModelTypeSet to_register =
       Difference(to_add, registered_types);
   DVLOG(2) << "OnExperimentsChanged called with types: "
-           << syncable::ModelTypeSetToString(to_add);
-  DVLOG(2) << "Enabling types: " << syncable::ModelTypeSetToString(to_register);
+           << syncer::ModelTypeSetToString(to_add);
+  DVLOG(2) << "Enabling types: " << syncer::ModelTypeSetToString(to_register);
 
-  for (syncable::ModelTypeSet::Iterator it = to_register.First();
+  for (syncer::ModelTypeSet::Iterator it = to_register.First();
        it.Good(); it.Inc()) {
     // Received notice to enable experimental type. Check if the type is
     // registered, and if not register a new datatype controller.
     RegisterNewDataType(it.Get());
 #if !defined(OS_ANDROID)
     // Enable the about:flags switch for the experimental type so we don't have
     // to always perform this reconfiguration. Once we set this, the type will
     // remain registered on restart, so we will no longer go down this code
     // path.
     std::string experiment_name = GetExperimentNameForDataType(it.Get());
@@ skipping 12 matching lines @@
   // covers the case where we're already in the process of reconfiguring
   // to turn an experimental type on.
   if (sync_prefs_.HasKeepEverythingSynced()) {
     // Mark all data types as preferred.
     sync_prefs_.SetPreferredDataTypes(registered_types, registered_types);
 
     // Only automatically turn on types if we have already finished set up.
     // Otherwise, just leave the experimental types on by default.
     if (!to_register.Empty() && HasSyncSetupCompleted() && migrator_.get()) {
       DVLOG(1) << "Dynamically enabling new datatypes: "
-               << syncable::ModelTypeSetToString(to_register);
+               << syncer::ModelTypeSetToString(to_register);
       OnMigrationNeededForTypes(to_register);
     }
   }
 
   // Now enable any non-datatype features.
   if (experiments.sync_tab_favicons) {
     DVLOG(1) << "Enabling syncing of tab favicons.";
     about_flags::SetExperimentEnabled(g_browser_process->local_state(),
                                       "sync-tab-favicons",
                                       true);
@@ skipping 75 matching lines @@
       "Passphrase no longer required but there is still a cached passphrase";
 
   // Reset passphrase_required_reason_ since we know we no longer require the
   // passphrase. We do this here rather than down in ResolvePassphraseRequired()
   // because that can be called by OnPassphraseRequired() if no encrypted data
   // types are enabled, and we don't want to clobber the true passphrase error.
   passphrase_required_reason_ = syncer::REASON_PASSPHRASE_NOT_REQUIRED;
 
   // Make sure the data types that depend on the passphrase are started at
   // this time.
-  const syncable::ModelTypeSet types = GetPreferredDataTypes();
+  const syncer::ModelTypeSet types = GetPreferredDataTypes();
 
   if (data_type_manager_.get()) {
     // Unblock the data type manager if necessary.
     data_type_manager_->Configure(types,
                                   syncer::CONFIGURE_REASON_RECONFIGURATION);
   }
 
   NotifyObservers();
 }
 
 void ProfileSyncService::OnEncryptedTypesChanged(
-    syncable::ModelTypeSet encrypted_types,
+    syncer::ModelTypeSet encrypted_types,
     bool encrypt_everything) {
   encrypted_types_ = encrypted_types;
   encrypt_everything_ = encrypt_everything;
   DVLOG(1) << "Encrypted types changed to "
-           << syncable::ModelTypeSetToString(encrypted_types_)
+           << syncer::ModelTypeSetToString(encrypted_types_)
            << " (encrypt everything is set to "
            << (encrypt_everything_ ? "true" : "false") << ")";
-  DCHECK(encrypted_types_.Has(syncable::PASSWORDS));
+  DCHECK(encrypted_types_.Has(syncer::PASSWORDS));
 }
 
 void ProfileSyncService::OnEncryptionComplete() {
   DVLOG(1) << "Encryption complete";
   if (encryption_pending_ && encrypt_everything_) {
     encryption_pending_ = false;
     // This is to nudge the integration tests when encryption is
     // finished.
     NotifyObservers();
   }
 }
 
 void ProfileSyncService::OnMigrationNeededForTypes(
-    syncable::ModelTypeSet types) {
+    syncer::ModelTypeSet types) {
   DCHECK(backend_initialized_);
   DCHECK(data_type_manager_.get());
 
   // Migrator must be valid, because we don't sync until it is created and this
   // callback originates from a sync cycle.
   migrator_->MigrateTypes(types);
 }
 
 void ProfileSyncService::OnActionableError(const SyncProtocolError& error) {
   last_actionable_error_ = error;
@@ skipping 103 matching lines @@
 
   base::TimeDelta last_synced = base::Time::Now() - last_synced_time_;
 
   if (last_synced < base::TimeDelta::FromMinutes(1))
     return l10n_util::GetStringUTF16(IDS_SYNC_TIME_JUST_NOW);
 
   return TimeFormat::TimeElapsed(last_synced);
 }
 
 void ProfileSyncService::UpdateSelectedTypesHistogram(
-    bool sync_everything, const syncable::ModelTypeSet chosen_types) const {
+    bool sync_everything, const syncer::ModelTypeSet chosen_types) const {
   if (!HasSyncSetupCompleted() ||
       sync_everything != sync_prefs_.HasKeepEverythingSynced()) {
     UMA_HISTOGRAM_BOOLEAN("Sync.SyncEverything", sync_everything);
   }
 
   // Only log the data types that are shown in the sync settings ui.
-  const syncable::ModelType model_types[] = {
-    syncable::APPS,
-    syncable::AUTOFILL,
-    syncable::BOOKMARKS,
-    syncable::EXTENSIONS,
-    syncable::PASSWORDS,
-    syncable::PREFERENCES,
-    syncable::SESSIONS,
-    syncable::THEMES,
-    syncable::TYPED_URLS
+  const syncer::ModelType model_types[] = {
+    syncer::APPS,
+    syncer::AUTOFILL,
+    syncer::BOOKMARKS,
+    syncer::EXTENSIONS,
+    syncer::PASSWORDS,
+    syncer::PREFERENCES,
+    syncer::SESSIONS,
+    syncer::THEMES,
+    syncer::TYPED_URLS
   };
 
   const browser_sync::user_selectable_type::UserSelectableSyncType
       user_selectable_types[] = {
     browser_sync::user_selectable_type::APPS,
     browser_sync::user_selectable_type::AUTOFILL,
     browser_sync::user_selectable_type::BOOKMARKS,
     browser_sync::user_selectable_type::EXTENSIONS,
     browser_sync::user_selectable_type::PASSWORDS,
     browser_sync::user_selectable_type::PREFERENCES,
     browser_sync::user_selectable_type::SESSIONS,
     browser_sync::user_selectable_type::THEMES,
     browser_sync::user_selectable_type::TYPED_URLS
   };
 
-  COMPILE_ASSERT(17 == syncable::MODEL_TYPE_COUNT,
-                 UpdateCustomConfigHistogram);
+  COMPILE_ASSERT(17 == syncer::MODEL_TYPE_COUNT, UpdateCustomConfigHistogram);
   COMPILE_ASSERT(arraysize(model_types) ==
                  browser_sync::user_selectable_type::SELECTABLE_DATATYPE_COUNT,
                  UpdateCustomConfigHistogram);
   COMPILE_ASSERT(arraysize(model_types) == arraysize(user_selectable_types),
                  UpdateCustomConfigHistogram);
 
   if (!sync_everything) {
-    const syncable::ModelTypeSet current_types = GetPreferredDataTypes();
+    const syncer::ModelTypeSet current_types = GetPreferredDataTypes();
     for (size_t i = 0; i < arraysize(model_types); ++i) {
-      const syncable::ModelType type = model_types[i];
+      const syncer::ModelType type = model_types[i];
       if (chosen_types.Has(type) &&
           (!HasSyncSetupCompleted() || !current_types.Has(type))) {
         // Selected type has changed - log it.
         UMA_HISTOGRAM_ENUMERATION(
             "Sync.CustomSync",
             user_selectable_types[i],
             browser_sync::user_selectable_type::SELECTABLE_DATATYPE_COUNT + 1);
       }
     }
   }
@@ skipping 10 matching lines @@
   std::string bootstrap_token;
   if (!temp_cryptographer.AddKey(key_params)) {
     NOTREACHED() << "Failed to add key to cryptographer.";
   }
   temp_cryptographer.GetBootstrapToken(&bootstrap_token);
   sync_prefs_.SetSpareBootstrapToken(bootstrap_token);
 }
 #endif
 
 void ProfileSyncService::OnUserChoseDatatypes(bool sync_everything,
-    syncable::ModelTypeSet chosen_types) {
+    syncer::ModelTypeSet chosen_types) {
   if (!backend_.get() && !HasUnrecoverableError()) {
     NOTREACHED();
     return;
   }
 
   UpdateSelectedTypesHistogram(sync_everything, chosen_types);
   sync_prefs_.SetKeepEverythingSynced(sync_everything);
 
   failed_datatypes_handler_.OnUserChoseDatatypes();
   ChangePreferredDataTypes(chosen_types);
   AcknowledgeSyncedTypes();
   NotifyObservers();
 }
 
 void ProfileSyncService::ChangePreferredDataTypes(
-    syncable::ModelTypeSet preferred_types) {
+    syncer::ModelTypeSet preferred_types) {
 
   DVLOG(1) << "ChangePreferredDataTypes invoked";
-  const syncable::ModelTypeSet registered_types = GetRegisteredDataTypes();
-  const syncable::ModelTypeSet registered_preferred_types =
+  const syncer::ModelTypeSet registered_types = GetRegisteredDataTypes();
+  const syncer::ModelTypeSet registered_preferred_types =
       Intersection(registered_types, preferred_types);
   sync_prefs_.SetPreferredDataTypes(registered_types,
                                     registered_preferred_types);
 
   // Now reconfigure the DTM.
   ReconfigureDatatypeManager();
 }
 
-syncable::ModelTypeSet ProfileSyncService::GetPreferredDataTypes() const {
-  const syncable::ModelTypeSet registered_types = GetRegisteredDataTypes();
-  const syncable::ModelTypeSet preferred_types =
+syncer::ModelTypeSet ProfileSyncService::GetPreferredDataTypes() const {
+  const syncer::ModelTypeSet registered_types = GetRegisteredDataTypes();
+  const syncer::ModelTypeSet preferred_types =
       sync_prefs_.GetPreferredDataTypes(registered_types);
-  const syncable::ModelTypeSet failed_types =
+  const syncer::ModelTypeSet failed_types =
       failed_datatypes_handler_.GetFailedTypes();
   return Difference(preferred_types, failed_types);
 }
 
-syncable::ModelTypeSet ProfileSyncService::GetRegisteredDataTypes() const {
-  syncable::ModelTypeSet registered_types;
+syncer::ModelTypeSet ProfileSyncService::GetRegisteredDataTypes() const {
+  syncer::ModelTypeSet registered_types;
   // The data_type_controllers_ are determined by command-line flags; that's
   // effectively what controls the values returned here.
   for (DataTypeController::TypeMap::const_iterator it =
        data_type_controllers_.begin();
        it != data_type_controllers_.end(); ++it) {
     registered_types.Put(it->first);
   }
   return registered_types;
 }
 
@@ skipping 31 matching lines @@
 
     // We create the migrator at the same time.
     migrator_.reset(
         new browser_sync::BackendMigrator(
             profile_->GetDebugName(), GetUserShare(),
             this, data_type_manager_.get(),
             base::Bind(&ProfileSyncService::StartSyncingWithServer,
                        base::Unretained(this))));
   }
 
-  const syncable::ModelTypeSet types = GetPreferredDataTypes();
+  const syncer::ModelTypeSet types = GetPreferredDataTypes();
   if (IsPassphraseRequiredForDecryption()) {
     // We need a passphrase still. We don't bother to attempt to configure
     // until we receive an OnPassphraseAccepted (which triggers a configure).
     DVLOG(1) << "ProfileSyncService::ConfigureDataTypeManager bailing out "
              << "because a passphrase required";
     NotifyObservers();
     return;
   }
   syncer::ConfigureReason reason = syncer::CONFIGURE_REASON_UNKNOWN;
   if (!HasSyncSetupCompleted()) {
@@ skipping 110 matching lines @@
                              ModelSafeGroupToString(routing_info[type]));
     } else {
       type_status->SetString("status", "warning");
       type_status->SetString("value", "Disabled by User");
     }
   }
   return result;
 }
 
 void ProfileSyncService::ActivateDataType(
-    syncable::ModelType type, syncer::ModelSafeGroup group,
+    syncer::ModelType type, syncer::ModelSafeGroup group,
     ChangeProcessor* change_processor) {
   if (!backend_.get()) {
     NOTREACHED();
     return;
   }
   DCHECK(backend_initialized_);
   backend_->ActivateDataType(type, group, change_processor);
 }
 
-void ProfileSyncService::DeactivateDataType(syncable::ModelType type) {
+void ProfileSyncService::DeactivateDataType(syncer::ModelType type) {
   if (!backend_.get())
     return;
   backend_->DeactivateDataType(type);
 }
 
 void ProfileSyncService::ConsumeCachedPassphraseIfPossible() {
   // If no cached passphrase, or sync backend hasn't started up yet, just exit.
   // If the backend isn't running yet, OnBackendInitialized() will call this
   // method again after the backend starts up.
   if (cached_passphrase_.empty() || !sync_initialized())
@@ skipping 73 matching lines @@
   // initialized (via IsEncryptedDatatypeEnabled and
   // IsPassphraseRequiredForDecryption).
   return encryption_pending_;
 }
 
 bool ProfileSyncService::EncryptEverythingEnabled() const {
   DCHECK(backend_initialized_);
   return encrypt_everything_ || encryption_pending_;
 }
 
-syncable::ModelTypeSet ProfileSyncService::GetEncryptedDataTypes() const {
-  DCHECK(encrypted_types_.Has(syncable::PASSWORDS));
+syncer::ModelTypeSet ProfileSyncService::GetEncryptedDataTypes() const {
+  DCHECK(encrypted_types_.Has(syncer::PASSWORDS));
   // We may be called during the setup process before we're
   // initialized.  In this case, we default to the sensitive types.
   return encrypted_types_;
 }
 
 void ProfileSyncService::OnSyncManagedPrefChange(bool is_sync_managed) {
   NotifyObservers();
   if (is_sync_managed) {
     DisableForUser();
   } else if (HasSyncSetupCompleted() &&
@@ skipping 52 matching lines @@
           configure_status_ != DataTypeManager::PARTIAL_SUCCESS) {
         // Something catastrophic had happened. We should only have one
         // error representing it.
         DCHECK_EQ(result->failed_data_types.size(),
                   static_cast<unsigned int>(1));
         syncer::SyncError error = result->failed_data_types.front();
         DCHECK(error.IsSet());
         std::string message =
           "Sync configuration failed with status " +
           DataTypeManager::ConfigureStatusToString(configure_status_) +
-          " during " + syncable::ModelTypeToString(error.type()) +
+          " during " + syncer::ModelTypeToString(error.type()) +
           ": " + error.message();
         LOG(ERROR) << "ProfileSyncService error: "
                    << message;
         OnInternalUnrecoverableError(error.location(),
                                      message,
                                      true,
                                      ERROR_REASON_CONFIGURATION_FAILURE);
         return;
       }
 
@@ skipping 216 matching lines @@
   // See http://stackoverflow.com/questions/6224121/is-new-this-myclass-undefined-behaviour-after-directly-calling-the-destru.
   ProfileSyncService* old_this = this;
   this->~ProfileSyncService();
   new(old_this) ProfileSyncService(
       new ProfileSyncComponentsFactoryImpl(profile,
                                            CommandLine::ForCurrentProcess()),
       profile,
       signin,
       behavior);
 }