Replace changes_channel with an observer list.

chrome/browser/sync/engine/all_status.h

 // Copyright (c) 2006-2009 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.
 //
 // The AllStatus object watches various sync engine components and aggregates
 // the status of all of them into one place.
 
 #ifndef CHROME_BROWSER_SYNC_ENGINE_ALL_STATUS_H_
 #define CHROME_BROWSER_SYNC_ENGINE_ALL_STATUS_H_
 
 #include <map>
 
 #include "base/atomicops.h"
 #include "base/lock.h"
 #include "base/scoped_ptr.h"
+#include "chrome/browser/sync/util/channel.h"
 #include "chrome/common/deprecated/event_sys.h"
 
 namespace browser_sync {
 
 class ScopedStatusLockWithNotify;
 class ServerConnectionManager;
 class Syncer;
 class SyncerThread;
 struct AllStatusEvent;
 struct AuthWatcherEvent;
 struct ServerConnectionEvent;
 struct SyncerEvent;
 
-class AllStatus {
+class AllStatus : public ChannelEventHandler<SyncerEvent> {
   friend class ScopedStatusLockWithNotify;
  public:
   typedef EventChannel<AllStatusEvent, Lock> Channel;
 
   // Status of the entire sync process distilled into a single enum.
   enum SyncStatus {
     // Can't connect to server, but there are no pending changes in
     // our local dataase.
     OFFLINE,
     // Can't connect to server, and there are pending changes in our
@@ skipping 50 matching lines @@
 
   AllStatus();
   ~AllStatus();
 
   void WatchConnectionManager(ServerConnectionManager* conn_mgr);
   void HandleServerConnectionEvent(const ServerConnectionEvent& event);
 
   void HandleAuthWatcherEvent(const AuthWatcherEvent& event);
 
   void WatchSyncerThread(SyncerThread* syncer_thread);
-  void HandleSyncerEvent(const SyncerEvent& event);
+  void HandleChannelEvent(const SyncerEvent& event);
 
   // Returns a string description of the SyncStatus (currently just the ascii
   // version of the enum). Will LOG(FATAL) if the status us out of range.
   static const char* GetSyncStatusString(SyncStatus status);
 
   Channel* channel() const { return channel_; }
 
   Status status() const;
 
   // DDOS avoidance function.  The argument and return value is in seconds
@@ skipping 16 matching lines @@
   Status CalcSyncing() const;
   Status CalcSyncing(const SyncerEvent& event) const;
   Status CreateBlankStatus() const;
 
   // Examines status to see what has changed, updates old_status in place.
   int CalcStatusChanges(Status* old_status);
 
   Status status_;
   Channel* const channel_;
   scoped_ptr<EventListenerHookup> conn_mgr_hookup_;
-  scoped_ptr<EventListenerHookup> syncer_thread_hookup_;
+  scoped_ptr<ChannelHookup<SyncerEvent> > syncer_thread_hookup_;
   scoped_ptr<EventListenerHookup> diskfull_hookup_;
   scoped_ptr<EventListenerHookup> talk_mediator_hookup_;
 
   mutable Lock mutex_;  // Protects all data members.
   DISALLOW_COPY_AND_ASSIGN(AllStatus);
 };
 
 struct AllStatusEvent {
   enum {  // A bit mask of which members have changed.
     SHUTDOWN =               0x0000,
@@ skipping 38 matching lines @@
   void NotifyOverQuota();
  protected:
   AllStatusEvent event_;
   AllStatus* const allstatus_;
   StatusNotifyPlan plan_;
 };
 
 }  // namespace browser_sync
 
 #endif  // CHROME_BROWSER_SYNC_ENGINE_ALL_STATUS_H_