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

Previously they were in 'syncer::syncable'.

Also remove aliases to those classes from 'syncable'.

BUG=128060
TEST=
TBR=pkasting@chromium.org,jhawkins@chromium.org,

Review URL: https://chromiumcodereview.appspot.com/10696087

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@145399 0039d316-1c4b-4281-b951-d872f2087c98

5 files changed, 85 insertions, 87 deletions

diff --git a/sync/util/cryptographer.cc b/sync/util/cryptographer.cc
index 6cb7fab..59e8a1a 100644
--- a/sync/util/cryptographer.cc
+++ b/sync/util/cryptographer.cc
@@ -309,12 +309,12 @@ Cryptographer::UpdateResult Cryptographer::Update(
 }
 
 // Static
-syncable::ModelTypeSet Cryptographer::SensitiveTypes() {
+syncer::ModelTypeSet Cryptographer::SensitiveTypes() {
   // Both of these have their own encryption schemes, but we include them
   // anyways.
-  syncable::ModelTypeSet types;
-  types.Put(syncable::PASSWORDS);
-  types.Put(syncable::NIGORI);
+  syncer::ModelTypeSet types;
+  types.Put(syncer::PASSWORDS);
+  types.Put(syncer::NIGORI);
   return types;
 }
 
@@ -325,33 +325,33 @@ void Cryptographer::UpdateEncryptedTypesFromNigori(
     return;
   }
 
-  syncable::ModelTypeSet encrypted_types(SensitiveTypes());
+  syncer::ModelTypeSet encrypted_types(SensitiveTypes());
   if (nigori.encrypt_bookmarks())
-    encrypted_types.Put(syncable::BOOKMARKS);
+    encrypted_types.Put(syncer::BOOKMARKS);
   if (nigori.encrypt_preferences())
-    encrypted_types.Put(syncable::PREFERENCES);
+    encrypted_types.Put(syncer::PREFERENCES);
   if (nigori.encrypt_autofill_profile())
-    encrypted_types.Put(syncable::AUTOFILL_PROFILE);
+    encrypted_types.Put(syncer::AUTOFILL_PROFILE);
   if (nigori.encrypt_autofill())
-    encrypted_types.Put(syncable::AUTOFILL);
+    encrypted_types.Put(syncer::AUTOFILL);
   if (nigori.encrypt_themes())
-    encrypted_types.Put(syncable::THEMES);
+    encrypted_types.Put(syncer::THEMES);
   if (nigori.encrypt_typed_urls())
-    encrypted_types.Put(syncable::TYPED_URLS);
+    encrypted_types.Put(syncer::TYPED_URLS);
   if (nigori.encrypt_extension_settings())
-    encrypted_types.Put(syncable::EXTENSION_SETTINGS);
+    encrypted_types.Put(syncer::EXTENSION_SETTINGS);
   if (nigori.encrypt_extensions())
-    encrypted_types.Put(syncable::EXTENSIONS);
+    encrypted_types.Put(syncer::EXTENSIONS);
   if (nigori.encrypt_search_engines())
-    encrypted_types.Put(syncable::SEARCH_ENGINES);
+    encrypted_types.Put(syncer::SEARCH_ENGINES);
   if (nigori.encrypt_sessions())
-    encrypted_types.Put(syncable::SESSIONS);
+    encrypted_types.Put(syncer::SESSIONS);
   if (nigori.encrypt_app_settings())
-    encrypted_types.Put(syncable::APP_SETTINGS);
+    encrypted_types.Put(syncer::APP_SETTINGS);
   if (nigori.encrypt_apps())
-    encrypted_types.Put(syncable::APPS);
+    encrypted_types.Put(syncer::APPS);
   if (nigori.encrypt_app_notifications())
-    encrypted_types.Put(syncable::APP_NOTIFICATIONS);
+    encrypted_types.Put(syncer::APP_NOTIFICATIONS);
 
   // Note: the initial version with encryption did not support the
   // encrypt_everything field. If anything more than the sensitive types were
@@ -369,38 +369,38 @@ void Cryptographer::UpdateNigoriFromEncryptedTypes(
     sync_pb::NigoriSpecifics* nigori) const {
   nigori->set_encrypt_everything(encrypt_everything_);
   nigori->set_encrypt_bookmarks(
-      encrypted_types_.Has(syncable::BOOKMARKS));
+      encrypted_types_.Has(syncer::BOOKMARKS));
   nigori->set_encrypt_preferences(
-      encrypted_types_.Has(syncable::PREFERENCES));
+      encrypted_types_.Has(syncer::PREFERENCES));
   nigori->set_encrypt_autofill_profile(
-      encrypted_types_.Has(syncable::AUTOFILL_PROFILE));
-  nigori->set_encrypt_autofill(encrypted_types_.Has(syncable::AUTOFILL));
-  nigori->set_encrypt_themes(encrypted_types_.Has(syncable::THEMES));
+      encrypted_types_.Has(syncer::AUTOFILL_PROFILE));
+  nigori->set_encrypt_autofill(encrypted_types_.Has(syncer::AUTOFILL));
+  nigori->set_encrypt_themes(encrypted_types_.Has(syncer::THEMES));
   nigori->set_encrypt_typed_urls(
-      encrypted_types_.Has(syncable::TYPED_URLS));
+      encrypted_types_.Has(syncer::TYPED_URLS));
   nigori->set_encrypt_extension_settings(
-      encrypted_types_.Has(syncable::EXTENSION_SETTINGS));
+      encrypted_types_.Has(syncer::EXTENSION_SETTINGS));
   nigori->set_encrypt_extensions(
-      encrypted_types_.Has(syncable::EXTENSIONS));
+      encrypted_types_.Has(syncer::EXTENSIONS));
   nigori->set_encrypt_search_engines(
-      encrypted_types_.Has(syncable::SEARCH_ENGINES));
-  nigori->set_encrypt_sessions(encrypted_types_.Has(syncable::SESSIONS));
+      encrypted_types_.Has(syncer::SEARCH_ENGINES));
+  nigori->set_encrypt_sessions(encrypted_types_.Has(syncer::SESSIONS));
   nigori->set_encrypt_app_settings(
-      encrypted_types_.Has(syncable::APP_SETTINGS));
-  nigori->set_encrypt_apps(encrypted_types_.Has(syncable::APPS));
+      encrypted_types_.Has(syncer::APP_SETTINGS));
+  nigori->set_encrypt_apps(encrypted_types_.Has(syncer::APPS));
   nigori->set_encrypt_app_notifications(
-      encrypted_types_.Has(syncable::APP_NOTIFICATIONS));
+      encrypted_types_.Has(syncer::APP_NOTIFICATIONS));
 }
 
 void Cryptographer::set_encrypt_everything() {
   if (encrypt_everything_) {
-    DCHECK(encrypted_types_.Equals(syncable::ModelTypeSet::All()));
+    DCHECK(encrypted_types_.Equals(syncer::ModelTypeSet::All()));
     return;
   }
   encrypt_everything_ = true;
   // Change |encrypted_types_| directly to avoid sending more than one
   // notification.
-  encrypted_types_ = syncable::ModelTypeSet::All();
+  encrypted_types_ = syncer::ModelTypeSet::All();
   EmitEncryptedTypesChangedNotification();
 }
 
