[Sync] Move ChangeRecord into its own file (change_record.{h,cc})

chrome/browser/sync/glue/bookmark_change_processor.cc

 // Copyright (c) 2011 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/string16.h"
 #include "base/string_util.h"
 #include "base/tracked.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/bookmarks/bookmark_model.h"
 #include "chrome/browser/bookmarks/bookmark_utils.h"
 #include "chrome/browser/favicon/favicon_service.h"
 #include "chrome/browser/profiles/profile.h"
+#include "chrome/browser/sync/internal_api/change_record.h"
 #include "chrome/browser/sync/internal_api/read_node.h"
 #include "chrome/browser/sync/internal_api/write_node.h"
 #include "chrome/browser/sync/internal_api/write_transaction.h"
 #include "chrome/browser/sync/profile_sync_service.h"
 #include "content/browser/browser_thread.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/gfx/codec/png_codec.h"
 
 namespace browser_sync {
 
@@ skipping 320 matching lines @@
   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 sync_api::BaseTransaction* trans,
-    const sync_api::SyncManager::ChangeRecord* changes,
-    int change_count) {
+    const sync_api::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.
   // 5. Repeat #4 until all items are in the list.
   //
   // "Predecessor" here means the previous item within a given folder; an item
   // in the first position is always said to have a synced predecessor.
   // For the most part, applying these changes in the order given will yield
   // the correct result.  There is one exception, however: for items that are
   // moved away from a folder that is being deleted, we will process the delete
   // before the move.  Since deletions in the bookmark model propagate from
   // parent to child, we must move them to a temporary location.
   BookmarkModel* model = bookmark_model_;
 
   // We are going to make changes to the bookmarks model, but don't want to end
   // up in a feedback loop, so remove ourselves as an observer while applying
   // 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;
-  for (int i = 0; i < change_count; ++i) {
+
+  // Whether we have passed all the deletes (which should be at the
+  // front of the list).
+  bool passed_deletes = false;
+  for (sync_api::ChangeRecordList::const_iterator it =
+           changes.Get().begin(); it != changes.Get().end(); ++it) {
     const BookmarkNode* dst =
-        model_associator_->GetChromeNodeFromSyncId(changes[i].id);
+        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 (changes[i].action ==
-        sync_api::SyncManager::ChangeRecord::ACTION_DELETE) {
+    if (it->action ==
+        sync_api::ChangeRecord::ACTION_DELETE) {
       // Deletions should always be at the front of the list.
-      DCHECK(i == 0 || changes[i-1].action == changes[i].action);
+      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(),
                                            model->other_node()->child_count(),
                                            string16());
         }
         for (int i = dst->child_count() - 1; i >= 0; --i) {
           model->Move(dst->GetChild(i), foster_parent,
                       foster_parent->child_count());
         }
       }
       DCHECK_EQ(dst->child_count(), 0) << "Node being deleted has children";
-      model_associator_->Disassociate(changes[i].id);
+      model_associator_->Disassociate(it->id);
       int index = parent->GetIndexOf(dst);
       if (index > -1)
         model->Remove(parent, index);
       dst = NULL;
     } else {
-      DCHECK_EQ((changes[i].action ==
-          sync_api::SyncManager::ChangeRecord::ACTION_ADD), (dst == NULL))
+      DCHECK_EQ((it->action ==
+          sync_api::ChangeRecord::ACTION_ADD), (dst == NULL))
           << "ACTION_ADD should be seen if and only if the node is unknown.";
+      passed_deletes = true;
 
       sync_api::ReadNode src(trans);
-      if (!src.InitByIdLookup(changes[i].id)) {
+      if (!src.InitByIdLookup(it->id)) {
         error_handler()->OnUnrecoverableError(FROM_HERE,
             "ApplyModelChanges was passed a bad ID");
         return;
       }
 
       CreateOrUpdateBookmarkNode(&src, model);
     }
   }
   // Clean up the temporary node.
   if (foster_parent) {
@@ skipping 117 matching lines @@
     const BookmarkNode* bookmark_node,
     BookmarkModel* model,
     sync_api::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