content/child/indexed_db/webidbcursor_impl_unittest.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/memory/scoped_ptr.h"
   6 #include "base/values.h"
   7 #include "content/child/indexed_db/indexed_db_dispatcher.h"
   8 #include "content/child/indexed_db/indexed_db_key_builders.h"
   9 #include "content/child/indexed_db/webidbcursor_impl.h"
  10 #include "content/child/thread_safe_sender.h"
  11 #include "content/common/indexed_db/indexed_db_key.h"
  12 #include "ipc/ipc_sync_message_filter.h"
  13 #include "testing/gtest/include/gtest/gtest.h"
  14 #include "third_party/WebKit/public/platform/WebData.h"
  15 #include "third_party/WebKit/public/platform/WebIDBCallbacks.h"
  16
  17 using blink::WebBlobInfo;
  18 using blink::WebData;
  19 using blink::WebIDBCallbacks;
  20 using blink::WebIDBDatabase;
  21 using blink::WebIDBKey;
  22 using blink::WebIDBKeyTypeNumber;
  23 using blink::WebVector;
  24
  25 namespace content {
  26
  27 namespace {
  28
  29 class MockDispatcher : public IndexedDBDispatcher {
  30  public:
  31   explicit MockDispatcher(ThreadSafeSender* thread_safe_sender)
  32       : IndexedDBDispatcher(thread_safe_sender),
  33         prefetch_calls_(0),
  34         last_prefetch_count_(0),
  35         reset_calls_(0),
  36         last_used_count_(0),
  37         advance_calls_(0),
  38         continue_calls_(0),
  39         destroyed_cursor_id_(0) {}
  40
  41   virtual void RequestIDBCursorPrefetch(int n,
  42                                         WebIDBCallbacks* callbacks,
  43                                         int32 ipc_cursor_id) OVERRIDE {
  44     ++prefetch_calls_;
  45     last_prefetch_count_ = n;
  46     callbacks_.reset(callbacks);
  47   }
  48
  49   virtual void RequestIDBCursorPrefetchReset(int used_prefetches,
  50                                              int unused_prefetches,
  51                                              int32 ipc_cursor_id) OVERRIDE {
  52     ++reset_calls_;
  53     last_used_count_ = used_prefetches;
  54   }
  55
  56   virtual void RequestIDBCursorAdvance(unsigned long count,
  57                                        WebIDBCallbacks* callbacks,
  58                                        int32 ipc_cursor_id,
  59                                        int64 transaction_id) OVERRIDE {
  60     ++advance_calls_;
  61     callbacks_.reset(callbacks);
  62   }
  63
  64   virtual void RequestIDBCursorContinue(const IndexedDBKey& key,
  65                                         const IndexedDBKey& primary_key,
  66                                         WebIDBCallbacks* callbacks,
  67                                         int32 ipc_cursor_id,
  68                                         int64 transaction_id) OVERRIDE {
  69     ++continue_calls_;
  70     callbacks_.reset(callbacks);
  71   }
  72
  73   virtual void CursorDestroyed(int32 ipc_cursor_id) OVERRIDE {
  74     destroyed_cursor_id_ = ipc_cursor_id;
  75   }
  76
  77   int prefetch_calls() { return prefetch_calls_; }
  78   int last_prefetch_count() { return last_prefetch_count_; }
  79   int reset_calls() { return reset_calls_; }
  80   int last_used_count() { return last_used_count_; }
  81   int advance_calls() { return advance_calls_; }
  82   int continue_calls() { return continue_calls_; }
  83   int32 destroyed_cursor_id() { return destroyed_cursor_id_; }
  84
  85  private:
  86   int prefetch_calls_;
  87   int last_prefetch_count_;
  88   int reset_calls_;
  89   int last_used_count_;
  90   int advance_calls_;
  91   int continue_calls_;
  92   int32 destroyed_cursor_id_;
  93   scoped_ptr<WebIDBCallbacks> callbacks_;
  94 };
  95
  96 class MockContinueCallbacks : public WebIDBCallbacks {
  97  public:
  98   MockContinueCallbacks(IndexedDBKey* key = 0,
  99                         WebVector<WebBlobInfo>* webBlobInfo = 0)
 100       : key_(key), webBlobInfo_(webBlobInfo) {}
 101
 102   virtual void onSuccess(const WebIDBKey& key,
 103                          const WebIDBKey& primaryKey,
 104                          const WebData& value,
 105                          const WebVector<WebBlobInfo>& webBlobInfo) OVERRIDE {
 106     if (key_)
 107       *key_ = IndexedDBKeyBuilder::Build(key);
 108     if (webBlobInfo_)
 109       *webBlobInfo_ = webBlobInfo;
 110   }
 111
 112  private:
 113   IndexedDBKey* key_;
 114   WebVector<WebBlobInfo>* webBlobInfo_;
 115 };
 116
 117 }  // namespace
 118
 119 class WebIDBCursorImplTest : public testing::Test {
 120  public:
 121   WebIDBCursorImplTest() {
 122     null_key_.assignNull();
 123     sync_message_filter_ = new IPC::SyncMessageFilter(NULL);
 124     thread_safe_sender_ = new ThreadSafeSender(
 125         base::MessageLoopProxy::current(), sync_message_filter_.get());
 126     dispatcher_ =
 127         make_scoped_ptr(new MockDispatcher(thread_safe_sender_.get()));
 128   }
 129
 130  protected:
 131   WebIDBKey null_key_;
 132   scoped_refptr<ThreadSafeSender> thread_safe_sender_;
 133   scoped_ptr<MockDispatcher> dispatcher_;
 134
 135  private:
 136   scoped_refptr<IPC::SyncMessageFilter> sync_message_filter_;
 137
 138   DISALLOW_COPY_AND_ASSIGN(WebIDBCursorImplTest);
 139 };
 140
 141 TEST_F(WebIDBCursorImplTest, PrefetchTest) {
 142   const int64 transaction_id = 1;
 143   {
 144     WebIDBCursorImpl cursor(WebIDBCursorImpl::kInvalidCursorId,
 145                             transaction_id,
 146                             thread_safe_sender_.get());
 147
 148     // Call continue() until prefetching should kick in.
 149     int continue_calls = 0;
 150     EXPECT_EQ(dispatcher_->continue_calls(), 0);
 151     for (int i = 0; i < WebIDBCursorImpl::kPrefetchContinueThreshold; ++i) {
 152       cursor.continueFunction(null_key_, new MockContinueCallbacks());
 153       EXPECT_EQ(++continue_calls, dispatcher_->continue_calls());
 154       EXPECT_EQ(0, dispatcher_->prefetch_calls());
 155     }
 156
 157     // Do enough repetitions to verify that the count grows each time,
 158     // but not so many that the maximum limit is hit.
 159     const int kPrefetchRepetitions = 5;
 160
 161     int expected_key = 0;
 162     int last_prefetch_count = 0;
 163     for (int repetitions = 0; repetitions < kPrefetchRepetitions;
 164          ++repetitions) {
 165       // Initiate the prefetch
 166       cursor.continueFunction(null_key_, new MockContinueCallbacks());
 167       EXPECT_EQ(continue_calls, dispatcher_->continue_calls());
 168       EXPECT_EQ(repetitions + 1, dispatcher_->prefetch_calls());
 169
 170       // Verify that the requested count has increased since last time.
 171       int prefetch_count = dispatcher_->last_prefetch_count();
 172       EXPECT_GT(prefetch_count, last_prefetch_count);
 173       last_prefetch_count = prefetch_count;
 174
 175       // Fill the prefetch cache as requested.
 176       std::vector<IndexedDBKey> keys;
 177       std::vector<IndexedDBKey> primary_keys(prefetch_count);
 178       std::vector<WebData> values(prefetch_count);
 179       std::vector<WebVector<WebBlobInfo> > blob_info;
 180       for (int i = 0; i < prefetch_count; ++i) {
 181         keys.push_back(IndexedDBKey(expected_key + i, WebIDBKeyTypeNumber));
 182         blob_info.push_back(
 183             WebVector<WebBlobInfo>(static_cast<size_t>(expected_key + i)));
 184       }
 185       cursor.SetPrefetchData(keys, primary_keys, values, blob_info);
 186
 187       // Note that the real dispatcher would call cursor->CachedContinue()
 188       // immediately after cursor->SetPrefetchData() to service the request
 189       // that initiated the prefetch.
 190
 191       // Verify that the cache is used for subsequent continue() calls.
 192       for (int i = 0; i < prefetch_count; ++i) {
 193         IndexedDBKey key;
 194         WebVector<WebBlobInfo> web_blob_info;
 195         cursor.continueFunction(
 196             null_key_, new MockContinueCallbacks(&key, &web_blob_info));
 197         EXPECT_EQ(continue_calls, dispatcher_->continue_calls());
 198         EXPECT_EQ(repetitions + 1, dispatcher_->prefetch_calls());
 199
 200         EXPECT_EQ(WebIDBKeyTypeNumber, key.type());
 201         EXPECT_EQ(expected_key, static_cast<int>(web_blob_info.size()));
 202         EXPECT_EQ(expected_key++, key.number());
 203       }
 204     }
 205   }
 206
 207   EXPECT_EQ(dispatcher_->destroyed_cursor_id(),
 208             WebIDBCursorImpl::kInvalidCursorId);
 209 }
 210
 211 TEST_F(WebIDBCursorImplTest, AdvancePrefetchTest) {
 212   const int64 transaction_id = 1;
 213   WebIDBCursorImpl cursor(WebIDBCursorImpl::kInvalidCursorId,
 214                           transaction_id,
 215                           thread_safe_sender_.get());
 216
 217   // Call continue() until prefetching should kick in.
 218   EXPECT_EQ(0, dispatcher_->continue_calls());
 219   for (int i = 0; i < WebIDBCursorImpl::kPrefetchContinueThreshold; ++i) {
 220     cursor.continueFunction(null_key_, new MockContinueCallbacks());
 221   }
 222   EXPECT_EQ(0, dispatcher_->prefetch_calls());
 223
 224   // Initiate the prefetch
 225   cursor.continueFunction(null_key_, new MockContinueCallbacks());
 226
 227   EXPECT_EQ(1, dispatcher_->prefetch_calls());
 228   EXPECT_EQ(static_cast<int>(WebIDBCursorImpl::kPrefetchContinueThreshold),
 229             dispatcher_->continue_calls());
 230   EXPECT_EQ(0, dispatcher_->advance_calls());
 231
 232   const int prefetch_count = dispatcher_->last_prefetch_count();
 233
 234   // Fill the prefetch cache as requested.
 235   int expected_key = 0;
 236   std::vector<IndexedDBKey> keys;
 237   std::vector<IndexedDBKey> primary_keys(prefetch_count);
 238   std::vector<WebData> values(prefetch_count);
 239   std::vector<WebVector<WebBlobInfo> > blob_info;
 240   for (int i = 0; i < prefetch_count; ++i) {
 241     keys.push_back(IndexedDBKey(expected_key + i, WebIDBKeyTypeNumber));
 242     blob_info.push_back(
 243         WebVector<WebBlobInfo>(static_cast<size_t>(expected_key + i)));
 244   }
 245   cursor.SetPrefetchData(keys, primary_keys, values, blob_info);
 246
 247   // Note that the real dispatcher would call cursor->CachedContinue()
 248   // immediately after cursor->SetPrefetchData() to service the request
 249   // that initiated the prefetch.
 250
 251   // Need at least this many in the cache for the test steps.
 252   ASSERT_GE(prefetch_count, 5);
 253
 254   // IDBCursor.continue()
 255   IndexedDBKey key;
 256   cursor.continueFunction(null_key_, new MockContinueCallbacks(&key));
 257   EXPECT_EQ(0, key.number());
 258
 259   // IDBCursor.advance(1)
 260   cursor.advance(1, new MockContinueCallbacks(&key));
 261   EXPECT_EQ(1, key.number());
 262
 263   // IDBCursor.continue()
 264   cursor.continueFunction(null_key_, new MockContinueCallbacks(&key));
 265   EXPECT_EQ(2, key.number());
 266
 267   // IDBCursor.advance(2)
 268   cursor.advance(2, new MockContinueCallbacks(&key));
 269   EXPECT_EQ(4, key.number());
 270
 271   EXPECT_EQ(0, dispatcher_->advance_calls());
 272
 273   // IDBCursor.advance(lots) - beyond the fetched amount
 274   cursor.advance(WebIDBCursorImpl::kMaxPrefetchAmount,
 275                  new MockContinueCallbacks(&key));
 276   EXPECT_EQ(1, dispatcher_->advance_calls());
 277   EXPECT_EQ(1, dispatcher_->prefetch_calls());
 278   EXPECT_EQ(static_cast<int>(WebIDBCursorImpl::kPrefetchContinueThreshold),
 279             dispatcher_->continue_calls());
 280 }
 281
 282 TEST_F(WebIDBCursorImplTest, PrefetchReset) {
 283   const int64 transaction_id = 1;
 284   WebIDBCursorImpl cursor(WebIDBCursorImpl::kInvalidCursorId,
 285                           transaction_id,
 286                           thread_safe_sender_.get());
 287
 288   // Call continue() until prefetching should kick in.
 289   int continue_calls = 0;
 290   EXPECT_EQ(dispatcher_->continue_calls(), 0);
 291   for (int i = 0; i < WebIDBCursorImpl::kPrefetchContinueThreshold; ++i) {
 292     cursor.continueFunction(null_key_, new MockContinueCallbacks());
 293     EXPECT_EQ(++continue_calls, dispatcher_->continue_calls());
 294     EXPECT_EQ(0, dispatcher_->prefetch_calls());
 295   }
 296
 297   // Initiate the prefetch
 298   cursor.continueFunction(null_key_, new MockContinueCallbacks());
 299   EXPECT_EQ(continue_calls, dispatcher_->continue_calls());
 300   EXPECT_EQ(1, dispatcher_->prefetch_calls());
 301   EXPECT_EQ(0, dispatcher_->reset_calls());
 302
 303   // Now invalidate it
 304   cursor.ResetPrefetchCache();
 305
 306   // No reset should have been sent since nothing has been received yet.
 307   EXPECT_EQ(0, dispatcher_->reset_calls());
 308
 309   // Fill the prefetch cache as requested.
 310   int prefetch_count = dispatcher_->last_prefetch_count();
 311   std::vector<IndexedDBKey> keys(prefetch_count);
 312   std::vector<IndexedDBKey> primary_keys(prefetch_count);
 313   std::vector<WebData> values(prefetch_count);
 314   std::vector<WebVector<WebBlobInfo> > blob_info(prefetch_count);
 315   cursor.SetPrefetchData(keys, primary_keys, values, blob_info);
 316
 317   // No reset should have been sent since prefetch data hasn't been used.
 318   EXPECT_EQ(0, dispatcher_->reset_calls());
 319
 320   // The real dispatcher would call cursor->CachedContinue(), so do that:
 321   scoped_ptr<WebIDBCallbacks> callbacks(new MockContinueCallbacks());
 322   cursor.CachedContinue(callbacks.get());
 323
 324   // Now the cursor should have reset the rest of the cache.
 325   EXPECT_EQ(1, dispatcher_->reset_calls());
 326   EXPECT_EQ(1, dispatcher_->last_used_count());
 327 }
 328
 329 }  // namespace content