Sending the proto files for review to unblcok the server team

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/profile.h"
 #include "chrome/browser/sync/engine/syncapi.h"
 #include "chrome/browser/sync/glue/autofill_change_processor.h"
 #include "chrome/browser/sync/profile_sync_service.h"
 #include "chrome/browser/sync/protocol/autofill_specifics.pb.h"
 #include "chrome/browser/webdata/web_database.h"
 #include "net/base/escape.h"
 
 using base::TimeTicks;
 
 namespace browser_sync {
 
 const char kAutofillTag[] = "google_chrome_autofill";
 const char kAutofillEntryNamespaceTag[] = "autofill_entry|";
-const char kAutofillProfileNamespaceTag[] = "autofill_profile|";
-
-static const int kMaxNumAttemptsToFindUniqueLabel = 100;
 
 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); }
 };
 
@@ skipping 74 matching lines @@
       node.SetTitle(UTF8ToWide(tag));
       AutofillChangeProcessor::WriteAutofillEntry(*ix, &node);
       Associate(&tag, node.GetId());
     }
 
     current_entries->insert(ix->key());
   }
   return true;
 }
 
-bool AutofillModelAssociator::TraverseAndAssociateChromeAutoFillProfiles(
-    sync_api::WriteTransaction* write_trans,
-    const sync_api::ReadNode& autofill_root,
-    const std::vector<AutoFillProfile*>& all_profiles_from_db,
-    std::set<string16>* current_profiles,
-    std::vector<AutoFillProfile*>* updated_profiles) {
-  const std::vector<AutoFillProfile*>& profiles = all_profiles_from_db;
-  for (std::vector<AutoFillProfile*>::const_iterator ix = profiles.begin();
-       ix != profiles.end(); ++ix) {
-    string16 label((*ix)->Label());
-    std::string tag(ProfileLabelToTag(label));
-
-    sync_api::ReadNode node(write_trans);
-    if (node.InitByClientTagLookup(syncable::AUTOFILL, tag)) {
-      const sync_pb::AutofillSpecifics& autofill(node.GetAutofillSpecifics());
-      DCHECK(autofill.has_profile());
-      DCHECK_EQ(ProfileLabelToTag(UTF8ToUTF16(autofill.profile().label())),
-                tag);
-      int64 sync_id = node.GetId();
-      if (id_map_.find(tag) != id_map_.end()) {
-        // We just looked up something we already associated.  Move aside.
-        label = MakeUniqueLabel(label, string16(), write_trans);
-        if (label.empty()) {
-          return false;
-        }
-        tag = ProfileLabelToTag(label);
-        // TODO(dhollowa): Replace with |AutoFillProfile::set_guid|.
-        // http://crbug.com/58813
-        (*ix)->set_label(label);
-        if (!MakeNewAutofillProfileSyncNode(write_trans, autofill_root,
-                                            tag, **ix, &sync_id)) {
-          return false;
-        }
-        updated_profiles->push_back(*ix);
-      } else {
-        // Overwrite local with cloud state.
-        if (OverwriteProfileWithServerData(*ix, autofill.profile()))
-          updated_profiles->push_back(*ix);
-        sync_id = node.GetId();
-      }
-
-      Associate(&tag, sync_id);
-    } else {
-      int64 id;
-      if (!MakeNewAutofillProfileSyncNode(write_trans, autofill_root,
-                                          tag, **ix, &id)) {
-        return false;
-      }
-      Associate(&tag, id);
-    }
-    current_profiles->insert(label);
-  }
-  return true;
-}
-
-// static
-string16 AutofillModelAssociator::MakeUniqueLabel(
-    const string16& non_unique_label,
-    const string16& existing_unique_label,
-    sync_api::BaseTransaction* trans) {
-  if (!non_unique_label.empty() && non_unique_label == existing_unique_label) {
-    return existing_unique_label;
-  }
-  int unique_id = 1;  // Priming so we start by appending "2".
-  while (unique_id++ < kMaxNumAttemptsToFindUniqueLabel) {
-    string16 suffix(base::IntToString16(unique_id));
-    string16 unique_label = non_unique_label + suffix;
-    if (unique_label == existing_unique_label)
-      return unique_label;  // We'll use the one we already have.
-    sync_api::ReadNode node(trans);
-    if (node.InitByClientTagLookup(syncable::AUTOFILL,
-                                   ProfileLabelToTag(unique_label))) {
-      continue;
-    }
-    return unique_label;
-  }
-
-  LOG(ERROR) << "Couldn't create unique tag for autofill node. Srsly?!";
-  return string16();
-}
-
 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);
