[Sync] Remove unneeded 'using syncer::' lines and 'syncer::' scopings

Since (almost) everything in sync/ is now in the 'syncer' namespace,
all of these are redundant.

Clean up indentation.

Put sync_{client,listen_notifications} into syncer namespace.

BUG=128060
TEST=


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

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

6 files changed, 82 insertions, 91 deletions

diff --git a/sync/util/cryptographer.cc b/sync/util/cryptographer.cc
index 59e8a1a..2c0d794 100644
--- a/sync/util/cryptographer.cc
+++ b/sync/util/cryptographer.cc
@@ -309,12 +309,12 @@ Cryptographer::UpdateResult Cryptographer::Update(
 }
 
 // Static
-syncer::ModelTypeSet Cryptographer::SensitiveTypes() {
+ModelTypeSet Cryptographer::SensitiveTypes() {
   // Both of these have their own encryption schemes, but we include them
   // anyways.
-  syncer::ModelTypeSet types;
-  types.Put(syncer::PASSWORDS);
-  types.Put(syncer::NIGORI);
+  ModelTypeSet types;
+  types.Put(PASSWORDS);
+  types.Put(NIGORI);
   return types;
 }
 
@@ -325,33 +325,33 @@ void Cryptographer::UpdateEncryptedTypesFromNigori(
     return;
   }
 
-  syncer::ModelTypeSet encrypted_types(SensitiveTypes());
+  ModelTypeSet encrypted_types(SensitiveTypes());
   if (nigori.encrypt_bookmarks())
-    encrypted_types.Put(syncer::BOOKMARKS);
+    encrypted_types.Put(BOOKMARKS);
   if (nigori.encrypt_preferences())
-    encrypted_types.Put(syncer::PREFERENCES);
+    encrypted_types.Put(PREFERENCES);
   if (nigori.encrypt_autofill_profile())
-    encrypted_types.Put(syncer::AUTOFILL_PROFILE);
+    encrypted_types.Put(AUTOFILL_PROFILE);
   if (nigori.encrypt_autofill())
-    encrypted_types.Put(syncer::AUTOFILL);
+    encrypted_types.Put(AUTOFILL);
   if (nigori.encrypt_themes())
-    encrypted_types.Put(syncer::THEMES);
+    encrypted_types.Put(THEMES);
   if (nigori.encrypt_typed_urls())
-    encrypted_types.Put(syncer::TYPED_URLS);
+    encrypted_types.Put(TYPED_URLS);
   if (nigori.encrypt_extension_settings())
-    encrypted_types.Put(syncer::EXTENSION_SETTINGS);
+    encrypted_types.Put(EXTENSION_SETTINGS);
   if (nigori.encrypt_extensions())
-    encrypted_types.Put(syncer::EXTENSIONS);
+    encrypted_types.Put(EXTENSIONS);
   if (nigori.encrypt_search_engines())
-    encrypted_types.Put(syncer::SEARCH_ENGINES);
+    encrypted_types.Put(SEARCH_ENGINES);
   if (nigori.encrypt_sessions())
-    encrypted_types.Put(syncer::SESSIONS);
+    encrypted_types.Put(SESSIONS);
   if (nigori.encrypt_app_settings())
-    encrypted_types.Put(syncer::APP_SETTINGS);
+    encrypted_types.Put(APP_SETTINGS);
   if (nigori.encrypt_apps())
-    encrypted_types.Put(syncer::APPS);
+    encrypted_types.Put(APPS);
   if (nigori.encrypt_app_notifications())
-    encrypted_types.Put(syncer::APP_NOTIFICATIONS);
+    encrypted_types.Put(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(syncer::BOOKMARKS));
+      encrypted_types_.Has(BOOKMARKS));
   nigori->set_encrypt_preferences(
-      encrypted_types_.Has(syncer::PREFERENCES));
+      encrypted_types_.Has(PREFERENCES));
   nigori->set_encrypt_autofill_profile(
-      encrypted_types_.Has(syncer::AUTOFILL_PROFILE));
-  nigori->set_encrypt_autofill(encrypted_types_.Has(syncer::AUTOFILL));
-  nigori->set_encrypt_themes(encrypted_types_.Has(syncer::THEMES));
+      encrypted_types_.Has(AUTOFILL_PROFILE));
+  nigori->set_encrypt_autofill(encrypted_types_.Has(AUTOFILL));
+  nigori->set_encrypt_themes(encrypted_types_.Has(THEMES));
   nigori->set_encrypt_typed_urls(
-      encrypted_types_.Has(syncer::TYPED_URLS));
+      encrypted_types_.Has(TYPED_URLS));
   nigori->set_encrypt_extension_settings(
-      encrypted_types_.Has(syncer::EXTENSION_SETTINGS));
+      encrypted_types_.Has(EXTENSION_SETTINGS));
   nigori->set_encrypt_extensions(
-      encrypted_types_.Has(syncer::EXTENSIONS));
+      encrypted_types_.Has(EXTENSIONS));
   nigori->set_encrypt_search_engines(
-      encrypted_types_.Has(syncer::SEARCH_ENGINES));
-  nigori->set_encrypt_sessions(encrypted_types_.Has(syncer::SESSIONS));
+      encrypted_types_.Has(SEARCH_ENGINES));
+  nigori->set_encrypt_sessions(encrypted_types_.Has(SESSIONS));
   nigori->set_encrypt_app_settings(
-      encrypted_types_.Has(syncer::APP_SETTINGS));
-  nigori->set_encrypt_apps(encrypted_types_.Has(syncer::APPS));
+      encrypted_types_.Has(APP_SETTINGS));
+  nigori->set_encrypt_apps(encrypted_types_.Has(APPS));
   nigori->set_encrypt_app_notifications(
-      encrypted_types_.Has(syncer::APP_NOTIFICATIONS));
+      encrypted_types_.Has(APP_NOTIFICATIONS));
 }
 
 void Cryptographer::set_encrypt_everything() {
   if (encrypt_everything_) {
-    DCHECK(encrypted_types_.Equals(syncer::ModelTypeSet::All()));
+    DCHECK(encrypted_types_.Equals(ModelTypeSet::All()));
     return;
   }
   encrypt_everything_ = true;
   // Change |encrypted_types_| directly to avoid sending more than one
   // notification.
-  encrypted_types_ = syncer::ModelTypeSet::All();
+  encrypted_types_ = ModelTypeSet::All();
   EmitEncryptedTypesChangedNotification();
 }
 
