Fix IndexedDB after r208777.

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 "base/format_macros.h"
 #include "base/lazy_instance.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/thread_local.h"
-#include "content/child/child_thread.h"
 #include "content/child/indexed_db/proxy_webidbcursor_impl.h"
 #include "content/child/indexed_db/proxy_webidbdatabase_impl.h"
+#include "content/child/thread_safe_sender.h"
 #include "content/common/indexed_db/indexed_db_messages.h"
 #include "ipc/ipc_channel.h"
 #include "third_party/WebKit/public/platform/WebIDBDatabaseCallbacks.h"
 #include "third_party/WebKit/public/platform/WebIDBDatabaseError.h"
 #include "third_party/WebKit/public/platform/WebIDBDatabaseException.h"
 #include "third_party/WebKit/public/platform/WebIDBKeyRange.h"
 
 using WebKit::WebData;
 using WebKit::WebIDBCallbacks;
 using WebKit::WebIDBDatabase;
@@ skipping 16 matching lines @@
 IndexedDBDispatcher* const kHasBeenDeleted =
     reinterpret_cast<IndexedDBDispatcher*>(0x1);
 
 int32 CurrentWorkerId() {
   return WorkerTaskRunner::Instance()->CurrentWorkerId();
 }
 }  // unnamed namespace
 
 const size_t kMaxIDBValueSizeInBytes = 64 * 1024 * 1024;
 
