contacts: Don't save deleted contacts to disk.

chrome/browser/chromeos/contacts/contact_database.cc

 // Copyright (c) 2012 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/chromeos/contacts/contact_database.h"
 
 #include <set>
 
 #include "base/file_util.h"
 #include "base/metrics/histogram.h"
@@ skipping 68 matching lines @@
       base::Bind(&ContactDatabase::InitFromTaskRunner,
                  base::Unretained(this),
                  database_dir,
                  success),
       base::Bind(&ContactDatabase::RunInitCallback,
                  weak_ptr_factory_.GetWeakPtr(),
                  callback,
                  base::Owned(success)));
 }
 
-void ContactDatabase::SaveContacts(scoped_ptr<ContactPointers> contacts,
+void ContactDatabase::SaveContacts(scoped_ptr<ContactPointers> contacts_to_save,
+                                   scoped_ptr<ContactIds> contact_ids_to_delete,
                                    scoped_ptr<UpdateMetadata> metadata,
                                    bool is_full_update,
                                    SaveCallback callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   bool* success = new bool(false);
   task_runner_->PostTaskAndReply(
       FROM_HERE,
       base::Bind(&ContactDatabase::SaveContactsFromTaskRunner,
                  base::Unretained(this),
-                 base::Passed(contacts.Pass()),
+                 base::Passed(contacts_to_save.Pass()),
+                 base::Passed(contact_ids_to_delete.Pass()),
                  base::Passed(metadata.Pass()),
                  is_full_update,
                  success),
       base::Bind(&ContactDatabase::RunSaveCallback,
                  weak_ptr_factory_.GetWeakPtr(),
                  callback,
                  base::Owned(success)));
 }
 
 void ContactDatabase::LoadContacts(LoadCallback callback) {
@@ skipping 96 matching lines @@
       break;
     }
   }
 
   UMA_HISTOGRAM_ENUMERATION("Contacts.DatabaseInitResult",
                             histogram_result,
                             HISTOGRAM_INIT_RESULT_MAX_VALUE);
 }
 
 void ContactDatabase::SaveContactsFromTaskRunner(
-    scoped_ptr<ContactPointers> contacts,
+    scoped_ptr<ContactPointers> contacts_to_save,
+    scoped_ptr<ContactIds> contact_ids_to_delete,
     scoped_ptr<UpdateMetadata> metadata,
     bool is_full_update,
     bool* success) {
   DCHECK(IsRunByTaskRunner());
   DCHECK(success);
-  VLOG(1) << "Saving " << contacts->size() << " contact(s) to database as "
+  VLOG(1) << "Saving " << contacts_to_save->size() << " contact(s) to database "
+          << "and deleting " << contact_ids_to_delete->size() << " as "
           << (is_full_update ? "full" : "incremental") << " update";
 
   *success = false;
 
   // If we're doing a full update, find all of the existing keys first so we can
   // delete ones that aren't present in the new set of contacts.
   std::set<std::string> keys_to_delete;
   if (is_full_update) {
     leveldb::ReadOptions options;
     scoped_ptr<leveldb::Iterator> db_iterator(db_->NewIterator(options));
     db_iterator->SeekToFirst();
     while (db_iterator->Valid()) {
       std::string key = db_iterator->key().ToString();
       if (key != kUpdateMetadataKey)
         keys_to_delete.insert(key);
       db_iterator->Next();
     }
+  } else {
+    for (ContactIds::const_iterator it = contact_ids_to_delete->begin();
+         it != contact_ids_to_delete->end(); ++it) {
+      keys_to_delete.insert(*it);
+    }
   }
 
   // TODO(derat): Serializing all of the contacts and so we can write them in a
   // single batch may be expensive, memory-wise.  Consider writing them in
   // several batches instead.  (To avoid using partial writes in the event of a
   // crash, maybe add a dummy "write completed" contact that's removed in the
   // first batch and added in the last.)
   leveldb::WriteBatch updates;
-  for (ContactPointers::const_iterator it = contacts->begin();
-       it != contacts->end(); ++it) {
+  for (ContactPointers::const_iterator it = contacts_to_save->begin();
+       it != contacts_to_save->end(); ++it) {
     const contacts::Contact& contact = **it;
     if (contact.contact_id() == kUpdateMetadataKey) {
       LOG(WARNING) << "Skipping contact with reserved ID "
                    << contact.contact_id();
       continue;
     }
     updates.Put(leveldb::Slice(contact.contact_id()),
                 leveldb::Slice(contact.SerializeAsString()));
     if (is_full_update)
       keys_to_delete.erase(contact.contact_id());
@@ skipping 64 matching lines @@
     db_iterator->Next();
   }
 
   *success = true;
   UMA_HISTOGRAM_ENUMERATION("Contacts.DatabaseLoadResult",
                             HISTOGRAM_LOAD_RESULT_SUCCESS,
                             HISTOGRAM_LOAD_RESULT_MAX_VALUE);
 }
 
 }  // namespace contacts