Remove content::NotificationObserver dependency from most Prefs code.

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>
 
 #include "base/callback_forward.h"
 #include "base/memory/weak_ptr.h"
+#include "base/prefs/public/pref_observer.h"
 #include "base/time.h"
 #include "chrome/browser/chromeos/drive/drive_cache.h"
 #include "chrome/browser/chromeos/drive/drive_cache_observer.h"
 #include "chrome/browser/chromeos/drive/drive_file_system_observer.h"
 #include "chrome/browser/chromeos/drive/drive_resource_metadata.h"
-#include "content/public/browser/notification_observer.h"
 #include "net/base/network_change_notifier.h"
 
 class Profile;
 class PrefChangeRegistrar;
 
 namespace drive {
 
 class DriveEntryProto;
 class DriveFileSystemInterface;
 class DrivePrefetcher;
 class DriveSyncClientObserver;
 
 // The DriveSyncClient is used to synchronize pinned files on Drive and the
 // cache on the local drive. The sync client works as follows.
 //
 // When the user pins files on Drive, this client is notified about the files
 // that get pinned, and queues tasks and starts fetching these files in the
 // background.
 //
 // 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 content::NotificationObserver,
+      public PrefObserver,
       public net::NetworkChangeNotifier::ConnectionTypeObserver {
  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 {
@@ skipping 112 matching lines @@
                            DriveFileError error,
                            const FilePath& local_path,
                            const std::string& ununsed_mime_type,
                            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);
 
-  // content::NotificationObserver override.
-  virtual void Observe(int type,
-                       const content::NotificationSource& source,
-                       const content::NotificationDetails& details) OVERRIDE;
+  // PrefObserver override.
+  virtual void OnPreferenceChanged(PrefServiceBase* service,
+                                   const std::string& pref_name) OVERRIDE;
 
   // net::NetworkChangeNotifier::ConnectionTypeObserver override.
   virtual void OnConnectionTypeChanged(
       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_;
@@ skipping 12 matching lines @@
   // 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_