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)

[gavinp, 2013/04/18 06:11:35]

This for loop needs braces.

[pasko-google - do not use, 2013/04/18 09:29:54]

Not required though. And I had an impression that Chromium prefers not to put
braces when it is not required. Apparently the rule is different. And not
documented. Thank you, Chromium reviewers.

It was so much easier to always put them, aaa letmealwaysputthebraces!

Done.

+    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;
+}
+
+std::set<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);
+  std::set<uint64>* ret_hashes = new std::set<uint64>();

[gavinp, 2013/04/18 06:11:35]

Can we make ret_hashes a scoped_ptr?

And it might be best to make the return type of ExtractEntriesBetween a
scoped_ptr, too.

[pasko-google - do not use, 2013/04/18 09:29:54]

Sure, I understand it may feel more cozy. Done.

+  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->insert(metadata.GetHashKey());
+      entries_set_.erase(it++);
+    } else {
+      it++;
+    }
+  }
+  return ret_hashes;
+}
+
+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