[Sync] Rename csync namespace to syncer

chrome/browser/sync/glue/bookmark_model_associator.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 "chrome/browser/sync/glue/bookmark_model_associator.h"
 
 #include <stack>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 66 matching lines @@
 // Provides the following abstraction: given a parent bookmark node, find best
 // matching child node for many sync nodes.
 class BookmarkNodeFinder {
  public:
   // Creates an instance with the given parent bookmark node.
   explicit BookmarkNodeFinder(const BookmarkNode* parent_node);
 
   // Finds best matching node for the given sync node.
   // Returns the matching node if one exists; NULL otherwise. If a matching
   // node is found, it's removed for further matches.
-  const BookmarkNode* FindBookmarkNode(const csync::BaseNode& sync_node);
+  const BookmarkNode* FindBookmarkNode(const syncer::BaseNode& sync_node);
 
  private:
   typedef std::multiset<const BookmarkNode*, BookmarkComparer> BookmarkNodesSet;
 
   const BookmarkNode* parent_node_;
   BookmarkNodesSet child_nodes_;
 
   DISALLOW_COPY_AND_ASSIGN(BookmarkNodeFinder);
 };
 
@@ skipping 15 matching lines @@
 };
 
 BookmarkNodeFinder::BookmarkNodeFinder(const BookmarkNode* parent_node)
     : parent_node_(parent_node) {
   for (int i = 0; i < parent_node_->child_count(); ++i) {
     child_nodes_.insert(parent_node_->GetChild(i));
   }
 }
 
 const BookmarkNode* BookmarkNodeFinder::FindBookmarkNode(
-    const csync::BaseNode& sync_node) {
+    const syncer::BaseNode& sync_node) {
   // Create a bookmark node from the given sync node.
   BookmarkNode temp_node(sync_node.GetURL());
   temp_node.SetTitle(UTF8ToUTF16(sync_node.GetTitle()));
   if (sync_node.GetIsFolder())
     temp_node.set_type(BookmarkNode::FOLDER);
   else
     temp_node.set_type(BookmarkNode::URL);
 
   const BookmarkNode* result = NULL;
   BookmarkNodesSet::iterator iter = child_nodes_.find(&temp_node);
@@ skipping 44 matching lines @@
     AddAll(node->GetChild(i));
 }
 
 const BookmarkNode* BookmarkNodeIdIndex::Find(int64 id) const {
   BookmarkIdMap::const_iterator iter = node_index_.find(id);
   return iter == node_index_.end() ? NULL : iter->second;
 }
 
 BookmarkModelAssociator::BookmarkModelAssociator(
     BookmarkModel* bookmark_model,
-    csync::UserShare* user_share,
+    syncer::UserShare* user_share,
     DataTypeErrorHandler* unrecoverable_error_handler,
     bool expect_mobile_bookmarks_folder)
     : bookmark_model_(bookmark_model),
       user_share_(user_share),
       unrecoverable_error_handler_(unrecoverable_error_handler),
       expect_mobile_bookmarks_folder_(expect_mobile_bookmarks_folder),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)),
       number_of_new_sync_nodes_created_at_association_(0) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(bookmark_model_);
   DCHECK(user_share_);
   DCHECK(unrecoverable_error_handler_);
 }
 
 BookmarkModelAssociator::~BookmarkModelAssociator() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 }
 
 void BookmarkModelAssociator::UpdatePermanentNodeVisibility() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(bookmark_model_->IsLoaded());
 
   bookmark_model_->SetPermanentNodeVisible(
       BookmarkNode::MOBILE,
       id_map_.find(bookmark_model_->mobile_node()->id()) != id_map_.end());
 }
 
