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

chrome/browser/sync/profile_sync_service_password_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 <vector>
 
 #include "testing/gtest/include/gtest/gtest.h"
 
 #include "base/bind.h"
 #include "base/location.h"
@@ skipping 107 matching lines @@
 
   void AddPasswordSyncNode(const PasswordForm& entry) {
     syncer::WriteTransaction trans(FROM_HERE, service_->GetUserShare());
     syncer::ReadNode password_root(&trans);
     ASSERT_EQ(syncer::BaseNode::INIT_OK,
               password_root.InitByTagLookup(browser_sync::kPasswordTag));
 
     syncer::WriteNode node(&trans);
     std::string tag = PasswordModelAssociator::MakeTag(entry);
     syncer::WriteNode::InitUniqueByCreationResult result =
-        node.InitUniqueByCreation(syncable::PASSWORDS, password_root, tag);
+        node.InitUniqueByCreation(syncer::PASSWORDS, password_root, tag);
     ASSERT_EQ(syncer::WriteNode::INIT_SUCCESS, result);
     PasswordModelAssociator::WriteToSyncNode(entry, &node);
   }
 
  protected:
   ProfileSyncServicePasswordTest() {}
 
   virtual void SetUp() {
     AbstractProfileSyncServiceTest::SetUp();
     profile_.CreateRequestContext();
@@ skipping 35 matching lines @@
       SigninManager* signin = SigninManagerFactory::GetForProfile(&profile_);
       signin->SetAuthenticatedUsername("test_user");
       token_service_ = static_cast<TokenService*>(
           TokenServiceFactory::GetInstance()->SetTestingFactoryAndUse(
               &profile_, BuildTokenService));
       ProfileSyncComponentsFactoryMock* factory =
           new ProfileSyncComponentsFactoryMock();
       service_.reset(new PasswordTestProfileSyncService(
           factory, &profile_, signin, false,
           root_callback, node_callback));
-      syncable::ModelTypeSet preferred_types =
-          service_->GetPreferredDataTypes();
-      preferred_types.Put(syncable::PASSWORDS);
+      syncer::ModelTypeSet preferred_types = service_->GetPreferredDataTypes();
+      preferred_types.Put(syncer::PASSWORDS);
       service_->ChangePreferredDataTypes(preferred_types);
       PasswordDataTypeController* data_type_controller =
           new PasswordDataTypeController(factory,
                                          &profile_,
                                          service_.get());
 
       EXPECT_CALL(*factory, CreatePasswordSyncComponents(_, _, _)).
           Times(AtLeast(1)).  // Can be more if we hit NEEDS_CRYPTO.
           WillRepeatedly(MakePasswordSyncComponents(service_.get(),
                                                     password_store_.get(),
@@ skipping 85 matching lines @@
   StartSyncService(base::Closure(), base::Closure());
   EXPECT_TRUE(service_->HasUnrecoverableError());
 }
 
 TEST_F(ProfileSyncServicePasswordTest, EmptyNativeEmptySync) {
   EXPECT_CALL(*password_store_, FillAutofillableLogins(_))
       .WillOnce(Return(true));
   EXPECT_CALL(*password_store_, FillBlacklistLogins(_))
       .WillOnce(Return(true));
   SetIdleChangeProcessorExpectations();
-  CreateRootHelper create_root(this, syncable::PASSWORDS);
+  CreateRootHelper create_root(this, syncer::PASSWORDS);
   StartSyncService(create_root.callback(), base::Closure());
   std::vector<PasswordForm> sync_entries;
   GetPasswordEntriesFromSyncDB(&sync_entries);
   EXPECT_EQ(0U, sync_entries.size());
 }
 
 TEST_F(ProfileSyncServicePasswordTest, HasNativeEntriesEmptySync) {
   std::vector<PasswordForm*> forms;
   std::vector<PasswordForm> expected_forms;
   PasswordForm* new_form = new PasswordForm;
   new_form->scheme = PasswordForm::SCHEME_HTML;
   new_form->signon_realm = "pie";
   new_form->origin = GURL("http://pie.com");
   new_form->action = GURL("http://pie.com/submit");
   new_form->username_element = UTF8ToUTF16("name");
   new_form->username_value = UTF8ToUTF16("tom");
   new_form->password_element = UTF8ToUTF16("cork");
   new_form->password_value = UTF8ToUTF16("password1");
   new_form->ssl_valid = true;
   new_form->preferred = false;
   new_form->date_created = base::Time::FromInternalValue(1234);
   new_form->blacklisted_by_user = false;
   forms.push_back(new_form);
   expected_forms.push_back(*new_form);
   EXPECT_CALL(*password_store_, FillAutofillableLogins(_))
       .WillOnce(DoAll(SetArgumentPointee<0>(forms), Return(true)));
   EXPECT_CALL(*password_store_, FillBlacklistLogins(_))
       .WillOnce(Return(true));
   SetIdleChangeProcessorExpectations();
-  CreateRootHelper create_root(this, syncable::PASSWORDS);
+  CreateRootHelper create_root(this, syncer::PASSWORDS);
   StartSyncService(create_root.callback(), base::Closure());
   std::vector<PasswordForm> sync_forms;
   GetPasswordEntriesFromSyncDB(&sync_forms);
   ASSERT_EQ(1U, sync_forms.size());
   EXPECT_TRUE(ComparePasswords(expected_forms[0], sync_forms[0]));
 }
 
 TEST_F(ProfileSyncServicePasswordTest, HasNativeEntriesEmptySyncSameUsername) {
   std::vector<PasswordForm*> forms;
   std::vector<PasswordForm> expected_forms;
@@ skipping 31 matching lines @@
     new_form->blacklisted_by_user = false;
     forms.push_back(new_form);
     expected_forms.push_back(*new_form);
   }
 
   EXPECT_CALL(*password_store_, FillAutofillableLogins(_))
       .WillOnce(DoAll(SetArgumentPointee<0>(forms), Return(true)));
   EXPECT_CALL(*password_store_, FillBlacklistLogins(_))
       .WillOnce(Return(true));
   SetIdleChangeProcessorExpectations();
-  CreateRootHelper create_root(this, syncable::PASSWORDS);
+  CreateRootHelper create_root(this, syncer::PASSWORDS);
   StartSyncService(create_root.callback(), base::Closure());
   std::vector<PasswordForm> sync_forms;
   GetPasswordEntriesFromSyncDB(&sync_forms);
   ASSERT_EQ(2U, sync_forms.size());
   EXPECT_TRUE(ComparePasswords(expected_forms[0], sync_forms[1]));
   EXPECT_TRUE(ComparePasswords(expected_forms[1], sync_forms[0]));
 }
 
 TEST_F(ProfileSyncServicePasswordTest, HasNativeHasSyncNoMerge) {
   std::vector<PasswordForm*> native_forms;
@@ skipping 34 matching lines @@
     new_form.blacklisted_by_user = false;
     sync_forms.push_back(new_form);
     expected_forms.push_back(new_form);
   }
 
   EXPECT_CALL(*password_store_, FillAutofillableLogins(_))
       .WillOnce(DoAll(SetArgumentPointee<0>(native_forms), Return(true)));
   EXPECT_CALL(*password_store_, FillBlacklistLogins(_)).WillOnce(Return(true));
   EXPECT_CALL(*password_store_, AddLoginImpl(_)).Times(1);
 
-  CreateRootHelper create_root(this, syncable::PASSWORDS);
+  CreateRootHelper create_root(this, syncer::PASSWORDS);
   StartSyncService(create_root.callback(),
                    base::Bind(&AddPasswordEntriesCallback, this, sync_forms));
 
   std::vector<PasswordForm> new_sync_forms;
   GetPasswordEntriesFromSyncDB(&new_sync_forms);
 
   EXPECT_EQ(2U, new_sync_forms.size());
   EXPECT_TRUE(ComparePasswords(expected_forms[0], new_sync_forms[0]));
   EXPECT_TRUE(ComparePasswords(expected_forms[1], new_sync_forms[1]));
 }
