Fix deadlock by introducing a new transaction event.

chrome/browser/sync/syncable/syncable.h

 // 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.
 
 #ifndef CHROME_BROWSER_SYNC_SYNCABLE_SYNCABLE_H_
 #define CHROME_BROWSER_SYNC_SYNCABLE_SYNCABLE_H_
 
 #include <algorithm>
 #include <bitset>
 #include <iosfwd>
@@ skipping 568 matching lines @@
 
 // A separate Event type and channel for very frequent changes, caused
 // by anything, not just the user.
 struct DirectoryChangeEvent {
   enum {
     // Means listener should go through list of original entries and
     // calculate what it needs to notify.  It should *not* call any
     // callbacks or attempt to lock anything because a
     // WriteTransaction is being held until the listener returns.
     CALCULATE_CHANGES,
+    // Means the WriteTransaction is ending, and this is the absolute
+    // last chance to perform any read operations in the current transaction.
+    // It is not recommended that the listener perform any writes.
+    TRANSACTION_ENDING,
     // Means the WriteTransaction has been released and the listener
     // can now take action on the changes it calculated.
     TRANSACTION_COMPLETE,
     // Channel is closing.
     SHUTDOWN
   } todo;
   // These members are only valid for CALCULATE_CHANGES.
   const OriginalEntries* originals;
-  BaseTransaction* trans;
+  BaseTransaction* trans;  // This is valid also for TRANSACTION_ENDING
   WriterTag writer;
   typedef DirectoryChangeEvent EventType;
   static inline bool IsChannelShutdownEvent(const EventType& e) {
     return SHUTDOWN == e.todo;
   }
 };
 
 // A list of metahandles whose metadata should not be purged.
 typedef std::multiset<int64> Pegs;
 
@@ skipping 429 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(ScopedKernelLock);
 };
 
 // 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);
 
   void UnlockAndLog(OriginalEntries* entries);
 
   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_;
   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(const ScopedDirLookup& scoped_dir,
                   const char* source_file, int line);
 
-  ~ReadTransaction();
+  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 {
@@ skipping 34 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_