[Sync] Split DirectoryChangeListener for thread-safety

chrome/browser/sync/syncable/syncable.h

 // Copyright (c) 2011 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_
 #pragma once
 
 #include <algorithm>
 #include <bitset>
 #include <iosfwd>
 #include <limits>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/atomicops.h"
 #include "base/basictypes.h"
 #include "base/file_path.h"
 #include "base/gtest_prod_util.h"
-#include "base/observer_list.h"
+#include "base/memory/ref_counted.h"
+#include "base/observer_list_threadsafe.h"
 #include "base/synchronization/lock.h"
 #include "base/time.h"
+#include "base/tracked.h"
 #include "chrome/browser/sync/protocol/sync.pb.h"
 #include "chrome/browser/sync/syncable/autofill_migration.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/syncable_id.h"
 #include "chrome/browser/sync/syncable/model_type.h"
 #include "chrome/browser/sync/util/dbgq.h"
 #include "chrome/common/deprecated/event_sys.h"
 
 class DictionaryValue;
 struct PurgeInfo;
 
 namespace sync_api {
 class ReadTransaction;
 class WriteNode;
 class ReadNode;
-}
+}  // sync_api
 
 namespace syncable {
-class DirectoryChangeListener;
+class DirectoryChangeDelegate;
+class TransactionObserver;
 class Entry;
 
 std::ostream& operator<<(std::ostream& s, const Entry& e);
 
 class DirectoryBackingStore;
 
 static const int64 kInvalidMetaHandle = 0;
 
 // Update syncable_enum_conversions{.h,.cc,_unittest.cc} if you change
 // any fields in this file.
@@ skipping 692 matching lines @@
 
     KernelShareInfoStatus kernel_info_status;
     PersistedKernelInfo kernel_info;
     OriginalEntries dirty_metas;
     MetahandleSet metahandles_to_purge;
   };
 
   Directory();
   virtual ~Directory();
 
-  DirOpenResult Open(const FilePath& file_path, const std::string& name);
+  // Does not take ownership of |delegate|, which must not be NULL.
+  // Starts sending events to |delegate| if the returned result is
+  // OPENED.  Note that events to |delegate| may be sent from *any*
+  // thread.
+  DirOpenResult Open(const FilePath& file_path, const std::string& name,
+                     DirectoryChangeDelegate* delegate);
 
+  // Stops sending events to the delegate.
   void Close();
 
   int64 NextMetahandle();
   // Always returns a negative id.  Positive client ids are generated
   // by the server only.
   Id NextId();
 
   const FilePath& file_path() const { return kernel_->db_path; }
   bool good() const { return NULL != store_; }
 
@@ skipping 29 matching lines @@
   // later.
   std::string store_birthday() const;
   void set_store_birthday(const std::string& store_birthday);
 
   std::string GetAndClearNotificationState();
   void SetNotificationState(const std::string& notification_state);
 
   // Unique to each account / client pair.
   std::string cache_guid() const;
 
-  void AddChangeListener(DirectoryChangeListener* listener);
-  void RemoveChangeListener(DirectoryChangeListener* listener);
+  // These are backed by a thread-safe observer list, and so can be
+  // called on any thread, and events will be sent to the observer on
+  // the same thread that it was added on.
+  void AddTransactionObserver(TransactionObserver* observer);
+  void RemoveTransactionObserver(TransactionObserver* observer);
 
  protected:  // for friends, mainly used by Entry constructors
   virtual EntryKernel* GetEntryByHandle(int64 handle);
   virtual EntryKernel* GetEntryByHandle(int64 metahandle,
       ScopedKernelLock* lock);
   virtual EntryKernel* GetEntryById(const Id& id);
   EntryKernel* GetEntryByServerTag(const std::string& tag);
   virtual 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();
 
   // These don't do semantic checking.
   // The semantic checking is implemented higher up.
   void UnlinkEntryFromOrder(EntryKernel* entry,
                             WriteTransaction* trans,
                             ScopedKernelLock* lock);
 
   // Overridden by tests.
   virtual DirectoryBackingStore* CreateBackingStore(
       const std::string& dir_name,
       const FilePath& backing_filepath);
 
  private:
   // These private versions expect the kernel lock to already be held
   // before calling.
   EntryKernel* GetEntryById(const Id& id, ScopedKernelLock* const lock);
 
-  DirOpenResult OpenImpl(const FilePath& file_path, const std::string& name);
+  DirOpenResult OpenImpl(const FilePath& file_path, const std::string& name,
+                         DirectoryChangeDelegate* delegate);
 
   template <class T> void TestAndSet(T* kernel_data, const T* data_to_set);
 
   struct DirectoryEventTraits {
     typedef DirectoryEvent EventType;
     static inline bool IsChannelShutdownEvent(const DirectoryEvent& event) {
       return DIRECTORY_DESTROYED == event;
     }
   };
  public:
@@ skipping 126 matching lines @@
   typedef Index<ParentIdAndHandleIndexer>::Set ParentIdChildIndex;
 
   // Contains both deleted and existing entries with tags.
   // We can't store only existing tags because the client would create
   // items that had a duplicated ID in the end, resulting in a DB key
   // violation. ID reassociation would fail after an attempted commit.
   typedef Index<ClientTagIndexer>::Set ClientTagIndex;
 
  protected:
   // Used by tests.
-  void init_kernel(const std::string& name);
+  void InitKernel(const std::string& name, DirectoryChangeDelegate* delegate);
 
  private:
 
   struct Kernel {
+    // |delegate| can be NULL.
     Kernel(const FilePath& db_path, const std::string& name,
-           const KernelLoadInfo& info);
+           const KernelLoadInfo& info, DirectoryChangeDelegate* delegate);
 
     ~Kernel();
 
     void AddRef();  // For convenience.
     void Release();
 