@@ skipping 44 matching lines @@
   EXPECT_CALL(*password_store_, FillAutofillableLogins(_))
       .WillOnce(DoAll(SetArgumentPointee<0>(native_forms),
                       AcquireSyncTransaction(this),
                       Return(true)));
   EXPECT_CALL(*password_store_, FillBlacklistLogins(_))
       .WillOnce(DoAll(AcquireSyncTransaction(this),
                       Return(true)));
   EXPECT_CALL(*password_store_, AddLoginImpl(_))
       .WillOnce(AcquireSyncTransaction(this));
 
-  CreateRootHelper create_root(this, syncable::PASSWORDS);
+  CreateRootHelper create_root(this, syncer::PASSWORDS);
   StartSyncService(create_root.callback(),
                    base::Bind(&AddPasswordEntriesCallback, this, sync_forms));
 
   std::vector<PasswordForm> new_sync_forms;
   GetPasswordEntriesFromSyncDB(&new_sync_forms);
 
   EXPECT_EQ(2U, new_sync_forms.size());
   EXPECT_TRUE(ComparePasswords(expected_forms[0], new_sync_forms[0]));
   EXPECT_TRUE(ComparePasswords(expected_forms[1], new_sync_forms[1]));
 }
@@ skipping 52 matching lines @@
     new_form.date_created = base::Time::FromInternalValue(12345);
     new_form.blacklisted_by_user = false;
     expected_forms.push_back(new_form);
   }
 
   EXPECT_CALL(*password_store_, FillAutofillableLogins(_))
       .WillOnce(DoAll(SetArgumentPointee<0>(native_forms), Return(true)));
   EXPECT_CALL(*password_store_, FillBlacklistLogins(_)).WillOnce(Return(true));
   EXPECT_CALL(*password_store_, UpdateLoginImpl(_)).Times(1);
 
-  CreateRootHelper create_root(this, syncable::PASSWORDS);
+  CreateRootHelper create_root(this, syncer::PASSWORDS);
   StartSyncService(create_root.callback(),
                    base::Bind(&AddPasswordEntriesCallback, this, sync_forms));
 
   std::vector<PasswordForm> new_sync_forms;
   GetPasswordEntriesFromSyncDB(&new_sync_forms);
 
   EXPECT_EQ(1U, new_sync_forms.size());
   EXPECT_TRUE(ComparePasswords(expected_forms[0], new_sync_forms[0]));
 }