contacts: Don't save deleted contacts to disk.

chrome/browser/chromeos/contacts/google_contact_store.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/google_contact_store.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/file_path.h"
@@ skipping 63 matching lines @@
 }
 
 void GoogleContactStore::TestAPI::NotifyAboutNetworkStateChange(bool online) {
   net::NetworkChangeNotifier::ConnectionType type =
       online ?
       net::NetworkChangeNotifier::CONNECTION_UNKNOWN :
       net::NetworkChangeNotifier::CONNECTION_NONE;
   store_->OnConnectionTypeChanged(type);
 }
 
+scoped_ptr<ContactPointers> GoogleContactStore::TestAPI::GetLoadedContacts() {
+  scoped_ptr<ContactPointers> contacts(new ContactPointers);
+  for (ContactMap::const_iterator it = store_->contacts_.begin();
+       it != store_->contacts_.end(); ++it) {
+    contacts->push_back(it->second);
+  }
+  return contacts.Pass();
+}
+
 GoogleContactStore::GoogleContactStore(Profile* profile)
     : profile_(profile),
       db_(new ContactDatabase),
       update_delay_on_next_failure_(
           base::TimeDelta::FromSeconds(kUpdateFailureInitialRetrySec)),
       is_online_(true),
       should_update_when_online_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_ptr_factory_(this)) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   net::NetworkChangeNotifier::AddConnectionTypeObserver(this);
@@ skipping 30 matching lines @@
   for (ContactMap::const_iterator it = contacts_.begin();
        it != contacts_.end(); ++it) {
     if (!it->second->deleted())
       contacts_out->push_back(it->second);
   }
 }
 
 const Contact* GoogleContactStore::GetContactById(
     const std::string& contact_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  const Contact* contact = contacts_.Find(contact_id);
-  return (contact && !contact->deleted()) ? contact : NULL;
+  return contacts_.Find(contact_id);
 }
 
 void GoogleContactStore::AddObserver(ContactStoreObserver* observer) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(observer);
   observers_.AddObserver(observer);
 }
 
 void GoogleContactStore::RemoveObserver(ContactStoreObserver* observer) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
@@ skipping 87 matching lines @@
   VLOG(1) << "Scheduling update of " << profile_->GetProfileName()
           << " in " << delay.InSeconds() << " second(s)";
   update_timer_.Start(
       FROM_HERE, delay, this, &GoogleContactStore::UpdateContacts);
 }
 
 void GoogleContactStore::MergeContacts(
     bool is_full_update,
     scoped_ptr<ScopedVector<Contact> > updated_contacts) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  if (is_full_update)
+
+  if (is_full_update) {
     contacts_.Clear();
-  size_t num_updated_contacts = updated_contacts->size();
-  contacts_.Merge(updated_contacts.Pass(), ContactMap::KEEP_DELETED_CONTACTS);
+    last_contact_update_time_ = base::Time();
+  }
 
-  if (is_full_update || num_updated_contacts > 0)
-    last_contact_update_time_ = contacts_.GetMaxUpdateTime();
+  // Find the maximum update time from |updated_contacts| since contacts whose
+  // |deleted| flags are set won't be saved to |contacts_|.
+  for (ScopedVector<Contact>::iterator it = updated_contacts->begin();
+       it != updated_contacts->end(); ++it) {
+    last_contact_update_time_ =
+        std::max(last_contact_update_time_,
+                 base::Time::FromInternalValue((*it)->update_time()));
+  }
   VLOG(1) << "Last contact update time is "
           << (last_contact_update_time_.is_null() ?
               std::string("null") :
               gdata::util::FormatTimeAsString(last_contact_update_time_));
