[Sync] Rename csync namespace to syncer

chrome/browser/sync/glue/bookmark_change_processor.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_change_processor.h"
 
 #include <stack>
 #include <vector>
 
 #include "base/location.h"
@@ skipping 40 matching lines @@
 
 void BookmarkChangeProcessor::StopImpl() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(bookmark_model_);
   bookmark_model_->RemoveObserver(this);
   bookmark_model_ = NULL;
   model_associator_ = NULL;
 }
 
 void BookmarkChangeProcessor::UpdateSyncNodeProperties(
-    const BookmarkNode* src, BookmarkModel* model, csync::WriteNode* dst) {
+    const BookmarkNode* src, BookmarkModel* model, syncer::WriteNode* dst) {
   // Set the properties of the item.
   dst->SetIsFolder(src->is_folder());
   dst->SetTitle(UTF16ToWideHack(src->GetTitle()));
   if (!src->is_folder())
     dst->SetURL(src->url());
   SetSyncNodeFavicon(src, model, dst);
 }
 
 // static
 void BookmarkChangeProcessor::EncodeFavicon(const BookmarkNode* src,
                                             BookmarkModel* model,
                                             std::vector<unsigned char>* dst) {
   const gfx::Image& favicon = model->GetFavicon(src);
 
   dst->clear();
 
   // Check for empty images.  This can happen if the favicon is
   // still being loaded.
   if (favicon.IsEmpty())
     return;
 
   // Re-encode the BookmarkNode's favicon as a PNG, and pass the data to the
   // sync subsystem.
   if (!gfx::PNGEncodedDataFromImage(favicon, dst))
     return;
 }
 
 void BookmarkChangeProcessor::RemoveOneSyncNode(
-    csync::WriteTransaction* trans, const BookmarkNode* node) {
-  csync::WriteNode sync_node(trans);
+    syncer::WriteTransaction* trans, const BookmarkNode* node) {
+  syncer::WriteNode sync_node(trans);
   if (!model_associator_->InitSyncNodeFromChromeId(node->id(), &sync_node)) {
     error_handler()->OnSingleDatatypeUnrecoverableError(FROM_HERE,
                                                         std::string());
     return;
   }
   // This node should have no children.
   DCHECK(!sync_node.HasChildren());
   // Remove association and delete the sync node.
   model_associator_->Disassociate(sync_node.GetId());
   sync_node.Remove();
 }
 
 void BookmarkChangeProcessor::RemoveSyncNodeHierarchy(
     const BookmarkNode* topmost) {
-  csync::WriteTransaction trans(FROM_HERE, share_handle());
+  syncer::WriteTransaction trans(FROM_HERE, share_handle());
 
   // Later logic assumes that |topmost| has been unlinked.
   DCHECK(topmost->is_root());
 
   // A BookmarkModel deletion event means that |node| and all its children were
   // deleted. Sync backend expects children to be deleted individually, so we do
   // a depth-first-search here.  At each step, we consider the |index|-th child
   // of |node|.  |index_stack| stores index values for the parent levels.
   std::stack<int> index_stack;
   index_stack.push(0);  // For the final pop.  It's never used.
@@ skipping 33 matching lines @@
   bookmark_model_ = NULL;
 }
 
 void BookmarkChangeProcessor::BookmarkNodeAdded(BookmarkModel* model,
                                                 const BookmarkNode* parent,
                                                 int index) {
   DCHECK(running());
   DCHECK(share_handle());
 
   // Acquire a scoped write lock via a transaction.
-  csync::WriteTransaction trans(FROM_HERE, share_handle());
+  syncer::WriteTransaction trans(FROM_HERE, share_handle());
 
   CreateSyncNode(parent, model, index, &trans, model_associator_,
                  error_handler());
 }
 
 // static
 int64 BookmarkChangeProcessor::CreateSyncNode(const BookmarkNode* parent,
-    BookmarkModel* model, int index, csync::WriteTransaction* trans,
+    BookmarkModel* model, int index, syncer::WriteTransaction* trans,
     BookmarkModelAssociator* associator,
     DataTypeErrorHandler* error_handler) {
   const BookmarkNode* child = parent->GetChild(index);
   DCHECK(child);
 
   // Create a WriteNode container to hold the new node.
-  csync::WriteNode sync_child(trans);
+  syncer::WriteNode sync_child(trans);
 
   // Actually create the node with the appropriate initial position.
   if (!PlaceSyncNode(CREATE, parent, index, trans, &sync_child, associator)) {
     error_handler->OnSingleDatatypeUnrecoverableError(FROM_HERE,
         "Sync node creation failed; recovery unlikely");
-    return csync::kInvalidId;
+    return syncer::kInvalidId;
   }
 
   UpdateSyncNodeProperties(child, model, &sync_child);
 
   // Associate the ID from the sync domain with the bookmark node, so that we
   // can refer back to this item later.
   associator->Associate(child, sync_child.GetId());
 
   return sync_child.GetId();
 }
