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

chrome/browser/sync/profile_sync_service_harness.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_harness.h"
 
 #include <cstddef>
 #include <iterator>
 #include <ostream>
 #include <set>
@@ skipping 83 matching lines @@
 bool StateChangeTimeoutEvent::Abort() {
   aborted_ = true;
   caller_ = NULL;
   return !did_timeout_;
 }
 
 ProfileSyncServiceHarness::ProfileSyncServiceHarness(
     Profile* profile,
     const std::string& username,
     const std::string& password)
-    : waiting_for_encryption_type_(syncable::UNSPECIFIED),
+    : waiting_for_encryption_type_(syncer::UNSPECIFIED),
       wait_state_(INITIAL_WAIT_STATE),
       profile_(profile),
       service_(NULL),
       timestamp_match_partner_(NULL),
       username_(username),
       password_(password),
       profile_debug_name_(profile->GetDebugName()),
       waiting_for_status_change_(false) {
   if (IsSyncAlreadySetup()) {
     service_ = ProfileSyncServiceFactory::GetInstance()->GetForProfile(
@@ skipping 22 matching lines @@
   username_ = username;
   password_ = password;
 }
 
 bool ProfileSyncServiceHarness::IsSyncAlreadySetup() {
   return ProfileSyncServiceFactory::GetInstance()->HasProfileSyncService(
       profile_);
 }
 
 bool ProfileSyncServiceHarness::SetupSync() {
-  bool result = SetupSync(syncable::ModelTypeSet::All());
+  bool result = SetupSync(syncer::ModelTypeSet::All());
   if (result == false) {
     std::string status = GetServiceStatus();
     LOG(ERROR) << profile_debug_name_
                << ": SetupSync failed. Syncer status:\n" << status;
   } else {
     DVLOG(1) << profile_debug_name_ << ": SetupSync successful.";
   }
   return result;
 }
 
 bool ProfileSyncServiceHarness::SetupSync(
-    syncable::ModelTypeSet synced_datatypes) {
+    syncer::ModelTypeSet synced_datatypes) {
   // Initialize the sync client's profile sync service object.
   service_ =
       ProfileSyncServiceFactory::GetInstance()->GetForProfile(profile_);
   if (service_ == NULL) {
     LOG(ERROR) << "SetupSync(): service_ is null.";
     return false;
   }
 
   // Subscribe sync client to notifications from the profile sync service.
   if (!service_->HasObserver(this))
@@ skipping 15 matching lines @@
   if (!AwaitBackendInitialized()) {
     LOG(ERROR) << "OnBackendInitialized() not seen after "
                << kLiveSyncOperationTimeoutMs / 1000
                << " seconds.";
     return false;
   }
 
   // Choose the datatypes to be synced. If all datatypes are to be synced,
   // set sync_everything to true; otherwise, set it to false.
   bool sync_everything =
-      synced_datatypes.Equals(syncable::ModelTypeSet::All());
+      synced_datatypes.Equals(syncer::ModelTypeSet::All());
   service()->OnUserChoseDatatypes(sync_everything, synced_datatypes);
 
   // Subscribe sync client to notifications from the backend migrator
   // (possible only after choosing data types).
   if (!TryListeningToMigrationEvents()) {
     NOTREACHED();
     return false;
   }
 
   // Make sure that a partner client hasn't already set an explicit passphrase.
@@ skipping 236 matching lines @@
 
 void ProfileSyncServiceHarness::OnMigrationStateChange() {
   // Update migration state.
   if (HasPendingBackendMigration()) {
     // Merge current pending migration types into
     // |pending_migration_types_|.
     pending_migration_types_.PutAll(
         service()->GetBackendMigratorForTest()->
             GetPendingMigrationTypesForTest());
     DVLOG(1) << profile_debug_name_ << ": new pending migration types "
-             << syncable::ModelTypeSetToString(pending_migration_types_);
+             << syncer::ModelTypeSetToString(pending_migration_types_);
   } else {
     // Merge just-finished pending migration types into
     // |migration_types_|.
     migrated_types_.PutAll(pending_migration_types_);
     pending_migration_types_.Clear();
     DVLOG(1) << profile_debug_name_ << ": new migrated types "
-             << syncable::ModelTypeSetToString(migrated_types_);
+             << syncer::ModelTypeSetToString(migrated_types_);
   }
   RunStateChangeMachine();
 }
 
 bool ProfileSyncServiceHarness::AwaitPassphraseRequired() {
   DVLOG(1) << GetClientInfoString("AwaitPassphraseRequired");
   if (wait_state_ == SYNC_DISABLED) {
     LOG(ERROR) << "Sync disabled for " << profile_debug_name_ << ".";
     return false;
   }
@@ skipping 130 matching lines @@
   CHECK(status.sync_protocol_error.action == syncer::UNKNOWN_ACTION);
   wait_state_ = WAITING_FOR_ACTIONABLE_ERROR;
   AwaitStatusChangeWithTimeout(kLiveSyncOperationTimeoutMs,
       "Waiting for actionable error");
   status = GetStatus();
   return (status.sync_protocol_error.action != syncer::UNKNOWN_ACTION &&
           service_->HasUnrecoverableError());
 }
 
 bool ProfileSyncServiceHarness::AwaitMigration(
-    syncable::ModelTypeSet expected_migrated_types) {
+    syncer::ModelTypeSet expected_migrated_types) {
   DVLOG(1) << GetClientInfoString("AwaitMigration");
   DVLOG(1) << profile_debug_name_ << ": waiting until migration is done for "
-          << syncable::ModelTypeSetToString(expected_migrated_types);
+          << syncer::ModelTypeSetToString(expected_migrated_types);
   while (true) {
     bool migration_finished = migrated_types_.HasAll(expected_migrated_types);
     DVLOG(1) << "Migrated types "
-             << syncable::ModelTypeSetToString(migrated_types_)
+             << syncer::ModelTypeSetToString(migrated_types_)
              << (migration_finished ? " contains " : " does not contain ")
-             << syncable::ModelTypeSetToString(expected_migrated_types);
+             << syncer::ModelTypeSetToString(expected_migrated_types);
     if (migration_finished) {
       return true;
     }
 
     if (HasPendingBackendMigration()) {
       wait_state_ = WAITING_FOR_MIGRATION_TO_FINISH;
     } else {
       wait_state_ = WAITING_FOR_MIGRATION_TO_START;
       AwaitStatusChangeWithTimeout(kLiveSyncOperationTimeoutMs,
                                    "Wait for migration to start");
@@ skipping 188 matching lines @@
     ProfileSyncServiceHarness* partner) {
   // TODO(akalin): Shouldn't this belong with the intersection check?
   // Otherwise, this function isn't symmetric.
   if (!IsFullySynced()) {
     DVLOG(2) << profile_debug_name_ << ": not synced, assuming doesn't match";
     return false;
   }
 
   // Only look for a match if we have at least one enabled datatype in
   // common with the partner client.
-  const syncable::ModelTypeSet common_types =
+  const syncer::ModelTypeSet common_types =
       Intersection(service()->GetPreferredDataTypes(),
                    partner->service()->GetPreferredDataTypes());
 
   DVLOG(2) << profile_debug_name_ << ", " << partner->profile_debug_name_
            << ": common types are "
-           << syncable::ModelTypeSetToString(common_types);
+           << syncer::ModelTypeSetToString(common_types);
 
   if (!common_types.Empty() && !partner->IsFullySynced()) {
     DVLOG(2) << "non-empty common types and "
              << partner->profile_debug_name_ << " isn't synced";
     return false;
   }
 
-  for (syncable::ModelTypeSet::Iterator i = common_types.First();
+  for (syncer::ModelTypeSet::Iterator i = common_types.First();
        i.Good(); i.Inc()) {
     const std::string timestamp = GetUpdatedTimestamp(i.Get());
     const std::string partner_timestamp = partner->GetUpdatedTimestamp(i.Get());
     if (timestamp != partner_timestamp) {
       if (VLOG_IS_ON(2)) {
         std::string timestamp_base64, partner_timestamp_base64;
         if (!base::Base64Encode(timestamp, &timestamp_base64)) {
           NOTREACHED();
         }
         if (!base::Base64Encode(
                 partner_timestamp, &partner_timestamp_base64)) {
           NOTREACHED();
         }
-        DVLOG(2) << syncable::ModelTypeToString(i.Get()) << ": "
+        DVLOG(2) << syncer::ModelTypeToString(i.Get()) << ": "
                  << profile_debug_name_ << " timestamp = "
                  << timestamp_base64 << ", "
                  << partner->profile_debug_name_
                  << " partner timestamp = "
                  << partner_timestamp_base64;
       }
       return false;
     }
   }
   return true;
 }
 
 SyncSessionSnapshot ProfileSyncServiceHarness::GetLastSessionSnapshot() const {
   DCHECK(service_ != NULL) << "Sync service has not yet been set up.";
   if (service_->sync_initialized()) {
     return service_->GetLastSessionSnapshot();
   }
   return SyncSessionSnapshot();
 }
 
 bool ProfileSyncServiceHarness::EnableSyncForDatatype(
-    syncable::ModelType datatype) {
+    syncer::ModelType datatype) {
   DVLOG(1) << GetClientInfoString(
       "EnableSyncForDatatype("
-      + std::string(syncable::ModelTypeToString(datatype)) + ")");
+      + std::string(syncer::ModelTypeToString(datatype)) + ")");
 
   if (wait_state_ == SYNC_DISABLED) {
-    return SetupSync(syncable::ModelTypeSet(datatype));
+    return SetupSync(syncer::ModelTypeSet(datatype));
   }
 
   if (service() == NULL) {
     LOG(ERROR) << "EnableSyncForDatatype(): service() is null.";
     return false;
   }
 
-  syncable::ModelTypeSet synced_datatypes =
+  syncer::ModelTypeSet synced_datatypes =
       service()->GetPreferredDataTypes();
   if (synced_datatypes.Has(datatype)) {
     DVLOG(1) << "EnableSyncForDatatype(): Sync already enabled for datatype "
-             << syncable::ModelTypeToString(datatype)
+             << syncer::ModelTypeToString(datatype)
              << " on " << profile_debug_name_ << ".";
     return true;
   }
 
-  synced_datatypes.Put(syncable::ModelTypeFromInt(datatype));
+  synced_datatypes.Put(syncer::ModelTypeFromInt(datatype));
   service()->OnUserChoseDatatypes(false, synced_datatypes);
   if (AwaitDataSyncCompletion("Datatype configuration.")) {
     DVLOG(1) << "EnableSyncForDatatype(): Enabled sync for datatype "
-             << syncable::ModelTypeToString(datatype)
+             << syncer::ModelTypeToString(datatype)
              << " on " << profile_debug_name_ << ".";
     return true;
   }
 
   DVLOG(0) << GetClientInfoString("EnableSyncForDatatype failed");
   return false;
 }
 
 bool ProfileSyncServiceHarness::DisableSyncForDatatype(
-    syncable::ModelType datatype) {
+    syncer::ModelType datatype) {
   DVLOG(1) << GetClientInfoString(
       "DisableSyncForDatatype("
-      + std::string(syncable::ModelTypeToString(datatype)) + ")");
+      + std::string(syncer::ModelTypeToString(datatype)) + ")");
 
   if (service() == NULL) {
     LOG(ERROR) << "DisableSyncForDatatype(): service() is null.";
     return false;
   }
 
-  syncable::ModelTypeSet synced_datatypes =
+  syncer::ModelTypeSet synced_datatypes =
       service()->GetPreferredDataTypes();
   if (!synced_datatypes.Has(datatype)) {
     DVLOG(1) << "DisableSyncForDatatype(): Sync already disabled for datatype "
-             << syncable::ModelTypeToString(datatype)
+             << syncer::ModelTypeToString(datatype)
              << " on " << profile_debug_name_ << ".";
     return true;
   }
 
   synced_datatypes.Remove(datatype);
   service()->OnUserChoseDatatypes(false, synced_datatypes);
   if (AwaitFullSyncCompletion("Datatype reconfiguration.")) {
     DVLOG(1) << "DisableSyncForDatatype(): Disabled sync for datatype "
-             << syncable::ModelTypeToString(datatype)
+             << syncer::ModelTypeToString(datatype)
              << " on " << profile_debug_name_ << ".";
     return true;
   }
 
   DVLOG(0) << GetClientInfoString("DisableSyncForDatatype failed");
   return false;
 }
 
 bool ProfileSyncServiceHarness::EnableSyncForAllDatatypes() {
   DVLOG(1) << GetClientInfoString("EnableSyncForAllDatatypes");
 
   if (wait_state_ == SYNC_DISABLED) {
     return SetupSync();
   }
 
   if (service() == NULL) {
     LOG(ERROR) << "EnableSyncForAllDatatypes(): service() is null.";
     return false;
   }
 
-  service()->OnUserChoseDatatypes(true, syncable::ModelTypeSet::All());
+  service()->OnUserChoseDatatypes(true, syncer::ModelTypeSet::All());
   if (AwaitFullSyncCompletion("Datatype reconfiguration.")) {
     DVLOG(1) << "EnableSyncForAllDatatypes(): Enabled sync for all datatypes "
              << "on " << profile_debug_name_ << ".";
     return true;
   }
 
   DVLOG(0) << GetClientInfoString("EnableSyncForAllDatatypes failed");
   return false;
 }
 
 bool ProfileSyncServiceHarness::DisableSyncForAllDatatypes() {
   DVLOG(1) << GetClientInfoString("DisableSyncForAllDatatypes");
 
   if (service() == NULL) {
     LOG(ERROR) << "DisableSyncForAllDatatypes(): service() is null.";
     return false;
   }
 
   service()->DisableForUser();
   wait_state_ = SYNC_DISABLED;
   DVLOG(1) << "DisableSyncForAllDatatypes(): Disabled sync for all "
            << "datatypes on " << profile_debug_name_;
   return true;
 }
 
 std::string ProfileSyncServiceHarness::GetUpdatedTimestamp(
-    syncable::ModelType model_type) {
+    syncer::ModelType model_type) {
   const SyncSessionSnapshot& snap = GetLastSessionSnapshot();
   return snap.download_progress_markers()[model_type];
 }
 
 std::string ProfileSyncServiceHarness::GetClientInfoString(
     const std::string& message) {
   std::stringstream os;
   os << profile_debug_name_ << ": " << message << ": ";
   if (service()) {
     const SyncSessionSnapshot& snap = GetLastSessionSnapshot();
@@ skipping 27 matching lines @@
        << HasPendingBackendMigration();
   } else {
     os << "Sync service not available";
   }
   return os.str();
 }
 
 // TODO(zea): Rename this EnableEncryption, since we no longer turn on
 // encryption for individual types but for all.
 bool ProfileSyncServiceHarness::EnableEncryptionForType(
-    syncable::ModelType type) {
-  const syncable::ModelTypeSet encrypted_types =
+    syncer::ModelType type) {
+  const syncer::ModelTypeSet encrypted_types =
       service_->GetEncryptedDataTypes();
   if (encrypted_types.Has(type))
     return true;
   service_->EnableEncryptEverything();
 
   // In order to kick off the encryption we have to reconfigure. Just grab the
   // currently synced types and use them.
-  const syncable::ModelTypeSet synced_datatypes =
+  const syncer::ModelTypeSet synced_datatypes =
       service_->GetPreferredDataTypes();
   bool sync_everything =
-      synced_datatypes.Equals(syncable::ModelTypeSet::All());
+      synced_datatypes.Equals(syncer::ModelTypeSet::All());
   service_->OnUserChoseDatatypes(sync_everything, synced_datatypes);
 
   // Wait some time to let the enryption finish.
   return WaitForTypeEncryption(type);
 }
 
 bool ProfileSyncServiceHarness::WaitForTypeEncryption(
-    syncable::ModelType type) {
+    syncer::ModelType type) {
   // The correctness of this if condition depends on the ordering of its
   // sub-expressions.  See crbug.com/95619.
   // TODO(rlarocque): Figure out a less brittle way of detecting this.
   if (IsTypeEncrypted(type) &&
       IsFullySynced() &&
       GetLastSessionSnapshot().num_encryption_conflicts() == 0) {
     // Encryption is already complete for |type|; do not wait.
     return true;
   }
 
   std::string reason = "Waiting for encryption.";
   wait_state_ = WAITING_FOR_ENCRYPTION;
   waiting_for_encryption_type_ = type;
   if (!AwaitStatusChangeWithTimeout(kLiveSyncOperationTimeoutMs, reason)) {
     LOG(ERROR) << "Did not receive EncryptionComplete notification after"
                << kLiveSyncOperationTimeoutMs / 1000
                << " seconds.";
     return false;
   }
   return IsTypeEncrypted(type);
 }
 
-bool ProfileSyncServiceHarness::IsTypeEncrypted(syncable::ModelType type) {
-  const syncable::ModelTypeSet encrypted_types =
+bool ProfileSyncServiceHarness::IsTypeEncrypted(syncer::ModelType type) {
+  const syncer::ModelTypeSet encrypted_types =
       service_->GetEncryptedDataTypes();
   bool is_type_encrypted = service_->GetEncryptedDataTypes().Has(type);
-  DVLOG(2) << syncable::ModelTypeToString(type) << " is "
+  DVLOG(2) << syncer::ModelTypeToString(type) << " is "
            << (is_type_encrypted ? "" : "not ") << "encrypted; "
            << "encrypted types = "
-           << syncable::ModelTypeSetToString(encrypted_types);
+           << syncer::ModelTypeSetToString(encrypted_types);
   return is_type_encrypted;
 }
 
-bool ProfileSyncServiceHarness::IsTypeRunning(syncable::ModelType type) {
+bool ProfileSyncServiceHarness::IsTypeRunning(syncer::ModelType type) {
   browser_sync::DataTypeController::StateMap state_map;
   service_->GetDataTypeControllerStates(&state_map);
   return (state_map.count(type) != 0 &&
           state_map[type] == browser_sync::DataTypeController::RUNNING);
 }
 
-bool ProfileSyncServiceHarness::IsTypePreferred(syncable::ModelType type) {
+bool ProfileSyncServiceHarness::IsTypePreferred(syncer::ModelType type) {
   return service_->GetPreferredDataTypes().Has(type);
 }
 
 size_t ProfileSyncServiceHarness::GetNumEntries() const {
   return GetLastSessionSnapshot().num_entries();
 }
 
 size_t ProfileSyncServiceHarness::GetNumDatatypes() const {
   browser_sync::DataTypeController::StateMap state_map;
   service_->GetDataTypeControllerStates(&state_map);
   return state_map.size();
 }
 
 std::string ProfileSyncServiceHarness::GetServiceStatus() {
   DictionaryValue value;
   sync_ui_util::ConstructAboutInformation(service_, &value);
   std::string service_status;
   base::JSONWriter::WriteWithOptions(&value,
                                      base::JSONWriter::OPTIONS_PRETTY_PRINT,
                                      &service_status);
   return service_status;
 }