Simple Cache: DoomEntriesBetween()

net/disk_cache/simple/simple_index.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 "net/disk_cache/simple/simple_index.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 59 matching lines @@
 }
 
 SimpleIndex::SimpleIndex(
     const scoped_refptr<base::TaskRunner>& cache_thread,
     const scoped_refptr<base::TaskRunner>& io_thread,
     const base::FilePath& path)
     : cache_size_(0),
       initialized_(false),
       index_filename_(path.AppendASCII("simple-index")),
       cache_thread_(cache_thread),
-      io_thread_(io_thread) {}
+      io_thread_(io_thread) {
+}
 
 SimpleIndex::~SimpleIndex() {
   DCHECK(io_thread_checker_.CalledOnValidThread());
+
+  // Fail all callbacks waiting for the index to come up.
+  for (CallbackList::iterator it = to_run_when_initialized_.begin(),
+       end = to_run_when_initialized_.end(); it != end; ++it) {
+    it->Run(net::ERR_ABORTED);
+  }
 }
 
 void SimpleIndex::Initialize() {
   DCHECK(io_thread_checker_.CalledOnValidThread());
   IndexCompletionCallback merge_callback =
       base::Bind(&SimpleIndex::MergeInitializingSet, this);
   base::WorkerPool::PostTask(FROM_HERE,
                              base::Bind(&SimpleIndex::LoadFromDisk,
                                         index_filename_,
                                         io_thread_,
                                         merge_callback),
                              true);
 }
 
+int SimpleIndex::ExecuteWhenReady(const net::CompletionCallback& task) {
+  DCHECK(io_thread_checker_.CalledOnValidThread());
+  if (initialized_)
+    io_thread_->PostTask(FROM_HERE, base::Bind(task, net::OK));
+  else
+    to_run_when_initialized_.push_back(task);
+  return net::ERR_IO_PENDING;
+}
+
+scoped_ptr<std::vector<uint64> > SimpleIndex::ExtractEntriesBetween(
+    const base::Time initial_time, const base::Time end_time) {
+  DCHECK_EQ(true, initialized_);
+  const base::Time extended_end_time =
+      end_time.is_null() ? base::Time::Max() : end_time;
+  DCHECK(extended_end_time >= initial_time);
+  scoped_ptr<std::vector<uint64> > ret_hashes(new std::vector<uint64>());
+  for (EntrySet::iterator it = entries_set_.begin(), end = entries_set_.end();
+       it != end;) {
+    EntryMetadata metadata = it->second;
+    base::Time entry_time = metadata.GetLastUsedTime();
+    if (initial_time <= entry_time && entry_time < extended_end_time) {
+      ret_hashes->push_back(metadata.GetHashKey());
+      entries_set_.erase(it++);
+    } else {
+      it++;
+    }
+  }
+  return ret_hashes.Pass();
+}
+
+int32 SimpleIndex::GetEntryCount() const {
+  // TODO(pasko): return a meaningful initial estimate before initialized.
+  return entries_set_.size();
+}
+
 void SimpleIndex::Insert(const std::string& key) {
   DCHECK(io_thread_checker_.CalledOnValidThread());
   // Upon insert we don't know yet the size of the entry.
   // It will be updated later when the SimpleEntryImpl finishes opening or
   // creating the new entry, and then UpdateEntrySize will be called.
   const uint64 hash_key = simple_util::GetEntryHashKey(key);
   InsertInEntrySet(EntryMetadata(hash_key, base::Time::Now(), 0),
                    &entries_set_);
   if (!initialized_)
     removed_entries_.erase(hash_key);
@@ skipping 156 matching lines @@
       // When Merging, existing valid data in the |current_entry| will prevail.
       current_entry->second.MergeWith(it->second);
       cache_size_ += current_entry->second.GetEntrySize();
     } else {
       InsertInEntrySet(it->second, &entries_set_);
       cache_size_ += it->second.GetEntrySize();
     }
   }
 
   initialized_ = true;
+
+  // Run all callbacks waiting for the index to come up.
+  for (CallbackList::iterator it = to_run_when_initialized_.begin(),
+       end = to_run_when_initialized_.end(); it != end; ++it) {
+    io_thread_->PostTask(FROM_HERE, base::Bind((*it), net::OK));
+  }
+  to_run_when_initialized_.clear();
 }
 
 void SimpleIndex::WriteToDisk() {
   DCHECK(io_thread_checker_.CalledOnValidThread());
   SimpleIndexFile::IndexMetadata index_metadata(entries_set_.size(),
                                                 cache_size_);
   scoped_ptr<Pickle> pickle = SimpleIndexFile::Serialize(index_metadata,
                                                          entries_set_);
   cache_thread_->PostTask(FROM_HERE, base::Bind(
       &SimpleIndex::WriteToDiskInternal,
       index_filename_,
       base::Passed(&pickle)));
 }
 
 }  // namespace disk_cache