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

content/browser/indexed_db/leveldb/leveldb_transaction_unittest.cc

 // Copyright 2017 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 <stddef.h>
 
 #include <algorithm>
 #include <cstring>
 #include <string>
 
 #include "base/files/file.h"
 #include "base/files/file_path.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/string_piece.h"
 #include "content/browser/indexed_db/leveldb/leveldb_comparator.h"
 #include "content/browser/indexed_db/leveldb/leveldb_database.h"
 #include "content/browser/indexed_db/leveldb/leveldb_env.h"
 #include "content/browser/indexed_db/leveldb/leveldb_iterator.h"
 #include "content/browser/indexed_db/leveldb/leveldb_transaction.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/leveldatabase/env_chromium.h"
 
 namespace content {
 
 namespace {
+static const size_t kTestingMaxOpenCursors = 3;
 
 class SimpleComparator : public LevelDBComparator {
  public:
   int Compare(const base::StringPiece& a,
               const base::StringPiece& b) const override {
     size_t len = std::min(a.size(), b.size());
     return memcmp(a.begin(), b.begin(), len);
   }
   const char* Name() const override { return "temp_comparator"; }
 };
 
+}  // namespace
+
 class LevelDBTransactionTest : public testing::Test {
  public:
   LevelDBTransactionTest() {}
   void SetUp() override {
     ASSERT_TRUE(temp_directory_.CreateUniqueTempDir());
-    LevelDBDatabase::Open(temp_directory_.GetPath(), &comparator_, &leveldb_);
+    leveldb::Status s =
+        LevelDBDatabase::Open(temp_directory_.GetPath(), &comparator_,
+                              &leveldb_, kTestingMaxOpenCursors);
+    ASSERT_TRUE(s.ok());
     ASSERT_TRUE(leveldb_);
   }
   void TearDown() override {}
 
  protected:
   // Convenience methods to access the database outside any
   // transaction to cut down on boilerplate around calls.
   void Put(const base::StringPiece& key, const std::string& value) {
     std::string put_value = value;
     leveldb::Status s = leveldb_->Put(key, &put_value);
@@ skipping 35 matching lines @@
     std::string put_value = value;
     transaction->Put(key, &put_value);
   }
 
   int Compare(const base::StringPiece& a, const base::StringPiece& b) const {
     return comparator_.Compare(a, b);
   }
 
   LevelDBDatabase* db() { return leveldb_.get(); }
 
+  scoped_refptr<LevelDBTransaction> CreateTransaction() {
+    return new LevelDBTransaction(db());
+  }
+
  private:
   base::ScopedTempDir temp_directory_;
   SimpleComparator comparator_;
   std::unique_ptr<LevelDBDatabase> leveldb_;
 
   DISALLOW_COPY_AND_ASSIGN(LevelDBTransactionTest);
 };
 
-}  // namespace
-
 TEST_F(LevelDBTransactionTest, GetAndPut) {
   leveldb::Status status;
 
   const std::string key("key");
   std::string got_value;
 
   const std::string old_value("value");
   Put(key, old_value);
 
   scoped_refptr<LevelDBTransaction> transaction = new LevelDBTransaction(db());
@@ skipping 84 matching lines @@
 
   Get(key1, &got_value, &found);
   EXPECT_TRUE(found);
   EXPECT_EQ(value1, got_value);
 
   Get(key2, &got_value, &found);
   EXPECT_TRUE(found);
   EXPECT_EQ(value3, got_value);
 }
 
+TEST_F(LevelDBTransactionTest, IterationWithEvictedCursors) {
+  leveldb::Status status;
+
+  const std::string key1("key1");

[pwnall, 2017/03/24 09:16:03]

You don't seem to reuse these strings (which is perfectly fine, the literals are
expressive enough). How about inlining them in the Put calls below?

[dmurph, 2017/03/24 23:33:39]

Done.

+  const std::string key2("key2");
+  const std::string key3("key3");
+  const std::string value1("value1");
+  const std::string value2("value2");
+  const std::string value3("value3");
+
+  Put(key1, value1);
+  Put(key2, value2);
+  Put(key3, value3);
+
+  scoped_refptr<LevelDBTransaction> transaction = CreateTransaction();
+
+  std::unique_ptr<LevelDBIterator> evicted_normal_location =
+      transaction->CreateIterator();
+
+  std::unique_ptr<LevelDBIterator> evicted_before_start =
+      transaction->CreateIterator();
+
+  std::unique_ptr<LevelDBIterator> evicted_after_end =
+      transaction->CreateIterator();
+
+  std::unique_ptr<LevelDBIterator> it1 = transaction->CreateIterator();
+  std::unique_ptr<LevelDBIterator> it2 = transaction->CreateIterator();
+  std::unique_ptr<LevelDBIterator> it3 = transaction->CreateIterator();
+
+  evicted_normal_location->Seek("key1");
+  evicted_before_start->Seek("key1");
+  evicted_before_start->Prev();
+  evicted_after_end->SeekToLast();
+  evicted_after_end->Next();
+
+  // Nothing is purged, as we just have 3 iterators used.
+  EXPECT_FALSE(evicted_normal_location->IsEvicted());
+  EXPECT_FALSE(evicted_before_start->IsEvicted());
+  EXPECT_FALSE(evicted_after_end->IsEvicted());
+  EXPECT_FALSE(evicted_before_start->IsValid());
+  EXPECT_FALSE(evicted_after_end->IsValid());
+
+  // Should purge all of our earlier iterators.
+  it1->Seek("key1");
+  it2->Seek("key2");
+  it3->Seek("key3");
+
+  EXPECT_TRUE(evicted_normal_location->IsEvicted());
+  EXPECT_TRUE(evicted_before_start->IsEvicted());
+  EXPECT_TRUE(evicted_after_end->IsEvicted());
+
+  // Check we don't need to reload for just the key.
+  EXPECT_EQ(key1, evicted_normal_location->Key());
+  EXPECT_TRUE(evicted_normal_location->IsEvicted());
+
+  // Make sure iterators are reloaded correctly.
+  EXPECT_TRUE(evicted_normal_location->IsValid());
+  EXPECT_EQ(value1, evicted_normal_location->Value());
+  EXPECT_FALSE(evicted_normal_location->IsEvicted());
+  EXPECT_FALSE(evicted_before_start->IsValid());
+  EXPECT_FALSE(evicted_after_end->IsValid());
+
+  // And our |Value()| call purged the earlier iterator.
+  EXPECT_TRUE(it1->IsEvicted());
+}
+
 namespace {
 enum RangePrepareMode {
   DataInMemory,
   DataInDatabase,
   DataMixed,
 };
 }  // namespace
 
 class LevelDBTransactionRangeTest
     : public LevelDBTransactionTest,
@@ skipping 131 matching lines @@
   EXPECT_EQ(Compare(key_after_range_, it->Key()), 0);
 }
 
 INSTANTIATE_TEST_CASE_P(LevelDBTransactionRangeTests,
                         LevelDBTransactionRangeTest,
                         ::testing::Values(DataInMemory,
                                           DataInDatabase,
                                           DataMixed));
 
 }  // namespace content