Rest of the autofill work.

chrome/browser/sync/glue/autofill_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_model_associator.h"
 
 #include <vector>
 
 #include "base/task.h"
 #include "base/time.h"
 #include "base/string_number_conversions.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/autofill/autofill_profile.h"
 #include "chrome/browser/browser_thread.h"
 #include "chrome/browser/guid.h"
+#include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sync/engine/syncapi.h"
 #include "chrome/browser/sync/glue/autofill_change_processor.h"
+#include "chrome/browser/sync/glue/autofill_profile_model_associator.h"
+#include "chrome/browser/sync/glue/do_optimistic_refresh_Task.h"
 #include "chrome/browser/sync/profile_sync_service.h"
 #include "chrome/browser/sync/protocol/autofill_specifics.pb.h"
+#include "chrome/browser/sync/syncable/syncable.h"

[tim (not reviewing), 2010/12/13 19:24:33]

illegal include

[lipalani, 2010/12/14 21:05:57]

Done.

 #include "chrome/browser/webdata/web_database.h"
+#include "chrome/common/pref_names.h"
 #include "net/base/escape.h"
 
 using base::TimeTicks;
 
 namespace browser_sync {
 
 const char kAutofillTag[] = "google_chrome_autofill";
 const char kAutofillEntryNamespaceTag[] = "autofill_entry|";
 
 struct AutofillModelAssociator::DataBundle {
   std::set<AutofillKey> current_entries;
   std::vector<AutofillEntry> new_entries;
   std::set<string16> current_profiles;
   std::vector<AutoFillProfile*> updated_profiles;
   std::vector<AutoFillProfile*> new_profiles;  // We own these pointers.
   ~DataBundle() { STLDeleteElements(&new_profiles); }
 };
 
-AutofillModelAssociator::DoOptimisticRefreshTask::DoOptimisticRefreshTask(
-    PersonalDataManager* pdm) : pdm_(pdm) {}
-
-AutofillModelAssociator::DoOptimisticRefreshTask::~DoOptimisticRefreshTask() {}
-
-void AutofillModelAssociator::DoOptimisticRefreshTask::Run() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  pdm_->Refresh();
-}
-
 AutofillModelAssociator::AutofillModelAssociator(
     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) {
+      autofill_migration_state_(syncable::NOT_DETERMINED),
+      abort_association_pending_(false),
+      number_of_entries_created_(0) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::DB));
   DCHECK(sync_service_);
   DCHECK(web_database_);
   DCHECK(personal_data_);
 }
 
 AutofillModelAssociator::~AutofillModelAssociator() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::DB));
 }
 
@@ skipping 38 matching lines @@
     } else {
       sync_api::WriteNode node(write_trans);
       if (!node.InitUniqueByCreation(syncable::AUTOFILL,
                                      autofill_root, tag)) {
         LOG(ERROR) << "Failed to create autofill sync node.";
         return false;
       }
       node.SetTitle(UTF8ToWide(tag));
       AutofillChangeProcessor::WriteAutofillEntry(*ix, &node);
       Associate(&tag, node.GetId());
+      number_of_entries_created_++;
     }
 
     current_entries->insert(ix->key());
   }
   return true;
 }
 
-bool AutofillModelAssociator::MakeNewAutofillProfileSyncNode(
-    sync_api::WriteTransaction* trans, const sync_api::BaseNode& autofill_root,
-    const std::string& tag, const AutoFillProfile& profile, int64* sync_id) {
-  sync_api::WriteNode node(trans);
-  if (!node.InitUniqueByCreation(syncable::AUTOFILL, autofill_root, tag)) {
-    LOG(ERROR) << "Failed to create autofill sync node.";
-    return false;
-  }
-  node.SetTitle(UTF8ToWide(tag));
-  AutofillChangeProcessor::WriteAutofillProfile(profile, &node);
-  *sync_id = node.GetId();
-  return true;
-}
-
-
 bool AutofillModelAssociator::LoadAutofillData(
     std::vector<AutofillEntry>* entries,
     std::vector<AutoFillProfile*>* profiles) {
   if (IsAbortPending())
     return false;
   if (!web_database_->GetAllAutofillEntries(entries))
     return false;
 
   if (IsAbortPending())
     return false;
@@ skipping 49 matching lines @@
   // Since we're on the DB thread, we don't have to worry about updating
   // the autofill database after closing the write transaction, since
   // this is the only thread that writes to the database.  We also don't have
   // to worry about the sync model getting out of sync, because changes are
   // propogated to the ChangeProcessor on this thread.
   if (!SaveChangesToWebData(bundle)) {
     LOG(ERROR) << "Failed to update autofill entries.";
     return false;
   }
 
+  if (sync_service_->backend()->GetAutofillMigrationState() !=
+      syncable::MIGRATED) {
+    syncable::AutofillMigrationDebugInfo debug_info;
+    debug_info.autofill_entries_added_during_migration =
+        number_of_entries_created_;
+    sync_service_->backend()->SetAutofillMigrationDebugInfo(
+        syncable::AutofillMigrationDebugInfo::ENTRIES_ADDED,
+        debug_info);
+  }
+
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
-      new DoOptimisticRefreshTask(personal_data_));
+      new DoOptimisticRefreshForAutofill(personal_data_));
   return true;
 }
 
 bool AutofillModelAssociator::SaveChangesToWebData(const DataBundle& bundle) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::DB));
 
   if (IsAbortPending())
     return false;
 
   if (bundle.new_entries.size() &&
@@ skipping 17 matching lines @@
   return true;
 }
 
 bool AutofillModelAssociator::TraverseAndAssociateAllSyncNodes(
     sync_api::WriteTransaction* write_trans,
     const sync_api::ReadNode& autofill_root,
     DataBundle* bundle,
     const std::vector<AutoFillProfile*>& all_profiles_from_db) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::DB));
 
