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

sync/util/cryptographer_unittest.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 "sync/util/cryptographer.h"
 
 #include <string>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/string_util.h"
 #include "sync/internal_api/public/base/model_type_test_util.h"
 #include "sync/protocol/nigori_specifics.pb.h"
 #include "sync/protocol/password_specifics.pb.h"
 #include "sync/test/fake_encryptor.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace syncer {
 
 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
 
 class SyncCryptographerTest : public ::testing::Test {
  protected:
   SyncCryptographerTest() : cryptographer_(&encryptor_) {}
 
   FakeEncryptor encryptor_;
   Cryptographer cryptographer_;
@@ skipping 197 matching lines @@
   cryptographer_.UpdateNigoriFromEncryptedTypes(&nigori);
   cryptographer2.UpdateEncryptedTypesFromNigori(nigori);
   EXPECT_TRUE(encrypted_types.Equals(cryptographer_.GetEncryptedTypes()));
   EXPECT_TRUE(encrypted_types.Equals(cryptographer2.GetEncryptedTypes()));
 
   Mock::VerifyAndClearExpectations(&observer);
   Mock::VerifyAndClearExpectations(&observer2);
 
   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);
   EXPECT_TRUE(encrypted_types.Equals(cryptographer_.GetEncryptedTypes()));
   EXPECT_TRUE(encrypted_types.Equals(cryptographer2.GetEncryptedTypes()));
 
    // Receiving an empty nigori should not reset any encrypted types or trigger
    // an observer notification.
    Mock::VerifyAndClearExpectations(&observer);
    nigori = sync_pb::NigoriSpecifics();
    cryptographer_.UpdateEncryptedTypesFromNigori(nigori);
    EXPECT_TRUE(encrypted_types.Equals(cryptographer_.GetEncryptedTypes()));
 }
 
 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);
 
   StrictMock<MockObserver> observer;
   cryptographer_.AddObserver(&observer);
 
   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()));
   }
 
   cryptographer_.UpdateEncryptedTypesFromNigori(specifics);
 
   EXPECT_TRUE(cryptographer_.encrypt_everything());
   encrypted_types = cryptographer_.GetEncryptedTypes();
   for (ModelTypeSet::Iterator iter = real_types.First();
        iter.Good(); iter.Inc()) {
     EXPECT_TRUE(encrypted_types.Has(iter.Get()));
   }
 
   // Shouldn't trigger another notification.
   specifics.set_encrypt_everything(true);
 
   cryptographer_.RemoveObserver(&observer);
 }
 
 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
 
   StrictMock<MockObserver> observer;
   cryptographer_.AddObserver(&observer);
 
   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()));
   }
 
   cryptographer_.UpdateEncryptedTypesFromNigori(specifics);
 
   EXPECT_TRUE(cryptographer_.encrypt_everything());
   encrypted_types = cryptographer_.GetEncryptedTypes();
   for (ModelTypeSet::Iterator iter = real_types.First();
        iter.Good(); iter.Inc()) {
     EXPECT_TRUE(encrypted_types.Has(iter.Get()));
   }
 
   // Shouldn't trigger another notification.
   specifics.set_encrypt_everything(true);
 
   cryptographer_.RemoveObserver(&observer);
 }
 
 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.
   specifics.set_encrypt_everything(false);
   specifics.set_encrypt_bookmarks(true);
 
   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(
                   HasModelTypes(expected_encrypted_types), false));
 
   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()));
   }
 
   cryptographer_.UpdateEncryptedTypesFromNigori(specifics);
 
   EXPECT_FALSE(cryptographer_.encrypt_everything());
   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()));
   }
 
   cryptographer_.RemoveObserver(&observer);
 }
 
 }  // namespace syncer