[Sync] Rename csync namespace to syncer

chrome/browser/sync/profile_sync_service_session_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 <map>
 #include <string>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
@@ skipping 37 matching lines @@
 #include "sync/test/engine/test_id_factory.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/base/ui_base_types.h"
 
 using browser_sync::SessionChangeProcessor;
 using browser_sync::SessionDataTypeController;
 using browser_sync::SessionModelAssociator;
 using browser_sync::SyncBackendHost;
 using content::BrowserThread;
-using csync::ChangeRecord;
+using syncer::ChangeRecord;
 using testing::_;
 using testing::Return;
-using csync::TestIdFactory;
+using syncer::TestIdFactory;
 
 namespace browser_sync {
 
 namespace {
 
 void BuildSessionSpecifics(const std::string& tag,
                            sync_pb::SessionSpecifics* meta) {
   meta->set_session_tag(tag);
   sync_pb::SessionHeader* header = meta->mutable_header();
   header->set_device_type(sync_pb::SessionHeader_DeviceType_TYPE_LINUX);
@@ skipping 228 matching lines @@
   CreateRootHelper create_root(this);
   ASSERT_TRUE(StartSyncService(create_root.callback(), false));
   ASSERT_TRUE(create_root.success());
 
   // Check that the DataTypeController associated the models.
   bool has_nodes;
   ASSERT_TRUE(model_associator_->SyncModelHasUserCreatedNodes(&has_nodes));
   ASSERT_TRUE(has_nodes);
   std::string machine_tag = model_associator_->GetCurrentMachineTag();
   int64 sync_id = model_associator_->GetSyncIdFromSessionTag(machine_tag);
-  ASSERT_NE(csync::kInvalidId, sync_id);
+  ASSERT_NE(syncer::kInvalidId, sync_id);
 
   // Check that we can get the correct session specifics back from the node.
-  csync::ReadTransaction trans(FROM_HERE, sync_service_->GetUserShare());
-  csync::ReadNode node(&trans);
-  ASSERT_EQ(csync::BaseNode::INIT_OK,
+  syncer::ReadTransaction trans(FROM_HERE, sync_service_->GetUserShare());
+  syncer::ReadNode node(&trans);
+  ASSERT_EQ(syncer::BaseNode::INIT_OK,
             node.InitByClientTagLookup(syncable::SESSIONS, machine_tag));
   const sync_pb::SessionSpecifics& specifics(node.GetSessionSpecifics());
   ASSERT_EQ(machine_tag, specifics.session_tag());
   ASSERT_TRUE(specifics.has_header());
   const sync_pb::SessionHeader& header_s = specifics.header();
   ASSERT_TRUE(header_s.has_device_type());
   ASSERT_EQ("TestSessionName", header_s.client_name());
   ASSERT_EQ(0, header_s.window_size());
 }
 
@@ skipping 11 matching lines @@
   ASSERT_TRUE(has_nodes);
   AddTab(browser(), GURL("http://foo/1"));
   NavigateAndCommitActiveTab(GURL("http://foo/2"));
   AddTab(browser(), GURL("http://bar/1"));
   NavigateAndCommitActiveTab(GURL("http://bar/2"));
 
   ASSERT_TRUE(model_associator_->SyncModelHasUserCreatedNodes(&has_nodes));
   ASSERT_TRUE(has_nodes);
   std::string machine_tag = model_associator_->GetCurrentMachineTag();
   int64 sync_id = model_associator_->GetSyncIdFromSessionTag(machine_tag);
-  ASSERT_NE(csync::kInvalidId, sync_id);
+  ASSERT_NE(syncer::kInvalidId, sync_id);
 
   // Check that this machine's data is not included in the foreign windows.
   std::vector<const SyncedSession*> foreign_sessions;
   ASSERT_FALSE(model_associator_->GetAllForeignSessions(&foreign_sessions));
   ASSERT_EQ(foreign_sessions.size(), 0U);
 
   // Get the tabs for this machine from the node and check that they were
   // filled.
   SessionModelAssociator::TabLinksMap tab_map = model_associator_->tab_map_;
   ASSERT_EQ(2U, tab_map.size());
@@ skipping 283 matching lines @@
 
 // Test the DataTypeController on update.
 TEST_F(ProfileSyncServiceSessionTest, UpdatedSyncNodeActionUpdate) {
   CreateRootHelper create_root(this);
   ASSERT_TRUE(StartSyncService(create_root.callback(), false));
   ASSERT_TRUE(create_root.success());
   int64 node_id = model_associator_->GetSyncIdFromSessionTag(
       model_associator_->GetCurrentMachineTag());
   ASSERT_FALSE(notified_of_update_);
   {
-    csync::WriteTransaction trans(FROM_HERE, sync_service_->GetUserShare());
+    syncer::WriteTransaction trans(FROM_HERE, sync_service_->GetUserShare());
     change_processor_->ApplyChangesFromSyncModel(
         &trans,
         ProfileSyncServiceTestHelper::MakeSingletonChangeRecordList(
             node_id, ChangeRecord::ACTION_UPDATE));
   }
   ASSERT_TRUE(notified_of_update_);
 }
 
 // Test the DataTypeController on add.
 TEST_F(ProfileSyncServiceSessionTest, UpdatedSyncNodeActionAdd) {
   CreateRootHelper create_root(this);
   ASSERT_TRUE(StartSyncService(create_root.callback(), false));
   ASSERT_TRUE(create_root.success());
 
   int64 node_id = model_associator_->GetSyncIdFromSessionTag(
       model_associator_->GetCurrentMachineTag());
   ASSERT_FALSE(notified_of_update_);
   {
-    csync::WriteTransaction trans(FROM_HERE, sync_service_->GetUserShare());
+    syncer::WriteTransaction trans(FROM_HERE, sync_service_->GetUserShare());
     change_processor_->ApplyChangesFromSyncModel(
         &trans,
         ProfileSyncServiceTestHelper::MakeSingletonChangeRecordList(
             node_id, ChangeRecord::ACTION_ADD));
   }
   ASSERT_TRUE(notified_of_update_);
 }
 
 // Test the DataTypeController on delete.
 TEST_F(ProfileSyncServiceSessionTest, UpdatedSyncNodeActionDelete) {
   CreateRootHelper create_root(this);
   ASSERT_TRUE(StartSyncService(create_root.callback(), false));
   ASSERT_TRUE(create_root.success());
 
   int64 node_id = model_associator_->GetSyncIdFromSessionTag(
       model_associator_->GetCurrentMachineTag());
   sync_pb::EntitySpecifics deleted_specifics;
   deleted_specifics.mutable_session()->set_session_tag("tag");
   ASSERT_FALSE(notified_of_update_);
   {
-    csync::WriteTransaction trans(FROM_HERE, sync_service_->GetUserShare());
+    syncer::WriteTransaction trans(FROM_HERE, sync_service_->GetUserShare());
     change_processor_->ApplyChangesFromSyncModel(
         &trans,
         ProfileSyncServiceTestHelper::MakeSingletonDeletionChangeRecordList(
             node_id, deleted_specifics));
   }
   ASSERT_TRUE(notified_of_update_);
 }
 // Test the TabNodePool when it starts off empty.
 TEST_F(ProfileSyncServiceSessionTest, TabNodePoolEmpty) {
   CreateRootHelper create_root(this);
@@ skipping 269 matching lines @@
 
   CreateRootHelper create_root(this);
   ASSERT_TRUE(StartSyncService(create_root.callback(), false));
   ASSERT_TRUE(create_root.success());
   bool has_nodes;
   ASSERT_TRUE(model_associator_->SyncModelHasUserCreatedNodes(&has_nodes));
   ASSERT_TRUE(has_nodes);
 
   std::string machine_tag = model_associator_->GetCurrentMachineTag();
   int64 sync_id = model_associator_->GetSyncIdFromSessionTag(machine_tag);
-  ASSERT_NE(csync::kInvalidId, sync_id);
+  ASSERT_NE(syncer::kInvalidId, sync_id);
 
   // Check that this machine's data is not included in the foreign windows.
   std::vector<const SyncedSession*> foreign_sessions;
   ASSERT_FALSE(model_associator_->GetAllForeignSessions(&foreign_sessions));
   ASSERT_EQ(foreign_sessions.size(), 0U);
 
   // Get the tabs for this machine from the node and check that they were
   // filled.
   SessionModelAssociator::TabLinksMap tab_map = model_associator_->tab_map_;
   ASSERT_EQ(2U, tab_map.size());
@@ skipping 14 matching lines @@
 }
 
 // TODO(jhorwich): Re-enable when crbug.com/121487 addressed
 TEST_F(ProfileSyncServiceSessionTest, DISABLED_MissingHeaderAndTab) {
   AddTab(browser(), GURL("http://foo1"));
   NavigateAndCommitActiveTab(GURL("http://foo2"));
   AddTab(browser(), GURL("http://bar1"));
   NavigateAndCommitActiveTab(GURL("http://bar2"));
   CreateRootHelper create_root(this);
   ASSERT_TRUE(StartSyncService(create_root.callback(), false));
-  csync::SyncError error;
+  syncer::SyncError error;
   std::string local_tag = model_associator_->GetCurrentMachineTag();
 
   error = model_associator_->DisassociateModels();
   ASSERT_FALSE(error.IsSet());
   {
     // Create a sync node with the local tag but neither header nor tab field.
-    csync::WriteTransaction trans(FROM_HERE, sync_service_->GetUserShare());
-    csync::ReadNode root(&trans);
+    syncer::WriteTransaction trans(FROM_HERE, sync_service_->GetUserShare());
+    syncer::ReadNode root(&trans);
     root.InitByTagLookup(syncable::ModelTypeToRootTag(syncable::SESSIONS));
-    csync::WriteNode extra_header(&trans);
-    csync::WriteNode::InitUniqueByCreationResult result =
+    syncer::WriteNode extra_header(&trans);
+    syncer::WriteNode::InitUniqueByCreationResult result =
         extra_header.InitUniqueByCreation(syncable::SESSIONS, root, "new_tag");
-    ASSERT_EQ(csync::WriteNode::INIT_SUCCESS, result);
+    ASSERT_EQ(syncer::WriteNode::INIT_SUCCESS, result);
     sync_pb::SessionSpecifics specifics;
     specifics.set_session_tag(local_tag);
     extra_header.SetSessionSpecifics(specifics);
   }
 
   error = model_associator_->AssociateModels();
   ASSERT_FALSE(error.IsSet());
 }
 
 // TODO(jhorwich): Re-enable when crbug.com/121487 addressed
 TEST_F(ProfileSyncServiceSessionTest, DISABLED_MultipleHeaders) {
   AddTab(browser(), GURL("http://foo1"));
   NavigateAndCommitActiveTab(GURL("http://foo2"));
   AddTab(browser(), GURL("http://bar1"));
   NavigateAndCommitActiveTab(GURL("http://bar2"));
   CreateRootHelper create_root(this);
   ASSERT_TRUE(StartSyncService(create_root.callback(), false));
-  csync::SyncError error;
+  syncer::SyncError error;
   std::string local_tag = model_associator_->GetCurrentMachineTag();
 
   error = model_associator_->DisassociateModels();
   ASSERT_FALSE(error.IsSet());
   {
     // Create another sync node with a header field and the local tag.
-    csync::WriteTransaction trans(FROM_HERE, sync_service_->GetUserShare());
-    csync::ReadNode root(&trans);
+    syncer::WriteTransaction trans(FROM_HERE, sync_service_->GetUserShare());
+    syncer::ReadNode root(&trans);
     root.InitByTagLookup(syncable::ModelTypeToRootTag(syncable::SESSIONS));
-    csync::WriteNode extra_header(&trans);
-    csync::WriteNode::InitUniqueByCreationResult result =
+    syncer::WriteNode extra_header(&trans);
+    syncer::WriteNode::InitUniqueByCreationResult result =
         extra_header.InitUniqueByCreation(syncable::SESSIONS,
                                           root, local_tag + "_");
-    ASSERT_EQ(csync::WriteNode::INIT_SUCCESS, result);
+    ASSERT_EQ(syncer::WriteNode::INIT_SUCCESS, result);
     sync_pb::SessionSpecifics specifics;
     specifics.set_session_tag(local_tag);
     specifics.mutable_header();
     extra_header.SetSessionSpecifics(specifics);
   }
   error = model_associator_->AssociateModels();
   ASSERT_FALSE(error.IsSet());
 }
 
 // TODO(jhorwich): Re-enable when crbug.com/121487 addressed
 TEST_F(ProfileSyncServiceSessionTest, DISABLED_CorruptedForeign) {
   AddTab(browser(), GURL("http://foo1"));
   NavigateAndCommitActiveTab(GURL("http://foo2"));
   AddTab(browser(), GURL("http://bar1"));
   NavigateAndCommitActiveTab(GURL("http://bar2"));
   CreateRootHelper create_root(this);
   ASSERT_TRUE(StartSyncService(create_root.callback(), false));
-  csync::SyncError error;
+  syncer::SyncError error;
 
   error = model_associator_->DisassociateModels();
   ASSERT_FALSE(error.IsSet());
   {
     // Create another sync node with neither header nor tab field and a foreign
     // tag.
     std::string foreign_tag = "foreign_tag";
-    csync::WriteTransaction trans(FROM_HERE, sync_service_->GetUserShare());
-    csync::ReadNode root(&trans);
+    syncer::WriteTransaction trans(FROM_HERE, sync_service_->GetUserShare());
+    syncer::ReadNode root(&trans);
     root.InitByTagLookup(syncable::ModelTypeToRootTag(syncable::SESSIONS));
-    csync::WriteNode extra_header(&trans);
-    csync::WriteNode::InitUniqueByCreationResult result =
+    syncer::WriteNode extra_header(&trans);
+    syncer::WriteNode::InitUniqueByCreationResult result =
         extra_header.InitUniqueByCreation(syncable::SESSIONS,
                                           root, foreign_tag);
-    ASSERT_EQ(csync::WriteNode::INIT_SUCCESS, result);
+    ASSERT_EQ(syncer::WriteNode::INIT_SUCCESS, result);
     sync_pb::SessionSpecifics specifics;
     specifics.set_session_tag(foreign_tag);
     extra_header.SetSessionSpecifics(specifics);
   }
   error = model_associator_->AssociateModels();
   ASSERT_FALSE(error.IsSet());
 }
 
 // TODO(jhorwich): Re-enable when crbug.com/121487 addressed
 TEST_F(ProfileSyncServiceSessionTest, DISABLED_MissingLocalTabNode) {
   AddTab(browser(), GURL("http://foo1"));
   NavigateAndCommitActiveTab(GURL("http://foo2"));
   AddTab(browser(), GURL("http://bar1"));
   NavigateAndCommitActiveTab(GURL("http://bar2"));
   CreateRootHelper create_root(this);
   ASSERT_TRUE(StartSyncService(create_root.callback(), false));
   std::string local_tag = model_associator_->GetCurrentMachineTag();
-  csync::SyncError error;
+  syncer::SyncError error;
 
   error = model_associator_->DisassociateModels();
   ASSERT_FALSE(error.IsSet());
   {
     // Delete the first sync tab node.
     std::string tab_tag = SessionModelAssociator::TabIdToTag(local_tag, 0);
 
-    csync::WriteTransaction trans(FROM_HERE, sync_service_->GetUserShare());
-    csync::ReadNode root(&trans);
+    syncer::WriteTransaction trans(FROM_HERE, sync_service_->GetUserShare());
+    syncer::ReadNode root(&trans);
     root.InitByTagLookup(syncable::ModelTypeToRootTag(syncable::SESSIONS));
-    csync::WriteNode tab_node(&trans);
+    syncer::WriteNode tab_node(&trans);
     ASSERT_TRUE(tab_node.InitByClientTagLookup(syncable::SESSIONS, tab_tag));
     tab_node.Remove();
   }
   error = model_associator_->AssociateModels();
   ASSERT_FALSE(error.IsSet());
 
   // Add some more tabs to ensure we don't conflict with the pre-existing tab
   // node.
   AddTab(browser(), GURL("http://baz1"));
   AddTab(browser(), GURL("http://baz2"));
@@ skipping 41 matching lines @@
 
 // TODO(jhorwich): Re-enable when crbug.com/121487 addressed
 TEST_F(ProfileSyncServiceSessionTest, DISABLED_CorruptedLocalHeader) {
   AddTab(browser(), GURL("http://foo1"));
   NavigateAndCommitActiveTab(GURL("http://foo2"));
   AddTab(browser(), GURL("http://bar1"));
   NavigateAndCommitActiveTab(GURL("http://bar2"));
   CreateRootHelper create_root(this);
   ASSERT_TRUE(StartSyncService(create_root.callback(), false));
   std::string local_tag = model_associator_->GetCurrentMachineTag();
-  csync::SyncError error;
+  syncer::SyncError error;
 
   error = model_associator_->DisassociateModels();
   ASSERT_FALSE(error.IsSet());
   {
     // Load the header node and clear it.
-    csync::WriteTransaction trans(FROM_HERE, sync_service_->GetUserShare());
-    csync::WriteNode header(&trans);
-    ASSERT_EQ(csync::BaseNode::INIT_OK,
+    syncer::WriteTransaction trans(FROM_HERE, sync_service_->GetUserShare());
+    syncer::WriteNode header(&trans);
+    ASSERT_EQ(syncer::BaseNode::INIT_OK,
               header.InitByClientTagLookup(syncable::SESSIONS, local_tag));
     sync_pb::SessionSpecifics specifics;
     header.SetSessionSpecifics(specifics);
   }
   // Ensure we associate properly despite the pre-existing node with our local
   // tag.
   error = model_associator_->AssociateModels();
   ASSERT_FALSE(error.IsSet());
 }
 
 }  // namespace browser_sync