Replace changes_channel with an observer list.

chrome/browser/sync/syncable/syncable.cc

 // Copyright (c) 2010 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/syncable/syncable.h"
 
 #include "build/build_config.h"
 
 #include <sys/stat.h>
 #if defined(OS_POSIX)
@@ skipping 154 matching lines @@
       name(name),
       metahandles_index(new Directory::MetahandlesIndex),
       ids_index(new Directory::IdsIndex),
       parent_id_child_index(new Directory::ParentIdChildIndex),
       client_tag_index(new Directory::ClientTagIndex),
       extended_attributes(new ExtendedAttributes),
       unapplied_update_metahandles(new MetahandleSet),
       unsynced_metahandles(new MetahandleSet),
       dirty_metahandles(new MetahandleSet),
       channel(new Directory::Channel(syncable::DIRECTORY_DESTROYED)),
-      changes_channel(new Directory::ChangesChannel(kShutdownChangesEvent)),
       info_status(Directory::KERNEL_SHARE_INFO_VALID),
       persisted_info(info.kernel_info),
       cache_guid(info.cache_guid),
       next_metahandle(info.max_metahandle + 1) {
 }
 
 inline void DeleteEntry(EntryKernel* kernel) {
   delete kernel;
 }
 
 void Directory::Kernel::AddRef() {
   base::subtle::NoBarrier_AtomicIncrement(&refcount, 1);
 }
 
 void Directory::Kernel::Release() {
   if (!base::subtle::NoBarrier_AtomicIncrement(&refcount, -1))
     delete this;
 }
 
 Directory::Kernel::~Kernel() {
   CHECK(0 == refcount);
   delete channel;
-  delete changes_channel;
+  changes_channel.Notify(kShutdownChangesEvent);
   delete unsynced_metahandles;
   delete unapplied_update_metahandles;
   delete dirty_metahandles;
   delete extended_attributes;
   delete parent_id_child_index;
   delete client_tag_index;
   delete ids_index;
   for_each(metahandles_index->begin(), metahandles_index->end(), DeleteEntry);
   delete metahandles_index;
 }
@@ skipping 682 matching lines @@
       LOG(INFO) << "Cutting Invariant check short after " << elapsed_ms << "ms."
         " Processed " << entries_done << "/" << handles.size() << " entries";
       return;
     }
   }
   // I did intend to add a check here to ensure no entries had been pulled into
   // memory by this function, but we can't guard against another ReadTransaction
   // pulling entries into RAM
 }
 
+browser_sync::ChannelHookup<DirectoryChangeEvent>* Directory::AddChangeObserver(
+    browser_sync::ChannelEventHandler<DirectoryChangeEvent>* observer) {
+  return kernel_->changes_channel.AddObserver(observer);
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 // ScopedKernelLocks
 
 ScopedKernelLock::ScopedKernelLock(const Directory* dir)
   :  scoped_lock_(dir->kernel_->mutex), dir_(const_cast<Directory*>(dir)) {
 }
 
 ///////////////////////////////////////////////////////////////////////////
 // Transactions
 #if defined LOG_ALL || !defined NDEBUG
@@ skipping 36 matching lines @@
 
   if (NULL == originals.get() || originals->empty()) {
     dirkernel_->transaction_mutex.Release();
     return;
   }
 
   AutoLock scoped_lock(dirkernel_->changes_channel_mutex);
   // Tell listeners to calculate changes while we still have the mutex.
   DirectoryChangeEvent event = { DirectoryChangeEvent::CALCULATE_CHANGES,
                                  originals.get(), this, writer_ };
-  dirkernel_->changes_channel->NotifyListeners(event);
+  dirkernel_->changes_channel.Notify(event);
 
   dirkernel_->transaction_mutex.Release();
 
   DirectoryChangeEvent complete_event =
       { DirectoryChangeEvent::TRANSACTION_COMPLETE,
         NULL, NULL, INVALID };
-  dirkernel_->changes_channel->NotifyListeners(complete_event);
+  dirkernel_->changes_channel.Notify(complete_event);
 }
 
 ReadTransaction::ReadTransaction(Directory* directory, const char* file,
                                  int line)
   : BaseTransaction(directory, "Read", file, line, INVALID) {
 }
 
 ReadTransaction::ReadTransaction(const ScopedDirLookup& scoped_dir,
                                  const char* file, int line)
   : BaseTransaction(scoped_dir.operator -> (), "Read", file, line, INVALID) {
@@ skipping 607 matching lines @@
   return s << std::dec;
 }
 
 FastDump& operator<<(FastDump& dump, const syncable::Blob& blob) {
   if (blob.empty())
     return dump;
   string buffer(HexEncode(&blob[0], blob.size()));
   dump.out_->sputn(buffer.c_str(), buffer.size());
   return dump;
 }