leveldb_service: Attempt to fix deadlock on shutdown.

components/leveldb/leveldb_file_thread.h

 // Copyright 2016 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 COMPONENTS_LEVELDB_LEVELDB_FILE_THREAD_H_
 #define COMPONENTS_LEVELDB_LEVELDB_FILE_THREAD_H_
 
+#include <map>
 #include <string>
+#include <utility>
+#include <vector>
 
 #include "base/files/file.h"
 #include "base/memory/ref_counted.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/thread.h"
 #include "components/filesystem/public/interfaces/directory.mojom.h"
 
 namespace leveldb {
 
 // The thread which services file requests from leveldb.
@@ skipping 70 matching lines @@
 
   // Unlocks a file. LevelDBFileThread takes ownership of lock. (We don't make
   // this a scoped_ptr because exporting the ctor/dtor for this struct publicly
   // defeats the purpose of the struct.)
   filesystem::FileError UnlockFile(OpaqueLock* lock);
 
  private:
   friend class base::RefCountedThreadSafe<LevelDBFileThread>;
   ~LevelDBFileThread() override;
 
+  // Called from the beginning of most impls which take an OpaqueDir. Returns
+  // true if the directory was unbound between the time the task was posted and
+  // the task was run on this thread. If it was, no further processing should
+  // be done (and the waitable event will be Signal()ed).
+  bool RegisterDirAndWaitableEvent(OpaqueDir* dir,
+                                   base::WaitableEvent* done_event);
+
+  // Cleans up internal state related to the waitable event before Signal()ing
+  // it.
+  void CompleteWaitableEvent(base::WaitableEvent* done_event);
+
+  // Called when one of our directory or files has a connection error. This
+  // will find all the outstanding waitable events that depend on it and signal
+  // them.
+  void OnConnectionError();
+
   void RegisterDirectoryImpl(
       base::WaitableEvent* done_event,
       mojo::InterfacePtrInfo<filesystem::Directory> directory_info,
       OpaqueDir** out_dir);
   void UnregisterDirectoryImpl(base::WaitableEvent* done_event,
                                OpaqueDir* dir);
 
   // Shared callback function which signals for the methods that only return an
   // error code.
   void OnSimpleComplete(base::WaitableEvent* done_event,
@@ skipping 101 matching lines @@
                              base::WaitableEvent* done_event,
                              filesystem::FileError* out_error,
                              filesystem::FileError in_error);
 
   // Overridden from base::Thread:
   void Init() override;
   void CleanUp() override;
 
   int outstanding_opaque_dirs_;
 
+  // When our public methods are called, we create a WaitableEvent on their
+  // thread so that we can block their thread on the LevelDBFileThread. We then
+  // need to track what DirectoryPtrs and FilePtrs, which if they get closed,
+  // should immediately trigger the waitable event.
+  struct WaitableEventDependencies;
+  std::map<base::WaitableEvent*, WaitableEventDependencies>
+      waitable_event_dependencies_;
+
   DISALLOW_COPY_AND_ASSIGN(LevelDBFileThread);
 };
 
 }  // namespace leveldb
 
 #endif  // COMPONENTS_LEVELDB_LEVELDB_FILE_THREAD_H_