Password sync refactoring: implemented ProcessSyncChanges() and GetAllSyncData()

chrome/browser/password_manager/password_syncable_service.cc

 // Copyright 2013 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/password_manager/password_syncable_service.h"
 
 #include "base/location.h"
 #include "base/memory/scoped_vector.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 97 matching lines @@
     syncer::ModelType type,
     const syncer::SyncDataList& initial_sync_data,
     scoped_ptr<syncer::SyncChangeProcessor> sync_processor,
     scoped_ptr<syncer::SyncErrorFactory> sync_error_factory) {
   DCHECK_EQ(syncer::PASSWORDS, type);
   syncer::SyncMergeResult merge_result(type);
   sync_error_factory_ = sync_error_factory.Pass();
   sync_processor_ = sync_processor.Pass();
 
   ScopedVector<autofill::PasswordForm> password_entries;
-  if (!password_store_->FillAutofillableLogins(&password_entries.get())) {
-    // Password store often fails to load passwords. Track failures with UMA.
-    // (http://crbug.com/249000)
-    UMA_HISTOGRAM_ENUMERATION("Sync.LocalDataFailedToLoad",
-                              syncer::PASSWORDS,
-                              syncer::MODEL_TYPE_COUNT);
+  PasswordEntryMap new_local_entries;
+  if (!ReadFromPasswordStore(&password_entries, &new_local_entries)) {
+    DCHECK(sync_error_factory_);
     merge_result.set_error(sync_error_factory_->CreateAndUploadError(
         FROM_HERE,
         "Failed to get passwords from store."));
     return merge_result;
   }
 
-  PasswordEntryMap new_local_entries;
-  for (PasswordForms::iterator it = password_entries.begin();
-       it != password_entries.end(); ++it) {
-     autofill::PasswordForm* password_form = *it;
-     // We add all the db entries as |new_local_entries| initially. During
-     // model association entries that match a sync entry will be
-     // removed and this list will only contain entries that are not in sync.

[Ilya Sherman, 2014/02/07 22:56:35]

This was a useful comment, IMO.  It would be nice to preserve it.

[vasilii, 2014/02/10 19:06:50]

Done.

-     new_local_entries.insert(
-         std::make_pair(MakePasswordSyncTag(*password_form), password_form));
-  }
-
   merge_result.set_num_items_before_association(new_local_entries.size());
 
   // List that contains the entries that are known only to sync.
   ScopedVector<autofill::PasswordForm> new_sync_entries;
 
   // List that contains the entries that are known to both sync and db but
   // have updates in sync. They need to be updated in the passwords db.
   ScopedVector<autofill::PasswordForm> updated_sync_entries;
 
   // Changes from password db that need to be propagated to sync.
   syncer::SyncChangeList updated_db_entries;
   for (syncer::SyncDataList::const_iterator sync_iter =
            initial_sync_data.begin();
        sync_iter != initial_sync_data.end(); ++sync_iter) {
     CreateOrUpdateEntry(*sync_iter,
                         &new_local_entries,
                         &new_sync_entries,
                         &updated_sync_entries,
                         &updated_db_entries);
   }
 
   WriteToPasswordStore(new_sync_entries.get(),
-                       updated_sync_entries.get());
+                       updated_sync_entries.get(),
+                       PasswordForms());
 
   merge_result.set_num_items_after_association(
       merge_result.num_items_before_association() + new_sync_entries.size());
 
   merge_result.set_num_items_added(new_sync_entries.size());
 
   merge_result.set_num_items_modified(updated_sync_entries.size());
 
   for (PasswordEntryMap::iterator it = new_local_entries.begin();
        it != new_local_entries.end();
        ++it) {
     updated_db_entries.push_back(
         syncer::SyncChange(FROM_HERE,
                            syncer::SyncChange::ACTION_ADD,
                            SyncDataFromPassword(*it->second)));
   }
 
   merge_result.set_error(
       sync_processor_->ProcessSyncChanges(FROM_HERE, updated_db_entries));
   return merge_result;
 }
 
 void PasswordSyncableService::StopSyncing(syncer::ModelType type) {
   sync_processor_.reset();
   sync_error_factory_.reset();
 }
 
 syncer::SyncDataList PasswordSyncableService::GetAllSyncData(
     syncer::ModelType type) const {
+  DCHECK_EQ(syncer::PASSWORDS, type);
+  ScopedVector<autofill::PasswordForm> password_entries;
+  ReadFromPasswordStore(&password_entries, NULL);
+
   syncer::SyncDataList sync_data;
+  for (PasswordForms::iterator i = password_entries.begin();

[Ilya Sherman, 2014/02/07 22:56:35]

nit: i -> it

[vasilii, 2014/02/10 19:06:50]

Done.

+       i != password_entries.end(); ++i) {
+    sync_data.push_back(SyncDataFromPassword(**i));
+  }
   return sync_data;
 }
 
 syncer::SyncError PasswordSyncableService::ProcessSyncChanges(
     const tracked_objects::Location& from_here,
     const syncer::SyncChangeList& change_list) {
-  syncer::SyncError error(FROM_HERE,
-                          syncer::SyncError::UNRECOVERABLE_ERROR,
-                          "Password Syncable Service Not Implemented.",
-                          syncer::PASSWORDS);
-  return error;
+  // The |db_entries_map| and associated vectors are filled only in case of
+  // add/update change.
+  PasswordEntryMap db_entries_map;
+  ScopedVector<autofill::PasswordForm> password_db_entries;
+  ScopedVector<autofill::PasswordForm> new_sync_entries;
+  ScopedVector<autofill::PasswordForm> updated_sync_entries;
+  ScopedVector<autofill::PasswordForm> deleted_entries;
+  bool has_read_passwords = false;
+
+  for (syncer::SyncChangeList::const_iterator it = change_list.begin();
+       it != change_list.end();
+       ++it) {
+    switch (it->change_type()) {
+      case syncer::SyncChange::ACTION_ADD:
+      case syncer::SyncChange::ACTION_UPDATE: {
+        if (!has_read_passwords) {
+          if (ReadFromPasswordStore(&password_db_entries,

[Nicolas Zea, 2014/02/07 21:16:47]

It seems expensive to read all passwords from the password store every time a
sync change arrives. Can we do better? Either by caching the metadata about
passwords, or adding support for only reading the individual password affected?

[Ilya Sherman, 2014/02/07 22:56:35]

FWIW, my vote is against caching unless we really can't get the desired
performance without it -- I've found that it tends to introduce lots of
complexity and, consequently, buginess.  It might indeed make sense to only read
the individual passwords that are affected.

[vasilii, 2014/02/10 19:06:50]

This implementation isn't slower than the existing one. I'm not sure that this
class is a proper place for the cache. Did you mean reading individual passwords
through GetLoginsImpl()? Should it be part of this CL?

+                                    &db_entries_map)) {
+            has_read_passwords = true;
+          } else {
+            return sync_error_factory_->CreateAndUploadError(
+                FROM_HERE,
+                "Failed to get passwords from store.");
+          }
+        }
+        syncer::SyncChangeList sync_changes;
+
+        // This item from sync will be compared to the data in passwords db and
+        // |new_sync_entries| or |updated_sync_entries| will be updated based on
+        // whether this sync item is an addition or update.

[Ilya Sherman, 2014/02/07 22:56:35]

Hmm, why is this needed?  That is, why is it not safe to assume that the Sync
change type is correct at this point?

[vasilii, 2014/02/10 19:06:50]

It's safe. I just reuse the existing method.

+        CreateOrUpdateEntry(it->sync_data(),
+                            &db_entries_map,
+                            &new_sync_entries,
+                            &updated_sync_entries,
+                            &sync_changes);
+        break;
+      }

[Ilya Sherman, 2014/02/07 22:56:35]

nit: Leave a blank line between cases, IMO.

[vasilii, 2014/02/10 19:06:50]

Done.

+      case syncer::SyncChange::ACTION_DELETE: {
+        const sync_pb::EntitySpecifics& specifics =
+            it->sync_data().GetSpecifics();
+        const sync_pb::PasswordSpecificsData& password_specifics(
+            specifics.password().client_only_encrypted_data());
+        autofill::PasswordForm* new_password = new autofill::PasswordForm;

[Ilya Sherman, 2014/02/07 22:56:35]

nit: I prefer to immediately wrap all |new|s in scoped_ptr's or the like, and
then explicitly transfer ownership.  This is a nice habit to get into for quick
and easy correct memory management.

[vasilii, 2014/02/10 19:06:50]

Done.

+        PasswordFromSpecifics(password_specifics, new_password);
+        deleted_entries.push_back(new_password);
+        break;
+      }
+      default: {

[Ilya Sherman, 2014/02/07 22:56:35]

nit: Rather than a default case, please have an explicit case for
ACTION_INVALID.  That way, if the enum ever grows, the compiler will remind us
to think about updating this switch stmt.

[vasilii, 2014/02/10 19:06:50]

Done.

+        return sync_error_factory_->CreateAndUploadError(
+            FROM_HERE,
+            "Failed to process sync changes for passwords datatype.");
+      }

[Ilya Sherman, 2014/02/07 22:56:35]

nit: No need for curly braces.

[vasilii, 2014/02/10 19:06:50]

Done.

+    }
+  }
+  WriteToPasswordStore(new_sync_entries.get(),
+                       updated_sync_entries.get(),
+                       deleted_entries.get());
+  return syncer::SyncError();
 }
 
 void PasswordSyncableService::ActOnPasswordStoreChanges(
     const PasswordStoreChangeList& local_changes) {
   if (!sync_processor_)
     return;
   syncer::SyncChangeList sync_changes;
   for (PasswordStoreChangeList::const_iterator it = local_changes.begin();
        it != local_changes.end();
        ++it) {
     sync_changes.push_back(
         syncer::SyncChange(FROM_HERE,
                            GetSyncChangeType(it->type()),
                            SyncDataFromPassword(it->form())));
   }
   sync_processor_->ProcessSyncChanges(FROM_HERE, sync_changes);
 }
 
