[IndexedDB] Pool and evict leveldb iterators, to save memory

content/browser/indexed_db/mock_browsertest_indexed_db_class_factory.cc

 // Copyright 2014 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/browser/indexed_db/mock_browsertest_indexed_db_class_factory.h"
 
 #include <stddef.h>
 #include <string>
 #include <utility>
 
@@ skipping 149 matching lines @@
 
   FunctionTracer commit_tracer_;
   FunctionTracer get_tracer_;
 };
 
 const std::string LevelDBTraceTransaction::s_class_name = "LevelDBTransaction";
 
 class LevelDBTraceIteratorImpl : public LevelDBIteratorImpl {
  public:
   LevelDBTraceIteratorImpl(std::unique_ptr<leveldb::Iterator> iterator,
+                           LevelDBDatabase* db,
+                           const leveldb::Snapshot* snapshot,
                            int inst_num)
-      : LevelDBIteratorImpl(std::move(iterator)),
+      : LevelDBIteratorImpl(std::move(iterator), db, snapshot),
         is_valid_tracer_(s_class_name, "IsValid", inst_num),
         seek_to_last_tracer_(s_class_name, "SeekToLast", inst_num),
         seek_tracer_(s_class_name, "Seek", inst_num),
         next_tracer_(s_class_name, "Next", inst_num),
         prev_tracer_(s_class_name, "Prev", inst_num),
         key_tracer_(s_class_name, "Key", inst_num),
         value_tracer_(s_class_name, "Value", inst_num) {}
   ~LevelDBTraceIteratorImpl() override {}
 
  private:
@@ skipping 35 matching lines @@
   mutable FunctionTracer prev_tracer_;
   mutable FunctionTracer key_tracer_;
   mutable FunctionTracer value_tracer_;
 };
 
 const std::string LevelDBTraceIteratorImpl::s_class_name = "LevelDBIterator";
 
 class LevelDBTestIteratorImpl : public content::LevelDBIteratorImpl {
  public:
   LevelDBTestIteratorImpl(std::unique_ptr<leveldb::Iterator> iterator,
+                          LevelDBDatabase* db,
+                          const leveldb::Snapshot* snapshot,
                           FailMethod fail_method,
                           int fail_on_call_num)
-      : LevelDBIteratorImpl(std::move(iterator)),
+      : LevelDBIteratorImpl(std::move(iterator), db, snapshot),
         fail_method_(fail_method),
         fail_on_call_num_(fail_on_call_num),
         current_call_num_(0) {}
   ~LevelDBTestIteratorImpl() override {}
 
  private:
   leveldb::Status Seek(const base::StringPiece& target) override {
     if (fail_method_ != FAIL_METHOD_SEEK ||
         ++current_call_num_ != fail_on_call_num_)
       return LevelDBIteratorImpl::Seek(target);
@@ skipping 52 matching lines @@
           failure_method_,
           fail_on_call_num_[FAIL_CLASS_LEVELDB_TRANSACTION]);
     } else {
       return IndexedDBClassFactory::CreateLevelDBTransaction(db);
     }
   }
 }
 
 std::unique_ptr<LevelDBIteratorImpl>
 MockBrowserTestIndexedDBClassFactory::CreateIteratorImpl(
-    std::unique_ptr<leveldb::Iterator> iterator) {
+    std::unique_ptr<leveldb::Iterator> iterator,
+    LevelDBDatabase* db,
+    const leveldb::Snapshot* snapshot) {
   instance_count_[FAIL_CLASS_LEVELDB_ITERATOR] =
       instance_count_[FAIL_CLASS_LEVELDB_ITERATOR] + 1;
   if (only_trace_calls_) {
     return base::MakeUnique<LevelDBTraceIteratorImpl>(
-        std::move(iterator), instance_count_[FAIL_CLASS_LEVELDB_ITERATOR]);
+        std::move(iterator), db, snapshot,
+        instance_count_[FAIL_CLASS_LEVELDB_ITERATOR]);
   } else {
     if (failure_class_ == FAIL_CLASS_LEVELDB_ITERATOR &&
         instance_count_[FAIL_CLASS_LEVELDB_ITERATOR] ==
             fail_on_instance_num_[FAIL_CLASS_LEVELDB_ITERATOR]) {
       return base::MakeUnique<LevelDBTestIteratorImpl>(
-          std::move(iterator), failure_method_,
+          std::move(iterator), db, snapshot, failure_method_,
           fail_on_call_num_[FAIL_CLASS_LEVELDB_ITERATOR]);
     } else {
-      return base::WrapUnique(new LevelDBIteratorImpl(std::move(iterator)));
+      return base::WrapUnique(
+          new LevelDBIteratorImpl(std::move(iterator), db, snapshot));
     }
   }
 }
 
 void MockBrowserTestIndexedDBClassFactory::FailOperation(
     FailClass failure_class,
     FailMethod failure_method,
     int fail_on_instance_num,
     int fail_on_call_num) {
   VLOG(0) << "FailOperation: class=" << failure_class
@@ skipping 11 matching lines @@
 
 void MockBrowserTestIndexedDBClassFactory::Reset() {
   failure_class_ = FAIL_CLASS_NOTHING;
   failure_method_ = FAIL_METHOD_NOTHING;
   instance_count_.clear();
   fail_on_instance_num_.clear();
   fail_on_call_num_.clear();
 }
 
 }  // namespace content