contacts: Rename provider_id to contact_id.

chrome/browser/chromeos/contacts/google_contact_store_unittest.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 "base/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/time.h"
@@ skipping 73 matching lines @@
 
   FakeContactDatabase* db_;  // not owned
   gdata::GDataContactsServiceStub* gdata_service_;  // not owned
 
  private:
   DISALLOW_COPY_AND_ASSIGN(GoogleContactStoreTest);
 };
 
 TEST_F(GoogleContactStoreTest, LoadFromDatabase) {
   // Store two contacts in the database.
-  const std::string kProviderId1 = "provider1";
-  const std::string kProviderId2 = "provider2";
+  const std::string kContactId1 = "contact1";
+  const std::string kContactId2 = "contact2";
   scoped_ptr<Contact> contact1(new Contact);
-  InitContact(kProviderId1, "1", false, contact1.get());
+  InitContact(kContactId1, "1", false, contact1.get());
   scoped_ptr<Contact> contact2(new Contact);
-  InitContact(kProviderId2, "2", false, contact2.get());
+  InitContact(kContactId2, "2", false, contact2.get());
   ContactPointers db_contacts;
   db_contacts.push_back(contact1.get());
   db_contacts.push_back(contact2.get());
   UpdateMetadata db_metadata;
   db_->SetContacts(db_contacts, db_metadata);
 
   // Tell the GData service to report failure, initialize the store, and check
   // that the contacts from the database are loaded.
   gdata_service_->set_download_should_succeed(false);
   store_->Init();
   ContactPointers loaded_contacts;
   store_->AppendContacts(&loaded_contacts);
   EXPECT_EQ(VarContactsToString(2, contact1.get(), contact2.get()),
             ContactsToString(loaded_contacts));
   EXPECT_TRUE(test_api_->update_scheduled());
   EXPECT_EQ(1, observer_.num_updates());
 
   // Check that we can also grab the contact via its ID.
-  const Contact* loaded_contact1 = store_->GetContactByProviderId(kProviderId1);
+  const Contact* loaded_contact1 = store_->GetContactById(kContactId1);
   ASSERT_TRUE(loaded_contact1);
   EXPECT_EQ(ContactToString(*contact1), ContactToString(*loaded_contact1));
 
   // We should get NULL if we request a nonexistent contact.
-  EXPECT_FALSE(store_->GetContactByProviderId("bogus_id"));
+  EXPECT_FALSE(store_->GetContactById("bogus_id"));
 }
 
 TEST_F(GoogleContactStoreTest, LoadFromGData) {
   // Store two contacts in the GData service.
   scoped_ptr<Contact> contact1(new Contact);
-  InitContact("provider1", "1", false, contact1.get());
+  InitContact("contact1", "1", false, contact1.get());
   scoped_ptr<Contact> contact2(new Contact);
-  InitContact("provider2", "2", false, contact2.get());
+  InitContact("contact2", "2", false, contact2.get());
   ContactPointers gdata_contacts;
   gdata_contacts.push_back(contact1.get());
   gdata_contacts.push_back(contact2.get());
   gdata_service_->SetContacts(gdata_contacts, base::Time());
 
   // Initialize the store and check that the contacts are loaded from GData.
   store_->Init();
   ContactPointers loaded_contacts;
   store_->AppendContacts(&loaded_contacts);
   EXPECT_EQ(VarContactsToString(2, contact1.get(), contact2.get()),
             ContactsToString(loaded_contacts));
   EXPECT_TRUE(test_api_->update_scheduled());
   EXPECT_EQ(1, observer_.num_updates());
 
   // The contacts should've been saved to the database, too.
   EXPECT_EQ(VarContactsToString(2, contact1.get(), contact2.get()),
             ContactsToString(db_->contacts()));
 }
 
 TEST_F(GoogleContactStoreTest, UpdateFromGData) {
   scoped_ptr<Contact> contact1(new Contact);
-  InitContact("provider1", "1", false, contact1.get());
+  InitContact("contact1", "1", false, contact1.get());
   scoped_ptr<Contact> contact2(new Contact);
-  InitContact("provider2", "2", false, contact2.get());
+  InitContact("contact2", "2", false, contact2.get());
   scoped_ptr<Contact> contact3(new Contact);
-  InitContact("provider3", "3", false, contact3.get());
+  InitContact("contact3", "3", false, contact3.get());
 
   // Store the first two contacts in the database.
   ContactPointers db_contacts;
   db_contacts.push_back(contact1.get());
   db_contacts.push_back(contact2.get());
   UpdateMetadata db_metadata;
   db_->SetContacts(db_contacts, db_metadata);
 
   // Store all three in the GData service. We expect the update request to ask
   // for all contacts updated one millisecond after the newest contact in the
@@ skipping 19 matching lines @@
   // All three contacts should've been saved to the database.
   EXPECT_EQ(VarContactsToString(
                 3, contact1.get(), contact2.get(), contact3.get()),
             ContactsToString(db_->contacts()));
   EXPECT_EQ(3, db_->num_saved_contacts());
   EXPECT_TRUE(test_api_->update_scheduled());
 }
 
 TEST_F(GoogleContactStoreTest, FetchUpdatedContacts) {
   scoped_ptr<Contact> contact1(new Contact);
-  InitContact("provider1", "1", false, contact1.get());
+  InitContact("contact1", "1", false, contact1.get());
   scoped_ptr<Contact> contact2(new Contact);
-  InitContact("provider2", "2", false, contact2.get());
+  InitContact("contact2", "2", false, contact2.get());
   scoped_ptr<Contact> contact3(new Contact);
-  InitContact("provider3", "3", false, contact3.get());
+  InitContact("contact3", "3", false, contact3.get());
 
   ContactPointers kAllContacts;
   kAllContacts.push_back(contact1.get());
   kAllContacts.push_back(contact2.get());
   kAllContacts.push_back(contact3.get());
 
   // Tell the GData service to return all three contacts in response to a full
   // update.
   ContactPointers gdata_contacts(kAllContacts);
   gdata_service_->SetContacts(gdata_contacts, base::Time());
@@ skipping 48 matching lines @@
   store_->AppendContacts(&loaded_contacts);
   EXPECT_EQ(ContactsToString(kAllContacts), ContactsToString(loaded_contacts));
   EXPECT_EQ(ContactsToString(kAllContacts), ContactsToString(db_->contacts()));
   EXPECT_EQ(1, db_->num_saved_contacts());
   EXPECT_TRUE(test_api_->update_scheduled());
   EXPECT_EQ(1, observer_.num_updates());
 }
 
 TEST_F(GoogleContactStoreTest, DontReturnDeletedContacts) {
   // Tell GData to return a single deleted contact.
-  const std::string kProviderId = "provider";
+  const std::string kContactId = "contact";
   scoped_ptr<Contact> contact(new Contact);
-  InitContact(kProviderId, "1", true, contact.get());
+  InitContact(kContactId, "1", true, contact.get());
   ContactPointers gdata_contacts;
   gdata_contacts.push_back(contact.get());
   gdata_service_->SetContacts(gdata_contacts, base::Time());
 
   // The contact shouldn't be returned by AppendContacts() or
-  // GetContactByProviderId().
+  // GetContactById().
   store_->Init();
   ContactPointers loaded_contacts;
   store_->AppendContacts(&loaded_contacts);
   EXPECT_TRUE(loaded_contacts.empty());
-  EXPECT_FALSE(store_->GetContactByProviderId(kProviderId));
+  EXPECT_FALSE(store_->GetContactById(kContactId));
 }
 
 // Test that we do a full refresh from GData if enough time has passed since the
 // last refresh that we might've missed some contact deletions (see
 // |kForceFullUpdateDays| in google_contact_store.cc).
 TEST_F(GoogleContactStoreTest, FullRefreshAfterThirtyDays) {
   base::Time::Exploded kInitTimeExploded = { 2012, 3, 0, 1, 16, 34, 56, 123 };
   base::Time kInitTime = base::Time::FromUTCExploded(kInitTimeExploded);
 
   base::Time kOldUpdateTime = kInitTime - base::TimeDelta::FromDays(31);
   scoped_ptr<Contact> contact1(new Contact);
-  InitContact("provider1", "1", false, contact1.get());
+  InitContact("contact1", "1", false, contact1.get());
   contact1->set_update_time(kOldUpdateTime.ToInternalValue());
   scoped_ptr<Contact> contact2(new Contact);
-  InitContact("provider2", "2", false, contact2.get());
+  InitContact("contact2", "2", false, contact2.get());
   contact2->set_update_time(kOldUpdateTime.ToInternalValue());
 
   // Put both contacts in the database, along with metadata saying that the last
   // successful update was 31 days in the past.
   ContactPointers db_contacts;
   db_contacts.push_back(contact1.get());
   db_contacts.push_back(contact2.get());
   UpdateMetadata db_metadata;
   db_metadata.set_last_update_start_time(kOldUpdateTime.ToInternalValue());
   db_->SetContacts(db_contacts, db_metadata);
@@ skipping 38 matching lines @@
   test_api_->set_current_time(kSecondUpdateTime);
   test_api_->DoUpdate();
   loaded_contacts.clear();
   store_->AppendContacts(&loaded_contacts);
   EXPECT_EQ(ContactsToString(gdata_contacts),
             ContactsToString(loaded_contacts));
 }
 
 TEST_F(GoogleContactStoreTest, HandleDatabaseInitFailure) {
   scoped_ptr<Contact> contact1(new Contact);
-  InitContact("provider1", "1", false, contact1.get());
+  InitContact("contact1", "1", false, contact1.get());
 
   // Store a contact in the database but make initialization fail.
   ContactPointers db_contacts;
   db_contacts.push_back(contact1.get());
   UpdateMetadata db_metadata;
   db_->SetContacts(db_contacts, db_metadata);
   db_->set_init_success(false);
 
   // Create a second contact and tell the GData service to return it.
   scoped_ptr<Contact> contact2(new Contact);
-  InitContact("provider2", "2", false, contact2.get());
+  InitContact("contact2", "2", false, contact2.get());
   ContactPointers gdata_contacts;
   gdata_contacts.push_back(contact2.get());
   gdata_service_->SetContacts(gdata_contacts, base::Time());
 
   // Initialize the store. We shouldn't get the first contact (since DB
   // initialization failed) but we should still fetch the second one from GData
   // and schedule an update.
   store_->Init();
   ContactPointers loaded_contacts;
   store_->AppendContacts(&loaded_contacts);
@@ skipping 27 matching lines @@
   EXPECT_EQ(0, gdata_service_->num_download_requests());
 
   // When we're back online, the update should happen.
   gdata_service_->reset_stats();
   test_api_->NotifyAboutNetworkStateChange(true);
   EXPECT_EQ(1, gdata_service_->num_download_requests());
 }
 
 }  // namespace test
 }  // namespace contacts