-csync::SyncError BookmarkModelAssociator::DisassociateModels() {
+syncer::SyncError BookmarkModelAssociator::DisassociateModels() {
   id_map_.clear();
   id_map_inverse_.clear();
   dirty_associations_sync_ids_.clear();
-  return csync::SyncError();
+  return syncer::SyncError();
 }
 
 int64 BookmarkModelAssociator::GetSyncIdFromChromeId(const int64& node_id) {
   BookmarkIdToSyncIdMap::const_iterator iter = id_map_.find(node_id);
-  return iter == id_map_.end() ? csync::kInvalidId : iter->second;
+  return iter == id_map_.end() ? syncer::kInvalidId : iter->second;
 }
 
 const BookmarkNode* BookmarkModelAssociator::GetChromeNodeFromSyncId(
     int64 sync_id) {
   SyncIdToBookmarkNodeMap::const_iterator iter = id_map_inverse_.find(sync_id);
   return iter == id_map_inverse_.end() ? NULL : iter->second;
 }
 
 bool BookmarkModelAssociator::InitSyncNodeFromChromeId(
     const int64& node_id,
-    csync::BaseNode* sync_node) {
+    syncer::BaseNode* sync_node) {
   DCHECK(sync_node);
   int64 sync_id = GetSyncIdFromChromeId(node_id);
-  if (sync_id == csync::kInvalidId)
+  if (sync_id == syncer::kInvalidId)
     return false;
-  if (sync_node->InitByIdLookup(sync_id) != csync::BaseNode::INIT_OK)
+  if (sync_node->InitByIdLookup(sync_id) != syncer::BaseNode::INIT_OK)
     return false;
   DCHECK(sync_node->GetId() == sync_id);
   return true;
 }
 
 void BookmarkModelAssociator::Associate(const BookmarkNode* node,
                                         int64 sync_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   int64 node_id = node->id();
-  DCHECK_NE(sync_id, csync::kInvalidId);
+  DCHECK_NE(sync_id, syncer::kInvalidId);
   DCHECK(id_map_.find(node_id) == id_map_.end());
   DCHECK(id_map_inverse_.find(sync_id) == id_map_inverse_.end());
   id_map_[node_id] = sync_id;
   id_map_inverse_[sync_id] = node;
   dirty_associations_sync_ids_.insert(sync_id);
   PostPersistAssociationsTask();
   UpdatePermanentNodeVisibility();
 }
 
 void BookmarkModelAssociator::Disassociate(int64 sync_id) {
@@ skipping 16 matching lines @@
   }
   int64 other_bookmarks_sync_id;
   if (!GetSyncIdForTaggedNode(kOtherBookmarksTag, &other_bookmarks_sync_id)) {
     return false;
   }
   int64 mobile_bookmarks_sync_id;
   if (!GetSyncIdForTaggedNode(kMobileBookmarksTag, &mobile_bookmarks_sync_id)) {
     has_mobile_folder = false;
   }
 
-  csync::ReadTransaction trans(FROM_HERE, user_share_);
+  syncer::ReadTransaction trans(FROM_HERE, user_share_);
 
-  csync::ReadNode bookmark_bar_node(&trans);
+  syncer::ReadNode bookmark_bar_node(&trans);
   if (bookmark_bar_node.InitByIdLookup(bookmark_bar_sync_id) !=
-          csync::BaseNode::INIT_OK) {
+          syncer::BaseNode::INIT_OK) {
     return false;
   }
 
-  csync::ReadNode other_bookmarks_node(&trans);
+  syncer::ReadNode other_bookmarks_node(&trans);
   if (other_bookmarks_node.InitByIdLookup(other_bookmarks_sync_id) !=
-          csync::BaseNode::INIT_OK) {
+          syncer::BaseNode::INIT_OK) {
     return false;
   }
 
-  csync::ReadNode mobile_bookmarks_node(&trans);
+  syncer::ReadNode mobile_bookmarks_node(&trans);
   if (has_mobile_folder &&
       mobile_bookmarks_node.InitByIdLookup(mobile_bookmarks_sync_id) !=
-          csync::BaseNode::INIT_OK) {
+          syncer::BaseNode::INIT_OK) {
     return false;
   }
 
   // Sync model has user created nodes if any of the permanent nodes has
   // children.
   *has_nodes = bookmark_bar_node.HasChildren() ||
       other_bookmarks_node.HasChildren() ||
       (has_mobile_folder && mobile_bookmarks_node.HasChildren());
   return true;
 }
 
 bool BookmarkModelAssociator::NodesMatch(
     const BookmarkNode* bookmark,
-    const csync::BaseNode* sync_node) const {
+    const syncer::BaseNode* sync_node) const {
   if (bookmark->GetTitle() != UTF8ToUTF16(sync_node->GetTitle()))
     return false;
   if (bookmark->is_folder() != sync_node->GetIsFolder())
     return false;
   if (bookmark->is_url()) {
     if (bookmark->url() != sync_node->GetURL())
       return false;
   }
   // Don't compare favicons here, because they are not really
   // user-updated and we don't have versioning information -- a site changing
   // its favicon shouldn't result in a bookmark mismatch.
   return true;
 }
 
