[Sync] Move //components/sync to the syncer namespace, take 2.

components/sync/core_impl/sync_manager_impl_unittest.cc

 // Copyright 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.
 
 // Unit tests for the SyncApi. Note that a lot of the underlying
 // functionality is provided by the Syncable layer, which has its own
 // unit tests. We'll test SyncApi specific things in this harness.
 
 #include "components/sync/core_impl/sync_manager_impl.h"
 
@@ skipping 271 matching lines @@
 }
 
 bool SyncApiTest::ReloadDir() {
   return test_user_share_.Reload();
 }
 
 void SyncApiTest::CreateEntryWithAttachmentMetadata(
     const ModelType& model_type,
     const std::string& client_tag,
     const sync_pb::AttachmentMetadata& attachment_metadata) {
-  syncer::WriteTransaction trans(FROM_HERE, user_share());
-  syncer::ReadNode root_node(&trans);
+  WriteTransaction trans(FROM_HERE, user_share());
+  ReadNode root_node(&trans);
   root_node.InitByRootLookup();
-  syncer::WriteNode node(&trans);
+  WriteNode node(&trans);
   ASSERT_EQ(node.InitUniqueByCreation(model_type, root_node, client_tag),
-            syncer::WriteNode::INIT_SUCCESS);
+            WriteNode::INIT_SUCCESS);
   node.SetAttachmentMetadata(attachment_metadata);
 }
 
 BaseNode::InitByLookupResult SyncApiTest::LookupEntryByClientTag(
     const ModelType& model_type,
     const std::string& client_tag) {
-  syncer::ReadTransaction trans(FROM_HERE, user_share());
-  syncer::ReadNode node(&trans);
+  ReadTransaction trans(FROM_HERE, user_share());
+  ReadNode node(&trans);
   return node.InitByClientTagLookup(model_type, client_tag);
 }
 
 void SyncApiTest::ReplaceWithTombstone(const ModelType& model_type,
                                        const std::string& client_tag) {
-  syncer::WriteTransaction trans(FROM_HERE, user_share());
-  syncer::WriteNode node(&trans);
+  WriteTransaction trans(FROM_HERE, user_share());
+  WriteNode node(&trans);
   ASSERT_EQ(node.InitByClientTagLookup(model_type, client_tag),
-            syncer::WriteNode::INIT_OK);
+            WriteNode::INIT_OK);
   node.Tombstone();
 }
 
 TEST_F(SyncApiTest, SanityCheckTest) {
   {
     ReadTransaction trans(FROM_HERE, user_share());
     EXPECT_TRUE(trans.GetWrappedTrans());
   }
   {
     WriteTransaction trans(FROM_HERE, user_share());
@@ skipping 370 matching lines @@
   ignore_result(MakeBookmarkWithParent(user_share(), child1, NULL));
   EXPECT_EQ(6, GetTotalNodeCount(user_share(), type_root));
   EXPECT_EQ(4, GetTotalNodeCount(user_share(), parent));
 }
 
 // Verify that Directory keeps track of which attachments are referenced by
 // which entries.
 TEST_F(SyncApiTest, AttachmentLinking) {
   // Add an entry with an attachment.
   std::string tag1("some tag");
-  syncer::AttachmentId attachment_id(syncer::AttachmentId::Create(0, 0));
+  AttachmentId attachment_id(AttachmentId::Create(0, 0));
   sync_pb::AttachmentMetadata attachment_metadata;
   sync_pb::AttachmentMetadataRecord* record = attachment_metadata.add_record();
   *record->mutable_id() = attachment_id.GetProto();
   ASSERT_FALSE(dir()->IsAttachmentLinked(attachment_id.GetProto()));
   CreateEntryWithAttachmentMetadata(PREFERENCES, tag1, attachment_metadata);
 
   // See that the directory knows it's linked.
   ASSERT_TRUE(dir()->IsAttachmentLinked(attachment_id.GetProto()));
 
   // Add a second entry referencing the same attachment.
   std::string tag2("some other tag");
   CreateEntryWithAttachmentMetadata(PREFERENCES, tag2, attachment_metadata);
 
   // See that the directory knows it's still linked.
   ASSERT_TRUE(dir()->IsAttachmentLinked(attachment_id.GetProto()));
 
   // Tombstone the first entry.
-  ReplaceWithTombstone(syncer::PREFERENCES, tag1);
+  ReplaceWithTombstone(PREFERENCES, tag1);
 
   // See that the attachment is still considered linked because the entry hasn't
   // been purged from the Directory.
   ASSERT_TRUE(dir()->IsAttachmentLinked(attachment_id.GetProto()));
 
   // Save changes and see that the entry is truly gone.
   ASSERT_TRUE(dir()->SaveChanges());
   ASSERT_EQ(LookupEntryByClientTag(PREFERENCES, tag1),
-            syncer::WriteNode::INIT_FAILED_ENTRY_NOT_GOOD);
+            WriteNode::INIT_FAILED_ENTRY_NOT_GOOD);
 
   // However, the attachment is still linked.
   ASSERT_TRUE(dir()->IsAttachmentLinked(attachment_id.GetProto()));
 
   // Save, destroy, and recreate the directory.  See that it's still linked.
   ASSERT_TRUE(ReloadDir());
   ASSERT_TRUE(dir()->IsAttachmentLinked(attachment_id.GetProto()));
 
   // Tombstone the second entry, save changes, see that it's truly gone.
-  ReplaceWithTombstone(syncer::PREFERENCES, tag2);
+  ReplaceWithTombstone(PREFERENCES, tag2);
   ASSERT_TRUE(dir()->SaveChanges());
   ASSERT_EQ(LookupEntryByClientTag(PREFERENCES, tag2),
-            syncer::WriteNode::INIT_FAILED_ENTRY_NOT_GOOD);
+            WriteNode::INIT_FAILED_ENTRY_NOT_GOOD);
 
   // Finally, the attachment is no longer linked.
   ASSERT_FALSE(dir()->IsAttachmentLinked(attachment_id.GetProto()));
 }
 
 // This tests directory integrity in the case of creating a new unique node
 // with client tag matching that of an existing unapplied node with server only
 // data. See crbug.com/505761.
 TEST_F(SyncApiTest, WriteNode_UniqueByCreation_UndeleteCase) {
   int64_t preferences_root = MakeTypeRoot(user_share(), PREFERENCES);
@@ skipping 148 matching lines @@
   }
 };
 
 class SyncManagerObserverMock : public SyncManager::Observer {
  public:
   MOCK_METHOD1(OnSyncCycleCompleted, void(const SyncCycleSnapshot&));  // NOLINT
   MOCK_METHOD4(OnInitializationComplete,
                void(const WeakHandle<JsBackend>&,
                     const WeakHandle<DataTypeDebugInfoListener>&,
                     bool,
-                    syncer::ModelTypeSet));                         // NOLINT
+                    ModelTypeSet));                                 // NOLINT
   MOCK_METHOD1(OnConnectionStatusChange, void(ConnectionStatus));   // NOLINT
   MOCK_METHOD1(OnUpdatedToken, void(const std::string&));           // NOLINT
   MOCK_METHOD1(OnActionableError, void(const SyncProtocolError&));  // NOLINT