-IndexedDBDispatcher::IndexedDBDispatcher() {
+IndexedDBDispatcher::IndexedDBDispatcher(ThreadSafeSender* thread_safe_sender)
+    : thread_safe_sender_(thread_safe_sender) {
   g_idb_dispatcher_tls.Pointer()->Set(this);
 }
 
 IndexedDBDispatcher::~IndexedDBDispatcher() {
   // Clear any pending callbacks - which may result in dispatch requests -
   // before marking the dispatcher as deleted.
   pending_callbacks_.Clear();
   pending_database_callbacks_.Clear();
 
   DCHECK(pending_callbacks_.IsEmpty());
   DCHECK(pending_database_callbacks_.IsEmpty());
 
   g_idb_dispatcher_tls.Pointer()->Set(kHasBeenDeleted);
 }
 
-IndexedDBDispatcher* IndexedDBDispatcher::ThreadSpecificInstance() {
+IndexedDBDispatcher* IndexedDBDispatcher::ThreadSpecificInstance(
+    ThreadSafeSender* thread_safe_sender) {
   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();
 
-  IndexedDBDispatcher* dispatcher = new IndexedDBDispatcher;
+  IndexedDBDispatcher* dispatcher = new IndexedDBDispatcher(thread_safe_sender);
   if (WorkerTaskRunner::Instance()->CurrentWorkerId())
     webkit_glue::WorkerTaskRunner::Instance()->AddStopObserver(dispatcher);
   return dispatcher;
 }
 
 void IndexedDBDispatcher::OnWorkerRunLoopStopped() { delete this; }
 
 WebIDBMetadata IndexedDBDispatcher::ConvertMetadata(
     const IndexedDBDatabaseMetadata& idb_metadata) {
   WebIDBMetadata web_metadata;
@@ skipping 69 matching lines @@
     IPC_MESSAGE_HANDLER(IndexedDBMsg_DatabaseCallbacksComplete, OnComplete)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   // If a message gets here, IndexedDBMessageFilter already determined that it
   // is an IndexedDB message.
   DCHECK(handled) << "Didn't handle a message defined at line "
                   << IPC_MESSAGE_ID_LINE(msg.type());
 }
 
 bool IndexedDBDispatcher::Send(IPC::Message* msg) {
-  if (!ChildThread::current()) {
-    // Unexpected - this may be happening during shutdown.
-    NOTREACHED();
-    return false;
-  }
-  if (CurrentWorkerId()) {
-    scoped_refptr<IPC::SyncMessageFilter> filter(
-        ChildThread::current()->sync_message_filter());
-    return filter->Send(msg);
-  }
-  return ChildThread::current()->Send(msg);
+  return thread_safe_sender_->Send(msg);
 }
 
 void IndexedDBDispatcher::RequestIDBCursorAdvance(
     unsigned long count,
     WebIDBCallbacks* callbacks_ptr,
     int32 ipc_cursor_id) {
   // Reset all cursor prefetch caches except for this cursor.
   ResetCursorPrefetchCaches(ipc_cursor_id);
 
   scoped_ptr<WebIDBCallbacks> callbacks(callbacks_ptr);
@@ skipping 276 matching lines @@
     int32 ipc_object_id,
     const IndexedDBDatabaseMetadata& idb_metadata) {
   DCHECK_EQ(ipc_thread_id, CurrentWorkerId());
   WebIDBCallbacks* callbacks = pending_callbacks_.Lookup(ipc_callbacks_id);
   if (!callbacks)
     return;
   WebIDBMetadata metadata(ConvertMetadata(idb_metadata));
   // If an upgrade was performed, count will be non-zero.
   if (!databases_.count(ipc_object_id))
     databases_[ipc_object_id] = new RendererWebIDBDatabaseImpl(
-        ipc_object_id, ipc_database_callbacks_id);
+        ipc_object_id, ipc_database_callbacks_id, thread_safe_sender_);
   DCHECK_EQ(databases_.count(ipc_object_id), 1u);
   callbacks->onSuccess(databases_[ipc_object_id], metadata);
   pending_callbacks_.Remove(ipc_callbacks_id);
 }
 
 void IndexedDBDispatcher::OnSuccessIndexedDBKey(int32 ipc_thread_id,
                                                 int32 ipc_callbacks_id,
                                                 const IndexedDBKey& key) {
   DCHECK_EQ(ipc_thread_id, CurrentWorkerId());
   WebIDBCallbacks* callbacks = pending_callbacks_.Lookup(ipc_callbacks_id);
@@ skipping 76 matching lines @@
   const IndexedDBKey& primary_key = p.primary_key;
   WebData web_value;
   if (p.value.size())
     web_value.assign(&p.value.front(), p.value.size());
 
   WebIDBCallbacks* callbacks = pending_callbacks_.Lookup(ipc_callbacks_id);
   if (!callbacks)
     return;
 
   RendererWebIDBCursorImpl* cursor =
-      new RendererWebIDBCursorImpl(ipc_object_id);
+      new RendererWebIDBCursorImpl(ipc_object_id, thread_safe_sender_);
   cursors_[ipc_object_id] = cursor;
   callbacks->onSuccess(cursor, key, primary_key, web_value);
 
   pending_callbacks_.Remove(ipc_callbacks_id);
 }
 
 void IndexedDBDispatcher::OnSuccessCursorContinue(
     const IndexedDBMsg_CallbacksSuccessCursorContinue_Params& p) {
   DCHECK_EQ(p.ipc_thread_id, CurrentWorkerId());
   int32 ipc_callbacks_id = p.ipc_callbacks_id;
@@ skipping 49 matching lines @@
 }
 
 void IndexedDBDispatcher::OnUpgradeNeeded(
     const IndexedDBMsg_CallbacksUpgradeNeeded_Params& p) {
   DCHECK_EQ(p.ipc_thread_id, CurrentWorkerId());
   WebIDBCallbacks* callbacks = pending_callbacks_.Lookup(p.ipc_callbacks_id);
   DCHECK(callbacks);
   WebIDBMetadata metadata(ConvertMetadata(p.idb_metadata));
   DCHECK(!databases_.count(p.ipc_database_id));
   databases_[p.ipc_database_id] = new RendererWebIDBDatabaseImpl(
-      p.ipc_database_id, p.ipc_database_callbacks_id);
+      p.ipc_database_id, p.ipc_database_callbacks_id, thread_safe_sender_);
   callbacks->onUpgradeNeeded(
       p.old_version,
       databases_[p.ipc_database_id],
       metadata,
       static_cast<WebIDBCallbacks::DataLoss>(p.data_loss));
 }
 
 void IndexedDBDispatcher::OnError(int32 ipc_thread_id,
                                   int32 ipc_callbacks_id,
                                   int code,
@@ skipping 58 matching lines @@
     int32 ipc_exception_cursor_id) {
   typedef std::map<int32, RendererWebIDBCursorImpl*>::iterator Iterator;
   for (Iterator i = cursors_.begin(); i != cursors_.end(); ++i) {
     if (i->first == ipc_exception_cursor_id)
       continue;
     i->second->ResetPrefetchCache();
   }
 }
 
 }  // namespace content