@@ skipping 41 matching lines @@
         sync_service_->backend()->GetUserShareHandle());
 
     sync_api::ReadNode autofill_root(&trans);
     if (!autofill_root.InitByTagLookup(kAutofillTag)) {
       LOG(ERROR) << "Server did not create the top-level autofill node. We "
                  << "might be running against an out-of-date server.";
       return false;
     }
 
     if (!TraverseAndAssociateChromeAutofillEntries(&trans, autofill_root,
-            entries, &bundle.current_entries, &bundle.new_entries) ||
-        !TraverseAndAssociateChromeAutoFillProfiles(&trans, autofill_root,
-            profiles.get(), &bundle.current_profiles,
-            &bundle.updated_profiles) ||
-        !TraverseAndAssociateAllSyncNodes(&trans, autofill_root, &bundle)) {
-      return false;
+      entries, &bundle.current_entries, &bundle.new_entries)) {
+        return false;
+    }
+    if(IsUpgrading()) {
+      if(!TraverseAndAssociateAllSyncNodes(
+              &trans,
+              autofill_root,
+              &bundle,
+              profiles.get())) {
+        return false;
+      }
     }
   }
 
   // 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.";
@@ skipping 28 matching lines @@
       return false;
     if (!web_database_->UpdateAutoFillProfile(*bundle.updated_profiles[i]))
       return false;
   }
   return true;
 }
 
 bool AutofillModelAssociator::TraverseAndAssociateAllSyncNodes(
     sync_api::WriteTransaction* write_trans,
     const sync_api::ReadNode& autofill_root,
-    DataBundle* bundle) {
+    DataBundle* bundle,
+    std::vector<AutoFillProfile*>& all_profiles_from_db) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::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())
-      AddNativeProfileIfNeeded(autofill.profile(), bundle, sync_child);
+    else if (autofill.has_profile()) {
+      DCHECK(IsUpgrading());
+      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;
 }
 