+  bool autofill_profile_not_migrated = HasNotMigratedYet(write_trans);
+
+  if (MigrationLoggingEnabled() &&
+     autofill_profile_not_migrated) {
+    VLOG(1) << "[AUTOFILL MIGRATION]"
+            << "Printing profiles from web db";
+
+    for (std::vector<AutoFillProfile*>::const_iterator ix =
+        all_profiles_from_db.begin(); ix != all_profiles_from_db.end(); ++ix) {
+      AutoFillProfile* p = *ix;
+      VLOG(1) << "[AUTOFILL MIGRATION]  "
+              << UTF16ToUTF8(p->GetFieldText(AutoFillType(NAME_FIRST)))
+              << UTF16ToUTF8(p->GetFieldText(AutoFillType(NAME_LAST)));
+    }
+  }
+
+  if (MigrationLoggingEnabled() && autofill_profile_not_migrated) {
+    VLOG(1) << "[AUTOFILL MIGRATION]"
+            << "Iterating over sync db";
+  }
+
   int64 sync_child_id = autofill_root.GetFirstChildId();
   while (sync_child_id != sync_api::kInvalidId) {
     sync_api::ReadNode sync_child(write_trans);
     if (!sync_child.InitByIdLookup(sync_child_id)) {
       LOG(ERROR) << "Failed to fetch child node.";
       return false;
     }
     const sync_pb::AutofillSpecifics& autofill(
         sync_child.GetAutofillSpecifics());
 
     if (autofill.has_value()) {
       AddNativeEntryIfNeeded(autofill, bundle, sync_child);
-    } else if (autofill.has_profile() && HasNotMigratedYet()) {
+    } else if (autofill.has_profile()) {
       // Ignore autofill profiles if we are not upgrading.
-      AddNativeProfileIfNeeded(
-          autofill.profile(),
-          bundle,
-          sync_child,
-          all_profiles_from_db);
+      if (autofill_profile_not_migrated) {
+        if (MigrationLoggingEnabled()) {
+          VLOG(1) << "[AUTOFILL MIGRATION] Looking for "

[tim (not reviewing), 2010/12/13 19:24:33]

it seems weird to combine vlog with another conditional log, should we just use
LOG(INFO) here instead if we're controlling it ourselves?

[lipalani, 2010/12/14 21:05:57]

Would it be OK if I dealt with logging on the next cl?
On 2010/12/13 19:24:33, timsteele wrote:

+                  << autofill.profile().name_first()
+                  << autofill.profile().name_last();
+        }
+        AddNativeProfileIfNeeded(
+            autofill.profile(),
+            bundle,
+            sync_child,
+            all_profiles_from_db);
+      }
     } else {
       NOTREACHED() << "AutofillSpecifics has no autofill data!";
     }
 
     sync_child_id = sync_child.GetSuccessorId();
   }
   return true;
 }
 
 // Define the functor to be used as the predicate in find_if call.
@@ skipping 49 matching lines @@
 }
 
 void AutofillModelAssociator::AddNativeProfileIfNeeded(
     const sync_pb::AutofillProfileSpecifics& profile,
     DataBundle* bundle,
     const sync_api::ReadNode& node,
     const std::vector<AutoFillProfile*>& all_profiles_from_db) {
 
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::DB));
 
-  scoped_ptr<AutoFillProfile> profile_in_web_db(FindCorrespondingNodeFromWebDB(
-      profile, all_profiles_from_db));
+  AutoFillProfile* profile_in_web_db = FindCorrespondingNodeFromWebDB(
+      profile, all_profiles_from_db);
 
