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 21 matching lines @@
 using base::MessageLoopProxy;
 using base::Time;
 using base::WorkerPool;
 
 // static
 int SimpleEntryImpl::OpenEntry(SimpleIndex* index,
                                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)) {
-    scoped_refptr<SimpleEntryImpl> new_entry =
-        new SimpleEntryImpl(index, path, key);
-    SynchronousCreationCallback sync_creation_callback =
-        base::Bind(&SimpleEntryImpl::CreationOperationComplete,
-                   new_entry, entry, callback);
-    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;
+  // If entry is not known to the index, initiate fast failover to the network.
+  if (index && !index->Has(key))
+    return net::ERR_FAILED;
+
+  // Go down to the disk to find the entry.
+  scoped_refptr<SimpleEntryImpl> new_entry =
+      new SimpleEntryImpl(index, path, key);
+  SynchronousCreationCallback sync_creation_callback =
+      base::Bind(&SimpleEntryImpl::CreationOperationComplete,
+                 new_entry, entry, callback);
+  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(SimpleIndex* index,
                                  const FilePath& path,
                                  const std::string& key,
                                  Entry** entry,
                                  const CompletionCallback& callback) {
   scoped_refptr<SimpleEntryImpl> new_entry =
       new SimpleEntryImpl(index, path, key);
@@ skipping 300 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