-    void AddChangeListener(DirectoryChangeListener* listener);
-    void RemoveChangeListener(DirectoryChangeListener* listener);
-
-    void CopyChangeListeners(
-        ObserverList<DirectoryChangeListener>* change_listeners);
-
     FilePath const db_path;
     // TODO(timsteele): audit use of the member and remove if possible
     volatile base::subtle::AtomicWord refcount;
 
     // Implements ReadTransaction / WriteTransaction using a simple lock.
     base::Lock transaction_mutex;
 
     // The name of this directory.
     std::string const name;
 
@@ skipping 46 matching lines @@
     // time; this mutex protects that activity.
     base::Lock save_changes_mutex;
 
     // The next metahandle is protected by kernel mutex.
     int64 next_metahandle;
 
     // Keep a history of recently flushed metahandles for debugging
     // purposes.  Protected by the save_changes_mutex.
     DebugQueue<int64, 1000> flushed_metahandles;
 
-   private:
-    // The listeners for directory change events, triggered when the
-    // transaction is ending (and its lock).
-    base::Lock change_listeners_lock_;
-    ObserverList<DirectoryChangeListener> change_listeners_;
+    // The delegate for directory change events.  Can be NULL.
+    DirectoryChangeDelegate* const delegate;
+
+    // The transaction observers.
+    scoped_refptr<ObserverListThreadSafe<TransactionObserver> > observers;
   };
 
   // Helper method used to do searches on |parent_id_child_index|.
   ParentIdChildIndex::iterator LocateInParentChildIndex(
       const ScopedKernelLock& lock,
       const Id& parent_id,
       int64 position_in_parent,
       const Id& item_id_for_tiebreaking);
 
   // Return an iterator to the beginning of the range of the children of
@@ skipping 31 matching lines @@
 // Transactions are now processed FIFO with a straight lock
 class BaseTransaction {
   friend class Entry;
  public:
   inline Directory* directory() const { return directory_; }
   inline Id root_id() const { return Id(); }
 
   virtual ~BaseTransaction();
 
  protected:
-  BaseTransaction(Directory* directory, const char* name,
-                  const char* source_file, int line, WriterTag writer);
-
-  // For unit testing. Everything will be mocked out no point initializing.
-  explicit BaseTransaction(Directory* directory);
+  BaseTransaction(Directory* directory,
+                  const char* name,
+                  const tracked_objects::Location& from_here,
+                  WriterTag writer);
 
   void UnlockAndLog(OriginalEntries* entries);
   virtual bool NotifyTransactionChangingAndEnding(
       OriginalEntries* entries,
       ModelTypeBitSet* models_with_changes);
   virtual void NotifyTransactionComplete(ModelTypeBitSet models_with_changes);
 
   Directory* const directory_;
   Directory::Kernel* const dirkernel_;  // for brevity
   const char* const name_;
   base::TimeTicks time_acquired_;
-  const char* const source_file_;
-  const int line_;
+  const tracked_objects::Location from_here_;
   WriterTag writer_;
 
  private:
   void Lock();
 
   DISALLOW_COPY_AND_ASSIGN(BaseTransaction);
 };
 
 // Locks db in constructor, unlocks in destructor.
 class ReadTransaction : public BaseTransaction {
  public:
-  ReadTransaction(Directory* directory, const char* source_file,
-                  int line);
+  ReadTransaction(Directory* directory,
+                  const tracked_objects::Location& from_here);
   ReadTransaction(const ScopedDirLookup& scoped_dir,
-                  const char* source_file, int line);
+                  const tracked_objects::Location& from_here);
 
   virtual ~ReadTransaction();
 
  protected:  // Don't allow creation on heap, except by sync API wrapper.
   friend class sync_api::ReadTransaction;
   void* operator new(size_t size) { return (::operator new)(size); }
 
   DISALLOW_COPY_AND_ASSIGN(ReadTransaction);
 };
 
 // Locks db in constructor, unlocks in destructor.
 class WriteTransaction : public BaseTransaction {
   friend class MutableEntry;
  public:
-  explicit WriteTransaction(Directory* directory, WriterTag writer,
-                            const char* source_file, int line);
-  explicit WriteTransaction(const ScopedDirLookup& directory,
-                            WriterTag writer, const char* source_file,
-                            int line);
+  WriteTransaction(Directory* directory, WriterTag writer,
+                  const tracked_objects::Location& from_here);
+  WriteTransaction(const ScopedDirLookup& directory, WriterTag writer,
+                   const tracked_objects::Location& from_here);
   virtual ~WriteTransaction();
 
   void SaveOriginal(EntryKernel* entry);
 
  protected:
   // Before an entry gets modified, we copy the original into a list
   // so that we can issue change notifications when the transaction
   // is done.
   OriginalEntries* const originals_;
 
-  explicit WriteTransaction(Directory *directory);
-
   DISALLOW_COPY_AND_ASSIGN(WriteTransaction);
 };
 
 bool IsLegalNewParent(BaseTransaction* trans, const Id& id, const Id& parentid);
 
 int64 Now();
 
 // This function sets only the flags needed to get this entry to sync.
 void MarkForSyncing(syncable::MutableEntry* e);
 
 // This is not a reset.  It just sets the numeric fields which are not
 // initialized by the constructor to zero.
 void ZeroFields(EntryKernel* entry, int first_field);
 
 }  // namespace syncable
 
 std::ostream& operator <<(std::ostream&, const syncable::Blob&);
 
 #endif  // CHROME_BROWSER_SYNC_SYNCABLE_SYNCABLE_H_