-csync::SyncError BookmarkModelAssociator::AssociateTaggedPermanentNode(
+syncer::SyncError BookmarkModelAssociator::AssociateTaggedPermanentNode(
     const BookmarkNode* permanent_node, const std::string&tag) {
   // Do nothing if |permanent_node| is already initialized and associated.
   int64 sync_id = GetSyncIdFromChromeId(permanent_node->id());
-  if (sync_id != csync::kInvalidId)
-    return csync::SyncError();
+  if (sync_id != syncer::kInvalidId)
+    return syncer::SyncError();
   if (!GetSyncIdForTaggedNode(tag, &sync_id))
     return unrecoverable_error_handler_->CreateAndUploadError(
         FROM_HERE,
         "Permanent node not found",
         model_type());
 
   Associate(permanent_node, sync_id);
-  return csync::SyncError();
+  return syncer::SyncError();
 }
 
 bool BookmarkModelAssociator::GetSyncIdForTaggedNode(const std::string& tag,
                                                      int64* sync_id) {
-  csync::ReadTransaction trans(FROM_HERE, user_share_);
-  csync::ReadNode sync_node(&trans);
-  if (sync_node.InitByTagLookup(tag.c_str()) != csync::BaseNode::INIT_OK)
+  syncer::ReadTransaction trans(FROM_HERE, user_share_);
+  syncer::ReadNode sync_node(&trans);
+  if (sync_node.InitByTagLookup(tag.c_str()) != syncer::BaseNode::INIT_OK)
     return false;
   *sync_id = sync_node.GetId();
   return true;
 }
 
-csync::SyncError BookmarkModelAssociator::AssociateModels() {
+syncer::SyncError BookmarkModelAssociator::AssociateModels() {
   scoped_ptr<ScopedAssociationUpdater> association_updater(
       new ScopedAssociationUpdater(bookmark_model_));
   // Try to load model associations from persisted associations first. If that
   // succeeds, we don't need to run the complex model matching algorithm.
   if (LoadAssociations())
-    return csync::SyncError();
+    return syncer::SyncError();
 
   DisassociateModels();
 
   // We couldn't load model associations from persisted associations. So build
   // them.
   return BuildAssociations();
 }
 
-csync::SyncError BookmarkModelAssociator::BuildAssociations() {
+syncer::SyncError BookmarkModelAssociator::BuildAssociations() {
   // Algorithm description:
   // Match up the roots and recursively do the following:
   // * For each sync node for the current sync parent node, find the best
   //   matching bookmark node under the corresponding bookmark parent node.
   //   If no matching node is found, create a new bookmark node in the same
   //   position as the corresponding sync node.
   //   If a matching node is found, update the properties of it from the
   //   corresponding sync node.
   // * When all children sync nodes are done, add the extra children bookmark
   //   nodes to the sync parent node.
   //
   // This algorithm will do a good job of merging when folder names are a good
   // indicator of the two folders being the same. It will handle reordering and
   // new node addition very well (without creating duplicates).
   // This algorithm will not do well if the folder name has changes but the
   // children under them are all the same.
 
-  csync::SyncError error;
+  syncer::SyncError error;
   DCHECK(bookmark_model_->IsLoaded());
 
   // To prime our association, we associate the top-level nodes, Bookmark Bar
   // and Other Bookmarks.
   error = AssociateTaggedPermanentNode(bookmark_model_->other_node(),
                                        kOtherBookmarksTag);
   if (error.IsSet()) {
     return error;
   }
 
   error = AssociateTaggedPermanentNode(bookmark_model_->bookmark_bar_node(),
                                        kBookmarkBarTag);
   if (error.IsSet()) {
     return error;
   }
 
   if (expect_mobile_bookmarks_folder_) {
     error = AssociateTaggedPermanentNode(bookmark_model_->mobile_node(),
                                          kMobileBookmarksTag);
     if (error.IsSet()) {
       return error;
     }
   }
 
   int64 bookmark_bar_sync_id = GetSyncIdFromChromeId(
       bookmark_model_->bookmark_bar_node()->id());
-  DCHECK_NE(bookmark_bar_sync_id, csync::kInvalidId);
+  DCHECK_NE(bookmark_bar_sync_id, syncer::kInvalidId);
   int64 other_bookmarks_sync_id = GetSyncIdFromChromeId(
       bookmark_model_->other_node()->id());
-  DCHECK_NE(other_bookmarks_sync_id, csync::kInvalidId);
+  DCHECK_NE(other_bookmarks_sync_id, syncer::kInvalidId);
   int64 mobile_bookmarks_sync_id = GetSyncIdFromChromeId(
        bookmark_model_->mobile_node()->id());
   if (expect_mobile_bookmarks_folder_) {
-    DCHECK_NE(csync::kInvalidId, mobile_bookmarks_sync_id);
+    DCHECK_NE(syncer::kInvalidId, mobile_bookmarks_sync_id);
   }
 
   std::stack<int64> dfs_stack;
-  if (mobile_bookmarks_sync_id != csync::kInvalidId)
+  if (mobile_bookmarks_sync_id != syncer::kInvalidId)
     dfs_stack.push(mobile_bookmarks_sync_id);
   dfs_stack.push(other_bookmarks_sync_id);
   dfs_stack.push(bookmark_bar_sync_id);
 
-  csync::WriteTransaction trans(FROM_HERE, user_share_);
+  syncer::WriteTransaction trans(FROM_HERE, user_share_);
 
   while (!dfs_stack.empty()) {
     int64 sync_parent_id = dfs_stack.top();
     dfs_stack.pop();
 
-    csync::ReadNode sync_parent(&trans);
+    syncer::ReadNode sync_parent(&trans);
     if (sync_parent.InitByIdLookup(sync_parent_id) !=
-            csync::BaseNode::INIT_OK) {
+            syncer::BaseNode::INIT_OK) {
       return unrecoverable_error_handler_->CreateAndUploadError(
           FROM_HERE,
           "Failed to lookup node.",
           model_type());
     }
     // Only folder nodes are pushed on to the stack.
     DCHECK(sync_parent.GetIsFolder());
 
     const BookmarkNode* parent_node = GetChromeNodeFromSyncId(sync_parent_id);
     DCHECK(parent_node->is_folder());
 
     BookmarkNodeFinder node_finder(parent_node);
 
     int index = 0;
     int64 sync_child_id = sync_parent.GetFirstChildId();
-    while (sync_child_id != csync::kInvalidId) {
-      csync::WriteNode sync_child_node(&trans);
+    while (sync_child_id != syncer::kInvalidId) {
+      syncer::WriteNode sync_child_node(&trans);
       if (sync_child_node.InitByIdLookup(sync_child_id) !=
-              csync::BaseNode::INIT_OK) {
+              syncer::BaseNode::INIT_OK) {
         return unrecoverable_error_handler_->CreateAndUploadError(
             FROM_HERE,
             "Failed to lookup node.",
             model_type());
       }
 
       const BookmarkNode* child_node = NULL;
       child_node = node_finder.FindBookmarkNode(sync_child_node);
       if (child_node) {
         bookmark_model_->Move(child_node, parent_node, index);
@@ skipping 28 matching lines @@
 
     // At this point all the children nodes of the parent sync node have
     // corresponding children in the parent bookmark node and they are all in
     // the right positions: from 0 to index - 1.
     // So the children starting from index in the parent bookmark node are the
     // ones that are not present in the parent sync node. So create them.
     for (int i = index; i < parent_node->child_count(); ++i) {
       sync_child_id = BookmarkChangeProcessor::CreateSyncNode(
           parent_node, bookmark_model_, i, &trans, this,
           unrecoverable_error_handler_);
-      if (csync::kInvalidId == sync_child_id) {
+      if (syncer::kInvalidId == sync_child_id) {
         return unrecoverable_error_handler_->CreateAndUploadError(
             FROM_HERE,
             "Failed to create sync node.",
             model_type());
       }
       if (parent_node->GetChild(i)->is_folder())
         dfs_stack.push(sync_child_id);
       number_of_new_sync_nodes_created_at_association_++;
     }
   }
 
-  return csync::SyncError();
+  return syncer::SyncError();
 }
 
 void BookmarkModelAssociator::PostPersistAssociationsTask() {
   // No need to post a task if a task is already pending.
   if (weak_factory_.HasWeakPtrs())
     return;
   MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(
           &BookmarkModelAssociator::PersistAssociations,
           weak_factory_.GetWeakPtr()));
 }
 
 void BookmarkModelAssociator::PersistAssociations() {
   // If there are no dirty associations we have nothing to do. We handle this
   // explicity instead of letting the for loop do it to avoid creating a write
   // transaction in this case.
   if (dirty_associations_sync_ids_.empty()) {
     DCHECK(id_map_.empty());
     DCHECK(id_map_inverse_.empty());
     return;
   }
 
-  csync::WriteTransaction trans(FROM_HERE, user_share_);
+  syncer::WriteTransaction trans(FROM_HERE, user_share_);
   DirtyAssociationsSyncIds::iterator iter;
   for (iter = dirty_associations_sync_ids_.begin();
        iter != dirty_associations_sync_ids_.end();
        ++iter) {
     int64 sync_id = *iter;
-    csync::WriteNode sync_node(&trans);
-    if (sync_node.InitByIdLookup(sync_id) != csync::BaseNode::INIT_OK) {
+    syncer::WriteNode sync_node(&trans);
+    if (sync_node.InitByIdLookup(sync_id) != syncer::BaseNode::INIT_OK) {
       unrecoverable_error_handler_->OnSingleDatatypeUnrecoverableError(
           FROM_HERE,
           "Could not lookup bookmark node for ID persistence.");
       return;
     }
     const BookmarkNode* node = GetChromeNodeFromSyncId(sync_id);
     if (node)
       sync_node.SetExternalId(node->id());
     else
       NOTREACHED();
@@ skipping 34 matching lines @@
   id_index.AddAll(bookmark_model_->bookmark_bar_node());
   id_index.AddAll(bookmark_model_->other_node());
   id_index.AddAll(bookmark_model_->mobile_node());
 
   std::stack<int64> dfs_stack;
   if (mobile_bookmarks_id != -1)
     dfs_stack.push(mobile_bookmarks_id);
   dfs_stack.push(other_bookmarks_id);
   dfs_stack.push(bookmark_bar_id);
 
-  csync::ReadTransaction trans(FROM_HERE, user_share_);
+  syncer::ReadTransaction trans(FROM_HERE, user_share_);
 
   // Count total number of nodes in sync model so that we can compare that
   // with the total number of nodes in the bookmark model.
   size_t sync_node_count = 0;
   while (!dfs_stack.empty()) {
     int64 parent_id = dfs_stack.top();
     dfs_stack.pop();
     ++sync_node_count;
-    csync::ReadNode sync_parent(&trans);
-    if (sync_parent.InitByIdLookup(parent_id) != csync::BaseNode::INIT_OK) {
+    syncer::ReadNode sync_parent(&trans);
+    if (sync_parent.InitByIdLookup(parent_id) != syncer::BaseNode::INIT_OK) {
       return false;
     }
 
     int64 external_id = sync_parent.GetExternalId();
     if (external_id == 0)
       return false;
 
     const BookmarkNode* node = id_index.Find(external_id);
     if (!node)
       return false;
 
     // Don't try to call NodesMatch on permanent nodes like bookmark bar and
     // other bookmarks. They are not expected to match.
     if (node != bookmark_model_->bookmark_bar_node() &&
         node != bookmark_model_->mobile_node() &&
         node != bookmark_model_->other_node() &&
         !NodesMatch(node, &sync_parent))
       return false;
 
     Associate(node, sync_parent.GetId());
 
     // Add all children of the current node to the stack.
     int64 child_id = sync_parent.GetFirstChildId();
-    while (child_id != csync::kInvalidId) {
+    while (child_id != syncer::kInvalidId) {
       dfs_stack.push(child_id);
-      csync::ReadNode child_node(&trans);
-      if (child_node.InitByIdLookup(child_id) != csync::BaseNode::INIT_OK) {
+      syncer::ReadNode child_node(&trans);
+      if (child_node.InitByIdLookup(child_id) != syncer::BaseNode::INIT_OK) {
         return false;
       }
       child_id = child_node.GetSuccessorId();
     }
   }
   DCHECK(dfs_stack.empty());
 
   // It's possible that the number of nodes in the bookmark model is not the
   // same as number of nodes in the sync model. This can happen when the sync
   // model doesn't get a chance to persist its changes, for example when
   // Chrome does not shut down gracefully. In such cases we can't trust the
   // loaded associations.
   return sync_node_count == id_index.count();
 }
 
 bool BookmarkModelAssociator::CryptoReadyIfNecessary() {
   // We only access the cryptographer while holding a transaction.
-  csync::ReadTransaction trans(FROM_HERE, user_share_);
+  syncer::ReadTransaction trans(FROM_HERE, user_share_);
   const syncable::ModelTypeSet encrypted_types =
-      csync::GetEncryptedTypes(&trans);
+      syncer::GetEncryptedTypes(&trans);
   return !encrypted_types.Has(syncable::BOOKMARKS) ||
       trans.GetCryptographer()->is_ready();
 }
 
 }  // namespace browser_sync