Dispatch IndexedDB IPC messages to worker threads

content/renderer/indexed_db_dispatcher.h

 // Copyright (c) 2011 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 CONTENT_RENDERER_INDEXED_DB_DISPATCHER_H_
 #define CONTENT_RENDERER_INDEXED_DB_DISPATCHER_H_
 #pragma once
 
 #include <map>
 #include <vector>
 
 #include "base/id_map.h"
 #include "base/nullable_string16.h"
+#include "content/common/indexed_db_message_filter.h"
 #include "ipc/ipc_channel.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebExceptionCode.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebIDBCallbacks.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebIDBDatabase.h"
+#include "third_party/WebKit/Source/WebKit/chromium/public/WebIDBDatabaseCallbacks.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebIDBObjectStore.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebIDBTransactionCallbacks.h"
 
 class IndexedDBKey;
 class RendererWebIDBCursorImpl;
 
 namespace WebKit {
 class WebFrame;
 class WebIDBKeyRange;
 class WebIDBTransaction;
 }
 
 namespace content {
 class SerializedScriptValue;
 }
 
 // Handle the indexed db related communication for this entire renderer.
-class IndexedDBDispatcher : public IPC::Channel::Listener {
+class IndexedDBDispatcher {
  public:
-  IndexedDBDispatcher();
+  IndexedDBDispatcher(IndexedDBMessageFilter*);
   virtual ~IndexedDBDispatcher();
 
-  // IPC::Channel::Listener implementation.
-  virtual bool OnMessageReceived(const IPC::Message& msg) OVERRIDE;
+  void OnMessageReceived(const IPC::Message& msg);
   void Send(IPC::Message* msg);
 
   void RequestIDBFactoryGetDatabaseNames(
       WebKit::WebIDBCallbacks* callbacks,
       const string16& origin,
       WebKit::WebFrame* web_frame);
 
   void RequestIDBFactoryOpen(
       const string16& name,
       WebKit::WebIDBCallbacks* callbacks,
@@ skipping 126 matching lines @@
                            const std::vector<string16>& value);
   void OnSuccessSerializedScriptValue(
       int32 response_id,
       const content::SerializedScriptValue& value);
   void OnError(int32 response_id, int code, const string16& message);
   void OnBlocked(int32 response_id);
   void OnAbort(int32 transaction_id);
   void OnComplete(int32 transaction_id);
   void OnVersionChange(int32 database_id, const string16& newVersion);
 
+  // This class facilitates mapping callback ids specified in incoming IPC
+  // messages to threads.  It:
+  // * Retrieves process-unique ids for each stored WebIDBCallbacks object.  The
+  //   browser process includes these ids in messages sent back to us.
+  // * Registers incoming transaction and database callback ids that are created
+  //   in the browser process.  We'll need to revisit this scheme if the browser
+  //   stops generating unique ids.
+  // * Ensures, through IDMap, that it is only called on a single thread.
+  template<class CallbackType>
+  class CallbackIDMap {
+   public:
+    CallbackIDMap(IndexedDBMessageFilter* filter) : filter_(filter) {
+    }
+    virtual int32 Add(CallbackType* callbacks) {
+      int id = filter_->GetUniqueCallbackIDWithThreadID();
+      map_.AddWithID(callbacks, id);
+      return id;
+    }
+    virtual void Remove(int32 id) {
+      map_.Remove(id);
+    }
+    CallbackType* Lookup(int32 id) {
+      return map_.Lookup(id);
+    }
+   protected:
+    // The filter is alive for the life of the process, nothing deletes it.
+    IndexedDBMessageFilter* filter_;
+    IDMap<CallbackType, IDMapOwnPointer> map_;
+  };
+
+  class TransactionCallbackIDMap :
+      public CallbackIDMap<WebKit::WebIDBTransactionCallbacks> {
+   public:
+    TransactionCallbackIDMap(IndexedDBMessageFilter* filter) :
+        CallbackIDMap<WebKit::WebIDBTransactionCallbacks>(filter) {
+    }
+    void AddWithID(WebKit::WebIDBTransactionCallbacks* callbacks, int32 id) {
+      filter_->DidAddTransactionID(id);
+      map_.AddWithID(callbacks, id);
+    }
+    virtual void Remove(int32 id) OVERRIDE {
+      filter_->DidRemoveTransactionID(id);
+      CallbackIDMap<WebKit::WebIDBTransactionCallbacks>::Remove(id);
+    }
+  };
+
   // Careful! WebIDBCallbacks wraps non-threadsafe data types. It must be
   // destroyed and used on the same thread it was created on.
-  IDMap<WebKit::WebIDBCallbacks, IDMapOwnPointer> pending_callbacks_;
-  IDMap<WebKit::WebIDBTransactionCallbacks, IDMapOwnPointer>
-      pending_transaction_callbacks_;
-  IDMap<WebKit::WebIDBDatabaseCallbacks, IDMapOwnPointer>
-      pending_database_callbacks_;
+  CallbackIDMap<WebKit::WebIDBCallbacks> pending_callbacks_;
+  TransactionCallbackIDMap pending_transaction_callbacks_;
+  CallbackIDMap<WebKit::WebIDBDatabaseCallbacks> pending_database_callbacks_;
 
   // Map from cursor id to RendererWebIDBCursorImpl.
   std::map<int32, RendererWebIDBCursorImpl*> cursors_;
 
+  std::map<int32, int32> database_id_to_callbacks_id_;
+
   DISALLOW_COPY_AND_ASSIGN(IndexedDBDispatcher);
 };
 
 #endif  // CONTENT_RENDERER_INDEXED_DB_DISPATCHER_H_