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

chrome/browser/sync/glue/autofill_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/autofill_change_processor.h"
 
 #include <string>
 #include <vector>
 
 #include "base/string_util.h"
 #include "base/tracked.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/autofill/personal_data_manager.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sync/glue/autofill_model_associator.h"
 #include "chrome/browser/sync/glue/do_optimistic_refresh_task.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 "chrome/browser/webdata/autofill_change.h"
 #include "chrome/browser/webdata/autofill_table.h"
 #include "chrome/browser/webdata/web_database.h"
 #include "chrome/browser/webdata/web_data_service.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/guid.h"
 #include "content/common/notification_service.h"
 
 namespace browser_sync {
 
 struct AutofillChangeProcessor::AutofillChangeRecord {
-  sync_api::SyncManager::ChangeRecord::Action action_;
+  sync_api::ChangeRecord::Action action_;
   int64 id_;
   sync_pb::AutofillSpecifics autofill_;
-  AutofillChangeRecord(sync_api::SyncManager::ChangeRecord::Action action,
+  AutofillChangeRecord(sync_api::ChangeRecord::Action action,
                        int64 id, const sync_pb::AutofillSpecifics& autofill)
       : action_(action),
         id_(id),
         autofill_(autofill) { }
 };
 
 AutofillChangeProcessor::AutofillChangeProcessor(
     AutofillModelAssociator* model_associator,
     WebDatabase* web_database,
     PersonalDataManager* personal_data,
@@ skipping 143 matching lines @@
           "Autofill node lookup failed.");
       return;
     }
     model_associator_->Disassociate(sync_node.GetId());
     sync_node.Remove();
   }
 }
 
 void AutofillChangeProcessor::ApplyChangesFromSyncModel(
     const sync_api::BaseTransaction* trans,
-    const sync_api::SyncManager::ChangeRecord* changes,
-    int change_count) {
+    const sync_api::ImmutableChangeRecordList& changes) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::DB));
   if (!running())
     return;
   StopObserving();
 
   sync_api::ReadNode autofill_root(trans);
   if (!autofill_root.InitByTagLookup(kAutofillTag)) {
     error_handler()->OnUnrecoverableError(FROM_HERE,
         "Autofill root node lookup failed.");
     return;
   }
 
