Simple Cache: DoomEntriesBetween()

net/disk_cache/simple/simple_backend_impl.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_backend_impl.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/file_util.h"
 #include "base/location.h"
 #include "base/message_loop_proxy.h"
 #include "base/threading/worker_pool.h"
 #include "net/base/net_errors.h"
 #include "net/disk_cache/simple/simple_entry_impl.h"
 #include "net/disk_cache/simple/simple_index.h"
+#include "net/disk_cache/simple/simple_synchronous_entry.h"
 
 using base::FilePath;
 using base::MessageLoopProxy;
 using base::Time;
 using base::WorkerPool;
 using file_util::DirectoryExists;
 using file_util::CreateDirectory;
 
 namespace {
 
@@ skipping 38 matching lines @@
                                      path_,
                                      initialize_index_callback));
   return net::ERR_IO_PENDING;
 }
 
 net::CacheType SimpleBackendImpl::GetCacheType() const {
   return net::DISK_CACHE;
 }
 
 int32 SimpleBackendImpl::GetEntryCount() const {
-  NOTIMPLEMENTED();
-  return 0;
+  return index_->GetEntryCount();

[gavinp, 2013/04/17 07:41:18]

Nice. Can we perhaps do better still though: isn't the directory entry count
useful too, especially if we don't have an index?

(Perhaps another CL)

[felipeg, 2013/04/17 16:35:04]

In another CL, not this one, please.

Also, I could not find an elegant/fast way of getting the file count in a
directory in unix.
man 2 stat  doesnt have that.

[pasko-google - do not use, 2013/04/17 19:47:52]

This should work pretty fast:
DirReaderPosix reader(path_); while (reader.Next()) { count++; }

Though it requires an ifdef. So I suggest do nothing of this kind unless we
realize it is absolutely necessary. Cross the fingers and try to pass all tests.

 }
 
 int SimpleBackendImpl::OpenEntry(const std::string& key,
                                  Entry** entry,
                                  const CompletionCallback& callback) {
   return SimpleEntryImpl::OpenEntry(
       index_->AsWeakPtr(), path_, key, entry, callback);
 }
 
 int SimpleBackendImpl::CreateEntry(const std::string& key,
                                    Entry** entry,
                                    const CompletionCallback& callback) {
   return SimpleEntryImpl::CreateEntry(
       index_->AsWeakPtr(), path_, key, entry, callback);
 }
 
 int SimpleBackendImpl::DoomEntry(const std::string& key,
                                  const net::CompletionCallback& callback) {
   return SimpleEntryImpl::DoomEntry(index_->AsWeakPtr(), path_, key, callback);
 }
 
 int SimpleBackendImpl::DoomAllEntries(const CompletionCallback& callback) {
-  NOTIMPLEMENTED();
-  return net::ERR_FAILED;
+  return DoomEntriesBetween(Time(), Time(), callback);
+}
+
+void SimpleBackendImpl::IndexReadyForDoom(const Time initial_time,
+                                          const Time end_time,
+                                          const CompletionCallback& callback,
+                                          int result) {
+  if (result != net::OK) {
+    callback.Run(result);
+    return;
+  }
+  scoped_ptr<std::set<uint64> > key_hashes(
+      index_->PullEntriesBetween(initial_time, end_time));
+  // TODO(pasko): Doom all entries that are known to be open at the moment.
+  WorkerPool::PostTask(FROM_HERE,
+                       base::Bind(&SimpleSynchronousEntry::DoomEntrySet,
+                                  base::Passed(&key_hashes),
+                                  path_,
+                                  MessageLoopProxy::current(),
+                                  callback),
+                       true);
 }
 
 int SimpleBackendImpl::DoomEntriesBetween(
     const Time initial_time,
     const Time end_time,
     const CompletionCallback& callback) {
-  NOTIMPLEMENTED();
-  return net::ERR_FAILED;
+  return index_->ExecuteWhenReady(
+      base::Bind(&SimpleBackendImpl::IndexReadyForDoom, AsWeakPtr(),
+                 initial_time, end_time, callback));
 }
 
 int SimpleBackendImpl::DoomEntriesSince(
     const Time initial_time,
     const CompletionCallback& callback) {
-  NOTIMPLEMENTED();
-  return net::ERR_FAILED;
+  return DoomEntriesBetween(initial_time, Time(), callback);
 }
 
 int SimpleBackendImpl::OpenNextEntry(void** iter,
                                      Entry** next_entry,
                                      const CompletionCallback& callback) {
   NOTIMPLEMENTED();
   return net::ERR_FAILED;
 }
 
 void SimpleBackendImpl::EndEnumeration(void** iter) {
   NOTIMPLEMENTED();
 }
 
 void SimpleBackendImpl::GetStats(
     std::vector<std::pair<std::string, std::string> >* stats) {
   NOTIMPLEMENTED();
 }
 
 void SimpleBackendImpl::OnExternalCacheHit(const std::string& key) {
-  NOTIMPLEMENTED();
+  index_->UseIfExists(key);

[gavinp, 2013/04/17 07:41:18]

Nice!

 }
 
 void SimpleBackendImpl::InitializeIndex(
     const CompletionCallback& callback, int result) {
   if (result == net::OK)
     index_->Initialize();
   callback.Run(result);
 }
 
 // static
 void SimpleBackendImpl::CreateDirectory(
     MessageLoopProxy* io_thread,
     const base::FilePath& path,
     const InitializeIndexCallback& initialize_index_callback) {
   int rv = net::OK;
   if (!file_util::PathExists(path) && !file_util::CreateDirectory(path)) {
     LOG(ERROR) << "Simple Cache Backend: failed to create: " << path.value();
     rv = net::ERR_FAILED;
   }
 
   io_thread->PostTask(FROM_HERE, base::Bind(initialize_index_callback, rv));
 }
 
 }  // namespace disk_cache