-  MOCK_METHOD1(OnMigrationRequested, void(syncer::ModelTypeSet));   // NOLINT
+  MOCK_METHOD1(OnMigrationRequested, void(ModelTypeSet));           // NOLINT
   MOCK_METHOD1(OnProtocolEvent, void(const ProtocolEvent&));        // NOLINT
 };
 
 class SyncEncryptionHandlerObserverMock
     : public SyncEncryptionHandler::Observer {
  public:
   MOCK_METHOD2(OnPassphraseRequired,
                void(PassphraseRequiredReason,
                     const sync_pb::EncryptedData&));  // NOLINT
   MOCK_METHOD0(OnPassphraseAccepted, void());         // NOLINT
@@ skipping 2430 matching lines @@
 // SyncManagerInitInvalidStorageTest::GetFactory will return
 // DirectoryBackingStore that ensures that SyncManagerImpl::OpenDirectory fails.
 // SyncManagerImpl initialization is done in SyncManagerTest::SetUp. This test's
 // task is to ensure that SyncManagerImpl reported initialization failure in
 // OnInitializationComplete callback.
 TEST_F(SyncManagerInitInvalidStorageTest, FailToOpenDatabase) {
   EXPECT_FALSE(initialization_succeeded_);
 }
 
 }  // namespace syncer