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

content/browser/indexed_db/leveldb/leveldb_transaction.cc

 // Copyright (c) 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/browser/indexed_db/leveldb/leveldb_transaction.h"
 
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/time/time.h"
@@ skipping 23 matching lines @@
 LevelDBTransaction::LevelDBTransaction(LevelDBDatabase* db)
     : db_(db),
       snapshot_(db),
       comparator_(db->Comparator()),
       data_comparator_(comparator_),
       data_(data_comparator_) {}
 
 LevelDBTransaction::Record::Record() {}
 LevelDBTransaction::Record::~Record() {}
 
-LevelDBTransaction::~LevelDBTransaction() {}
+LevelDBTransaction::~LevelDBTransaction() {
+  for (TransactionIterator* iter : iterators_) {
+    db_->NotifyIteratorDestroyed(iter);
+  }
+}
 
 void LevelDBTransaction::Set(const StringPiece& key,
                              std::string* value,
                              bool deleted) {
   DCHECK(!finished_);
   DataType::iterator it = data_.find(key);
 
   if (it == data_.end()) {
     std::unique_ptr<Record> record = base::MakeUnique<Record>();
     record->key.assign(key.begin(), key.end() - key.begin());
@@ skipping 186 matching lines @@
 
 LevelDBTransaction::TransactionIterator::~TransactionIterator() {
   transaction_->UnregisterIterator(this);
 }
 
 bool LevelDBTransaction::TransactionIterator::IsValid() const {
   return !!current_;
 }
 
 leveldb::Status LevelDBTransaction::TransactionIterator::SeekToLast() {
+  LoadDBIteratorIfEvicted();
   leveldb::Status s = data_iterator_->SeekToLast();
   DCHECK(s.ok());
   s = db_iterator_->SeekToLast();
   if (!s.ok())
     return s;
   direction_ = REVERSE;
 
   HandleConflictsAndDeletes();
   SetCurrentIteratorToLargestKey();
   return s;
 }
 
 leveldb::Status LevelDBTransaction::TransactionIterator::Seek(
     const StringPiece& target) {
+  LoadDBIteratorIfEvicted();
   leveldb::Status s = data_iterator_->Seek(target);
   DCHECK(s.ok());
   s = db_iterator_->Seek(target);
   if (!s.ok())
     return s;
   direction_ = FORWARD;
 
   HandleConflictsAndDeletes();
   SetCurrentIteratorToSmallestKey();
   return s;
 }
 
 leveldb::Status LevelDBTransaction::TransactionIterator::Next() {
+  LoadDBIteratorIfEvicted();
   DCHECK(IsValid());
   if (data_changed_)
     RefreshDataIterator();
 
   leveldb::Status s;
   if (direction_ != FORWARD) {
     // Ensure the non-current iterator is positioned after Key().
 
     LevelDBIterator* non_current = (current_ == db_iterator_.get())
                                        ? data_iterator_.get()
@@ skipping 16 matching lines @@
 
   s = current_->Next();
   if (!s.ok())
     return s;
   HandleConflictsAndDeletes();
   SetCurrentIteratorToSmallestKey();
   return leveldb::Status::OK();
 }
 
 leveldb::Status LevelDBTransaction::TransactionIterator::Prev() {
+  LoadDBIteratorIfEvicted();
   DCHECK(IsValid());
   leveldb::Status s;
   if (data_changed_)
     RefreshDataIterator();
 
   if (direction_ != REVERSE) {
     // Ensure the non-current iterator is positioned before Key().
 
     LevelDBIterator* non_current = (current_ == db_iterator_.get())
                                        ? data_iterator_.get()
@@ skipping 23 matching lines @@
     return s;
   HandleConflictsAndDeletes();
   SetCurrentIteratorToLargestKey();
   return leveldb::Status::OK();
 }
 
 StringPiece LevelDBTransaction::TransactionIterator::Key() const {
   DCHECK(IsValid());
   if (data_changed_)
     RefreshDataIterator();
+  if (current_ == db_iterator_.get() && is_evicted_) {
+    return key_after_eviction_;
+  }
   return current_->Key();
 }
 
 StringPiece LevelDBTransaction::TransactionIterator::Value() const {
   DCHECK(IsValid());
   if (data_changed_)
     RefreshDataIterator();
+  if (current_ == db_iterator_.get()) {
+    const_cast<LevelDBTransaction::TransactionIterator*>(this)
+        ->LoadDBIteratorIfEvicted();
+  }
   return current_->Value();
 }
 
+void LevelDBTransaction::TransactionIterator::EvictWorkingMemory() {
+  DCHECK(!is_evicted_);
+  is_evicted_ = true;
+  key_after_eviction_ = db_iterator_->Key().as_string();
+  db_iterator_.reset();
+}
+
 void LevelDBTransaction::TransactionIterator::DataChanged() {
   data_changed_ = true;
 }
 
 void LevelDBTransaction::TransactionIterator::Delete() {
   DCHECK(IsValid());
   if (current_ == data_iterator_.get()) {
     data_iterator_->Delete();
   } else {
     std::unique_ptr<Record> record = base::MakeUnique<Record>();
@@ skipping 27 matching lines @@
       // If going backward, seek to a key less than the db iterator.
       DCHECK_EQ(REVERSE, direction_);
       data_iterator_->Seek(db_iterator_->Key());
       if (data_iterator_->IsValid())
         data_iterator_->Prev();
     }
   }
 }
 
 bool LevelDBTransaction::TransactionIterator::DataIteratorIsLower() const {
+  DCHECK(!is_evicted_);
   return comparator_->Compare(data_iterator_->Key(), db_iterator_->Key()) < 0;
 }
 
 bool LevelDBTransaction::TransactionIterator::DataIteratorIsHigher() const {
+  DCHECK(!is_evicted_);
   return comparator_->Compare(data_iterator_->Key(), db_iterator_->Key()) > 0;
 }
 
+void LevelDBTransaction::TransactionIterator::LoadDBIteratorIfEvicted() {
+  transaction_->db_->NotifyIteratorUsed(this);
+  if (!is_evicted_)
+    return;
+
+  db_iterator_ = transaction_->db_->CreateIterator(&transaction_->snapshot_);
+  db_iterator_->Seek(key_after_eviction_);
+  key_after_eviction_.clear();
+  is_evicted_ = false;
+}
+
 void LevelDBTransaction::TransactionIterator::HandleConflictsAndDeletes() {
+  LoadDBIteratorIfEvicted();
   bool loop = true;
 
   while (loop) {
     loop = false;
 
     if (data_iterator_->IsValid() && db_iterator_->IsValid() &&
         !comparator_->Compare(data_iterator_->Key(), db_iterator_->Key())) {
       // For equal keys, the data iterator takes precedence, so move the
       // database iterator another step.
       if (direction_ == FORWARD)
@@ skipping 13 matching lines @@
                  (!db_iterator_->IsValid() || DataIteratorIsHigher())) {
         data_iterator_->Prev();
         loop = true;
       }
     }
   }
 }
 
 void
 LevelDBTransaction::TransactionIterator::SetCurrentIteratorToSmallestKey() {
+  DCHECK(!is_evicted_);
   LevelDBIterator* smallest = nullptr;
 
   if (data_iterator_->IsValid())
     smallest = data_iterator_.get();
 
   if (db_iterator_->IsValid()) {
     if (!smallest ||
         comparator_->Compare(db_iterator_->Key(), smallest->Key()) < 0)
       smallest = db_iterator_.get();
   }
@@ skipping 17 matching lines @@
 }
 
 void LevelDBTransaction::RegisterIterator(TransactionIterator* iterator) {
   DCHECK(iterators_.find(iterator) == iterators_.end());
   iterators_.insert(iterator);
 }
 
 void LevelDBTransaction::UnregisterIterator(TransactionIterator* iterator) {
   DCHECK(iterators_.find(iterator) != iterators_.end());
   iterators_.erase(iterator);
+  db_->NotifyIteratorDestroyed(iterator);
 }
 
 void LevelDBTransaction::NotifyIterators() {
   for (auto* transaction_iterator : iterators_)
     transaction_iterator->DataChanged();
 }
 
 std::unique_ptr<LevelDBDirectTransaction> LevelDBDirectTransaction::Create(
     LevelDBDatabase* db) {
   return base::WrapUnique(new LevelDBDirectTransaction(db));
@@ skipping 34 matching lines @@
 
   leveldb::Status s = db_->Write(*write_batch_);
   if (s.ok()) {
     finished_ = true;
     write_batch_->Clear();
   }
   return s;
 }
 
 }  // namespace content