[Sync] Rename csync namespace to syncer

chrome/browser/sync/profile_sync_service_bookmark_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.
 
 // TODO(akalin): This file is basically just a unit test for
 // BookmarkChangeProcessor.  Write unit tests for
 // BookmarkModelAssociator separately.
 
 #include <stack>
 #include <vector>
@@ skipping 26 matching lines @@
 #include "sync/internal_api/public/write_node.h"
 #include "sync/internal_api/public/write_transaction.h"
 #include "sync/syncable/mutable_entry.h"  // TODO(tim): Remove. Bug 131130.
 #include "sync/test/engine/test_id_factory.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace browser_sync {
 
 using content::BrowserThread;
-using csync::BaseNode;
+using syncer::BaseNode;
 using testing::_;
 using testing::InvokeWithoutArgs;
 using testing::Mock;
 using testing::StrictMock;
 
 class TestBookmarkModelAssociator : public BookmarkModelAssociator {
  public:
   TestBookmarkModelAssociator(
       BookmarkModel* bookmark_model,
-      csync::UserShare* user_share,
+      syncer::UserShare* user_share,
       DataTypeErrorHandler* error_handler)
       : BookmarkModelAssociator(bookmark_model, user_share,
                                 error_handler,
                                 true /* expect_mobile_bookmarks_folder */),
         user_share_(user_share) {}
 
   // TODO(akalin): This logic lazily creates any tagged node that is
   // requested.  A better way would be to have utility functions to
   // create sync nodes from some bookmark structure and to use that.
   virtual bool GetSyncIdForTaggedNode(const std::string& tag, int64* sync_id) {
     std::string tag_str = std::string(tag.c_str(), tag.length());
     bool root_exists = false;
     syncable::ModelType type = model_type();
     {
-      csync::WriteTransaction trans(FROM_HERE, user_share_);
-      csync::ReadNode uber_root(&trans);
+      syncer::WriteTransaction trans(FROM_HERE, user_share_);
+      syncer::ReadNode uber_root(&trans);
       uber_root.InitByRootLookup();
 
-      csync::ReadNode root(&trans);
+      syncer::ReadNode root(&trans);
       root_exists = root.InitByTagLookup(
           ProfileSyncServiceTestHelper::GetTagForType(type)) ==
               BaseNode::INIT_OK;
     }
 
     if (!root_exists) {
       bool created = ProfileSyncServiceTestHelper::CreateRoot(
           type,
           user_share_,
           &id_factory_);
       if (!created)
         return false;
     }
 
-    csync::WriteTransaction trans(FROM_HERE, user_share_);
-    csync::ReadNode root(&trans);
+    syncer::WriteTransaction trans(FROM_HERE, user_share_);
+    syncer::ReadNode root(&trans);
     EXPECT_EQ(BaseNode::INIT_OK, root.InitByTagLookup(
         ProfileSyncServiceTestHelper::GetTagForType(type)));
 
     // First, try to find a node with the title among the root's children.
     // This will be the case if we are testing model persistence, and
     // are reloading a sync repository created earlier in the test.
-    int64 last_child_id = csync::kInvalidId;
-    for (int64 id = root.GetFirstChildId(); id != csync::kInvalidId; /***/) {
-      csync::ReadNode child(&trans);
+    int64 last_child_id = syncer::kInvalidId;
+    for (int64 id = root.GetFirstChildId(); id != syncer::kInvalidId; /***/) {
+      syncer::ReadNode child(&trans);
       EXPECT_EQ(BaseNode::INIT_OK, child.InitByIdLookup(id));
       last_child_id = id;
       if (tag_str == child.GetTitle()) {
         *sync_id = id;
         return true;
       }
       id = child.GetSuccessorId();
     }
 
-    csync::ReadNode predecessor_node(&trans);
-    csync::ReadNode* predecessor = NULL;
-    if (last_child_id != csync::kInvalidId) {
+    syncer::ReadNode predecessor_node(&trans);
+    syncer::ReadNode* predecessor = NULL;
+    if (last_child_id != syncer::kInvalidId) {
       EXPECT_EQ(BaseNode::INIT_OK,
                 predecessor_node.InitByIdLookup(last_child_id));
       predecessor = &predecessor_node;
     }
-    csync::WriteNode node(&trans);
+    syncer::WriteNode node(&trans);
     // Create new fake tagged nodes at the end of the ordering.
     node.InitByCreation(type, root, predecessor);
     node.SetIsFolder(true);
     node.GetMutableEntryForTest()->Put(syncable::UNIQUE_SERVER_TAG, tag);
     node.SetTitle(UTF8ToWide(tag_str));
     node.SetExternalId(0);
     *sync_id = node.GetId();
     return true;
   }
 
  private:
-  csync::UserShare* user_share_;
-  csync::TestIdFactory id_factory_;
+  syncer::UserShare* user_share_;
+  syncer::TestIdFactory id_factory_;
 };
 
 namespace {
 
-// FakeServerChange constructs a list of csync::ChangeRecords while modifying
+// FakeServerChange constructs a list of syncer::ChangeRecords while modifying
 // the sync model, and can pass the ChangeRecord list to a
-// csync::SyncObserver (i.e., the ProfileSyncService) to test the client
+// syncer::SyncObserver (i.e., the ProfileSyncService) to test the client
 // change-application behavior.
 // Tests using FakeServerChange should be careful to avoid back-references,
 // since FakeServerChange will send the edits in the order specified.
 class FakeServerChange {
  public:
-  explicit FakeServerChange(csync::WriteTransaction* trans) : trans_(trans) {
+  explicit FakeServerChange(syncer::WriteTransaction* trans) : trans_(trans) {
   }
 
   // Pretend that the server told the syncer to add a bookmark object.
   int64 Add(const std::wstring& title,
             const std::string& url,
             bool is_folder,
             int64 parent_id,
             int64 predecessor_id) {
-    csync::ReadNode parent(trans_);
+    syncer::ReadNode parent(trans_);
     EXPECT_EQ(BaseNode::INIT_OK, parent.InitByIdLookup(parent_id));
-    csync::WriteNode node(trans_);
+    syncer::WriteNode node(trans_);
     if (predecessor_id == 0) {
       EXPECT_TRUE(node.InitByCreation(syncable::BOOKMARKS, parent, NULL));
     } else {
-      csync::ReadNode predecessor(trans_);
+      syncer::ReadNode predecessor(trans_);
       EXPECT_EQ(BaseNode::INIT_OK, predecessor.InitByIdLookup(predecessor_id));
       EXPECT_EQ(predecessor.GetParentId(), parent.GetId());
       EXPECT_TRUE(node.InitByCreation(syncable::BOOKMARKS, parent,
                                       &predecessor));
     }
     EXPECT_EQ(node.GetPredecessorId(), predecessor_id);
     EXPECT_EQ(node.GetParentId(), parent_id);
     node.SetIsFolder(is_folder);
     node.SetTitle(title);
     if (!is_folder)
       node.SetURL(GURL(url));
-    csync::ChangeRecord record;
-    record.action = csync::ChangeRecord::ACTION_ADD;
+    syncer::ChangeRecord record;
+    record.action = syncer::ChangeRecord::ACTION_ADD;
     record.id = node.GetId();
     changes_.push_back(record);
     return node.GetId();
   }
 
   // Add a bookmark folder.
   int64 AddFolder(const std::wstring& title,
                   int64 parent_id,
                   int64 predecessor_id) {
     return Add(title, std::string(), true, parent_id, predecessor_id);
   }
 
   // Add a bookmark.
   int64 AddURL(const std::wstring& title,
                const std::string& url,
                int64 parent_id,
                int64 predecessor_id) {
     return Add(title, url, false, parent_id, predecessor_id);
   }
 
   // Pretend that the server told the syncer to delete an object.
   void Delete(int64 id) {
     {
       // Delete the sync node.
-      csync::WriteNode node(trans_);
+      syncer::WriteNode node(trans_);
       EXPECT_EQ(BaseNode::INIT_OK, node.InitByIdLookup(id));
       EXPECT_FALSE(node.GetFirstChildId());
       node.Remove();
     }
     {
       // Verify the deletion.
-      csync::ReadNode node(trans_);
+      syncer::ReadNode node(trans_);
       EXPECT_EQ(BaseNode::INIT_FAILED_ENTRY_IS_DEL, node.InitByIdLookup(id));
     }
 
-    csync::ChangeRecord record;
-    record.action = csync::ChangeRecord::ACTION_DELETE;
+    syncer::ChangeRecord record;
+    record.action = syncer::ChangeRecord::ACTION_DELETE;
     record.id = id;
     // Deletions are always first in the changelist, but we can't actually do
     // WriteNode::Remove() on the node until its children are moved. So, as
     // a practical matter, users of FakeServerChange must move or delete
     // children before parents.  Thus, we must insert the deletion record
     // at the front of the vector.
     changes_.insert(changes_.begin(), record);
   }
 
   // Set a new title value, and return the old value.
   std::wstring ModifyTitle(int64 id, const std::wstring& new_title) {
-    csync::WriteNode node(trans_);
+    syncer::WriteNode node(trans_);
     EXPECT_EQ(BaseNode::INIT_OK, node.InitByIdLookup(id));
     std::string old_title = node.GetTitle();
     node.SetTitle(new_title);
     SetModified(id);
     return UTF8ToWide(old_title);
   }
 
   // Set a new parent and predecessor value.  Return the old parent id.
   // We could return the old predecessor id, but it turns out not to be
   // very useful for assertions.
   int64 ModifyPosition(int64 id, int64 parent_id, int64 predecessor_id) {
-    csync::ReadNode parent(trans_);
+    syncer::ReadNode parent(trans_);
     EXPECT_EQ(BaseNode::INIT_OK, parent.InitByIdLookup(parent_id));
-    csync::WriteNode node(trans_);
+    syncer::WriteNode node(trans_);
     EXPECT_EQ(BaseNode::INIT_OK, node.InitByIdLookup(id));
     int64 old_parent_id = node.GetParentId();
     if (predecessor_id == 0) {
       EXPECT_TRUE(node.SetPosition(parent, NULL));
     } else {
-      csync::ReadNode predecessor(trans_);
+      syncer::ReadNode predecessor(trans_);
       EXPECT_EQ(BaseNode::INIT_OK, predecessor.InitByIdLookup(predecessor_id));
       EXPECT_EQ(predecessor.GetParentId(), parent.GetId());
       EXPECT_TRUE(node.SetPosition(parent, &predecessor));
     }
     SetModified(id);
     return old_parent_id;
   }
 
   // Pass the fake change list to |service|.
   void ApplyPendingChanges(ChangeProcessor* processor) {
     processor->ApplyChangesFromSyncModel(
-        trans_, csync::ImmutableChangeRecordList(&changes_));
+        trans_, syncer::ImmutableChangeRecordList(&changes_));
   }
 
-  const csync::ChangeRecordList& changes() {
+  const syncer::ChangeRecordList& changes() {
     return changes_;
   }
 
  private:
   // Helper function to push an ACTION_UPDATE record onto the back
   // of the changelist.
   void SetModified(int64 id) {
     // Coalesce multi-property edits.
     if (!changes_.empty() && changes_.back().id == id &&
         changes_.back().action ==
-        csync::ChangeRecord::ACTION_UPDATE)
+        syncer::ChangeRecord::ACTION_UPDATE)
       return;
-    csync::ChangeRecord record;
-    record.action = csync::ChangeRecord::ACTION_UPDATE;
+    syncer::ChangeRecord record;
+    record.action = syncer::ChangeRecord::ACTION_UPDATE;
     record.id = id;
     changes_.push_back(record);
   }
 
   // The transaction on which everything happens.
-  csync::WriteTransaction *trans_;
+  syncer::WriteTransaction *trans_;
 
   // The change list we construct.
-  csync::ChangeRecordList changes_;
+  syncer::ChangeRecordList changes_;
 };
 
 class ExtensiveChangesBookmarkModelObserver : public BaseBookmarkModelObserver {
  public:
   explicit ExtensiveChangesBookmarkModelObserver()
       : started_count_(0),
         completed_count_at_started_(0),
         completed_count_(0) {}
 
   virtual void ExtensiveBookmarkChangesBeginning(
@@ skipping 67 matching lines @@
       model_->ClearStore();
     message_loop_.RunAllPending();
   }
 
   void StartSync() {
     // Set up model associator.
     model_associator_.reset(new TestBookmarkModelAssociator(
         profile_.GetBookmarkModel(),
         test_user_share_.user_share(),
         &mock_error_handler_));
-    csync::SyncError error = model_associator_->AssociateModels();
+    syncer::SyncError error = model_associator_->AssociateModels();
     EXPECT_FALSE(error.IsSet());
     MessageLoop::current()->RunAllPending();
 
     // Set up change processor.
     change_processor_.reset(
         new BookmarkChangeProcessor(model_associator_.get(),
                                     &mock_error_handler_));
     change_processor_->Start(&profile_, test_user_share_.user_share());
   }
 
   void StopSync() {
     change_processor_->Stop();
     change_processor_.reset();
-    csync::SyncError error = model_associator_->DisassociateModels();
+    syncer::SyncError error = model_associator_->DisassociateModels();
     EXPECT_FALSE(error.IsSet());
     model_associator_.reset();
 
     message_loop_.RunAllPending();
 
     // TODO(akalin): Actually close the database and flush it to disk
     // (and make StartSync reload from disk).  This would require
     // refactoring TestUserShare.
   }
 
   void UnloadBookmarkModel() {
     profile_.CreateBookmarkModel(false /* delete_bookmarks */);
     model_ = NULL;
     message_loop_.RunAllPending();
   }
 
   bool InitSyncNodeFromChromeNode(const BookmarkNode* bnode,
-                                  csync::BaseNode* sync_node) {
+                                  syncer::BaseNode* sync_node) {
     return model_associator_->InitSyncNodeFromChromeId(bnode->id(),
                                                        sync_node);
   }
 
-  void ExpectSyncerNodeMatching(csync::BaseTransaction* trans,
+  void ExpectSyncerNodeMatching(syncer::BaseTransaction* trans,
                                 const BookmarkNode* bnode) {
-    csync::ReadNode gnode(trans);
+    syncer::ReadNode gnode(trans);
     ASSERT_TRUE(InitSyncNodeFromChromeNode(bnode, &gnode));
     // Non-root node titles and parents must match.
     if (!model_->is_permanent_node(bnode)) {
       EXPECT_EQ(bnode->GetTitle(), UTF8ToUTF16(gnode.GetTitle()));
       EXPECT_EQ(
           model_associator_->GetChromeNodeFromSyncId(gnode.GetParentId()),
           bnode->parent());
     }
     EXPECT_EQ(bnode->is_folder(), gnode.GetIsFolder());
     if (bnode->is_url())
       EXPECT_EQ(bnode->url(), gnode.GetURL());
 
     // Check for position matches.
     int browser_index = bnode->parent()->GetIndexOf(bnode);
     if (browser_index == 0) {
       EXPECT_EQ(gnode.GetPredecessorId(), 0);
     } else {
       const BookmarkNode* bprev =
           bnode->parent()->GetChild(browser_index - 1);
-      csync::ReadNode gprev(trans);
+      syncer::ReadNode gprev(trans);
       ASSERT_TRUE(InitSyncNodeFromChromeNode(bprev, &gprev));
       EXPECT_EQ(gnode.GetPredecessorId(), gprev.GetId());
       EXPECT_EQ(gnode.GetParentId(), gprev.GetParentId());
     }
     if (browser_index == bnode->parent()->child_count() - 1) {
       EXPECT_EQ(gnode.GetSuccessorId(), 0);
     } else {
       const BookmarkNode* bnext =
           bnode->parent()->GetChild(browser_index + 1);
-      csync::ReadNode gnext(trans);
+      syncer::ReadNode gnext(trans);
       ASSERT_TRUE(InitSyncNodeFromChromeNode(bnext, &gnext));
       EXPECT_EQ(gnode.GetSuccessorId(), gnext.GetId());
       EXPECT_EQ(gnode.GetParentId(), gnext.GetParentId());
     }
     if (!bnode->empty())
       EXPECT_TRUE(gnode.GetFirstChildId());
   }
 
   void ExpectSyncerNodeMatching(const BookmarkNode* bnode) {
-    csync::ReadTransaction trans(FROM_HERE, test_user_share_.user_share());
+    syncer::ReadTransaction trans(FROM_HERE, test_user_share_.user_share());
     ExpectSyncerNodeMatching(&trans, bnode);
   }
 
-  void ExpectBrowserNodeMatching(csync::BaseTransaction* trans,
+  void ExpectBrowserNodeMatching(syncer::BaseTransaction* trans,
                                  int64 sync_id) {
     EXPECT_TRUE(sync_id);
     const BookmarkNode* bnode =
         model_associator_->GetChromeNodeFromSyncId(sync_id);
     ASSERT_TRUE(bnode);
     int64 id = model_associator_->GetSyncIdFromChromeId(bnode->id());
     EXPECT_EQ(id, sync_id);
     ExpectSyncerNodeMatching(trans, bnode);
   }
 
   void ExpectBrowserNodeUnknown(int64 sync_id) {
     EXPECT_FALSE(model_associator_->GetChromeNodeFromSyncId(sync_id));
   }
 
   void ExpectBrowserNodeKnown(int64 sync_id) {
     EXPECT_TRUE(model_associator_->GetChromeNodeFromSyncId(sync_id));
   }
 
   void ExpectSyncerNodeKnown(const BookmarkNode* node) {
     int64 sync_id = model_associator_->GetSyncIdFromChromeId(node->id());
-    EXPECT_NE(sync_id, csync::kInvalidId);
+    EXPECT_NE(sync_id, syncer::kInvalidId);
   }
 
   void ExpectSyncerNodeUnknown(const BookmarkNode* node) {
     int64 sync_id = model_associator_->GetSyncIdFromChromeId(node->id());
-    EXPECT_EQ(sync_id, csync::kInvalidId);
+    EXPECT_EQ(sync_id, syncer::kInvalidId);
   }
 
   void ExpectBrowserNodeTitle(int64 sync_id, const std::wstring& title) {
     const BookmarkNode* bnode =
         model_associator_->GetChromeNodeFromSyncId(sync_id);
     ASSERT_TRUE(bnode);
     EXPECT_EQ(bnode->GetTitle(), WideToUTF16Hack(title));
   }
 
   void ExpectBrowserNodeURL(int64 sync_id, const std::string& url) {
     const BookmarkNode* bnode =
         model_associator_->GetChromeNodeFromSyncId(sync_id);
     ASSERT_TRUE(bnode);
     EXPECT_EQ(GURL(url), bnode->url());
   }
 
   void ExpectBrowserNodeParent(int64 sync_id, int64 parent_sync_id) {
     const BookmarkNode* node =
         model_associator_->GetChromeNodeFromSyncId(sync_id);
     ASSERT_TRUE(node);
     const BookmarkNode* parent =
         model_associator_->GetChromeNodeFromSyncId(parent_sync_id);
     EXPECT_TRUE(parent);
     EXPECT_EQ(node->parent(), parent);
   }
 
-  void ExpectModelMatch(csync::BaseTransaction* trans) {
+  void ExpectModelMatch(syncer::BaseTransaction* trans) {
     const BookmarkNode* root = model_->root_node();
     EXPECT_EQ(root->GetIndexOf(model_->bookmark_bar_node()), 0);
     EXPECT_EQ(root->GetIndexOf(model_->other_node()), 1);
     EXPECT_EQ(root->GetIndexOf(model_->mobile_node()), 2);
 
     std::stack<int64> stack;
     stack.push(bookmark_bar_id());
     while (!stack.empty()) {
       int64 id = stack.top();
       stack.pop();
       if (!id) continue;
 
       ExpectBrowserNodeMatching(trans, id);
 
-      csync::ReadNode gnode(trans);
+      syncer::ReadNode gnode(trans);
       ASSERT_EQ(BaseNode::INIT_OK, gnode.InitByIdLookup(id));
       stack.push(gnode.GetFirstChildId());
       stack.push(gnode.GetSuccessorId());
     }
   }
 
   void ExpectModelMatch() {
-    csync::ReadTransaction trans(FROM_HERE, test_user_share_.user_share());
+    syncer::ReadTransaction trans(FROM_HERE, test_user_share_.user_share());
     ExpectModelMatch(&trans);
   }
 
   int64 mobile_bookmarks_id() {
     return
         model_associator_->GetSyncIdFromChromeId(model_->mobile_node()->id());
   }
 
   int64 other_bookmarks_id() {
     return
@@ skipping 10 matching lines @@
   MessageLoop message_loop_;
   content::TestBrowserThread ui_thread_;
   // Needed by |model_|.
   content::TestBrowserThread file_thread_;
 
   TestingProfile profile_;
   scoped_ptr<TestBookmarkModelAssociator> model_associator_;
 
  protected:
   BookmarkModel* model_;
-  csync::TestUserShare test_user_share_;
+  syncer::TestUserShare test_user_share_;
   scoped_ptr<BookmarkChangeProcessor> change_processor_;
   StrictMock<DataTypeErrorHandlerMock> mock_error_handler_;
 };
 
 TEST_F(ProfileSyncServiceBookmarkTest, InitialState) {
   LoadBookmarkModel(DELETE_EXISTING_STORAGE, DONT_SAVE_TO_STORAGE);
   StartSync();
 
   EXPECT_TRUE(other_bookmarks_id());
   EXPECT_TRUE(bookmark_bar_id());
@@ skipping 57 matching lines @@
                  folder2->parent()->GetIndexOf(folder2));
   ExpectModelMatch();
   model_->Remove(model_->mobile_node(), 0);
   ExpectModelMatch();
 }
 
 TEST_F(ProfileSyncServiceBookmarkTest, ServerChangeProcessing) {
   LoadBookmarkModel(DELETE_EXISTING_STORAGE, DONT_SAVE_TO_STORAGE);
   StartSync();
 
-  csync::WriteTransaction trans(FROM_HERE, test_user_share_.user_share());
+  syncer::WriteTransaction trans(FROM_HERE, test_user_share_.user_share());
 
   FakeServerChange adds(&trans);
   int64 f1 = adds.AddFolder(L"Server Folder B", bookmark_bar_id(), 0);
   int64 f2 = adds.AddFolder(L"Server Folder A", bookmark_bar_id(), f1);
   int64 u1 = adds.AddURL(L"Some old site", "ftp://nifty.andrew.cmu.edu/",
                          bookmark_bar_id(), f2);
   int64 u2 = adds.AddURL(L"Nifty", "ftp://nifty.andrew.cmu.edu/", f1, 0);
   // u3 is a duplicate URL
   int64 u3 = adds.AddURL(L"Nifty2", "ftp://nifty.andrew.cmu.edu/", f1, u2);
   // u4 is a duplicate title, different URL.
   adds.AddURL(L"Some old site", "http://slog.thestranger.com/",
               bookmark_bar_id(), u1);
   // u5 tests an empty-string title.
   std::string javascript_url(
       "javascript:(function(){var w=window.open(" \
       "'about:blank','gnotesWin','location=0,menubar=0," \
       "scrollbars=0,status=0,toolbar=0,width=300," \
       "height=300,resizable');});");
   adds.AddURL(L"", javascript_url, other_bookmarks_id(), 0);
   int64 u6 = adds.AddURL(L"Sync1", "http://www.syncable.edu/",
                          mobile_bookmarks_id(), 0);
 
-  csync::ChangeRecordList::const_iterator it;
+  syncer::ChangeRecordList::const_iterator it;
   // The bookmark model shouldn't yet have seen any of the nodes of |adds|.
   for (it = adds.changes().begin(); it != adds.changes().end(); ++it)
     ExpectBrowserNodeUnknown(it->id);
 
   adds.ApplyPendingChanges(change_processor_.get());
 
   // Make sure the bookmark model received all of the nodes in |adds|.
   for (it = adds.changes().begin(); it != adds.changes().end(); ++it)
     ExpectBrowserNodeMatching(&trans, it->id);
   ExpectModelMatch(&trans);
@@ skipping 53 matching lines @@
 }
 
 // Tests a specific case in ApplyModelChanges where we move the
 // children out from under a parent, and then delete the parent
 // in the same changelist.  The delete shows up first in the changelist,
 // requiring the children to be moved to a temporary location.
 TEST_F(ProfileSyncServiceBookmarkTest, ServerChangeRequiringFosterParent) {
   LoadBookmarkModel(DELETE_EXISTING_STORAGE, DONT_SAVE_TO_STORAGE);
   StartSync();
 
-  csync::WriteTransaction trans(FROM_HERE, test_user_share_.user_share());
+  syncer::WriteTransaction trans(FROM_HERE, test_user_share_.user_share());
 
   // Stress the immediate children of other_node because that's where
   // ApplyModelChanges puts a temporary foster parent node.
   std::string url("http://dev.chromium.org/");
   FakeServerChange adds(&trans);
   int64 f0 = other_bookmarks_id();                 // + other_node
   int64 f1 = adds.AddFolder(L"f1",      f0, 0);    //   + f1
   int64 f2 = adds.AddFolder(L"f2",      f1, 0);    //     + f2
   int64 u3 = adds.AddURL(   L"u3", url, f2, 0);    //       + u3    NOLINT
   int64 u4 = adds.AddURL(   L"u4", url, f2, u3);   //       + u4    NOLINT
   int64 u5 = adds.AddURL(   L"u5", url, f1, f2);   //     + u5      NOLINT
   int64 f6 = adds.AddFolder(L"f6",      f1, u5);   //     + f6
   int64 u7 = adds.AddURL(   L"u7", url, f0, f1);   //   + u7        NOLINT
 
-  csync::ChangeRecordList::const_iterator it;
+  syncer::ChangeRecordList::const_iterator it;
   // The bookmark model shouldn't yet have seen any of the nodes of |adds|.
   for (it = adds.changes().begin(); it != adds.changes().end(); ++it)
     ExpectBrowserNodeUnknown(it->id);
 
   adds.ApplyPendingChanges(change_processor_.get());
 
   // Make sure the bookmark model received all of the nodes in |adds|.
   for (it = adds.changes().begin(); it != adds.changes().end(); ++it)
     ExpectBrowserNodeMatching(&trans, it->id);
   ExpectModelMatch(&trans);
@@ skipping 13 matching lines @@
 
   ExpectModelMatch(&trans);
 }
 
 // Simulate a server change record containing a valid but non-canonical URL.
 TEST_F(ProfileSyncServiceBookmarkTest, ServerChangeWithNonCanonicalURL) {
   LoadBookmarkModel(DELETE_EXISTING_STORAGE, SAVE_TO_STORAGE);
   StartSync();
 
   {
-    csync::WriteTransaction trans(FROM_HERE, test_user_share_.user_share());
+    syncer::WriteTransaction trans(FROM_HERE, test_user_share_.user_share());
 
     FakeServerChange adds(&trans);
     std::string url("http://dev.chromium.org");
     EXPECT_NE(GURL(url).spec(), url);
     adds.AddURL(L"u1", url, other_bookmarks_id(), 0);
 
     adds.ApplyPendingChanges(change_processor_.get());
 
     EXPECT_TRUE(model_->other_node()->child_count() == 1);
     ExpectModelMatch(&trans);
@@ skipping 10 matching lines @@
 }
 
 // Simulate a server change record containing an invalid URL (per GURL).
 // TODO(ncarter): Disabled due to crashes.  Fix bug 1677563.
 TEST_F(ProfileSyncServiceBookmarkTest, DISABLED_ServerChangeWithInvalidURL) {
   LoadBookmarkModel(DELETE_EXISTING_STORAGE, SAVE_TO_STORAGE);
   StartSync();
 
   int child_count = 0;
   {
-    csync::WriteTransaction trans(FROM_HERE, test_user_share_.user_share());
+    syncer::WriteTransaction trans(FROM_HERE, test_user_share_.user_share());
 
     FakeServerChange adds(&trans);
     std::string url("x");
     EXPECT_FALSE(GURL(url).is_valid());
     adds.AddURL(L"u1", url, other_bookmarks_id(), 0);
 
     adds.ApplyPendingChanges(change_processor_.get());
 
     // We're lenient about what should happen -- the model could wind up with
     // the node or without it; but things should be consistent, and we
@@ skipping 96 matching lines @@
 
   // Add a node which will be the target of the consistency violation.
   const BookmarkNode* node =
       model_->AddFolder(model_->other_node(), 0, ASCIIToUTF16("node"));
   ExpectSyncerNodeMatching(node);
 
   // Now destroy the syncer node as if we were the ProfileSyncService without
   // updating the ProfileSyncService state.  This should introduce
   // inconsistency between the two models.
   {
-    csync::WriteTransaction trans(FROM_HERE, test_user_share_.user_share());
-    csync::WriteNode sync_node(&trans);
+    syncer::WriteTransaction trans(FROM_HERE, test_user_share_.user_share());
+    syncer::WriteNode sync_node(&trans);
     ASSERT_TRUE(InitSyncNodeFromChromeNode(node, &sync_node));
     sync_node.Remove();
   }
   // The models don't match at this point, but the ProfileSyncService
   // doesn't know it yet.
   ExpectSyncerNodeKnown(node);
 
   // Add a child to the inconsistent node.  This should cause detection of the
   // problem and the syncer should stop processing changes.
   model_->AddFolder(node, 0, ASCIIToUTF16("nested"));
@@ skipping 549 matching lines @@
   EXPECT_EQ(1, observer.get_started());
   EXPECT_EQ(0, observer.get_completed_count_at_started());
   EXPECT_EQ(1, observer.get_completed());
 
   model_->RemoveObserver(&observer);
 }
 
 }  // namespace
 
 }  // namespace browser_sync