Replace changes_channel with an observer list.

chrome/browser/sync/engine/syncapi.cc

 // 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.
 
 #include "chrome/browser/sync/engine/syncapi.h"
 
 #include "build/build_config.h"
 
 #include <iomanip>
 #include <list>
@@ skipping 759 matching lines @@
  private:
   const std::string gaia_source_;
   scoped_ptr<HttpPostProviderFactory> post_factory_;
   DISALLOW_COPY_AND_ASSIGN(BridgedGaiaAuthenticator);
 };
 
 //////////////////////////////////////////////////////////////////////////
 // SyncManager's implementation: SyncManager::SyncInternal
 class SyncManager::SyncInternal
     : public net::NetworkChangeNotifier::Observer,
-      public TalkMediator::Delegate {
+      public TalkMediator::Delegate,
+      public browser_sync::ChannelEventHandler<syncable::DirectoryChangeEvent>,
+      public browser_sync::ChannelEventHandler<SyncerEvent>{
   static const int kDefaultNudgeDelayMilliseconds;
   static const int kPreferencesNudgeDelayMilliseconds;
  public:
   explicit SyncInternal(SyncManager* sync_manager)
       : core_message_loop_(NULL),
         observer_(NULL),
         auth_problem_(AuthError::NONE),
         sync_manager_(sync_manager),
         registrar_(NULL),
         notification_pending_(false),
@@ skipping 47 matching lines @@
   // Tell the sync engine to start the syncing process.
   void StartSyncing();
 
   // Call periodically from a database-safe thread to persist recent changes
   // to the syncapi model.
   void SaveChanges();
 
   // This listener is called upon completion of a syncable transaction, and
   // builds the list of sync-engine initiated changes that will be forwarded to
   // the SyncManager's Observers.
-  void HandleChangeEvent(const syncable::DirectoryChangeEvent& event);
+  virtual void HandleChannelEvent(const syncable::DirectoryChangeEvent& event);
   void HandleTransactionCompleteChangeEvent(
       const syncable::DirectoryChangeEvent& event);
   void HandleCalculateChangesChangeEventFromSyncApi(
       const syncable::DirectoryChangeEvent& event);
   void HandleCalculateChangesChangeEventFromSyncer(
       const syncable::DirectoryChangeEvent& event);
 
   // This listener is called by the syncer channel for all syncer events.
-  void HandleSyncerEvent(const SyncerEvent& event);
+  virtual void HandleChannelEvent(const SyncerEvent& event);
 
   // We have a direct hookup to the authwatcher to be notified for auth failures
   // on startup, to serve our UI needs.
   void HandleAuthWatcherEvent(const AuthWatcherEvent& event);
 
   // Login to the talk mediator with the given credentials.
   void TalkMediatorLogin(
       const std::string& email, const std::string& token);
 
   // TalkMediator::Delegate implementation.
@@ skipping 193 matching lines @@
   scoped_refptr<AuthWatcher> auth_watcher_;
 
   // Each element of this array is a store of change records produced by
   // HandleChangeEvent during the CALCULATE_CHANGES step.  The changes are
   // segregated by model type, and are stored here to be processed and
   // forwarded to the observer slightly later, at the TRANSACTION_COMPLETE
   // step by HandleTransactionCompleteChangeEvent.
   ChangeReorderBuffer change_buffers_[syncable::MODEL_TYPE_COUNT];
 
   // The event listener hookup that is registered for HandleChangeEvent.
-  scoped_ptr<EventListenerHookup> dir_change_hookup_;
+  scoped_ptr<browser_sync::ChannelHookup<syncable::DirectoryChangeEvent> >
+      dir_change_hookup_;
 
   // The event listener hookup registered for HandleSyncerEvent.
-  scoped_ptr<EventListenerHookup> syncer_event_;
+  scoped_ptr<browser_sync::ChannelHookup<SyncerEvent> > syncer_event_;
 
   // The event listener hookup registered for HandleAuthWatcherEvent.
   scoped_ptr<EventListenerHookup> authwatcher_hookup_;
 
   // Our cache of a recent authentication problem. If no authentication problem
   // occurred, or if the last problem encountered has been cleared (by a
   // subsequent AuthWatcherEvent), this is set to NONE.
   AuthError::State auth_problem_;
 
   // The sync dir_manager to which we belong.
@@ skipping 183 matching lines @@
   // Build a SyncSessionContext and store the worker in it.
   SyncSessionContext* context = new SyncSessionContext(
       connection_manager_.get(), auth_watcher(),
           dir_manager(), model_safe_worker_registrar);
 
   // The SyncerThread takes ownership of |context|.
   syncer_thread_ = new SyncerThread(context, &allstatus_);
   allstatus_.WatchSyncerThread(syncer_thread());
 
   // Subscribe to the syncer thread's channel.
-  syncer_event_.reset(
-      NewEventListenerHookup(syncer_thread()->relay_channel(), this,
-          &SyncInternal::HandleSyncerEvent));
+  syncer_event_.reset(syncer_thread()->relay_channel()->AddObserver(this));
 
   bool attempting_auth = false;
   std::string username, auth_token;
   if (attempt_last_user_authentication &&
       auth_watcher()->settings()->GetLastUserAndServiceToken(
           SYNC_SERVICE_NAME, &username, &auth_token)) {
     if (invalidate_last_user_auth_token) {
       auth_token += "bogus";
     }
     attempting_auth = AuthenticateForUser(username, auth_token);
@@ skipping 204 matching lines @@
 void SyncManager::SyncInternal::OnIPAddressChanged() {
   LOG(INFO) << "IP address change detected";
   // TODO(akalin): CheckServerReachable() can block, which may cause
   // jank if we try to shut down sync.  Fix this.
   connection_manager()->CheckServerReachable();
 }
 
 // Listen to model changes, filter out ones initiated by the sync API, and
 // saves the rest (hopefully just backend Syncer changes resulting from
 // ApplyUpdates) to data_->changelist.
-void SyncManager::SyncInternal::HandleChangeEvent(
+void SyncManager::SyncInternal::HandleChannelEvent(
     const syncable::DirectoryChangeEvent& event) {
   if (event.todo == syncable::DirectoryChangeEvent::TRANSACTION_COMPLETE) {
     HandleTransactionCompleteChangeEvent(event);
     return;
   } else if (event.todo == syncable::DirectoryChangeEvent::CALCULATE_CHANGES) {
     if (event.writer == syncable::SYNCAPI) {
       HandleCalculateChangesChangeEventFromSyncApi(event);
       return;
     }
     HandleCalculateChangesChangeEventFromSyncer(event);
@@ skipping 152 matching lines @@
         allstatus_.status().initial_sync_ended,
         allstatus_.status().syncer_stuck,
         allstatus_.status().updates_available,
         allstatus_.status().updates_received,
         allstatus_.status().disk_full,
         false,   // TODO(ncarter): invalid store?
         allstatus_.status().max_consecutive_errors};
   return return_status;
 }
 
-void SyncManager::SyncInternal::HandleSyncerEvent(const SyncerEvent& event) {
+void SyncManager::SyncInternal::HandleChannelEvent(const SyncerEvent& event) {
   if (!initialized()) {
     // This could be the first time that the syncer has completed a full
     // download; if so, we should signal that initialization is complete.
     if (event.snapshot->is_share_usable)
       MarkAndNotifyInitializationComplete();
     return;
   }
 
   if (!observer_)
     return;
@@ skipping 63 matching lines @@
         observer_->OnAuthError(AuthError::None());
 
       // Hook up the DirectoryChangeEvent listener, HandleChangeEvent.
       {
         syncable::ScopedDirLookup lookup(dir_manager(), username_for_share());
         if (!lookup.good()) {
           DCHECK(false) << "ScopedDirLookup creation failed; unable to hook "
                         << "up directory change event listener!";
           return;
         }
-        dir_change_hookup_.reset(NewEventListenerHookup(
-            lookup->changes_channel(), this,
-            &SyncInternal::HandleChangeEvent));
+        dir_change_hookup_.reset(lookup->AddChangeObserver(this));
       }
       if (InitialSyncEndedForAllEnabledTypes())
         MarkAndNotifyInitializationComplete();
 
       if (!event.auth_token.empty()) {
         core_message_loop_->PostTask(
             FROM_HERE,
             NewRunnableMethod(
                 this, &SyncManager::SyncInternal::TalkMediatorLogin,
                 event.user_email, event.auth_token));
@@ skipping 141 matching lines @@
     DCHECK(false) << "Could not open directory when running in test mode";
 
   // Hook up the DirectoryChangeEvent listener, HandleChangeEvent.
   {
     syncable::ScopedDirLookup lookup(dir_manager(), username_for_share());
     if (!lookup.good()) {
       DCHECK(false) << "ScopedDirLookup creation failed; unable to hook "
                     << "up directory change event listener!";
       return;
     }
-    dir_change_hookup_.reset(NewEventListenerHookup(
-        lookup->changes_channel(), this,
-        &SyncInternal::HandleChangeEvent));
+    dir_change_hookup_.reset(lookup->AddChangeObserver(this));
   }
   MarkAndNotifyInitializationComplete();
 }
 
 //////////////////////////////////////////////////////////////////////////
 // BaseTransaction member definitions
 BaseTransaction::BaseTransaction(UserShare* share)
     : lookup_(NULL) {
   DCHECK(share && share->dir_manager.get());
   lookup_ = new syncable::ScopedDirLookup(share->dir_manager.get(),
                                         share->authenticated_name);
   if (!(lookup_->good()))
     DCHECK(false) << "ScopedDirLookup failed on valid DirManager.";
 }
 BaseTransaction::~BaseTransaction() {
   delete lookup_;
 }
 
 UserShare* SyncManager::GetUserShare() const {
   DCHECK(data_->initialized()) << "GetUserShare requires initialization!";
   return data_->GetUserShare();
 }
 
 SyncManager::ExtraAutofillChangeRecordData::~ExtraAutofillChangeRecordData() {
   delete pre_deletion_data;
 }
 
 }  // namespace sync_api