+
+  contacts_.Merge(updated_contacts.Pass(), ContactMap::DROP_DELETED_CONTACTS);
 }
 
 void GoogleContactStore::OnDownloadSuccess(
     bool is_full_update,
     const base::Time& update_start_time,
     scoped_ptr<ScopedVector<Contact> > updated_contacts) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   VLOG(1) << "Got " << updated_contacts->size() << " contact(s) for "
           << profile_->GetProfileName();
 
   // Copy the pointers so we can update just these contacts in the database.
   scoped_ptr<ContactPointers> contacts_to_save_to_db(new ContactPointers);
+  scoped_ptr<ContactDatabaseInterface::ContactIds>
+      contact_ids_to_delete_from_db(new ContactDatabaseInterface::ContactIds);
   if (db_) {
-    for (size_t i = 0; i < updated_contacts->size(); ++i)
-      contacts_to_save_to_db->push_back((*updated_contacts)[i]);
+    for (size_t i = 0; i < updated_contacts->size(); ++i) {
+      Contact* contact = (*updated_contacts)[i];
+      if (contact->deleted())
+        contact_ids_to_delete_from_db->push_back(contact->contact_id());
+      else
+        contacts_to_save_to_db->push_back(contact);
+    }
   }
   bool got_updates = !updated_contacts->empty();
 
   MergeContacts(is_full_update, updated_contacts.Pass());
   last_successful_update_start_time_ = update_start_time;
 
   if (is_full_update || got_updates) {
     FOR_EACH_OBSERVER(ContactStoreObserver,
                       observers_,
                       OnContactsUpdated(this));
   }
 
   if (db_) {
     // Even if this was an incremental update and we didn't get any updated
     // contacts, we still want to write updated metadata containing
     // |update_start_time|.
     VLOG(1) << "Saving " << contacts_to_save_to_db->size() << " contact(s) to "
-            << "database as " << (is_full_update ? "full" : "incremental")
-            << " update";
+            << "database and deleting " << contact_ids_to_delete_from_db->size()
+            << " as " << (is_full_update ? "full" : "incremental") << " update";
+
     scoped_ptr<UpdateMetadata> metadata(new UpdateMetadata);
     metadata->set_last_update_start_time(update_start_time.ToInternalValue());
+    metadata->set_last_contact_update_time(
+        last_contact_update_time_.ToInternalValue());
+
     db_->SaveContacts(
         contacts_to_save_to_db.Pass(),
+        contact_ids_to_delete_from_db.Pass(),
         metadata.Pass(),
         is_full_update,
         base::Bind(&GoogleContactStore::OnDatabaseContactsSaved,
                    weak_ptr_factory_.GetWeakPtr()));
 
     // We'll schedule an update from OnDatabaseContactsSaved() after we're done
     // writing to the database -- we don't want to modify the contacts while
     // they're being used by the database.
   } else {
     ScheduleUpdate(true);
@@ skipping 26 matching lines @@
 void GoogleContactStore::OnDatabaseContactsLoaded(
     bool success,
     scoped_ptr<ScopedVector<Contact> > contacts,
     scoped_ptr<UpdateMetadata> metadata) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (success) {
     VLOG(1) << "Loaded " << contacts->size() << " contact(s) from database";
     MergeContacts(true, contacts.Pass());
     last_successful_update_start_time_ =
         base::Time::FromInternalValue(metadata->last_update_start_time());
+    last_contact_update_time_ = std::max(
+        last_contact_update_time_,
+        base::Time::FromInternalValue(metadata->last_contact_update_time()));
 
     if (!contacts_.empty()) {
       FOR_EACH_OBSERVER(ContactStoreObserver,
                         observers_,
                         OnContactsUpdated(this));
     }
   } else {
     LOG(WARNING) << "Failed to load contacts from database";
   }
   UpdateContacts();
@@ skipping 22 matching lines @@
   return gdata::util::IsGDataAvailable(profile);
 }
 
 ContactStore* GoogleContactStoreFactory::CreateContactStore(Profile* profile) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(CanCreateContactStoreForProfile(profile));
   return new GoogleContactStore(profile);
 }
 
 }  // namespace contacts