Replace changes_channel with an observer list.

chrome/browser/sync/syncable/syncable.h

 // 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.
 
 #ifndef CHROME_BROWSER_SYNC_SYNCABLE_SYNCABLE_H_
 #define CHROME_BROWSER_SYNC_SYNCABLE_SYNCABLE_H_
 
 #include <algorithm>
 #include <bitset>
 #include <iosfwd>
 #include <limits>
 #include <map>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/atomicops.h"
 #include "base/basictypes.h"
 #include "base/file_path.h"
 #include "base/lock.h"
 #include "base/time.h"
 #include "chrome/browser/sync/protocol/sync.pb.h"
 #include "chrome/browser/sync/syncable/blob.h"
 #include "chrome/browser/sync/syncable/dir_open_result.h"
 #include "chrome/browser/sync/syncable/directory_event.h"
 #include "chrome/browser/sync/syncable/path_name_cmp.h"
 #include "chrome/browser/sync/syncable/syncable_id.h"
 #include "chrome/browser/sync/syncable/model_type.h"
+#include "chrome/browser/sync/util/channel.h"
 #include "chrome/browser/sync/util/dbgq.h"
 #include "chrome/browser/sync/util/row_iterator.h"
 #include "chrome/browser/sync/util/sync_types.h"
 #include "chrome/common/deprecated/event_sys.h"
 #include "testing/gtest/include/gtest/gtest_prod.h"  // For FRIEND_TEST
 
 struct PurgeInfo;
 
 namespace sync_api {
 class ReadTransaction;
@@ skipping 626 matching lines @@
   friend class ReadTransaction;
   friend class ReadTransactionWithoutDB;
   friend class ScopedKernelLock;
   friend class ScopedKernelUnlock;
   friend class WriteTransaction;
   friend class SyncableDirectoryTest;
   FRIEND_TEST(SyncableDirectoryTest, TakeSnapshotGetsAllDirtyHandlesTest);
   FRIEND_TEST(SyncableDirectoryTest, TakeSnapshotGetsOnlyDirtyHandlesTest);
 
  public:
+  class EventListenerHookup;
+
   // Various data that the Directory::Kernel we are backing (persisting data
   // for) needs saved across runs of the application.
   struct PersistedKernelInfo {
     // Last sync timestamp fetched from the server.
     int64 last_download_timestamp[MODEL_TYPE_COUNT];
     // true iff we ever reached the end of the changelog.
     ModelTypeBitSet initial_sync_ended;
     // The store birthday we were given by the server. Contents are opaque to
     // the client.
     std::string store_birthday;
@@ skipping 88 matching lines @@
 
   // (Account) Store birthday is opaque to the client,
   // so we keep it in the format it is in the proto buffer
   // in case we switch to a binary birthday later.
   std::string store_birthday() const;
   void set_store_birthday(std::string store_birthday);
 
   // Unique to each account / client pair.
   std::string cache_guid() const;
 
+  browser_sync::ChannelHookup<DirectoryChangeEvent>* AddChangeObserver(
+      browser_sync::ChannelEventHandler<DirectoryChangeEvent>* observer);
+
  protected:  // for friends, mainly used by Entry constructors
   EntryKernel* GetEntryByHandle(const int64 handle);
   EntryKernel* GetEntryByHandle(const int64 metahandle, ScopedKernelLock* lock);
   EntryKernel* GetEntryById(const Id& id);
   EntryKernel* GetEntryByServerTag(const std::string& tag);
   EntryKernel* GetEntryByClientTag(const std::string& tag);
   EntryKernel* GetRootEntry();
   bool ReindexId(EntryKernel* const entry, const Id& new_id);
   void ReindexParentId(EntryKernel* const entry, const Id& new_parent_id);
   void ClearDirtyMetahandles();
@@ skipping 16 matching lines @@
   DirOpenResult OpenImpl(const FilePath& file_path, const std::string& name);
 
   struct DirectoryEventTraits {
     typedef DirectoryEvent EventType;
     static inline bool IsChannelShutdownEvent(const DirectoryEvent& event) {
       return DIRECTORY_DESTROYED == event;
     }
   };
  public:
   typedef EventChannel<DirectoryEventTraits, Lock> Channel;
-  typedef EventChannel<DirectoryChangeEvent, Lock> ChangesChannel;
   typedef std::vector<int64> ChildHandles;
 
   // Returns the child meta handles for given parent id.
   void GetChildHandles(BaseTransaction*, const Id& parent_id,
       const std::string& path_spec, ChildHandles* result);
   void GetChildHandles(BaseTransaction*, const Id& parent_id,
       ChildHandles* result);
   void GetChildHandlesImpl(BaseTransaction* trans, const Id& parent_id,
                            PathMatcher* matcher, ChildHandles* result);
 
@@ skipping 32 matching lines @@
   // Get all extended attribute keys associated with a metahandle
   void GetExtendedAttributesList(BaseTransaction* trans, int64 metahandle,
                                  AttributeKeySet* result);
   // Flags all extended attributes for deletion on the next SaveChanges.
   void DeleteAllExtendedAttributes(WriteTransaction* trans, int64 metahandle);
 
   // Get the channel for post save notification, used by the syncer.
   inline Channel* channel() const {
     return kernel_->channel;
   }
-  inline ChangesChannel* changes_channel() const {
-    return kernel_->changes_channel;
-  }
 
   // Checks tree metadata consistency.
   // If full_scan is false, the function will avoid pulling any entries from the
   // db and scan entries currently in ram.
   // If full_scan is true, all entries will be pulled from the database.
   // No return value, CHECKs will be triggered if we're given bad
   // information.
   void CheckTreeInvariants(syncable::BaseTransaction* trans,
                            bool full_scan);
 
@@ skipping 106 matching lines @@
     // Contains metahandles that are most likely dirty (though not
     // necessarily).  Dirtyness is confirmed in TakeSnapshotForSaveChanges().
     MetahandleSet* const dirty_metahandles;
 
     // TODO(ncarter): Figure out what the hell this is, and comment it.
     Channel* const channel;
 
     // The changes channel mutex is explicit because it must be locked
     // while holding the transaction mutex and released after
     // releasing the transaction mutex.
-    ChangesChannel* const changes_channel;
+    browser_sync::Channel<DirectoryChangeEvent> changes_channel;
+
     Lock changes_channel_mutex;
     KernelShareInfoStatus info_status;
 
     // These 3 members are backed in the share_info table, and
     // their state is marked by the flag above.
 
     // A structure containing the Directory state that is written back into the
     // database on SaveChanges.
     PersistedKernelInfo persisted_info;
 
@@ skipping 159 matching lines @@
 void ZeroFields(EntryKernel* entry, int first_field);
 
 }  // namespace syncable
 
 std::ostream& operator <<(std::ostream&, const syncable::Blob&);
 
 browser_sync::FastDump& operator <<
   (browser_sync::FastDump&, const syncable::Blob&);
 
 #endif  // CHROME_BROWSER_SYNC_SYNCABLE_SYNCABLE_H_