+bool PasswordSyncableService::ReadFromPasswordStore(
+    ScopedVector<autofill::PasswordForm>* password_entries,
+    PasswordEntryMap* passwords_entry_map) const {
+  DCHECK(password_entries);

[Ilya Sherman, 2014/02/07 22:56:35]

nit: No need for this, IMO, since you dereference the variable on the next line.

[vasilii, 2014/02/10 19:06:50]

For better log readability?

+  if (!password_store_->FillAutofillableLogins(&password_entries->get()) ||
+      !password_store_->FillBlacklistLogins(&password_entries->get())) {

[Ilya Sherman, 2014/02/07 22:56:35]

Have you added test coverage for blacklisted logins?

[vasilii, 2014/02/10 19:06:50]

I modified PasswordSyncableServiceTest.ProcessSyncChanges and
PasswordSyncableServiceTest.GetAllSyncData

[Ilya Sherman, 2014/02/11 07:59:45]

Lovely, thanks :)

+    // Password store often fails to load passwords. Track failures with UMA.
+    // (http://crbug.com/249000)
+    UMA_HISTOGRAM_ENUMERATION("Sync.LocalDataFailedToLoad",
+                              ModelTypeToHistogramInt(syncer::PASSWORDS),
+                              syncer::MODEL_TYPE_COUNT);
+    return false;
+  }
+
+  if (!passwords_entry_map)
+    return true;
+
+  for (PasswordForms::iterator it = password_entries->begin();
+       it != password_entries->end(); ++it) {
+     autofill::PasswordForm* password_form = *it;
+     passwords_entry_map->insert(
+         std::make_pair(MakePasswordSyncTag(*password_form), password_form));
+  }
+
+  return true;
+}
+
 void PasswordSyncableService::WriteToPasswordStore(
     const PasswordForms& new_entries,
-    const PasswordForms& updated_entries) {
+    const PasswordForms& updated_entries,
+    const PasswordForms& deleted_entries) {
   PasswordStoreChangeList changes;
   for (std::vector<autofill::PasswordForm*>::const_iterator it =
            new_entries.begin();
        it != new_entries.end();
        ++it) {
     AppendChanges(password_store_->AddLoginImpl(**it), &changes);
   }
 
   for (std::vector<autofill::PasswordForm*>::const_iterator it =
            updated_entries.begin();
        it != updated_entries.end();
        ++it) {
     AppendChanges(password_store_->UpdateLoginImpl(**it), &changes);
   }
 
+  for (std::vector<autofill::PasswordForm*>::const_iterator it =
+           deleted_entries.begin();
+       it != deleted_entries.end();
+       ++it) {
+    AppendChanges(password_store_->RemoveLoginImpl(**it), &changes);
+  }
+
   // We have to notify password store observers of the change by hand since
   // we use internal password store interfaces to make changes synchronously.
   NotifyPasswordStoreOfLoginChanges(changes);
 }
 
 void PasswordSyncableService::NotifyPasswordStoreOfLoginChanges(
     const PasswordStoreChangeList& changes) {
   password_store_->NotifyLoginsChanged(changes);
 }
 
@@ skipping 89 matching lines @@
 }
 
 std::string MakePasswordSyncTag(
     const sync_pb::PasswordSpecificsData& password) {
   return MakePasswordSyncTag(password.origin(),
                              password.username_element(),
                              password.username_value(),
                              password.password_element(),
                              password.signon_realm());
 }