Simple Cache: DoomEntriesBetween()

net/disk_cache/simple/simple_synchronous_entry.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_synchronous_entry.h"
 
 #include <algorithm>
 #include <cstring>
 #include <limits>
 
@@ skipping 22 matching lines @@
 using base::PLATFORM_FILE_READ;
 using base::PLATFORM_FILE_WRITE;
 using base::ReadPlatformFile;
 using base::TaskRunner;
 using base::Time;
 using base::TruncatePlatformFile;
 using base::WritePlatformFile;
 
 namespace disk_cache {
 
+using simple_util::ConvertEntryHashKeyToHexString;
+using simple_util::GetEntryHashKeyAsHexString;
+using simple_util::GetFilenameFromHexStringAndIndex;
 using simple_util::GetFilenameFromKeyAndIndex;
 using simple_util::GetDataSizeFromKeyAndFileSize;
 using simple_util::GetFileSizeFromKeyAndDataSize;
 using simple_util::GetFileOffsetFromKeyAndDataOffset;
 
 // static
 void SimpleSynchronousEntry::OpenEntry(
     const FilePath& path,
     const std::string& key,
     const scoped_refptr<TaskRunner>& callback_runner,
@@ skipping 22 matching lines @@
     if (rv != net::ERR_FILE_EXISTS) {
       sync_entry->Doom();
     }
     delete sync_entry;
     sync_entry = NULL;
   }
   callback_runner->PostTask(FROM_HERE, base::Bind(callback, sync_entry));
 }
 
 // static
+bool SimpleSynchronousEntry::DeleteFilesForEntry(const FilePath& path,
+                                                 const std::string& hash_key) {
+  bool result = true;
+  for (int i = 0; i < kSimpleEntryFileCount; ++i) {
+    FilePath to_delete = path.AppendASCII(
+        GetFilenameFromHexStringAndIndex(hash_key, i));
+    if (!file_util::Delete(to_delete, false)) {
+      result = false;
+      DLOG(ERROR) << "Could not delete " << to_delete.MaybeAsASCII();
+    }
+  }
+  return result;
+}
+
+// static
 void SimpleSynchronousEntry::DoomEntry(
     const FilePath& path,
     const std::string& key,
     scoped_refptr<TaskRunner> callback_runner,
     const net::CompletionCallback& callback) {
-  for (int i = 0; i < kSimpleEntryFileCount; ++i) {
-    FilePath to_delete = path.AppendASCII(GetFilenameFromKeyAndIndex(key, i));
-    bool ALLOW_UNUSED result = file_util::Delete(to_delete, false);
-    DLOG_IF(ERROR, !result) << "Could not delete " << to_delete.MaybeAsASCII();
-  }
+  bool deleted_well = DeleteFilesForEntry(path,
+                                          GetEntryHashKeyAsHexString(key));
+  int result = deleted_well ? net::OK : net::ERR_FAILED;
   if (!callback.is_null())
-    callback_runner->PostTask(FROM_HERE, base::Bind(callback, net::OK));
+    callback_runner->PostTask(FROM_HERE, base::Bind(callback, result));
+}
+
+// static
+void SimpleSynchronousEntry::DoomEntrySet(
+    scoped_ptr<std::set<uint64> > key_hashes,
+    const FilePath& path,
+    scoped_refptr<TaskRunner> callback_runner,
+    const net::CompletionCallback& callback) {
+  bool deleted_well = true;
+  for (std::set<uint64>::const_iterator it = key_hashes->begin(),
+       end = key_hashes->end(); it != end; ++it)
+    deleted_well &= DeleteFilesForEntry(path,
+                                        ConvertEntryHashKeyToHexString((*it)));
+  int result = deleted_well ? net::OK : net::ERR_FAILED;
+  if (!callback.is_null())
+    callback_runner->PostTask(FROM_HERE, base::Bind(callback, result));
 }
 
 void SimpleSynchronousEntry::Close() {
   for (int i = 0; i < kSimpleEntryFileCount; ++i) {
     bool ALLOW_UNUSED result = ClosePlatformFile(files_[i]);
     DLOG_IF(INFO, !result) << "Could not Close() file.";
   }
   delete this;
 }
 
@@ skipping 187 matching lines @@
       DLOG(WARNING) << "Could not write keys to new cache entry.";
       return net::ERR_FAILED;
     }
   }
   initialized_ = true;
   return net::OK;
 }
 
 void SimpleSynchronousEntry::Doom() {
   // TODO(gavinp): Consider if we should guard against redundant Doom() calls.
   DoomEntry(path_, key_,

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

Should this call DeleteFilesForEntry now?

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

Yes. Nice. Done.

             scoped_refptr<base::TaskRunner>(), net::CompletionCallback());
 }
 
 }  // namespace disk_cache