+// [TODO] fix the p1 and p2.
+bool CompareAutofillProfiles(const AutoFillProfile& p1,
+                             const AutoFillProfile& p2)
+{
+  if(p1.Compare(p2) == 0)
+    return true;
+  else return false;
+}
+
+// Define the functor to be used as the predicate in find_if call.
+struct CompareProfiles :
+  public std::binary_function<AutoFillProfile*,
+                              AutoFillProfile*,
+                              bool> {
+  bool operator() (AutoFillProfile* p1, AutoFillProfile* p2) const {
+    return CompareAutofillProfiles(*p1, *p2);
+  }
+
+};
+
+AutoFillProfile* AutofillModelAssociator::FindCorrespondingNodeFromWebDB(
+    const sync_pb::AutofillProfileSpecifics& profile,
+    const std::vector<AutoFillProfile*>& all_profiles_from_db) {
+  
+  static std::string guid(guid::GenerateGUID());
+  AutoFillProfile p;
+  p.set_guid(guid);
+  if(!OverwriteProfileWithServerData(&p, profile))
+  {
+    // Not a big deal. We encountered an error. Just say this profile does not 
+    // exist.
+    LOG(ERROR) << " Profile could not be associated";
+    return NULL;
+  }
+
+  // Now instantiate the functor and call find_if.
+  std::vector<AutoFillProfile*>::const_iterator ix = 
+    std::find_if(all_profiles_from_db.begin(), 
+                 all_profiles_from_db.end(),
+                 std::bind2nd(CompareProfiles(), &p));
+
+  return (ix == all_profiles_from_db.end()) ? NULL : *ix;
+}
+
 void AutofillModelAssociator::AddNativeEntryIfNeeded(
     const sync_pb::AutofillSpecifics& autofill, DataBundle* bundle,
     const sync_api::ReadNode& node) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::DB));
   AutofillKey key(UTF8ToUTF16(autofill.name()), UTF8ToUTF16(autofill.value()));
 
   if (bundle->current_entries.find(key) == bundle->current_entries.end()) {
     std::vector<base::Time> timestamps;
     int timestamps_count = autofill.usage_timestamp_size();
     for (int c = 0; c < timestamps_count; ++c) {
       timestamps.push_back(base::Time::FromInternalValue(
           autofill.usage_timestamp(c)));
     }
     std::string tag(KeyToTag(key.name(), key.value()));
     Associate(&tag, node.GetId());
     bundle->new_entries.push_back(AutofillEntry(key, timestamps));
   }
 }
 
 void AutofillModelAssociator::AddNativeProfileIfNeeded(
-    const sync_pb::AutofillProfileSpecifics& profile, DataBundle* bundle,
-    const sync_api::ReadNode& node) {
+    const sync_pb::AutofillProfileSpecifics& profile, 
+    DataBundle* bundle,
+    const sync_api::ReadNode& node,
+    std::vector<AutoFillProfile*>& all_profiles_from_db) {
+  
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::DB));
-  if (bundle->current_profiles.find(UTF8ToUTF16(profile.label())) ==
-      bundle->current_profiles.end()) {
-    std::string tag(ProfileLabelToTag(UTF8ToUTF16(profile.label())));
-    Associate(&tag, node.GetId());
-    AutoFillProfile* p = personal_data_->
-        CreateNewEmptyAutoFillProfileForDBThread(UTF8ToUTF16(profile.label()));
+  
+  scoped_ptr<AutoFillProfile> profile_in_web_db(FindCorrespondingNodeFromWebDB(
+      profile, all_profiles_from_db));
+
+  if(profile_in_web_db.get() != NULL) {
+    int64 sync_id = node.GetId();
+    Associate(&(profile_in_web_db->guid()), sync_id);
+    return;
+  } else { // Create a new node.
+    std::string guid = guid::GenerateGUID();
+    Associate(&guid, node.GetId());
+    AutoFillProfile* p = new AutoFillProfile(guid);
     OverwriteProfileWithServerData(p, profile);
     bundle->new_profiles.push_back(p);
   }
 }
 
 bool AutofillModelAssociator::DisassociateModels() {
+
   id_map_.clear();
   id_map_inverse_.clear();
   return true;
 }
 
 bool AutofillModelAssociator::SyncModelHasUserCreatedNodes(bool* has_nodes) {
   DCHECK(has_nodes);
   *has_nodes = false;
   int64 autofill_sync_id;
   if (!GetSyncIdForTaggedNode(kAutofillTag, &autofill_sync_id)) {
@@ skipping 18 matching lines @@
 }
 
 void AutofillModelAssociator::AbortAssociation() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   AutoLock lock(abort_association_pending_lock_);
   abort_association_pending_ = true;
 }
 
 const std::string*
 AutofillModelAssociator::GetChromeNodeFromSyncId(int64 sync_id) {
-  return NULL;
+  SyncIdToAutofillMap::const_iterator iter = id_map_inverse_.find(sync_id);
+  return iter == id_map_inverse_.end() ? NULL : &(iter->second);
 }
 
 bool AutofillModelAssociator::InitSyncNodeFromChromeId(
     std::string node_id,
     sync_api::BaseNode* sync_node) {
   return false;
 }
 
 int64 AutofillModelAssociator::GetSyncIdFromChromeId(
     const std::string autofill) {
@@ skipping 38 matching lines @@
 
 // static
 std::string AutofillModelAssociator::KeyToTag(const string16& name,
                                               const string16& value) {
   std::string ns(kAutofillEntryNamespaceTag);
   return ns + EscapePath(UTF16ToUTF8(name)) + "|" +
          EscapePath(UTF16ToUTF8(value));
 }
 
 // static
-std::string AutofillModelAssociator::ProfileLabelToTag(const string16& label) {
-  std::string ns(kAutofillProfileNamespaceTag);
-  return ns + EscapePath(UTF16ToUTF8(label));
-}
-
-// static
 bool AutofillModelAssociator::MergeTimestamps(
     const sync_pb::AutofillSpecifics& autofill,
     const std::vector<base::Time>& timestamps,
     std::vector<base::Time>* new_timestamps) {
   DCHECK(new_timestamps);
   std::set<base::Time> timestamp_union(timestamps.begin(),
                                        timestamps.end());
 
   size_t timestamps_count = autofill.usage_timestamp_size();
 
@@ skipping 41 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::IsUpgrading()
+{
+  return true;
+}
+
 }  // namespace browser_sync