Simple Cache: DoomEntriesBetween()

net/disk_cache/simple/simple_entry_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_entry_impl.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/location.h"
@@ skipping 16 matching lines @@
 
 namespace disk_cache {
 
 using base::FilePath;
 using base::MessageLoopProxy;
 using base::Time;
 using base::WeakPtr;
 using base::WorkerPool;
 
 // static
 int SimpleEntryImpl::OpenEntry(WeakPtr<SimpleIndex> index,

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

Do we need this parameter now? I think leave it alone though, since this has a
big conflict with a CL I'm working on (add refcounting).

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

As Felipe suggests in another comment we should look at the index here.

                                const FilePath& path,
                                const std::string& key,
                                Entry** entry,
                                const CompletionCallback& callback) {
   // TODO(gavinp): More closely unify the last_used_ in the
   // SimpleSynchronousEntry  and the SimpleIndex.
-  if (!index || index->UseIfExists(key)) {

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

please keep this
and use the method index->Has(key) instead

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

Oh yes, that's the whole purpose of the index: quickly answer if we do not have
stuff.

I inverted the condition since it looks nicer that way, also removed the
TODO(gavinp) above since we have basically the same TODO(felipeg) below in a
more relevant place.

Done.

This reminds me of stale index (not knowing about new entries added), that would
fail the open, which may be not ideal for offline reading. Detecting a stale
index is not trivial, so I would not even add a TODO for adding a histogram
here. Thanks, now I have a creepy feeling that is not easy to fix.

[felipeg, 2013/04/18 09:54:59]

A stale and valid index (with the correct file entries and CRC) should be really
really rare.
And our garbage collector will take care of getting rid of it from time to time.
(I am working in the GC CL).

And I strongly suggest we have a histogram here, we need numbers to justify
having the index.

-    SynchronousCreationCallback sync_creation_callback =
-        base::Bind(&SimpleEntryImpl::CreationOperationComplete,
-                   index, callback, key, entry);
-    WorkerPool::PostTask(FROM_HERE,
-                         base::Bind(&SimpleSynchronousEntry::OpenEntry, path,
-                                    key, MessageLoopProxy::current(),
-                                    sync_creation_callback),
-                         true);
-    return net::ERR_IO_PENDING;
-  }
-  return net::ERR_FAILED;
+  SynchronousCreationCallback sync_creation_callback =
+      base::Bind(&SimpleEntryImpl::CreationOperationComplete,
+                 index, callback, key, entry);
+  WorkerPool::PostTask(FROM_HERE,
+                       base::Bind(&SimpleSynchronousEntry::OpenEntry, path,
+                                  key, MessageLoopProxy::current(),
+                                  sync_creation_callback),
+                       true);
+  return net::ERR_IO_PENDING;
 }
 
 // static
 int SimpleEntryImpl::CreateEntry(WeakPtr<SimpleIndex> index,
                                  const FilePath& path,
                                  const std::string& key,
                                  Entry** entry,
                                  const CompletionCallback& callback) {
   SynchronousCreationCallback sync_creation_callback =
       base::Bind(&SimpleEntryImpl::CreationOperationComplete,
@@ skipping 247 matching lines @@
   // adding an IO thread index (for fast misses etc...), we can store this data
   // in that structure. This also solves problems with last_used() on ext4
   // filesystems not being accurate.
   last_used_ = synchronous_entry_->last_used();
   last_modified_ = synchronous_entry_->last_modified();
   for (int i = 0; i < kSimpleEntryFileCount; ++i)
     data_size_[i] = synchronous_entry_->data_size(i);
 }
 
 }  // namespace disk_cache