Replace changes_channel with an observer list.

chrome/browser/sync/engine/syncer_thread.cc

 // Copyright (c) 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/syncer_thread.h"
 
 #include "build/build_config.h"
 
 #if defined(OS_MACOSX)
 #include <CoreFoundation/CFNumber.h>
 #include <IOKit/IOTypes.h>
@@ skipping 56 matching lines @@
       allstatus_(all_status),
       syncer_short_poll_interval_seconds_(kDefaultShortPollIntervalSeconds),
       syncer_long_poll_interval_seconds_(kDefaultLongPollIntervalSeconds),
       syncer_polling_interval_(kDefaultShortPollIntervalSeconds),
       syncer_max_interval_(kDefaultMaxPollIntervalMs),
       directory_manager_hookup_(NULL),
       syncer_events_(NULL),
       session_context_(context),
       disable_idle_detection_(false) {
   DCHECK(context);
-  syncer_event_relay_channel_.reset(new SyncerEventChannel(SyncerEvent(
-      SyncerEvent::SHUTDOWN_USE_WITH_CARE)));
+  syncer_event_relay_channel_.reset(new SyncerEventChannel());
 
   if (context->directory_manager()) {
     directory_manager_hookup_.reset(NewEventListenerHookup(
         context->directory_manager()->channel(), this,
             &SyncerThread::HandleDirectoryManagerEvent));
   }
 
   if (context->connection_manager())
     WatchConnectionManager(context->connection_manager());
 
 }
 
 SyncerThread::~SyncerThread() {
   conn_mgr_hookup_.reset();
+  syncer_event_relay_channel_->Notify(SyncerEvent(
+      SyncerEvent::SHUTDOWN_USE_WITH_CARE));
   syncer_event_relay_channel_.reset();
   directory_manager_hookup_.reset();
   syncer_events_.reset();
   delete vault_.syncer_;
   CHECK(!thread_.IsRunning());
 }
 
 // Creates and starts a syncer thread.
 // Returns true if it creates a thread or if there's currently a thread running
 // and false otherwise.
@@ skipping 195 matching lines @@
         &user_idle_milliseconds, &continue_sync_cycle, nudged);
   }
 #if defined(OS_LINUX)
   idle_query_.reset();
 #endif
 }
 
 void SyncerThread::PauseUntilResumedOrQuit() {
   LOG(INFO) << "Syncer thread entering pause.";
   SyncerEvent event(SyncerEvent::PAUSED);
-  relay_channel()->NotifyListeners(event);
+  relay_channel()->Notify(event);
 
   // Thread will get stuck here until either a resume is requested
   // or shutdown is started.
   while (vault_.pause_ && !vault_.stop_syncer_thread_)
     vault_field_changed_.Wait();
 
   // Notify that we have resumed if we are not shutting down.
   if (!vault_.stop_syncer_thread_) {
     SyncerEvent event(SyncerEvent::RESUMED);
-    relay_channel()->NotifyListeners(event);
+    relay_channel()->Notify(event);
   }
   LOG(INFO) << "Syncer thread exiting pause.";
 }
 
 // We check how long the user's been idle and sync less often if the machine is
 // not in use. The aim is to reduce server load.
 // TODO(timsteele): Should use Time(Delta).
 SyncerThread::WaitInterval SyncerThread::CalculatePollingWaitTime(
     const AllStatus::Status& status,
     int last_poll_wait,  // Time in seconds.
@@ skipping 143 matching lines @@
         break;
       case kUnknown:
       default:
         updates_source = sync_pb::GetUpdatesCallerInfo::UNKNOWN;
         break;
     }
   }
   vault_.syncer_->set_updates_source(updates_source);
 }
 
-void SyncerThread::HandleSyncerEvent(const SyncerEvent& event) {
+void SyncerThread::HandleChannelEvent(const SyncerEvent& event) {
   AutoLock lock(lock_);
-  relay_channel()->NotifyListeners(event);
+  relay_channel()->Notify(event);
   if (SyncerEvent::REQUEST_SYNC_NUDGE != event.what_happened) {
     return;
   }
   NudgeSyncImpl(event.nudge_delay_milliseconds, kUnknown);
 }
 
 void SyncerThread::HandleDirectoryManagerEvent(
     const syncable::DirectoryManagerEvent& event) {
   LOG(INFO) << "Handling a directory manager event";
   if (syncable::DirectoryManagerEvent::OPENED == event.what_happened) {
     AutoLock lock(lock_);
     LOG(INFO) << "Syncer starting up for: " << event.dirname;
     // The underlying database structure is ready, and we should create
     // the syncer.
     CHECK(vault_.syncer_ == NULL);
     session_context_->set_account_name(event.dirname);
     vault_.syncer_ = new Syncer(session_context_.get());
 
-    syncer_events_.reset(NewEventListenerHookup(
-        session_context_->syncer_event_channel(), this,
-        &SyncerThread::HandleSyncerEvent));
+    syncer_events_.reset(
+        session_context_->syncer_event_channel()->AddObserver(this));
     vault_field_changed_.Broadcast();
   }
 }
 
 // Sets |*connected| to false if it is currently true but |code| suggests that
 // the current network configuration and/or auth state cannot be used to make
 // forward progress, and user intervention (e.g changing server URL or auth
 // credentials) is likely necessary.  If |*connected| is false, set it to true
 // if |code| suggests that we just recently made healthy contact with the
 // server.
@@ skipping 157 matching lines @@
     was_logged = true;
     LOG(INFO) << "UserIdleTime unimplemented on this platform, "
         "synchronization will not throttle when user idle";
   }
 #endif
 
   return 0;
 }
 
 }  // namespace browser_sync