contacts: Defer updates when offline.

chrome/browser/chromeos/contacts/google_contact_store.h

 // 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.
 
 #ifndef CHROME_BROWSER_CHROMEOS_CONTACTS_GOOGLE_CONTACT_STORE_H_
 #define CHROME_BROWSER_CHROMEOS_CONTACTS_GOOGLE_CONTACT_STORE_H_
 
 #include "chrome/browser/chromeos/contacts/contact_store.h"
 
 #include <map>
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
 #include "base/memory/weak_ptr.h"
 #include "base/observer_list.h"
 #include "base/stl_util.h"
 #include "base/time.h"
 #include "base/timer.h"
+#include "net/base/network_change_notifier.h"
 
 class Profile;
 
 namespace gdata {
 class GDataContactsServiceInterface;
 }
 
 namespace contacts {
 
 class Contact;
 class ContactDatabaseInterface;
 class UpdateMetadata;
 
 // A collection of contacts from a Google account.
-class GoogleContactStore : public ContactStore {
+class GoogleContactStore
+    : public ContactStore,
+      public net::NetworkChangeNotifier::ConnectionTypeObserver {

[satorux1, 2012/08/08 21:42:27]

I didn't know about this. in gdata_sync_client.cc, I used a Chrome OS specific
class NetworkLibrary, but net::NetworkChangeNotifier seems to be a better
solution. I'll file a bug about the cleanup.

  public:
   class TestAPI {
    public:
     explicit TestAPI(GoogleContactStore* store);
     ~TestAPI();
 
     bool update_scheduled() { return store_->update_timer_.IsRunning(); }
 
     void set_current_time(const base::Time& time) {
       store_->current_time_for_testing_ = time;
     }
 
     // Takes ownership of |db|. Must be called before Init().
     void SetDatabase(ContactDatabaseInterface* db);
 
     // Takes ownership of |service|. Must be called before Init().
     void SetGDataService(gdata::GDataContactsServiceInterface* service);
 
     // Triggers an update, similar to what happens when the update timer fires.
     void DoUpdate();
 
+    // Notifies the store that the system has gone online or offline.
+    void NotifyAboutNetworkStateChange(bool online);
+
    private:
     GoogleContactStore* store_;  // not owned
 
     DISALLOW_COPY_AND_ASSIGN(TestAPI);
   };
 
   explicit GoogleContactStore(Profile* profile);
   virtual ~GoogleContactStore();
 
   // ContactStore implementation:
   virtual void Init() OVERRIDE;
   virtual void AppendContacts(ContactPointers* contacts_out) OVERRIDE;
   virtual const Contact* GetContactByProviderId(
       const std::string& provider_id) OVERRIDE;
   virtual void AddObserver(ContactStoreObserver* observer) OVERRIDE;
   virtual void RemoveObserver(ContactStoreObserver* observer) OVERRIDE;
 
+  // net::NetworkChangeNotifier::ConnectionTypeObserver implementation:
+  virtual void OnConnectionTypeChanged(
+      net::NetworkChangeNotifier::ConnectionType type) OVERRIDE;
+
  private:
   // Map from a contact's Google-assigned ID to the contact itself.
   typedef std::map<std::string, Contact*> ContactMap;
 
   // Returns the current time. Uses |current_time_for_testing_| instead if it's
   // set.
   base::Time GetCurrentTime() const;
 
   // Destroys |db_| if non-NULL and resets the pointer.
   // The underlying data is preserved on-disk.
@@ skipping 57 matching lines @@
   // Used to schedule calls to UpdateContacts().
   base::OneShotTimer<GoogleContactStore> update_timer_;
 
   // Time at which the last successful update was started.
   base::Time last_successful_update_start_time_;
 
   // Amount of time that we'll wait before retrying the next time that an update
   // fails.
   base::TimeDelta update_delay_on_next_failure_;
 
+  // Do we believe that it's likely that we'll be able to make network
+  // connections?
+  bool is_online_;
+
+  // Should we call UpdateContacts() when |is_online_| becomes true?  Set when
+  // UpdateContacts() is called while we're offline.
+  bool should_update_when_online_;
+
   // If non-null, used in place of base::Time::Now() when the current time is
   // needed.
   base::Time current_time_for_testing_;
 
   // Note: This should remain the last member so it'll be destroyed and
   // invalidate its weak pointers before any other members are destroyed.
   base::WeakPtrFactory<GoogleContactStore> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(GoogleContactStore);
 };
 
 // ContactStoreFactory implementation that returns GoogleContactStores.
 class GoogleContactStoreFactory : public ContactStoreFactory {
  public:
   GoogleContactStoreFactory();
   virtual ~GoogleContactStoreFactory();
 
   // ContactStoreFactory implementation:
   virtual bool CanCreateContactStoreForProfile(Profile* profile) OVERRIDE;
   virtual ContactStore* CreateContactStore(Profile* profile) OVERRIDE;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(GoogleContactStoreFactory);
 };
 
 }  // namespace contacts
 
 #endif  // CHROME_BROWSER_CHROMEOS_CONTACTS_GOOGLE_CONTACT_STORE_H_