@@ -408,17 +408,15 @@ bool Cryptographer::encrypt_everything() const {
   return encrypt_everything_;
 }
 
-syncer::ModelTypeSet Cryptographer::GetEncryptedTypes() const {
+ModelTypeSet Cryptographer::GetEncryptedTypes() const {
   return encrypted_types_;
 }
 
-void Cryptographer::MergeEncryptedTypesForTest(
-    syncer::ModelTypeSet encrypted_types) {
+void Cryptographer::MergeEncryptedTypesForTest(ModelTypeSet encrypted_types) {
   MergeEncryptedTypes(encrypted_types);
 }
 
-void Cryptographer::MergeEncryptedTypes(
-    syncer::ModelTypeSet encrypted_types) {
+void Cryptographer::MergeEncryptedTypes(ModelTypeSet encrypted_types) {
   if (encrypted_types_.HasAll(encrypted_types)) {
     return;
   }
diff --git a/sync/util/cryptographer.h b/sync/util/cryptographer.h
index b6f99af..f02875a 100644
--- a/sync/util/cryptographer.h
+++ b/sync/util/cryptographer.h
@@ -64,7 +64,7 @@ class Cryptographer {
     // set of encrypted types is SensitiveTypes() and that the encrypt
     // everything flag is false.
     virtual void OnEncryptedTypesChanged(
-        syncer::ModelTypeSet encrypted_types,
+        ModelTypeSet encrypted_types,
         bool encrypt_everything) = 0;
 
    protected:
@@ -180,7 +180,7 @@ class Cryptographer {
   UpdateResult Update(const sync_pb::NigoriSpecifics& nigori);
 
   // The set of types that are always encrypted.
-  static syncer::ModelTypeSet SensitiveTypes();
+  static ModelTypeSet SensitiveTypes();
 
   // Reset our set of encrypted types based on the contents of the nigori
   // specifics.
@@ -197,10 +197,10 @@ class Cryptographer {
   bool encrypt_everything() const;
 
   // Return the set of encrypted types.
-  syncer::ModelTypeSet GetEncryptedTypes() const;
+  ModelTypeSet GetEncryptedTypes() const;
 
   // Forwards to MergeEncryptedTypes.
-  void MergeEncryptedTypesForTest(syncer::ModelTypeSet encrypted_types);
+  void MergeEncryptedTypesForTest(ModelTypeSet encrypted_types);
 
  private:
   FRIEND_TEST_ALL_PREFIXES(SyncCryptographerTest, PackUnpack);
@@ -208,7 +208,7 @@ class Cryptographer {
 
   // Merges the given set of encrypted types with the existing set and emits a
   // notification if necessary.
-  void MergeEncryptedTypes(syncer::ModelTypeSet encrypted_types);
+  void MergeEncryptedTypes(ModelTypeSet encrypted_types);
 
   void EmitEncryptedTypesChangedNotification();
 
@@ -240,7 +240,7 @@ class Cryptographer {
 
   scoped_ptr<sync_pb::EncryptedData> pending_keys_;
 
-  syncer::ModelTypeSet encrypted_types_;
+  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 fe0798d..d729311 100644
--- a/sync/util/cryptographer_unittest.cc
+++ b/sync/util/cryptographer_unittest.cc
@@ -25,8 +25,7 @@ using ::testing::StrictMock;
 
 class MockObserver : public Cryptographer::Observer {
  public:
-  MOCK_METHOD2(OnEncryptedTypesChanged,
-               void(syncer::ModelTypeSet, bool));
+  MOCK_METHOD2(OnEncryptedTypesChanged, void(ModelTypeSet, bool));
 };
 
 }  // namespace
@@ -244,15 +243,13 @@ TEST_F(SyncCryptographerTest, NigoriEncryptionTypes) {
 
   EXPECT_CALL(observer,
               OnEncryptedTypesChanged(
-                  HasModelTypes(syncer::ModelTypeSet::All()),
-                  false));
+                  HasModelTypes(ModelTypeSet::All()), false));
   EXPECT_CALL(observer2,
               OnEncryptedTypesChanged(
-                  HasModelTypes(syncer::ModelTypeSet::All()),
-                  false));
+                  HasModelTypes(ModelTypeSet::All()), false));
 
   // Set all encrypted types
-  encrypted_types = syncer::ModelTypeSet::All();
+  encrypted_types = ModelTypeSet::All();
   cryptographer_.MergeEncryptedTypesForTest(encrypted_types);
   cryptographer_.UpdateNigoriFromEncryptedTypes(&nigori);
   cryptographer2.UpdateEncryptedTypesFromNigori(nigori);
@@ -268,7 +265,7 @@ TEST_F(SyncCryptographerTest, NigoriEncryptionTypes) {
 }
 
 TEST_F(SyncCryptographerTest, EncryptEverythingExplicit) {
-  ModelTypeSet real_types = syncer::ModelTypeSet::All();
+  ModelTypeSet real_types = ModelTypeSet::All();
   sync_pb::NigoriSpecifics specifics;
   specifics.set_encrypt_everything(true);
 
@@ -277,13 +274,13 @@ TEST_F(SyncCryptographerTest, EncryptEverythingExplicit) {
 
   EXPECT_CALL(observer,
               OnEncryptedTypesChanged(
-                  HasModelTypes(syncer::ModelTypeSet::All()), true));
+                  HasModelTypes(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() == syncer::PASSWORDS || iter.Get() == syncer::NIGORI)
+    if (iter.Get() == PASSWORDS || iter.Get() == NIGORI)
       EXPECT_TRUE(encrypted_types.Has(iter.Get()));
     else
       EXPECT_FALSE(encrypted_types.Has(iter.Get()));
@@ -305,7 +302,7 @@ TEST_F(SyncCryptographerTest, EncryptEverythingExplicit) {
 }
 
 TEST_F(SyncCryptographerTest, EncryptEverythingImplicit) {
-  ModelTypeSet real_types = syncer::ModelTypeSet::All();
+  ModelTypeSet real_types = ModelTypeSet::All();
   sync_pb::NigoriSpecifics specifics;
   specifics.set_encrypt_bookmarks(true);  // Non-passwords = encrypt everything
 
@@ -314,13 +311,13 @@ TEST_F(SyncCryptographerTest, EncryptEverythingImplicit) {
 
   EXPECT_CALL(observer,
               OnEncryptedTypesChanged(
-                  HasModelTypes(syncer::ModelTypeSet::All()), true));
+                  HasModelTypes(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() == syncer::PASSWORDS || iter.Get() == syncer::NIGORI)
+    if (iter.Get() == PASSWORDS || iter.Get() == NIGORI)
       EXPECT_TRUE(encrypted_types.Has(iter.Get()));
     else
       EXPECT_FALSE(encrypted_types.Has(iter.Get()));
@@ -342,7 +339,7 @@ TEST_F(SyncCryptographerTest, EncryptEverythingImplicit) {
 }
 
 TEST_F(SyncCryptographerTest, UnknownSensitiveTypes) {
-  ModelTypeSet real_types = syncer::ModelTypeSet::All();
+  ModelTypeSet real_types = ModelTypeSet::All();
   sync_pb::NigoriSpecifics specifics;
   // Explicitly setting encrypt everything should override logic for implicit
   // encrypt everything.
@@ -352,9 +349,8 @@ TEST_F(SyncCryptographerTest, UnknownSensitiveTypes) {
   StrictMock<MockObserver> observer;
   cryptographer_.AddObserver(&observer);
 
-  syncer::ModelTypeSet expected_encrypted_types =
-      Cryptographer::SensitiveTypes();
-  expected_encrypted_types.Put(syncer::BOOKMARKS);
+  ModelTypeSet expected_encrypted_types = Cryptographer::SensitiveTypes();
+  expected_encrypted_types.Put(BOOKMARKS);
 
   EXPECT_CALL(observer,
               OnEncryptedTypesChanged(
@@ -364,7 +360,7 @@ TEST_F(SyncCryptographerTest, UnknownSensitiveTypes) {
   ModelTypeSet encrypted_types = cryptographer_.GetEncryptedTypes();
   for (ModelTypeSet::Iterator iter = real_types.First();
        iter.Good(); iter.Inc()) {
-    if (iter.Get() == syncer::PASSWORDS || iter.Get() == syncer::NIGORI)
+    if (iter.Get() == PASSWORDS || iter.Get() == NIGORI)
       EXPECT_TRUE(encrypted_types.Has(iter.Get()));
     else
       EXPECT_FALSE(encrypted_types.Has(iter.Get()));
@@ -376,9 +372,9 @@ TEST_F(SyncCryptographerTest, UnknownSensitiveTypes) {
   encrypted_types = cryptographer_.GetEncryptedTypes();
   for (ModelTypeSet::Iterator iter = real_types.First();
        iter.Good(); iter.Inc()) {
-    if (iter.Get() == syncer::PASSWORDS ||
-        iter.Get() == syncer::NIGORI ||
-        iter.Get() == syncer::BOOKMARKS)
+    if (iter.Get() == PASSWORDS ||
+        iter.Get() == NIGORI ||
+        iter.Get() == 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 00a81df..77eb57c 100644
--- a/sync/util/data_type_histogram.h
+++ b/sync/util/data_type_histogram.h
@@ -36,54 +36,54 @@
 #define SYNC_DATA_TYPE_HISTOGRAM(datatype) \
   do { \
     switch (datatype) { \
-      case syncer::BOOKMARKS: \
+      case ::syncer::BOOKMARKS: \
         PER_DATA_TYPE_MACRO("Bookmarks"); \
         break; \
-      case syncer::PREFERENCES: \
+      case ::syncer::PREFERENCES: \
         PER_DATA_TYPE_MACRO("Preferences"); \
         break; \
-      case syncer::PASSWORDS: \
+      case ::syncer::PASSWORDS: \
         PER_DATA_TYPE_MACRO("Passwords"); \
         break; \
-      case syncer::AUTOFILL: \
+      case ::syncer::AUTOFILL: \
         PER_DATA_TYPE_MACRO("Autofill"); \
         break; \
-      case syncer::AUTOFILL_PROFILE: \
+      case ::syncer::AUTOFILL_PROFILE: \
         PER_DATA_TYPE_MACRO("AutofillProfiles"); \
         break; \
-      case syncer::THEMES: \
+      case ::syncer::THEMES: \
         PER_DATA_TYPE_MACRO("Themes"); \
         break; \
-      case syncer::TYPED_URLS: \
+      case ::syncer::TYPED_URLS: \
         PER_DATA_TYPE_MACRO("TypedUrls"); \
         break; \
-      case syncer::EXTENSIONS: \
+      case ::syncer::EXTENSIONS: \
         PER_DATA_TYPE_MACRO("Extensions"); \
         break; \
-      case syncer::NIGORI: \
+      case ::syncer::NIGORI: \
         PER_DATA_TYPE_MACRO("Nigori"); \
         break; \
-      case syncer::SEARCH_ENGINES: \
+      case ::syncer::SEARCH_ENGINES: \
         PER_DATA_TYPE_MACRO("SearchEngines"); \
         break; \
-      case syncer::SESSIONS: \
+      case ::syncer::SESSIONS: \
         PER_DATA_TYPE_MACRO("Sessions"); \
         break; \
-      case syncer::APPS: \
+      case ::syncer::APPS: \
         PER_DATA_TYPE_MACRO("Apps"); \
         break; \
-      case syncer::APP_SETTINGS: \
+      case ::syncer::APP_SETTINGS: \
         PER_DATA_TYPE_MACRO("AppSettings"); \
         break; \
-      case syncer::EXTENSION_SETTINGS: \
+      case ::syncer::EXTENSION_SETTINGS: \
         PER_DATA_TYPE_MACRO("ExtensionSettings"); \
         break; \
-      case syncer::APP_NOTIFICATIONS: \
+      case ::syncer::APP_NOTIFICATIONS: \
         PER_DATA_TYPE_MACRO("AppNotifications"); \
         break; \
       default: \
         NOTREACHED() << "Unknown datatype " \
-                     << syncer::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 f43a19b..6ca1619 100644
--- a/sync/util/data_type_histogram_unittest.cc
+++ b/sync/util/data_type_histogram_unittest.cc
@@ -16,9 +16,8 @@ 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 = syncer::FIRST_REAL_MODEL_TYPE;
-       i <= syncer::LAST_REAL_MODEL_TYPE; ++i) {
-    syncer::ModelType type = syncer::ModelTypeFromInt(i);
+  for (int i = FIRST_REAL_MODEL_TYPE; i <= LAST_REAL_MODEL_TYPE; ++i) {
+    ModelType type = ModelTypeFromInt(i);
 #define PER_DATA_TYPE_MACRO(type_str) \
     HISTOGRAM_COUNTS("Prefix" type_str "Suffix", 1);
     SYNC_DATA_TYPE_HISTOGRAM(type);
@@ -29,9 +28,8 @@ TEST(DataTypeHistogramTest, BasicCount) {
 // Create a histogram of type SYNC_FREQ_HISTOGRAM for each model type. Nothing
 // should break.
 TEST(DataTypeHistogramTest, BasicFreq) {
-  for (int i = syncer::FIRST_REAL_MODEL_TYPE;
-       i <= syncer::LAST_REAL_MODEL_TYPE; ++i) {
-    syncer::ModelType type = syncer::ModelTypeFromInt(i);
+  for (int i = FIRST_REAL_MODEL_TYPE; i <= LAST_REAL_MODEL_TYPE; ++i) {
+    ModelType type = ModelTypeFromInt(i);
 #define PER_DATA_TYPE_MACRO(type_str) \
     SYNC_FREQ_HISTOGRAM("Prefix" type_str "Suffix", \
                         base::TimeDelta::FromSeconds(1));
@@ -48,9 +46,8 @@ TEST(DataTypeHistogramTest, BasicEnum) {
     TYPE_2,
     TYPE_COUNT,
   };
-  for (int i = syncer::FIRST_REAL_MODEL_TYPE;
-       i <= syncer::LAST_REAL_MODEL_TYPE; ++i) {
-    syncer::ModelType type = syncer::ModelTypeFromInt(i);
+  for (int i = FIRST_REAL_MODEL_TYPE; i <= LAST_REAL_MODEL_TYPE; ++i) {
+    ModelType type = ModelTypeFromInt(i);
 #define PER_DATA_TYPE_MACRO(type_str) \
     UMA_HISTOGRAM_ENUMERATION("Prefix" type_str "Suffix", \
                               (i % 2 ? TYPE_1 : TYPE_2), TYPE_COUNT);
diff --git a/sync/util/logging.h b/sync/util/logging.h
index e6da535..f23d9c1 100644
--- a/sync/util/logging.h
+++ b/sync/util/logging.h
@@ -29,6 +29,6 @@ bool VlogIsOnForLocation(const tracked_objects::Location& from_here,
       VLOG_LOC_STREAM(from_here, verbose_level),                        \
       ::logging::DEBUG_MODE &&                                          \
       (VLOG_IS_ON(verbose_level) ||                                     \
-       ::syncer::VlogIsOnForLocation(from_here, verbose_level)))  \
+       ::syncer::VlogIsOnForLocation(from_here, verbose_level)))        \
 
 #endif  // SYNC_UTIL_LOGGING_H_