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

sync/syncable/syncable_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 <string>
 
 #include "base/compiler_specific.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/location.h"
@@ skipping 18 matching lines @@
 #include "sync/syncable/syncable_util.h"
 #include "sync/syncable/write_transaction.h"
 #include "sync/test/engine/test_id_factory.h"
 #include "sync/test/engine/test_syncable_utils.h"
 #include "sync/test/fake_encryptor.h"
 #include "sync/test/null_directory_change_delegate.h"
 #include "sync/test/null_transaction_observer.h"
 #include "sync/util/test_unrecoverable_error_handler.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
-using base::ExpectDictBooleanValue;
-using base::ExpectDictStringValue;
-using syncer::FakeEncryptor;
-using syncer::TestIdFactory;
-using syncer::TestUnrecoverableErrorHandler;
-
 namespace syncer {
 namespace syncable {
 
+using base::ExpectDictBooleanValue;
+using base::ExpectDictStringValue;
+
 class SyncableKernelTest : public testing::Test {};
 
 // TODO(akalin): Add unit tests for EntryKernel::ContainsString().
 
 TEST_F(SyncableKernelTest, ToValue) {
   EntryKernel kernel;
   scoped_ptr<DictionaryValue> value(kernel.ToValue());
   if (value.get()) {
     // Not much to check without repeating the ToValue() code.
     EXPECT_TRUE(value->HasKey("isDirty"));
@@ skipping 483 matching lines @@
         all_handles.insert(e.Get(META_HANDLE));
       } else {
         AddDefaultFieldValue(PREFERENCES, &specs);
         all_handles.insert(e.Get(META_HANDLE));
       }
       e.Put(SPECIFICS, specs);
       e.Put(SERVER_SPECIFICS, specs);
     }
   }
 
-  syncer::ModelTypeSet to_purge(BOOKMARKS);
+  ModelTypeSet to_purge(BOOKMARKS);
   dir_->PurgeEntriesWithTypeIn(to_purge);
 
   Directory::SaveChangesSnapshot snapshot1;
   base::AutoLock scoped_lock(dir_->kernel_->save_changes_mutex);
   dir_->TakeSnapshotForSaveChanges(&snapshot1);
   EXPECT_TRUE(expected_purges == snapshot1.metahandles_to_purge);
 
   to_purge.Clear();
   to_purge.Put(PREFERENCES);
   dir_->PurgeEntriesWithTypeIn(to_purge);
@@ skipping 260 matching lines @@
     WriteTransaction trans(FROM_HERE, UNITTEST, dir_.get());
     dir_->GetUnsyncedMetaHandles(&trans, &handles);
     ASSERT_TRUE(1 == handles.size());
     ASSERT_TRUE(handle2 == handles[0]);
   }
 }
 
 TEST_F(SyncableDirectoryTest, TestGetUnappliedUpdates) {
   std::vector<int64> handles;
   int64 handle1, handle2;
-  const syncer::FullModelTypeSet all_types = syncer::FullModelTypeSet::All();
+  const FullModelTypeSet all_types = FullModelTypeSet::All();
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, dir_.get());
 
     dir_->GetUnappliedUpdateMetaHandles(&trans, all_types, &handles);
     ASSERT_TRUE(0 == handles.size());
 
     MutableEntry e1(&trans, CREATE, trans.root_id(), "abba");
     ASSERT_TRUE(e1.good());
     handle1 = e1.Get(META_HANDLE);
     e1.Put(IS_UNAPPLIED_UPDATE, false);
@@ skipping 553 matching lines @@
   sync_pb::EntitySpecifics bookmark_specs;
   sync_pb::EntitySpecifics autofill_specs;
   sync_pb::EntitySpecifics preference_specs;
   AddDefaultFieldValue(BOOKMARKS, &bookmark_specs);
   AddDefaultFieldValue(PREFERENCES, &preference_specs);
   AddDefaultFieldValue(AUTOFILL, &autofill_specs);
   dir_->set_initial_sync_ended_for_type(BOOKMARKS, true);
   dir_->set_initial_sync_ended_for_type(PREFERENCES, true);
   dir_->set_initial_sync_ended_for_type(AUTOFILL, true);
 
-  syncer::ModelTypeSet types_to_purge(PREFERENCES, AUTOFILL);
+  ModelTypeSet types_to_purge(PREFERENCES, AUTOFILL);
 
   TestIdFactory id_factory;
   // Create some items for each type.
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, dir_.get());
     MutableEntry item1(&trans, CREATE, trans.root_id(), "Item");
     ASSERT_TRUE(item1.good());
     item1.Put(SPECIFICS, bookmark_specs);
     item1.Put(SERVER_SPECIFICS, bookmark_specs);
     item1.Put(IS_UNSYNCED, true);
@@ skipping 271 matching lines @@
     EXPECT_TRUE(e1.GetKernelCopy().is_dirty());
     EXPECT_TRUE(IsInDirtyMetahandles(handle1));
   }
   ASSERT_TRUE(dir_->SaveChanges());
 
   // Now do some operations using a directory for which SaveChanges will
   // always fail.
   SwapInUnsaveableDirectory();
   ASSERT_TRUE(dir_->good());
 
-  syncer::ModelTypeSet set(BOOKMARKS);
+  ModelTypeSet set(BOOKMARKS);
   dir_->PurgeEntriesWithTypeIn(set);
   EXPECT_TRUE(IsInMetahandlesToPurge(handle1));
   ASSERT_FALSE(dir_->SaveChanges());
   EXPECT_TRUE(IsInMetahandlesToPurge(handle1));
 }
 
 }  // namespace
 
 void SyncableDirectoryTest::ValidateEntry(BaseTransaction* trans,
                                           int64 id,
@@ skipping 234 matching lines @@
   EXPECT_TRUE(CreateWithDefaultTag(factory_.NewServerId(), true));
   EXPECT_FALSE(CreateWithDefaultTag(factory_.NewServerId(), true));
   EXPECT_FALSE(CreateWithDefaultTag(factory_.NewServerId(), false));
   EXPECT_FALSE(CreateWithDefaultTag(factory_.NewLocalId(), false));
   EXPECT_FALSE(CreateWithDefaultTag(factory_.NewLocalId(), true));
 }
 
 }  // namespace
 }  // namespace syncable
 }  // namespace syncer