@@ -408,17 +408,17 @@ bool Cryptographer::encrypt_everything() const {
   return encrypt_everything_;
 }
 
-syncable::ModelTypeSet Cryptographer::GetEncryptedTypes() const {
+syncer::ModelTypeSet Cryptographer::GetEncryptedTypes() const {
   return encrypted_types_;
 }
 
 void Cryptographer::MergeEncryptedTypesForTest(
-    syncable::ModelTypeSet encrypted_types) {
+    syncer::ModelTypeSet encrypted_types) {
   MergeEncryptedTypes(encrypted_types);
 }
 
 void Cryptographer::MergeEncryptedTypes(
-    syncable::ModelTypeSet encrypted_types) {
+    syncer::ModelTypeSet encrypted_types) {
   if (encrypted_types_.HasAll(encrypted_types)) {
     return;
   }
diff --git a/sync/util/cryptographer.h b/sync/util/cryptographer.h
index f68655d..c234952 100644
--- a/sync/util/cryptographer.h
+++ b/sync/util/cryptographer.h
@@ -65,7 +65,7 @@ class Cryptographer {
     // set of encrypted types is SensitiveTypes() and that the encrypt
     // everything flag is false.
     virtual void OnEncryptedTypesChanged(
-        syncable::ModelTypeSet encrypted_types,
+        syncer::ModelTypeSet encrypted_types,
         bool encrypt_everything) = 0;
 
    protected:
@@ -181,7 +181,7 @@ class Cryptographer {
   UpdateResult Update(const sync_pb::NigoriSpecifics& nigori);
 
   // The set of types that are always encrypted.
-  static syncable::ModelTypeSet SensitiveTypes();
+  static syncer::ModelTypeSet SensitiveTypes();
 
   // Reset our set of encrypted types based on the contents of the nigori
   // specifics.
@@ -198,11 +198,10 @@ class Cryptographer {
   bool encrypt_everything() const;
 
   // Return the set of encrypted types.
-  syncable::ModelTypeSet GetEncryptedTypes() const;
+  syncer::ModelTypeSet GetEncryptedTypes() const;
 
   // Forwards to MergeEncryptedTypes.
-  void MergeEncryptedTypesForTest(
-      syncable::ModelTypeSet encrypted_types);
+  void MergeEncryptedTypesForTest(syncer::ModelTypeSet encrypted_types);
 
  private:
   FRIEND_TEST_ALL_PREFIXES(SyncCryptographerTest, PackUnpack);
@@ -210,7 +209,7 @@ class Cryptographer {
 
   // Merges the given set of encrypted types with the existing set and emits a
   // notification if necessary.
-  void MergeEncryptedTypes(syncable::ModelTypeSet encrypted_types);
+  void MergeEncryptedTypes(syncer::ModelTypeSet encrypted_types);
 
   void EmitEncryptedTypesChangedNotification();
 
@@ -242,7 +241,7 @@ class Cryptographer {
 
   scoped_ptr<sync_pb::EncryptedData> pending_keys_;
 
-  syncable::ModelTypeSet encrypted_types_;
+  syncer::ModelTypeSet encrypted_types_;
   bool encrypt_everything_;
 
   DISALLOW_COPY_AND_ASSIGN(Cryptographer);
diff --git a/sync/util/cryptographer_unittest.cc b/sync/util/cryptographer_unittest.cc
index d493b20..fe0798d 100644
--- a/sync/util/cryptographer_unittest.cc
+++ b/sync/util/cryptographer_unittest.cc
@@ -22,12 +22,11 @@ namespace {
 using ::testing::_;
 using ::testing::Mock;
 using ::testing::StrictMock;
-using syncable::ModelTypeSet;
 
 class MockObserver : public Cryptographer::Observer {
  public:
   MOCK_METHOD2(OnEncryptedTypesChanged,
-               void(syncable::ModelTypeSet, bool));
+               void(syncer::ModelTypeSet, bool));
 };
 
 }  // namespace
@@ -245,15 +244,15 @@ TEST_F(SyncCryptographerTest, NigoriEncryptionTypes) {
 
   EXPECT_CALL(observer,
               OnEncryptedTypesChanged(
-                  HasModelTypes(syncable::ModelTypeSet::All()),
+                  HasModelTypes(syncer::ModelTypeSet::All()),
                   false));
   EXPECT_CALL(observer2,
               OnEncryptedTypesChanged(
-                  HasModelTypes(syncable::ModelTypeSet::All()),
+                  HasModelTypes(syncer::ModelTypeSet::All()),
                   false));
 
   // Set all encrypted types
-  encrypted_types = syncable::ModelTypeSet::All();
+  encrypted_types = syncer::ModelTypeSet::All();
   cryptographer_.MergeEncryptedTypesForTest(encrypted_types);
   cryptographer_.UpdateNigoriFromEncryptedTypes(&nigori);
   cryptographer2.UpdateEncryptedTypesFromNigori(nigori);
@@ -269,7 +268,7 @@ TEST_F(SyncCryptographerTest, NigoriEncryptionTypes) {
 }
 
 TEST_F(SyncCryptographerTest, EncryptEverythingExplicit) {
-  ModelTypeSet real_types = syncable::ModelTypeSet::All();
+  ModelTypeSet real_types = syncer::ModelTypeSet::All();
   sync_pb::NigoriSpecifics specifics;
   specifics.set_encrypt_everything(true);
 
@@ -278,13 +277,13 @@ TEST_F(SyncCryptographerTest, EncryptEverythingExplicit) {
 
   EXPECT_CALL(observer,
               OnEncryptedTypesChanged(
-                  HasModelTypes(syncable::ModelTypeSet::All()), true));
+                  HasModelTypes(syncer::ModelTypeSet::All()), true));
 
   EXPECT_FALSE(cryptographer_.encrypt_everything());
   ModelTypeSet encrypted_types = cryptographer_.GetEncryptedTypes();
   for (ModelTypeSet::Iterator iter = real_types.First();
        iter.Good(); iter.Inc()) {
-    if (iter.Get() == syncable::PASSWORDS || iter.Get() == syncable::NIGORI)
+    if (iter.Get() == syncer::PASSWORDS || iter.Get() == syncer::NIGORI)
       EXPECT_TRUE(encrypted_types.Has(iter.Get()));
     else
       EXPECT_FALSE(encrypted_types.Has(iter.Get()));
@@ -306,7 +305,7 @@ TEST_F(SyncCryptographerTest, EncryptEverythingExplicit) {
 }
 
 TEST_F(SyncCryptographerTest, EncryptEverythingImplicit) {
-  ModelTypeSet real_types = syncable::ModelTypeSet::All();
+  ModelTypeSet real_types = syncer::ModelTypeSet::All();
   sync_pb::NigoriSpecifics specifics;
   specifics.set_encrypt_bookmarks(true);  // Non-passwords = encrypt everything
 
@@ -315,13 +314,13 @@ TEST_F(SyncCryptographerTest, EncryptEverythingImplicit) {
 
   EXPECT_CALL(observer,
               OnEncryptedTypesChanged(
-                  HasModelTypes(syncable::ModelTypeSet::All()), true));
+                  HasModelTypes(syncer::ModelTypeSet::All()), true));
 
   EXPECT_FALSE(cryptographer_.encrypt_everything());
   ModelTypeSet encrypted_types = cryptographer_.GetEncryptedTypes();
   for (ModelTypeSet::Iterator iter = real_types.First();
        iter.Good(); iter.Inc()) {
-    if (iter.Get() == syncable::PASSWORDS || iter.Get() == syncable::NIGORI)
+    if (iter.Get() == syncer::PASSWORDS || iter.Get() == syncer::NIGORI)
       EXPECT_TRUE(encrypted_types.Has(iter.Get()));
     else
       EXPECT_FALSE(encrypted_types.Has(iter.Get()));
@@ -343,7 +342,7 @@ TEST_F(SyncCryptographerTest, EncryptEverythingImplicit) {
 }
 
 TEST_F(SyncCryptographerTest, UnknownSensitiveTypes) {
-  ModelTypeSet real_types = syncable::ModelTypeSet::All();
+  ModelTypeSet real_types = syncer::ModelTypeSet::All();
   sync_pb::NigoriSpecifics specifics;
   // Explicitly setting encrypt everything should override logic for implicit
   // encrypt everything.
@@ -353,9 +352,9 @@ TEST_F(SyncCryptographerTest, UnknownSensitiveTypes) {
   StrictMock<MockObserver> observer;
   cryptographer_.AddObserver(&observer);
 
-  syncable::ModelTypeSet expected_encrypted_types =
+  syncer::ModelTypeSet expected_encrypted_types =
       Cryptographer::SensitiveTypes();
-  expected_encrypted_types.Put(syncable::BOOKMARKS);
+  expected_encrypted_types.Put(syncer::BOOKMARKS);
 
   EXPECT_CALL(observer,
               OnEncryptedTypesChanged(
@@ -365,7 +364,7 @@ TEST_F(SyncCryptographerTest, UnknownSensitiveTypes) {
   ModelTypeSet encrypted_types = cryptographer_.GetEncryptedTypes();
   for (ModelTypeSet::Iterator iter = real_types.First();
        iter.Good(); iter.Inc()) {
-    if (iter.Get() == syncable::PASSWORDS || iter.Get() == syncable::NIGORI)
+    if (iter.Get() == syncer::PASSWORDS || iter.Get() == syncer::NIGORI)
       EXPECT_TRUE(encrypted_types.Has(iter.Get()));
     else
       EXPECT_FALSE(encrypted_types.Has(iter.Get()));
@@ -377,9 +376,9 @@ TEST_F(SyncCryptographerTest, UnknownSensitiveTypes) {
   encrypted_types = cryptographer_.GetEncryptedTypes();
   for (ModelTypeSet::Iterator iter = real_types.First();
        iter.Good(); iter.Inc()) {
-    if (iter.Get() == syncable::PASSWORDS ||
-        iter.Get() == syncable::NIGORI ||
-        iter.Get() == syncable::BOOKMARKS)
+    if (iter.Get() == syncer::PASSWORDS ||
+        iter.Get() == syncer::NIGORI ||
+        iter.Get() == syncer::BOOKMARKS)
       EXPECT_TRUE(encrypted_types.Has(iter.Get()));
     else
       EXPECT_FALSE(encrypted_types.Has(iter.Get()));
diff --git a/sync/util/data_type_histogram.h b/sync/util/data_type_histogram.h
index ed66bb7..6a1b9c36 100644
--- a/sync/util/data_type_histogram.h
+++ b/sync/util/data_type_histogram.h
@@ -21,7 +21,7 @@
 // version of the datatype.
 //
 // Example usage (ignoring newlines necessary for multiline macro):
-// std::vector<syncable::ModelType> types = GetEntryTypes();
+// std::vector<syncer::ModelType> types = GetEntryTypes();
 // for (int i = 0; i < types.size(); ++i) {
 // #define PER_DATA_TYPE_MACRO(type_str)
 //     UMA_HISTOGRAM_ENUMERATION("Sync." type_str "StartFailures",
@@ -37,54 +37,54 @@
 #define SYNC_DATA_TYPE_HISTOGRAM(datatype) \
   do { \
     switch (datatype) { \
-      case syncable::BOOKMARKS: \
+      case syncer::BOOKMARKS: \
         PER_DATA_TYPE_MACRO("Bookmarks"); \
         break; \
-      case syncable::PREFERENCES: \
+      case syncer::PREFERENCES: \
         PER_DATA_TYPE_MACRO("Preferences"); \
         break; \
-      case syncable::PASSWORDS: \
+      case syncer::PASSWORDS: \
         PER_DATA_TYPE_MACRO("Passwords"); \
         break; \
-      case syncable::AUTOFILL: \
+      case syncer::AUTOFILL: \
         PER_DATA_TYPE_MACRO("Autofill"); \
         break; \
-      case syncable::AUTOFILL_PROFILE: \
+      case syncer::AUTOFILL_PROFILE: \
         PER_DATA_TYPE_MACRO("AutofillProfiles"); \
         break; \
-      case syncable::THEMES: \
+      case syncer::THEMES: \
         PER_DATA_TYPE_MACRO("Themes"); \
         break; \
-      case syncable::TYPED_URLS: \
+      case syncer::TYPED_URLS: \
         PER_DATA_TYPE_MACRO("TypedUrls"); \
         break; \
-      case syncable::EXTENSIONS: \
+      case syncer::EXTENSIONS: \
         PER_DATA_TYPE_MACRO("Extensions"); \
         break; \
-      case syncable::NIGORI: \
+      case syncer::NIGORI: \
         PER_DATA_TYPE_MACRO("Nigori"); \
         break; \
-      case syncable::SEARCH_ENGINES: \
+      case syncer::SEARCH_ENGINES: \
         PER_DATA_TYPE_MACRO("SearchEngines"); \
         break; \
-      case syncable::SESSIONS: \
+      case syncer::SESSIONS: \
         PER_DATA_TYPE_MACRO("Sessions"); \
         break; \
-      case syncable::APPS: \
+      case syncer::APPS: \
         PER_DATA_TYPE_MACRO("Apps"); \
         break; \
-      case syncable::APP_SETTINGS: \
+      case syncer::APP_SETTINGS: \
         PER_DATA_TYPE_MACRO("AppSettings"); \
         break; \
-      case syncable::EXTENSION_SETTINGS: \
+      case syncer::EXTENSION_SETTINGS: \
         PER_DATA_TYPE_MACRO("ExtensionSettings"); \
         break; \
-      case syncable::APP_NOTIFICATIONS: \
+      case syncer::APP_NOTIFICATIONS: \
         PER_DATA_TYPE_MACRO("AppNotifications"); \
         break; \
       default: \
         NOTREACHED() << "Unknown datatype " \
-                     << syncable::ModelTypeToString(datatype); \
+                     << syncer::ModelTypeToString(datatype); \
     } \
   } while (0)
 
diff --git a/sync/util/data_type_histogram_unittest.cc b/sync/util/data_type_histogram_unittest.cc
index 0601d31..f43a19b 100644
--- a/sync/util/data_type_histogram_unittest.cc
+++ b/sync/util/data_type_histogram_unittest.cc
@@ -16,9 +16,9 @@ class DataTypeHistogramTest : public testing::Test {
 // Create a histogram of type HISTOGRAM_COUNTS for each model type. Nothing
 // should break.
 TEST(DataTypeHistogramTest, BasicCount) {
-  for (int i = syncable::FIRST_REAL_MODEL_TYPE;
-       i <= syncable::LAST_REAL_MODEL_TYPE; ++i) {
-    syncable::ModelType type = syncable::ModelTypeFromInt(i);
+  for (int i = syncer::FIRST_REAL_MODEL_TYPE;
+       i <= syncer::LAST_REAL_MODEL_TYPE; ++i) {
+    syncer::ModelType type = syncer::ModelTypeFromInt(i);
 #define PER_DATA_TYPE_MACRO(type_str) \
     HISTOGRAM_COUNTS("Prefix" type_str "Suffix", 1);
     SYNC_DATA_TYPE_HISTOGRAM(type);
@@ -29,9 +29,9 @@ TEST(DataTypeHistogramTest, BasicCount) {
 // Create a histogram of type SYNC_FREQ_HISTOGRAM for each model type. Nothing
 // should break.
 TEST(DataTypeHistogramTest, BasicFreq) {
-  for (int i = syncable::FIRST_REAL_MODEL_TYPE;
-       i <= syncable::LAST_REAL_MODEL_TYPE; ++i) {
-    syncable::ModelType type = syncable::ModelTypeFromInt(i);
+  for (int i = syncer::FIRST_REAL_MODEL_TYPE;
+       i <= syncer::LAST_REAL_MODEL_TYPE; ++i) {
+    syncer::ModelType type = syncer::ModelTypeFromInt(i);
 #define PER_DATA_TYPE_MACRO(type_str) \
     SYNC_FREQ_HISTOGRAM("Prefix" type_str "Suffix", \
                         base::TimeDelta::FromSeconds(1));
@@ -48,9 +48,9 @@ TEST(DataTypeHistogramTest, BasicEnum) {
     TYPE_2,
     TYPE_COUNT,
   };
-  for (int i = syncable::FIRST_REAL_MODEL_TYPE;
-       i <= syncable::LAST_REAL_MODEL_TYPE; ++i) {
-    syncable::ModelType type = syncable::ModelTypeFromInt(i);
+  for (int i = syncer::FIRST_REAL_MODEL_TYPE;
+       i <= syncer::LAST_REAL_MODEL_TYPE; ++i) {
+    syncer::ModelType type = syncer::ModelTypeFromInt(i);
 #define PER_DATA_TYPE_MACRO(type_str) \
     UMA_HISTOGRAM_ENUMERATION("Prefix" type_str "Suffix", \
                               (i % 2 ? TYPE_1 : TYPE_2), TYPE_COUNT);