Switch from OnIPAddressChanged and OnConnectionTypeChange to OnNetworkChanged

chrome/browser/chromeos/drive/drive_sync_client.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_DRIVE_DRIVE_SYNC_CLIENT_H_
 #define CHROME_BROWSER_CHROMEOS_DRIVE_DRIVE_SYNC_CLIENT_H_
 
 #include <deque>
 #include <string>
 #include <vector>
@@ skipping 26 matching lines @@
 //
 // When the user unpins files on Drive, this client is notified about the
 // files that get unpinned, cancels tasks if these are still in the queue.
 //
 // If the user logs out before fetching of the pinned files is complete, this
 // client resumes fetching operations next time the user logs in, based on
 // the states left in the cache.
 class DriveSyncClient
     : public DriveFileSystemObserver,
       public DriveCacheObserver,
-      public net::NetworkChangeNotifier::ConnectionTypeObserver {
+      public net::NetworkChangeNotifier::NetworkChangeObserver {
  public:
   // Types of sync tasks.
   enum SyncType {
     FETCH,  // Fetch a file from the Drive server.
     UPLOAD,  // Upload a file to the Drive server.
   };
 
   // The struct is used to queue tasks for fetching and uploading.
   struct SyncTask {
     SyncTask(SyncType in_sync_type,
@@ skipping 49 matching lines @@
   void AddResourceIdForTesting(SyncType sync_type,
                                const std::string& resource_id) {
     queue_.push_back(SyncTask(sync_type, resource_id, base::Time::Now()));
   }
 
   // Sets a delay for testing.
   void set_delay_for_testing(const base::TimeDelta& delay) {
     delay_ = delay;
   }
 
-  // Starts the sync loop if it's not running.
-  void StartSyncLoop();
+  // Starts the sync loop if it's not running. |force_offline| implies there
+  // is no usable network connection.
+  void StartSyncLoop(bool force_offline);
 
  private:
   friend class DriveSyncClientTest;
 
   // Adds the given task to the queue. If the same task is queued, remove the
   // existing one, and adds a new one to the end of the queue.
   void AddTaskToQueue(const SyncTask& sync_task);
 
   // Runs the sync loop that fetches/uploads files in |queue_|. One file is
   // fetched/uploaded at a time, rather than in parallel. The loop ends when
-  // the queue becomes empty.
-  void DoSyncLoop();
+  // the queue becomes empty. |force_offline| implies there is no usable network
+  // connection.
+  void DoSyncLoop(bool force_offline);
 
-  // Returns true if we should stop the sync loop.
-  bool ShouldStopSyncLoop();
+  // Returns true if we should stop the sync loop. |force_offline| implies there
+  // is no usable network connection.
+  bool ShouldStopSyncLoop(bool force_offline);
 
   // Called when the resource IDs of files in the backlog are obtained.
   void OnGetResourceIdsOfBacklog(const std::vector<std::string>* to_fetch,
                                  const std::vector<std::string>* to_upload);
 
   // Called when the resource ID of a pinned file is obtained.
   void OnGetResourceIdOfExistingPinnedFile(const std::string& resource_id,
                                            const DriveCacheEntry& cache_entry);
 
   // Called when a file entry is obtained.
@@ skipping 24 matching lines @@
                            DriveFileType file_type);
 
   // Called when the file for |resource_id| is uploaded.
   // Calls DoSyncLoop() to go back to the sync loop.
   void OnUploadFileComplete(const std::string& resource_id,
                             DriveFileError error);
 
   // Called on prefs changes.
   void OnDriveSyncPreferenceChanged();
 
-  // net::NetworkChangeNotifier::ConnectionTypeObserver override.
-  virtual void OnConnectionTypeChanged(
+  // net::NetworkChangeNotifier::NetworkChangeObserver override.
+  virtual void OnNetworkChanged(
       net::NetworkChangeNotifier::ConnectionType type) OVERRIDE;
 
   Profile* profile_;
   DriveFileSystemInterface* file_system_;  // Owned by DriveSystemService.
   DriveCache* cache_;  // Owned by DriveSystemService.
   scoped_ptr<PrefChangeRegistrar> registrar_;
   ObserverList<DriveSyncClientObserver> observers_;
 
   // The queue of tasks used to fetch/upload files in the background
   // thread. Note that this class does not use a lock to protect |queue_| as
   // all methods touching |queue_| run on the UI thread.
   std::deque<SyncTask> queue_;
 
   // The delay is used for delaying processing SyncTasks in DoSyncLoop().
   base::TimeDelta delay_;
 
   // True if the sync loop is running.
   bool sync_loop_is_running_;
 
   // 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<DriveSyncClient> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(DriveSyncClient);
 };
 
 }  // namespace drive
 
 #endif  // CHROME_BROWSER_CHROMEOS_DRIVE_DRIVE_SYNC_CLIENT_H_