IndexedDB: Recycle cursor objects when calling continue().

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 "base/id_map.h"
 #include "base/nullable_string16.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/WebIDBObjectStore.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebIDBTransactionCallbacks.h"
+#include <map>
 
 class IndexedDBKey;
 
 namespace WebKit {
 class WebDOMStringList;
 class WebFrame;
 class WebIDBKeyRange;
 class WebIDBTransaction;
 }
 
@@ skipping 119 matching lines @@
       int32 idb_object_store_id,
       const WebKit::WebIDBTransaction& transaction,
       WebKit::WebExceptionCode* ec);
 
   void RegisterWebIDBTransactionCallbacks(
       WebKit::WebIDBTransactionCallbacks* callbacks,
       int32 id);
 
   static int32 TransactionId(const WebKit::WebIDBTransaction& transaction);
 
+  IndexedDBKey getCursorKey(int32 cursor_id);
+  IndexedDBKey getCursorPrimaryKey(int32 cursor_id);
+  content::SerializedScriptValue getCursorValue(int32 cursor_id);
+  void CursorDestroyed(int32 cursor_id);
+
  private:
   // IDBCallback message handlers.
   void OnSuccessNull(int32 response_id);
   void OnSuccessIDBDatabase(int32 response_id, int32 object_id);
   void OnSuccessIndexedDBKey(int32 response_id, const IndexedDBKey& key);
   void OnSuccessIDBTransaction(int32 response_id, int32 object_id);
   void OnSuccessOpenCursor(int32 response_id, int32 object_id,
                            const IndexedDBKey& key,
                            const IndexedDBKey& primary_key,
                            const content::SerializedScriptValue& value);
+  void OnSuccessCursorContinue(int32 response_id,
+                               const IndexedDBKey& key,
+                               const IndexedDBKey& primary_key,
+                               const content::SerializedScriptValue& value);
   void OnSuccessStringList(int32 response_id,
                            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);
 
   // 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_;
 
+  // Map from response id to cursor id.
+  std::map<int32,int32> pending_cursor_continues_;
+
+  // FIXME: Double check these are only used on WebKit thread.

[dgrogan, 2011/10/29 00:54:28]

You could use IDMap and AddWithID.  IDMap ensures it's not called on multiple
threads.  But you don't have any threading problems.  Incoming messages are
already on the right thread by the time they get to IndexedDBDispatcher.

[hans, 2011/10/31 16:11:52]

OK, thanks.

+  std::map<int32, IndexedDBKey> cursor_key_; // Map from cursor id to key.
+  std::map<int32, IndexedDBKey> cursor_primary_key_;
+  std::map<int32, content::SerializedScriptValue> cursor_value_;
+
   DISALLOW_COPY_AND_ASSIGN(IndexedDBDispatcher);
 };
 
 #endif  // CONTENT_RENDERER_INDEXED_DB_DISPATCHER_H_