Reland: [IndexedDB] Delete callbacks state on worker thread exit.

content/child/indexed_db/indexed_db_dispatcher.cc

 // Copyright 2013 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 "content/child/indexed_db/indexed_db_dispatcher.h"
 
 #include <utility>
 
 #include "base/lazy_instance.h"
 #include "base/threading/thread_local.h"
@@ skipping 18 matching lines @@
 IndexedDBDispatcher* const kHasBeenDeleted =
     reinterpret_cast<IndexedDBDispatcher*>(0x1);
 
 }  // unnamed namespace
 
 IndexedDBDispatcher::IndexedDBDispatcher() {
   g_idb_dispatcher_tls.Pointer()->Set(this);
 }
 
 IndexedDBDispatcher::~IndexedDBDispatcher() {
+  in_destructor_ = true;
+  mojo_owned_callback_state_.clear();
+  mojo_owned_database_callback_state_.clear();
+
   g_idb_dispatcher_tls.Pointer()->Set(kHasBeenDeleted);
 }
 
 IndexedDBDispatcher* IndexedDBDispatcher::ThreadSpecificInstance() {
   if (g_idb_dispatcher_tls.Pointer()->Get() == kHasBeenDeleted) {
     NOTREACHED() << "Re-instantiating TLS IndexedDBDispatcher.";
     g_idb_dispatcher_tls.Pointer()->Set(NULL);
   }
   if (g_idb_dispatcher_tls.Pointer()->Get())
     return g_idb_dispatcher_tls.Pointer()->Get();
@@ skipping 42 matching lines @@
 }
 
 void IndexedDBDispatcher::RemoveObservers(
     const std::vector<int32_t>& observer_ids_to_remove) {
   for (int32_t id : observer_ids_to_remove)
     observers_.Remove(id);
 }
 
 void IndexedDBDispatcher::RegisterMojoOwnedCallbacks(
     IndexedDBCallbacksImpl::InternalState* callbacks) {
-  mojo_owned_callback_state_.insert(callbacks);
+  mojo_owned_callback_state_[callbacks] = base::WrapUnique(callbacks);
 }
 
 void IndexedDBDispatcher::UnregisterMojoOwnedCallbacks(
     IndexedDBCallbacksImpl::InternalState* callbacks) {
-  DCHECK(base::ContainsValue(mojo_owned_callback_state_, callbacks));
-  mojo_owned_callback_state_.erase(callbacks);
+  if (in_destructor_)
+    return;
+
+  auto it = mojo_owned_callback_state_.find(callbacks);
+  DCHECK(it != mojo_owned_callback_state_.end());
+  it->second.release();
+  mojo_owned_callback_state_.erase(it);
 }
 
 void IndexedDBDispatcher::RegisterMojoOwnedDatabaseCallbacks(
     blink::WebIDBDatabaseCallbacks* callbacks) {
-  mojo_owned_database_callback_state_.insert(callbacks);
+  mojo_owned_database_callback_state_[callbacks] = base::WrapUnique(callbacks);
 }
 
 void IndexedDBDispatcher::UnregisterMojoOwnedDatabaseCallbacks(
     blink::WebIDBDatabaseCallbacks* callbacks) {
-  DCHECK(base::ContainsValue(mojo_owned_database_callback_state_, callbacks));
-  mojo_owned_database_callback_state_.erase(callbacks);
+  if (in_destructor_)
+    return;
+
+  auto it = mojo_owned_database_callback_state_.find(callbacks);
+  DCHECK(it != mojo_owned_database_callback_state_.end());
+  it->second.release();
+  mojo_owned_database_callback_state_.erase(it);
 }
 
 void IndexedDBDispatcher::OnDatabaseChanges(
     int32_t ipc_thread_id,
     const IndexedDBMsg_ObserverChanges& changes) {
   DCHECK_EQ(ipc_thread_id, CurrentWorkerId());
   std::vector<WebIDBObservation> observations(
       ConvertObservations(changes.observations));
   for (auto& it : changes.observation_index) {
     WebIDBObserver* observer = observers_.Lookup(it.first);
@@ skipping 20 matching lines @@
     int64_t transaction_id,
     WebIDBCursorImpl* exception_cursor) {
   for (WebIDBCursorImpl* cursor : cursors_) {
     if (cursor != exception_cursor &&
         cursor->transaction_id() == transaction_id)
       cursor->ResetPrefetchCache();
   }
 }
 
 }  // namespace content