-  if (profile_in_web_db.get() != NULL) {
+  if (profile_in_web_db != NULL) {
+    if (MigrationLoggingEnabled()) {
+      VLOG(1) << "[AUTOFILL MIGRATION]"
+              << "Node found in web db. So associating";
+    }
     int64 sync_id = node.GetId();
     std::string guid = profile_in_web_db->guid();
     Associate(&guid, sync_id);
     return;
   } else {  // Create a new node.
+    if (MigrationLoggingEnabled()) {
+      VLOG(1) << "[AUTOFILL MIGRATION]"
+              << "Node not found in web db so creating and associating";
+    }
     std::string guid = guid::GenerateGUID();
     Associate(&guid, node.GetId());
     AutoFillProfile* p = new AutoFillProfile(guid);
     FillProfileWithServerData(p, profile);
     bundle->new_profiles.push_back(p);
   }
 }
 
 bool AutofillModelAssociator::DisassociateModels() {
   id_map_.clear();
@@ skipping 148 matching lines @@
   diff = MergeField(p, ADDRESS_HOME_ZIP, s.address_home_zip()) || diff;
   diff = MergeField(p, EMAIL_ADDRESS, s.email_address()) || diff;
   diff = MergeField(p, COMPANY_NAME, s.company_name()) || diff;
   diff = MergeField(p, PHONE_FAX_WHOLE_NUMBER, s.phone_fax_whole_number())
       || diff;
   diff = MergeField(p, PHONE_HOME_WHOLE_NUMBER, s.phone_home_whole_number())
       || diff;
   return diff;
 }
 
-bool AutofillModelAssociator::HasNotMigratedYet() {
-  return true;
+bool AutofillModelAssociator::HasNotMigratedYet(
+    const sync_api::BaseTransaction* trans) {
+
+  // If state is migrated in our cached variable return true. We dont have
+  // to check against the directory as it will not change.
+  if (autofill_migration_state_ ==

[tim (not reviewing), 2010/12/13 19:24:33]

I thought we were getting rid of this cache?

[lipalani, 2010/12/14 21:05:57]

Yeah I got rid of it! it is reflected in the current cl.
On 2010/12/13 19:24:33, timsteele wrote:

+    syncable::MIGRATED) {

[tim (not reviewing), 2010/12/13 19:24:33]

I think this fits on previous line, but it shouldn't be syncable:: namespace.

[lipalani, 2010/12/14 21:05:57]

I fixed the line indentation. Not sure I understand about the syncable
namespace. The header file autofill_migration.h is in syncable namespace similar
to model_types.h
On 2010/12/13 19:24:33, timsteele wrote:

+    return false;
+  }
+
+  // Now read the current value from the directory.
+  autofill_migration_state_ =
+    sync_service()->backend()->GetAutofillMigrationState();
+
+  DCHECK_NE(autofill_migration_state_, syncable::NOT_DETERMINED);
+
+  if (autofill_migration_state_== syncable::NOT_DETERMINED) {
+    VLOG(1) << "Autofill migration state is not determined inside "
+            << " model associator";
+  }
+  if (autofill_migration_state_ ==
+     syncable::NOT_MIGRATED) {

[tim (not reviewing), 2010/12/13 19:24:33]

same comment as above

[lipalani, 2010/12/14 21:05:57]

Done.

+    return true;
+  }
+
+  if (autofill_migration_state_ ==
+    syncable::INSUFFICIENT_INFO_TO_DETERMINE) {
+      if (MigrationLoggingEnabled()) {
+        VLOG(1) << "[AUTOFILL MIGRATION]"
+                << "current autofill migration state is insufficient info to"
+                << "Determine";
+      }
+      sync_api::ReadNode autofill_profile_root_node(trans);
+      if (!autofill_profile_root_node.InitByTagLookup(
+          browser_sync::kAutofillProfileTag) ||
+          autofill_profile_root_node.GetFirstChildId()==
+            static_cast<int64>(0)) {
+        sync_service()->backend()->SetAutofillMigrationState(
+            syncable::NOT_MIGRATED);
+
+        if (MigrationLoggingEnabled()) {
+          VLOG(1) << "[AUTOFILL MIGRATION]"
+                  << "Current autofill migration state is NOT Migrated becausse"
+                  << "legacy autofil root node is preseent whereas new "
+                  << "Autofill profile root node is not present";
+        }
+        return true;
+      }
+
+      sync_service()->backend()->SetAutofillMigrationState(
+          syncable::MIGRATED);
+
+      if (MigrationLoggingEnabled()) {
+          VLOG(1) << "[AUTOFILL MIGRATION]"
+                  << "Current autofill migration state is migrated";
+      }
+      autofill_migration_state_ =
+        syncable::MIGRATED;

[tim (not reviewing), 2010/12/13 19:24:33]

prev line

[lipalani, 2010/12/14 21:05:57]

Removed.
On 2010/12/13 19:24:33, timsteele wrote:

+  }
+
+  return false;
 }
 
+bool AutofillModelAssociator::MigrationLoggingEnabled() {
+  // [TODO] enable logging via a command line flag.

[tim (not reviewing), 2010/12/13 19:24:33]

what's the plan here?

[lipalani, 2010/12/14 21:05:57]

Logging part of the next cl?
On 2010/12/13 19:24:33, timsteele wrote:

+  return false;
+}
 }  // namespace browser_sync
+