IndexedDB: Optimize IDBCursor.advance() if it occurs within prefetched range

content/child/indexed_db/proxy_webidbcursor_impl.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/proxy_webidbcursor_impl.h"
 
 #include <vector>
 
 #include "content/child/thread_safe_sender.h"
 #include "content/child/indexed_db/indexed_db_dispatcher.h"
@@ skipping 30 matching lines @@
   IndexedDBDispatcher* dispatcher =
       IndexedDBDispatcher::ThreadSpecificInstance(thread_safe_sender_.get());
   dispatcher->CursorDestroyed(ipc_cursor_id_);
 }
 
 void RendererWebIDBCursorImpl::advance(unsigned long count,
                                        WebIDBCallbacks* callbacks_ptr) {
   IndexedDBDispatcher* dispatcher =
       IndexedDBDispatcher::ThreadSpecificInstance(thread_safe_sender_.get());
   scoped_ptr<WebIDBCallbacks> callbacks(callbacks_ptr);
+  if (count <= prefetch_keys_.size()) {
+    CachedAdvance(count, callbacks.get());
+    return;
+  }
   ResetPrefetchCache();
   dispatcher->RequestIDBCursorAdvance(
       count, callbacks.release(), ipc_cursor_id_);
 }
 
 void RendererWebIDBCursorImpl::continueFunction(
     const WebIDBKey& key,
     WebIDBCallbacks* callbacks_ptr) {
   continueFunction(key, WebIDBKey::createNull(), callbacks_ptr);
 }
@@ skipping 37 matching lines @@
 
   dispatcher->RequestIDBCursorContinue(IndexedDBKeyBuilder::Build(key),
                                        IndexedDBKeyBuilder::Build(primary_key),
                                        callbacks.release(),
                                        ipc_cursor_id_);
 }
 
 void RendererWebIDBCursorImpl::postSuccessHandlerCallback() {
   pending_onsuccess_callbacks_--;
 
-  // If the onsuccess callback called continue() on the cursor again,
-  // and that continue was served by the prefetch cache, then
-  // pending_onsuccess_callbacks_ would be incremented.
-  // If not, it means the callback did something else, or nothing at all,
-  // in which case we need to reset the cache.
+  // If the onsuccess callback called continue()/advance() on the cursor
+  // again, and that request was served by the prefetch cache, then
+  // pending_onsuccess_callbacks_ would be incremented. If not, it means the
+  // callback did something else, or nothing at all, in which case we need to
+  // reset the cache.
 
   if (pending_onsuccess_callbacks_ == 0)
     ResetPrefetchCache();
 }
 
 void RendererWebIDBCursorImpl::SetPrefetchData(
     const std::vector<IndexedDBKey>& keys,
     const std::vector<IndexedDBKey>& primary_keys,
     const std::vector<WebData>& values) {
   prefetch_keys_.assign(keys.begin(), keys.end());
   prefetch_primary_keys_.assign(primary_keys.begin(), primary_keys.end());
   prefetch_values_.assign(values.begin(), values.end());
 
   used_prefetches_ = 0;
   pending_onsuccess_callbacks_ = 0;
 }
 
+void RendererWebIDBCursorImpl::CachedAdvance(unsigned long count,
+                                             WebIDBCallbacks* callbacks) {
+  DCHECK_GE(prefetch_keys_.size(), count);
+  DCHECK_EQ(prefetch_primary_keys_.size(), prefetch_keys_.size());
+  DCHECK_EQ(prefetch_values_.size(), prefetch_keys_.size());
+
+  while (count > 1) {

[jsbell, 2013/12/12 00:18:44]

If we think this will be common we could replace the std::deque usage here with
std::vector so we can just slice off the front of the queue.

[alecflett, 2013/12/19 00:41:39]

I'd do that in another patch under the umbrella of code cleanup.. (which I'd
happily review too) I'd be surprised if it made any difference for the size of
prefetches we do..

+    prefetch_keys_.pop_front();
+    prefetch_primary_keys_.pop_front();
+    prefetch_values_.pop_front();
+    ++used_prefetches_;
+    --count;
+  }
+
+  CachedContinue(callbacks);
+}
+
 void RendererWebIDBCursorImpl::CachedContinue(WebIDBCallbacks* callbacks) {
   DCHECK_GT(prefetch_keys_.size(), 0ul);
-  DCHECK(prefetch_primary_keys_.size() == prefetch_keys_.size());
-  DCHECK(prefetch_values_.size() == prefetch_keys_.size());
+  DCHECK_EQ(prefetch_primary_keys_.size(), prefetch_keys_.size());
+  DCHECK_EQ(prefetch_values_.size(), prefetch_keys_.size());
 
   IndexedDBKey key = prefetch_keys_.front();
   IndexedDBKey primary_key = prefetch_primary_keys_.front();
-  // this could be a real problem.. we need 2 CachedContinues
   WebData value = prefetch_values_.front();
 
   prefetch_keys_.pop_front();
   prefetch_primary_keys_.pop_front();
   prefetch_values_.pop_front();
-  used_prefetches_++;
+  ++used_prefetches_;
 
-  pending_onsuccess_callbacks_++;
+  ++pending_onsuccess_callbacks_;
 
   callbacks->onSuccess(WebIDBKeyBuilder::Build(key),
                        WebIDBKeyBuilder::Build(primary_key), value);
 }
 
 void RendererWebIDBCursorImpl::ResetPrefetchCache() {
   continue_count_ = 0;
   prefetch_amount_ = kMinPrefetchAmount;
 
   if (!prefetch_keys_.size()) {
     // No prefetch cache, so no need to reset the cursor in the back-end.
     return;
   }
 
   IndexedDBDispatcher* dispatcher =
       IndexedDBDispatcher::ThreadSpecificInstance(thread_safe_sender_.get());
   dispatcher->RequestIDBCursorPrefetchReset(
       used_prefetches_, prefetch_keys_.size(), ipc_cursor_id_);
   prefetch_keys_.clear();
   prefetch_primary_keys_.clear();
   prefetch_values_.clear();
 
   pending_onsuccess_callbacks_ = 0;
 }
 
 }  // namespace content