@@ skipping 10 matching lines @@
 void BookmarkChangeProcessor::BookmarkNodeChanged(BookmarkModel* model,
                                                   const BookmarkNode* node) {
   DCHECK(running());
   // We shouldn't see changes to the top-level nodes.
   if (model->is_permanent_node(node)) {
     NOTREACHED() << "Saw update to permanent node!";
     return;
   }
 
   // Acquire a scoped write lock via a transaction.
-  csync::WriteTransaction trans(FROM_HERE, share_handle());
+  syncer::WriteTransaction trans(FROM_HERE, share_handle());
 
   // Lookup the sync node that's associated with |node|.
-  csync::WriteNode sync_node(&trans);
+  syncer::WriteNode sync_node(&trans);
   if (!model_associator_->InitSyncNodeFromChromeId(node->id(), &sync_node)) {
     // TODO(tim): Investigating bug 121587.
     if (model_associator_->GetSyncIdFromChromeId(node->id()) ==
-                                                 csync::kInvalidId) {
+                                                 syncer::kInvalidId) {
       error_handler()->OnSingleDatatypeUnrecoverableError(FROM_HERE,
           "Bookmark id not found in model associator on BookmarkNodeChanged");
       LOG(ERROR) << "Bad id.";
     } else if (!sync_node.GetEntry()->good()) {
       error_handler()->OnSingleDatatypeUnrecoverableError(FROM_HERE,
           "Could not InitByIdLookup on BookmarkNodeChanged, good() failed");
       LOG(ERROR) << "Bad entry.";
     } else if (sync_node.GetEntry()->Get(syncable::IS_DEL)) {
       error_handler()->OnSingleDatatypeUnrecoverableError(FROM_HERE,
           "Could not InitByIdLookup on BookmarkNodeChanged, is_del true");
       LOG(ERROR) << "Deleted entry.";
     } else {
-      csync::Cryptographer* crypto = trans.GetCryptographer();
+      syncer::Cryptographer* crypto = trans.GetCryptographer();
       syncable::ModelTypeSet encrypted_types(crypto->GetEncryptedTypes());
       const sync_pb::EntitySpecifics& specifics =
           sync_node.GetEntry()->Get(syncable::SPECIFICS);
       CHECK(specifics.has_encrypted());
       const bool can_decrypt = crypto->CanDecrypt(specifics.encrypted());
       const bool agreement = encrypted_types.Has(syncable::BOOKMARKS);
       if (!agreement && !can_decrypt) {
         error_handler()->OnSingleDatatypeUnrecoverableError(FROM_HERE,
             "Could not InitByIdLookup on BookmarkNodeChanged, "
             " Cryptographer thinks bookmarks not encrypted, and CanDecrypt"
@@ skipping 40 matching lines @@
       const BookmarkNode* new_parent, int new_index) {
   DCHECK(running());
   const BookmarkNode* child = new_parent->GetChild(new_index);
   // We shouldn't see changes to the top-level nodes.
   if (model->is_permanent_node(child)) {
     NOTREACHED() << "Saw update to permanent node!";
     return;
   }
 
   // Acquire a scoped write lock via a transaction.
-  csync::WriteTransaction trans(FROM_HERE, share_handle());
+  syncer::WriteTransaction trans(FROM_HERE, share_handle());
 
   // Lookup the sync node that's associated with |child|.
-  csync::WriteNode sync_node(&trans);
+  syncer::WriteNode sync_node(&trans);
   if (!model_associator_->InitSyncNodeFromChromeId(child->id(), &sync_node)) {
     error_handler()->OnSingleDatatypeUnrecoverableError(FROM_HERE,
                                                         std::string());
     return;
   }
 
   if (!PlaceSyncNode(MOVE, new_parent, new_index, &trans, &sync_node,
                      model_associator_)) {
     error_handler()->OnSingleDatatypeUnrecoverableError(FROM_HERE,
                                                         std::string());
     return;
   }
 }
 
 void BookmarkChangeProcessor::BookmarkNodeFaviconChanged(
     BookmarkModel* model,
     const BookmarkNode* node) {
   DCHECK(running());
   BookmarkNodeChanged(model, node);
 }
 
 void BookmarkChangeProcessor::BookmarkNodeChildrenReordered(
     BookmarkModel* model, const BookmarkNode* node) {
 
   // Acquire a scoped write lock via a transaction.
-  csync::WriteTransaction trans(FROM_HERE, share_handle());
+  syncer::WriteTransaction trans(FROM_HERE, share_handle());
 
   // The given node's children got reordered. We need to reorder all the
   // children of the corresponding sync node.
   for (int i = 0; i < node->child_count(); ++i) {
-    csync::WriteNode sync_child(&trans);
+    syncer::WriteNode sync_child(&trans);
     if (!model_associator_->InitSyncNodeFromChromeId(node->GetChild(i)->id(),
                                                      &sync_child)) {
       error_handler()->OnSingleDatatypeUnrecoverableError(FROM_HERE,
                                                           std::string());
       return;
     }
     DCHECK_EQ(sync_child.GetParentId(),
               model_associator_->GetSyncIdFromChromeId(node->id()));
 
     if (!PlaceSyncNode(MOVE, node, i, &trans, &sync_child,
                        model_associator_)) {
       error_handler()->OnSingleDatatypeUnrecoverableError(FROM_HERE,
                                                           std::string());
       return;
     }
   }
 }
 
 // static
 bool BookmarkChangeProcessor::PlaceSyncNode(MoveOrCreate operation,
-      const BookmarkNode* parent, int index, csync::WriteTransaction* trans,
-      csync::WriteNode* dst, BookmarkModelAssociator* associator) {
-  csync::ReadNode sync_parent(trans);
+      const BookmarkNode* parent, int index, syncer::WriteTransaction* trans,
+      syncer::WriteNode* dst, BookmarkModelAssociator* associator) {
+  syncer::ReadNode sync_parent(trans);
   if (!associator->InitSyncNodeFromChromeId(parent->id(), &sync_parent)) {
     LOG(WARNING) << "Parent lookup failed";
     return false;
   }
 
   bool success = false;
   if (index == 0) {
     // Insert into first position.
     success = (operation == CREATE) ?
         dst->InitByCreation(syncable::BOOKMARKS, sync_parent, NULL) :
         dst->SetPosition(sync_parent, NULL);
     if (success) {
       DCHECK_EQ(dst->GetParentId(), sync_parent.GetId());
       DCHECK_EQ(dst->GetId(), sync_parent.GetFirstChildId());
-      DCHECK_EQ(dst->GetPredecessorId(), csync::kInvalidId);
+      DCHECK_EQ(dst->GetPredecessorId(), syncer::kInvalidId);
     }
   } else {
     // Find the bookmark model predecessor, and insert after it.
     const BookmarkNode* prev = parent->GetChild(index - 1);
-    csync::ReadNode sync_prev(trans);
+    syncer::ReadNode sync_prev(trans);
     if (!associator->InitSyncNodeFromChromeId(prev->id(), &sync_prev)) {
       LOG(WARNING) << "Predecessor lookup failed";
       return false;
     }
     success = (operation == CREATE) ?
         dst->InitByCreation(syncable::BOOKMARKS, sync_parent, &sync_prev) :
         dst->SetPosition(sync_parent, &sync_prev);
     if (success) {
       DCHECK_EQ(dst->GetParentId(), sync_parent.GetId());
       DCHECK_EQ(dst->GetPredecessorId(), sync_prev.GetId());
       DCHECK_EQ(dst->GetId(), sync_prev.GetSuccessorId());
     }
   }
   return success;
 }
 
 // Determine the bookmark model index to which a node must be moved so that
 // predecessor of the node (in the bookmark model) matches the predecessor of
 // |source| (in the sync model).
 // As a precondition, this assumes that the predecessor of |source| has been
 // updated and is already in the correct position in the bookmark model.
 int BookmarkChangeProcessor::CalculateBookmarkModelInsertionIndex(
     const BookmarkNode* parent,
-    const csync::BaseNode* child_info) const {
+    const syncer::BaseNode* child_info) const {
   DCHECK(parent);
   DCHECK(child_info);
   int64 predecessor_id = child_info->GetPredecessorId();
   // A return ID of kInvalidId indicates no predecessor.
-  if (predecessor_id == csync::kInvalidId)
+  if (predecessor_id == syncer::kInvalidId)
     return 0;
 
   // Otherwise, insert after the predecessor bookmark node.
   const BookmarkNode* predecessor =
       model_associator_->GetChromeNodeFromSyncId(predecessor_id);
   DCHECK(predecessor);
   DCHECK_EQ(predecessor->parent(), parent);
   return parent->GetIndexOf(predecessor) + 1;
 }
 
 // ApplyModelChanges is called by the sync backend after changes have been made
 // to the sync engine's model.  Apply these changes to the browser bookmark
 // model.
 void BookmarkChangeProcessor::ApplyChangesFromSyncModel(
-    const csync::BaseTransaction* trans,
-    const csync::ImmutableChangeRecordList& changes) {
+    const syncer::BaseTransaction* trans,
+    const syncer::ImmutableChangeRecordList& changes) {
   if (!running())
     return;
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   // A note about ordering.  Sync backend is responsible for ordering the change
   // records in the following order:
   //
   // 1. Deletions, from leaves up to parents.
   // 2. Existing items with synced parents & predecessors.
   // 3. New items with synced parents & predecessors.
   // 4. Items with parents & predecessors in the list.
@@ skipping 13 matching lines @@
   // changes.
   model->RemoveObserver(this);
 
   // A parent to hold nodes temporarily orphaned by parent deletion.  It is
   // lazily created inside the loop.
   const BookmarkNode* foster_parent = NULL;
 
   // Whether we have passed all the deletes (which should be at the
   // front of the list).
   bool passed_deletes = false;
-  for (csync::ChangeRecordList::const_iterator it =
+  for (syncer::ChangeRecordList::const_iterator it =
            changes.Get().begin(); it != changes.Get().end(); ++it) {
     const BookmarkNode* dst =
         model_associator_->GetChromeNodeFromSyncId(it->id);
     // Ignore changes to the permanent top-level nodes.  We only care about
     // their children.
     if (model->is_permanent_node(dst))
       continue;
     if (it->action ==
-        csync::ChangeRecord::ACTION_DELETE) {
+        syncer::ChangeRecord::ACTION_DELETE) {
       // Deletions should always be at the front of the list.
       DCHECK(!passed_deletes);
       // Children of a deleted node should not be deleted; they may be
       // reparented by a later change record.  Move them to a temporary place.
       if (!dst) // Can't do anything if we can't find the chrome node.
         continue;
       const BookmarkNode* parent = dst->parent();
       if (!dst->empty()) {
         if (!foster_parent) {
           foster_parent = model->AddFolder(model->other_node(),
@@ skipping 11 matching lines @@
         }
       }
       DCHECK_EQ(dst->child_count(), 0) << "Node being deleted has children";
       model_associator_->Disassociate(it->id);
       int index = parent->GetIndexOf(dst);
       if (index > -1)
         model->Remove(parent, index);
       dst = NULL;
     } else {
       DCHECK_EQ((it->action ==
-          csync::ChangeRecord::ACTION_ADD), (dst == NULL))
+          syncer::ChangeRecord::ACTION_ADD), (dst == NULL))
           << "ACTION_ADD should be seen if and only if the node is unknown.";
       passed_deletes = true;
 
-      csync::ReadNode src(trans);
-      if (src.InitByIdLookup(it->id) != csync::BaseNode::INIT_OK) {
+      syncer::ReadNode src(trans);
+      if (src.InitByIdLookup(it->id) != syncer::BaseNode::INIT_OK) {
         error_handler()->OnSingleDatatypeUnrecoverableError(FROM_HERE,
             "ApplyModelChanges was passed a bad ID");
         return;
       }
 
       if (!CreateOrUpdateBookmarkNode(&src, model)) {
         // Because the Synced Bookmarks node can be created server side, it's
         // possible it'll arrive at the client as an update. In that case it
         // won't have been associated at startup, the GetChromeNodeFromSyncId
         // call above will return NULL, and we won't detect it as a permanent
         // node, resulting in us trying to create it here (which will
         // fail). Therefore, we add special logic here just to detect the
         // Synced Bookmarks folder.
-        csync::ReadNode synced_bookmarks(trans);
+        syncer::ReadNode synced_bookmarks(trans);
         if (synced_bookmarks.InitByTagLookup(kMobileBookmarksTag) ==
-                csync::BaseNode::INIT_OK &&
+                syncer::BaseNode::INIT_OK &&
             synced_bookmarks.GetId() == it->id) {
           // This is a newly created Synced Bookmarks node. Associate it.
           model_associator_->Associate(model->mobile_node(), it->id);
         } else {
           // We ignore bookmarks we can't add. Chances are this is caused by
           // a bookmark that was not fully associated.
           LOG(ERROR) << "Failed to create bookmark node with title "
                      << src.GetTitle() + " and url "
                      << src.GetURL().possibly_invalid_spec();
         }
@@ skipping 12 matching lines @@
   // The visibility of the mobile node may need to change.
   model_associator_->UpdatePermanentNodeVisibility();
 
   // We are now ready to hear about bookmarks changes again.
   model->AddObserver(this);
 }
 
 // Create a bookmark node corresponding to |src| if one is not already
 // associated with |src|.
 const BookmarkNode* BookmarkChangeProcessor::CreateOrUpdateBookmarkNode(
-    csync::BaseNode* src,
+    syncer::BaseNode* src,
     BookmarkModel* model) {
   const BookmarkNode* parent =
       model_associator_->GetChromeNodeFromSyncId(src->GetParentId());
   if (!parent) {
     DLOG(WARNING) << "Could not find parent of node being added/updated."
       << " Node title: " << src->GetTitle()
       << ", parent id = " << src->GetParentId();
 
     return NULL;
   }
@@ skipping 19 matching lines @@
     SetBookmarkFavicon(src, dst, model);
   }
 
   return dst;
 }
 
 // static
 // Creates a bookmark node under the given parent node from the given sync
 // node. Returns the newly created node.
 const BookmarkNode* BookmarkChangeProcessor::CreateBookmarkNode(
-    csync::BaseNode* sync_node,
+    syncer::BaseNode* sync_node,
     const BookmarkNode* parent,
     BookmarkModel* model,
     int index) {
   DCHECK(parent);
   DCHECK(index >= 0 && index <= parent->child_count());
 
   const BookmarkNode* node;
   if (sync_node->GetIsFolder()) {
     node = model->AddFolder(parent, index,
                             UTF8ToUTF16(sync_node->GetTitle()));
   } else {
     node = model->AddURL(parent, index,
                          UTF8ToUTF16(sync_node->GetTitle()),
                          sync_node->GetURL());
     if (node)
       SetBookmarkFavicon(sync_node, node, model);
   }
   return node;
 }
 
 // static
 // Sets the favicon of the given bookmark node from the given sync node.
 bool BookmarkChangeProcessor::SetBookmarkFavicon(
-    csync::BaseNode* sync_node,
+    syncer::BaseNode* sync_node,
     const BookmarkNode* bookmark_node,
     BookmarkModel* bookmark_model) {
   std::vector<unsigned char> icon_bytes_vector;
   sync_node->GetFaviconBytes(&icon_bytes_vector);
   if (icon_bytes_vector.empty())
     return false;
 
   ApplyBookmarkFavicon(bookmark_node, bookmark_model->profile(),
                        icon_bytes_vector);
 
@@ skipping 23 matching lines @@
   favicon_service->SetFavicon(bookmark_node->url(),
                               fake_icon_url,
                               icon_bytes_vector,
                               history::FAVICON);
 }
 
 // static
 void BookmarkChangeProcessor::SetSyncNodeFavicon(
     const BookmarkNode* bookmark_node,
     BookmarkModel* model,
-    csync::WriteNode* sync_node) {
+    syncer::WriteNode* sync_node) {
   std::vector<unsigned char> favicon_bytes;
   EncodeFavicon(bookmark_node, model, &favicon_bytes);
   if (!favicon_bytes.empty())
     sync_node->SetFaviconBytes(favicon_bytes);
 }
 
 }  // namespace browser_sync