Rest of the autofill work.

chrome/browser/sync/glue/autofill_profile_model_associator.cc

 // Copyright (c) 2010 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_profile_model_associator.h"
 
 #include "base/utf_string_conversions.h"
+#include "chrome/browser/sync/glue/autofill_profile_change_processor.h"
+#include "chrome/browser/sync/glue/do_optimistic_refresh_Task.h"
+#include "chrome/browser/sync/syncable/syncable.h"
 #include "chrome/browser/sync/profile_sync_service.h"
 #include "chrome/browser/webdata/web_database.h"
 
 using sync_api::ReadNode;
 namespace browser_sync {
 
-const char kAutofillProfileTag[] = "google_chrome_autofill_profile";
+const char kAutofillProfileTag[] = "google_chrome_autofill_profiles";
 
 AutofillProfileModelAssociator::AutofillProfileModelAssociator(
     ProfileSyncService* sync_service,
     WebDatabase* web_database,
     PersonalDataManager* personal_data)
     : sync_service_(sync_service),
       web_database_(web_database),
       personal_data_(personal_data),
       autofill_node_id_(sync_api::kInvalidId),
-      abort_association_pending_(false) {
+      abort_association_pending_(false),
+      number_of_profiles_created_(0) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::DB));
   DCHECK(sync_service_);
   DCHECK(web_database_);
   DCHECK(personal_data_);
 }
 
 AutofillProfileModelAssociator::~AutofillProfileModelAssociator() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::DB));
 }
 
@@ skipping 24 matching lines @@
       current_profiles->insert(guid);
     } else {
       MakeNewAutofillProfileSyncNodeIfNeeded(write_trans,
           autofill_root,
           (**ix),
           new_profiles,
           current_profiles,
           profiles_to_delete);
     }
   }
-
+  return true;
+}
+
+bool AutofillProfileModelAssociator::GetSyncIdForTaggedNode(
+    const std::string& tag,
+    int64* sync_id) {
+  sync_api::ReadTransaction trans(
+      sync_service_->backend()->GetUserShareHandle());
+  sync_api::ReadNode sync_node(&trans);
+  if (!sync_node.InitByTagLookup(tag.c_str()))
+    return false;
+  *sync_id = sync_node.GetId();
   return true;
 }
 
 bool AutofillProfileModelAssociator::LoadAutofillData(
     std::vector<AutoFillProfile*>* profiles) {
   if (IsAbortPending())
     return false;
 
   if (!web_database_->GetAutoFillProfiles(profiles))
     return false;
@@ skipping 38 matching lines @@
         !TraverseAndAssociateAllSyncNodes(&trans, autofill_root, &bundle)) {
       return false;
     }
   }
 
   if (!SaveChangesToWebData(bundle)) {
     LOG(ERROR) << "Failed to update autofill entries.";
     return false;
   }
 
-  // TODO(lipalani) Bug 64111- split out the OptimisticRefreshTask
-  // into its own class
-  // from autofill_model_associator
-  // Will be done as part of the autofill_model_associator work.
-  // BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
-  // new DoOptimisticRefreshTask(personal_data_));
+  if (sync_service_->backend()->GetAutofillMigrationState() !=
+     syncable::Directory::PersistedKernelInfo::MIGRATED) {
+    syncable::AutofillMigrationDebugInfo debug_info;
+    debug_info.autofill_profile_added_during_migration =
+      number_of_profiles_created_;
+    sync_service_->backend()->SetAutofillMigrationDebugInfo(
+      syncable::AutofillMigrationDebugInfo::PROFILES_ADDED,
+      debug_info);
+  }
+

[lipalani, 2010/12/09 19:45:25]

move this code above.

[lipalani, 2010/12/11 00:12:36]

Done.

+  sync_service()->backend()->SetAutofillMigrationState(
+    syncable::Directory::PersistedKernelInfo::MIGRATED);
+
+  BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+    new DoOptimisticRefreshForAutofill(personal_data_));
   return true;
 }
 
 bool AutofillProfileModelAssociator::DisassociateModels() {
   id_map_.clear();
   id_map_inverse_.clear();
   return true;
 }
 
 // Helper to compare the local value and cloud value of a field, merge into
 // the local value if they differ, and return whether the merge happened.
 bool AutofillProfileModelAssociator::MergeField(FormGroup* f,
     AutoFillFieldType t,
     const std::string& specifics_field) {
   if (UTF16ToUTF8(f->GetFieldText(AutoFillType(t))) == specifics_field)
     return false;
   f->SetInfo(AutoFillType(t), UTF8ToUTF16(specifics_field));
   return true;
 }
 bool AutofillProfileModelAssociator::SyncModelHasUserCreatedNodes(
     bool *has_nodes) {
   CHECK_NE(has_nodes, reinterpret_cast<bool*>(NULL));
   sync_api::ReadTransaction trans(
       sync_service_->backend()->GetUserShareHandle());
 
   sync_api::ReadNode node(&trans);
 
-  if (!node.InitByClientTagLookup(
-        syncable::AUTOFILL_PROFILE,
-        kAutofillProfileTag)) {
+  if (!node.InitByTagLookup(kAutofillProfileTag)) {
     LOG(ERROR) << "Sever did not create a top level node"
                << "Out of data server or autofill type not enabled";
     return false;
   }
 
   *has_nodes = sync_api::kInvalidId != node.GetFirstChildId();
   return true;
 }
 // static
 bool AutofillProfileModelAssociator::OverwriteProfileWithServerData(
@@ skipping 73 matching lines @@
     current_profiles->insert(autofill_specifics.guid());
   } else {
     sync_api::WriteNode node(trans);
     if (!node.InitUniqueByCreation(
              syncable::AUTOFILL_PROFILE, autofill_root, profile.guid())) {
       LOG(ERROR) << "Failed to create autofill sync node.";
       return false;
     }
     node.SetTitle(UTF8ToWide(profile.guid()));
 
-    // TODO(lipalani) -Bug 64111 This needs rewriting. This will be tackled
-    // when rewriting autofill change processor.
-    // AutofillChangeProcessor::WriteAutofillProfile(profile, &node);
+    AutofillProfileChangeProcessor::WriteAutofillProfile(profile, &node);
+    current_profiles->insert(profile.guid());
+    number_of_profiles_created_++;
   }
   return true;
 }
 
 bool AutofillProfileModelAssociator::TraverseAndAssociateAllSyncNodes(
     sync_api::WriteTransaction* write_trans,
     const sync_api::ReadNode& autofill_root,
     DataBundle* bundle) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::DB));
 
@@ skipping 85 matching lines @@
   AutofillToSyncIdMap::const_iterator iter = id_map_.find(autofill);
   return iter == id_map_.end() ? sync_api::kInvalidId : iter->second;
 }
 
 void AutofillProfileModelAssociator::AbortAssociation() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   AutoLock lock(abort_association_pending_lock_);
   abort_association_pending_ = true;
 }
 
+const std::string* AutofillProfileModelAssociator::GetChromeNodeFromSyncId(
+    int64 sync_id) {
+  SyncIdToAutofillMap::const_iterator iter = id_map_inverse_.find(sync_id);
+  return iter == id_map_inverse_.end() ? NULL : &(iter->second);
+}
+
 bool AutofillProfileModelAssociator::IsAbortPending() {
   AutoLock lock(abort_association_pending_lock_);
   return abort_association_pending_;
 }
 
 }  // namespace browser_sync