Fix ProfileSyncService unit test.

chrome/browser/sync/glue/model_associator.cc

 // Copyright (c) 2006-2009 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.
 
 #if defined(BROWSER_SYNC)
 
 #include "chrome/browser/sync/glue/model_associator.h"
 
 #include <stack>
 
@@ skipping 103 matching lines @@
 
 ModelAssociator::ModelAssociator(ProfileSyncService* sync_service)
     : sync_service_(sync_service),
       task_pending_(false) {
   DCHECK(sync_service_);
 }
 
 void ModelAssociator::ClearAll() {
   id_map_.clear();
   id_map_inverse_.clear();
-  dirty_assocations_sync_ids_.clear();
+  dirty_associations_sync_ids_.clear();
 }
 
 int64 ModelAssociator::GetSyncIdFromBookmarkId(int64 node_id) const {
   BookmarkIdToSyncIdMap::const_iterator iter = id_map_.find(node_id);
   return iter == id_map_.end() ? sync_api::kInvalidId : iter->second;
 }
 
 bool ModelAssociator::GetBookmarkIdFromSyncId(int64 sync_id,
                                               int64* node_id) const {
   SyncIdToBookmarkIdMap::const_iterator iter = id_map_inverse_.find(sync_id);
@@ skipping 23 matching lines @@
   BookmarkModel* model = sync_service_->profile()->GetBookmarkModel();
   return model->GetNodeByID(node_id);
 }
 
 void ModelAssociator::AssociateIds(int64 node_id, int64 sync_id) {
   DCHECK_NE(sync_id, sync_api::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_id;
-  dirty_assocations_sync_ids_.insert(sync_id);
+  dirty_associations_sync_ids_.insert(sync_id);
   PostPersistAssociationsTask();
 }
 
 void ModelAssociator::DisassociateIds(int64 sync_id) {
   SyncIdToBookmarkIdMap::iterator iter = id_map_inverse_.find(sync_id);
   if (iter == id_map_inverse_.end())
     return;
   id_map_.erase(iter->second);
   id_map_inverse_.erase(iter);
-  dirty_assocations_sync_ids_.erase(sync_id);
+  dirty_associations_sync_ids_.erase(sync_id);
 }
 
 bool ModelAssociator::BookmarkModelHasUserCreatedNodes() const {
   BookmarkModel* model = sync_service_->profile()->GetBookmarkModel();
   DCHECK(model->IsLoaded());
   return model->GetBookmarkBarNode()->GetChildCount() > 0 ||
          model->other_node()->GetChildCount() > 0;
 }
 
 bool ModelAssociator::SyncModelHasUserCreatedNodes() {
@@ skipping 73 matching lines @@
 }
 
 bool ModelAssociator::AssociateModels() {
   // 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 true;
 
   ClearAll();
 
-  // We couldn't load model assocations from persisted assocations. So build
+  // We couldn't load model associations from persisted associations. So build
   // them.
-  return BuildAssocations();
+  return BuildAssociations();
 }
 
-bool ModelAssociator::BuildAssocations() {
+bool ModelAssociator::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.
@@ skipping 108 matching lines @@
   task_pending_ = true;
   MessageLoop::current()->PostTask(
       FROM_HERE,
       NewRunnableMethod(this, &ModelAssociator::PersistAssociations));
 }
 
 void ModelAssociator::PersistAssociations() {
   DCHECK(task_pending_);
   task_pending_ = false;
 
-  // If there are no dirty assocations we have nothing to do. We handle this
+  // 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_assocations_sync_ids_.empty()) {
+  if (dirty_associations_sync_ids_.empty()) {
     DCHECK(id_map_.empty());
     DCHECK(id_map_inverse_.empty());
     return;
   }
 
   sync_api::WriteTransaction trans(
       sync_service_->backend()->GetUserShareHandle());
-  DirtyAssocationsSyncIds::iterator iter;
-  for (iter = dirty_assocations_sync_ids_.begin();
-       iter != dirty_assocations_sync_ids_.end();
+  DirtyAssociationsSyncIds::iterator iter;
+  for (iter = dirty_associations_sync_ids_.begin();
+       iter != dirty_associations_sync_ids_.end();
        ++iter) {
     int64 sync_id = *iter;
     sync_api::WriteNode sync_node(&trans);
     if (!sync_node.InitByIdLookup(sync_id)) {
       sync_service_->OnUnrecoverableError();
       return;
     }
     int64 node_id;
     if (GetBookmarkIdFromSyncId(sync_id, &node_id))
       sync_node.SetExternalId(node_id);
     else
       NOTREACHED();
   }
-  dirty_assocations_sync_ids_.clear();
+  dirty_associations_sync_ids_.clear();
 }
 
 bool ModelAssociator::LoadAssociations() {
   BookmarkModel* model = sync_service_->profile()->GetBookmarkModel();
   DCHECK(model->IsLoaded());
-  // If the bookmarks changed externally, our previous assocations may not be
+  // If the bookmarks changed externally, our previous associations may not be
   // valid; so return false.
   if (model->file_changed())
     return false;
 
-  // Our persisted assocations should be valid. Try to populate id assocation
-  // maps using persisted assocations.
-
-  int64 other_bookmarks_id;
-  if (!GetSyncIdForTaggedNode(WideToUTF16(kOtherBookmarksTag),
-                              &other_bookmarks_id)) {
-    // We should always be able to find the permanent nodes.
-    sync_service_->OnUnrecoverableError();
-    return false;
-  }
+  // Our persisted associations should be valid. Try to populate id association
+  // maps using persisted associations.
   int64 bookmark_bar_id;
   if (!GetSyncIdForTaggedNode(WideToUTF16(kBookmarkBarTag), &bookmark_bar_id)) {
     // We should always be able to find the permanent nodes.
     sync_service_->OnUnrecoverableError();
     return false;
   }
+  int64 other_bookmarks_id;
+  if (!GetSyncIdForTaggedNode(WideToUTF16(kOtherBookmarksTag),
+    &other_bookmarks_id)) {
+      // We should always be able to find the permanent nodes.
+      sync_service_->OnUnrecoverableError();
+      return false;
+  }
 
   std::stack<int64> dfs_stack;
   dfs_stack.push(other_bookmarks_id);
   dfs_stack.push(bookmark_bar_id);
 
   sync_api::ReadTransaction trans(
       sync_service_->backend()->GetUserShareHandle());
 
   while (!dfs_stack.empty()) {
     int64 parent_id = dfs_stack.top();
@@ skipping 33 matching lines @@
       child_id = child_node.GetSuccessorId();
     }
   }
   DCHECK(dfs_stack.empty());
   return true;
 }
 
 }  // namespace browser_sync
 
 #endif  // defined(BROWSER_SYNC)