Make SimpleEntryImpl::Doom() completely asynchronous.

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 56 matching lines @@
                                const std::string& key,
                                const CompletionCallback& callback) {
   WorkerPool::PostTask(FROM_HERE,
                        base::Bind(&SimpleSynchronousEntry::DoomEntry, path, key,
                                   MessageLoopProxy::current(), callback),
                        true);
   return net::ERR_IO_PENDING;
 }
 
 void SimpleEntryImpl::Doom() {
-  if (synchronous_entry_in_use_by_worker_) {
-    NOTIMPLEMENTED();
-    return;
-  }
-  WorkerPool::PostTask(FROM_HERE,
-                       base::Bind(&SimpleSynchronousEntry::DoomAndClose,
-                                  base::Unretained(synchronous_entry_)),
-                       true);
-  synchronous_entry_ = NULL;
-  has_been_doomed_ = true;
+#if defined(OS_POSIX)
+  // This call to static SimpleEntryImpl::DoomEntry() will just erase the
+  // underlying files. On POSIX, this is fine; the files are still open on the
+  // SimpleSynchronousEntry, and operations can even happen on them. The files
+  // will be removed from the filesystem when they are closed.
+  DoomEntry(path_, key_, CompletionCallback());
+#else
+  NOTIMPLEMENTED();
+#endif
 }
 
 void SimpleEntryImpl::Close() {
   if (synchronous_entry_in_use_by_worker_) {
     NOTIMPLEMENTED();
     delete this;
     return;
   }
-  DCHECK(synchronous_entry_ || has_been_doomed_);
-  if (!has_been_doomed_) {
-    WorkerPool::PostTask(FROM_HERE,
-                         base::Bind(&SimpleSynchronousEntry::Close,
-                                    base::Unretained(synchronous_entry_)),
-                         true);
-    synchronous_entry_ = NULL;
-  }
+  DCHECK(synchronous_entry_);
+  WorkerPool::PostTask(FROM_HERE,
+                       base::Bind(&SimpleSynchronousEntry::Close,
+                                  base::Unretained(synchronous_entry_)),
+                       true);
+  synchronous_entry_ = NULL;
   // Entry::Close() is expected to release this entry. See disk_cache.h for
   // details.
   delete this;
 }
 
 std::string SimpleEntryImpl::GetKey() const {
   return key_;
 }
 
 Time SimpleEntryImpl::GetLastUsed() const {
@@ skipping 98 matching lines @@
   NOTIMPLEMENTED();
   return net::ERR_FAILED;
 }
 
 SimpleEntryImpl::SimpleEntryImpl(
     SimpleSynchronousEntry* synchronous_entry)
     : ALLOW_THIS_IN_INITIALIZER_LIST(weak_ptr_factory_(this)),
       path_(synchronous_entry->path()),
       key_(synchronous_entry->key()),
       synchronous_entry_(synchronous_entry),
-      synchronous_entry_in_use_by_worker_(false),
-      has_been_doomed_(false) {
+      synchronous_entry_in_use_by_worker_(false) {
   DCHECK(synchronous_entry);
   SetSynchronousData();
 }
 
 SimpleEntryImpl::~SimpleEntryImpl() {
   DCHECK(!synchronous_entry_);
 }
 
 // static
 void SimpleEntryImpl::CreationOperationComplete(
@@ skipping 29 matching lines @@
   // 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