Fix deadlock by introducing a new transaction event.

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 932 matching lines @@
   }
 }
 
 BaseTransaction::BaseTransaction(Directory* directory, const char* name,
                  const char* source_file, int line, WriterTag writer)
   : directory_(directory), dirkernel_(directory->kernel_), name_(name),
     source_file_(source_file), line_(line), writer_(writer) {
   Lock();
 }
 
+BaseTransaction::~BaseTransaction() {}
+
 void BaseTransaction::UnlockAndLog(OriginalEntries* originals_arg) {
   dirkernel_->transaction_mutex.AssertAcquired();
 
   scoped_ptr<OriginalEntries> originals(originals_arg);
   const base::TimeDelta elapsed = base::TimeTicks::Now() - time_acquired_;
   if (kLoggingInfo && elapsed.InMilliseconds() > 50) {
     logging::LogMessage(source_file_, line_, logging::LOG_INFO).stream()
         << name_ << " transaction completed in " << elapsed.InSecondsF()
         << " seconds.";
   }
 
   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.Notify(event);
 
+  // Necessary for reads to be performed prior to transaction mutex release.
+  // Allows the listener to use the current transaction to perform reads.
+  DirectoryChangeEvent ending_event =
+      { DirectoryChangeEvent::TRANSACTION_ENDING,
+        NULL, this, INVALID };
+  dirkernel_->changes_channel.Notify(ending_event);
+
   dirkernel_->transaction_mutex.Release();
 
+  // Directly after transaction mutex release, but lock on changes channel.
+  // You cannot be re-entrant to a transaction in this handler.
   DirectoryChangeEvent complete_event =
       { DirectoryChangeEvent::TRANSACTION_COMPLETE,
         NULL, NULL, INVALID };
   dirkernel_->changes_channel.Notify(complete_event);
 }
 
 ReadTransaction::ReadTransaction(Directory* directory, const char* file,
                                  int line)
   : BaseTransaction(directory, "Read", file, line, INVALID) {
 }
@@ skipping 571 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;
 }