-  for (int i = 0; i < change_count; ++i) {
-    sync_api::SyncManager::ChangeRecord::Action action(changes[i].action);
-    if (sync_api::SyncManager::ChangeRecord::ACTION_DELETE == action) {
-      DCHECK(changes[i].specifics.HasExtension(sync_pb::autofill))
+  for (sync_api::ChangeRecordList::const_iterator it =
+           changes.Get().begin(); it != changes.Get().end(); ++it) {
+    sync_api::ChangeRecord::Action action(it->action);
+    if (sync_api::ChangeRecord::ACTION_DELETE == action) {
+      DCHECK(it->specifics.HasExtension(sync_pb::autofill))
           << "Autofill specifics data not present on delete!";
       const sync_pb::AutofillSpecifics& autofill =
-          changes[i].specifics.GetExtension(sync_pb::autofill);
+          it->specifics.GetExtension(sync_pb::autofill);
       if (autofill.has_value()) {
-        autofill_changes_.push_back(AutofillChangeRecord(changes[i].action,
-                                                         changes[i].id,
+        autofill_changes_.push_back(AutofillChangeRecord(it->action,
+                                                         it->id,
                                                          autofill));
       } else if (autofill.has_profile()) {
         LOG(WARNING) << "Change for old-style autofill profile being dropped!";
       } else {
         NOTREACHED() << "Autofill specifics has no data!";
       }
       continue;
     }
 
     // Handle an update or add.
     sync_api::ReadNode sync_node(trans);
-    if (!sync_node.InitByIdLookup(changes[i].id)) {
+    if (!sync_node.InitByIdLookup(it->id)) {
       error_handler()->OnUnrecoverableError(FROM_HERE,
           "Autofill node lookup failed.");
       return;
     }
 
     // Check that the changed node is a child of the autofills folder.
     DCHECK(autofill_root.GetId() == sync_node.GetParentId());
     DCHECK(syncable::AUTOFILL == sync_node.GetModelType());
 
     const sync_pb::AutofillSpecifics& autofill(
         sync_node.GetAutofillSpecifics());
     int64 sync_id = sync_node.GetId();
     if (autofill.has_value()) {
-      autofill_changes_.push_back(AutofillChangeRecord(changes[i].action,
+      autofill_changes_.push_back(AutofillChangeRecord(it->action,
                                                        sync_id, autofill));
     } else if (autofill.has_profile()) {
       LOG(WARNING) << "Change for old-style autofill profile being dropped!";
     } else {
       NOTREACHED() << "Autofill specifics has no data!";
     }
   }
 
   StartObserving();
 }
 
 void AutofillChangeProcessor::CommitChangesFromSyncModel() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::DB));
   if (!running())
     return;
   StopObserving();
 
   std::vector<AutofillEntry> new_entries;
   for (unsigned int i = 0; i < autofill_changes_.size(); i++) {
     // Handle deletions.
-    if (sync_api::SyncManager::ChangeRecord::ACTION_DELETE ==
+    if (sync_api::ChangeRecord::ACTION_DELETE ==
         autofill_changes_[i].action_) {
       if (autofill_changes_[i].autofill_.has_value()) {
         ApplySyncAutofillEntryDelete(autofill_changes_[i].autofill_);
       } else if (autofill_changes_[i].autofill_.has_profile()) {
         ApplySyncAutofillProfileDelete(autofill_changes_[i].id_);
       } else {
         NOTREACHED() << "Autofill's CommitChanges received change with no"
             " data!";
       }
       continue;
@@ skipping 30 matching lines @@
       const sync_pb::AutofillSpecifics& autofill) {
   if (!web_database_->GetAutofillTable()->RemoveFormElement(
       UTF8ToUTF16(autofill.name()), UTF8ToUTF16(autofill.value()))) {
     error_handler()->OnUnrecoverableError(FROM_HERE,
         "Could not remove autofill node.");
     return;
   }
 }
 
 void AutofillChangeProcessor::ApplySyncAutofillEntryChange(
-      sync_api::SyncManager::ChangeRecord::Action action,
+      sync_api::ChangeRecord::Action action,
       const sync_pb::AutofillSpecifics& autofill,
       std::vector<AutofillEntry>* new_entries,
       int64 sync_id) {
-  DCHECK_NE(sync_api::SyncManager::ChangeRecord::ACTION_DELETE, action);
+  DCHECK_NE(sync_api::ChangeRecord::ACTION_DELETE, action);
 
   std::vector<base::Time> timestamps;
   size_t timestamps_size = autofill.usage_timestamp_size();
   for (size_t c = 0; c < timestamps_size; ++c) {
     timestamps.push_back(
         base::Time::FromInternalValue(autofill.usage_timestamp(c)));
   }
   AutofillKey k(UTF8ToUTF16(autofill.name()), UTF8ToUTF16(autofill.value()));
   AutofillEntry new_entry(k, timestamps);
 
   new_entries->push_back(new_entry);
   std::string tag(AutofillModelAssociator::KeyToTag(k.name(), k.value()));
-  if (action == sync_api::SyncManager::ChangeRecord::ACTION_ADD)
+  if (action == sync_api::ChangeRecord::ACTION_ADD)
     model_associator_->Associate(&tag, sync_id);
 }
 
 void AutofillChangeProcessor::ApplySyncAutofillProfileChange(
-    sync_api::SyncManager::ChangeRecord::Action action,
+    sync_api::ChangeRecord::Action action,
     const sync_pb::AutofillProfileSpecifics& profile,
     int64 sync_id) {
-  DCHECK_NE(sync_api::SyncManager::ChangeRecord::ACTION_DELETE, action);
+  DCHECK_NE(sync_api::ChangeRecord::ACTION_DELETE, action);
 
   switch (action) {
-    case sync_api::SyncManager::ChangeRecord::ACTION_ADD: {
+    case sync_api::ChangeRecord::ACTION_ADD: {
       std::string guid(guid::GenerateGUID());
       if (guid::IsValidGUID(guid) == false) {
         DCHECK(false) << "Guid generated is invalid " << guid;
         return;
       }
       scoped_ptr<AutofillProfile> p(new AutofillProfile);
       p->set_guid(guid);
       AutofillModelAssociator::FillProfileWithServerData(p.get(),
                                                               profile);
       if (!web_database_->GetAutofillTable()->AddAutofillProfile(*p.get())) {
         NOTREACHED() << "Couldn't add autofill profile: " << guid;
         return;
       }
       model_associator_->Associate(&guid, sync_id);
       break;
     }
-    case sync_api::SyncManager::ChangeRecord::ACTION_UPDATE: {
+    case sync_api::ChangeRecord::ACTION_UPDATE: {
       const std::string* guid = model_associator_->GetChromeNodeFromSyncId(
           sync_id);
       if (guid == NULL) {
         LOG(ERROR) << " Model association has not happened for " << sync_id;
         error_handler()->OnUnrecoverableError(FROM_HERE,
             "model association has not happened");
         return;
       }
       AutofillProfile *temp_ptr;
       if (!web_database_->GetAutofillTable()->GetAutofillProfile(
@@ skipping 66 matching lines @@
   autofill.set_value(UTF16ToUTF8(entry.key().value()));
   const std::vector<base::Time>& ts(entry.timestamps());
   for (std::vector<base::Time>::const_iterator timestamp = ts.begin();
        timestamp != ts.end(); ++timestamp) {
     autofill.add_usage_timestamp(timestamp->ToInternalValue());
   }
   node->SetAutofillSpecifics(autofill);
 }
 
 }  // namespace browser_sync