Fix ProfileSyncService unit test.

chrome/browser/sync/glue/model_associator.h

 // 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)
 
-#ifndef CHROME_BROWSER_SYNC_GLUE_MODEL_ASSOCATOR_H_
-#define CHROME_BROWSER_SYNC_GLUE_MODEL_ASSOCATOR_H_
+#ifndef CHROME_BROWSER_SYNC_GLUE_MODEL_ASSOCIATOR_H_
+#define CHROME_BROWSER_SYNC_GLUE_MODEL_ASSOCIATOR_H_
 
 #include <map>
 #include <set>
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/ref_counted.h"
 #include "base/scoped_ptr.h"
 #include "base/string16.h"
 
 class BookmarkNode;
 
 namespace sync_api {
 class BaseNode;
 class BaseTransaction;
 class ReadNode;
 }
 
 class ProfileSyncService;
 
 namespace browser_sync {
 
 class ChangeProcessor;
 
-// Contains all model assocation related logic:
+// Contains all model association related logic:
 // * Algorithm to associate bookmark model and sync model.
 // * Methods to get a bookmark node for a given sync node and vice versa.
-// * Persisting model assocations and loading them back.
+// * Persisting model associations and loading them back.
 class ModelAssociator
     : public base::RefCountedThreadSafe<ModelAssociator> {
  public:
   explicit ModelAssociator(ProfileSyncService* sync_service);
   virtual ~ModelAssociator() { }
 
-  // Clears all assocations.
+  // Clears all associations.
   void ClearAll();
 
   // Returns sync id for the given bookmark node id.
   // Returns sync_api::kInvalidId if the sync node is not found for the given
   // bookmark node id.
   int64 GetSyncIdFromBookmarkId(int64 node_id) const;
 
   // Stores bookmark node id for the given sync id in bookmark_id. Returns true
   // if the bookmark id was successfully found; false otherwise.
   bool GetBookmarkIdFromSyncId(int64 sync_id, int64* bookmark_id) const;
@@ skipping 35 matching lines @@
   // Returns of that node was found successfully.
   // Tests override this.
   virtual bool GetSyncIdForTaggedNode(const string16& tag, int64* sync_id);
 
   // Returns sync service instance.
   ProfileSyncService* sync_service() { return sync_service_; }
 
  private:
   typedef std::map<int64, int64> BookmarkIdToSyncIdMap;
   typedef std::map<int64, int64> SyncIdToBookmarkIdMap;
-  typedef std::set<int64> DirtyAssocationsSyncIds;
+  typedef std::set<int64> DirtyAssociationsSyncIds;
 
-  // Posts a task to persist dirty assocations.
+  // Posts a task to persist dirty associations.
   void PostPersistAssociationsTask();
-  // Persists all dirty assocations.
+  // Persists all dirty associations.
   void PersistAssociations();
 
-  // Loads the persisted assocations into in-memory maps.
+  // Loads the persisted associations into in-memory maps.
   // If the persisted associations are out-of-date due to some reason, returns
-  // false; otehrwise returns true.
+  // false; otherwise returns true.
   bool LoadAssociations();
 
   // Matches up the bookmark model and the sync model to build model
-  // assocations.
-  bool BuildAssocations();
+  // associations.
+  bool BuildAssociations();
 
   // Associate a top-level node of the bookmark model with a permanent node in
   // the sync domain.  Such permanent nodes are identified by a tag that is
   // well known to the server and the client, and is unique within a particular
   // user's share.  For example, "other_bookmarks" is the tag for the Other
   // Bookmarks folder.  The sync nodes are server-created.
   bool AssociateTaggedPermanentNode(const BookmarkNode* permanent_node,
                                     const string16& tag);
 
   // Compare the properties of a pair of nodes from either domain.
   bool NodesMatch(const BookmarkNode* bookmark,
                   const sync_api::BaseNode* sync_node) const;
 
   ProfileSyncService* sync_service_;
   BookmarkIdToSyncIdMap id_map_;
   SyncIdToBookmarkIdMap id_map_inverse_;
   // Stores sync ids for dirty associations.
-  DirtyAssocationsSyncIds dirty_assocations_sync_ids_;
+  DirtyAssociationsSyncIds dirty_associations_sync_ids_;
 
   // Indicates whether there is already a pending task to persist dirty model
   // associations.
   bool task_pending_;
 
   DISALLOW_COPY_AND_ASSIGN(ModelAssociator);
 };
 
 }  // namespace browser_sync
 
-#endif  // CHROME_BROWSER_SYNC_GLUE_MODEL_ASSOCATOR_H_
+#endif  // CHROME_BROWSER_SYNC_GLUE_MODEL_ASSOCIATOR_H_
 #endif  // defined(BROWSER_SYNC)