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 156 matching lines @@
                                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() {
   DCHECK(thread_checker_.CalledOnValidThread());
-  if (!synchronous_entry_) {
-    NOTIMPLEMENTED() << ": Overlapping an asynchronous operation.";
-    return;
-  }
-  WorkerPool::PostTask(FROM_HERE,
-                       base::Bind(&SimpleSynchronousEntry::DoomAndClose,
-                                  base::Unretained(ReleaseSynchronousEntry())),
-                       true);
-  has_been_doomed_ = true;
+#if defined(OS_WIN)

[felipeg, 2013/02/12 13:36:56]

For windows we could fallback to the previous implementation (synchronous with
that boolean var).

[gavinp, 2013/02/12 16:36:31]

Hmmm. But I've removed SimpleSynchronousEntry::DoomAndClose(). Do we really want
too maintain parallel implementations this early?

+  NOTIMPLEMENTED();
+#else
+  // This implementation depends on POSIX file erasure semantics working.

[felipeg, 2013/02/12 13:36:56]

Maybe adding a little bit more info here would be good.
Such as the comment on your cl.

[gavinp, 2013/02/12 16:36:31]

Done.

+  DoomEntry(path_, key_, CompletionCallback());
+#endif
 }
 
 void SimpleEntryImpl::Close() {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (!synchronous_entry_) {
     NOTIMPLEMENTED() << ": Overlapping an asynchronous operation.";
     delete this;
     return;
   }
-  if (!has_been_doomed_) {
-    WorkerPool::PostTask(FROM_HERE,
-                         base::Bind(&SimpleSynchronousEntry::Close,
-                                    base::Unretained(
-                                        ReleaseSynchronousEntry())),
-                         true);
-  }
+
+  WorkerPool::PostTask(FROM_HERE,
+                       base::Bind(&SimpleSynchronousEntry::Close,
+                                  base::Unretained(
+                                      ReleaseSynchronousEntry())),
+                       true);
   // Entry::Close() is expected to release this entry. See disk_cache.h for
   // details.
   delete this;
 }
 
 std::string SimpleEntryImpl::GetKey() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   return key_;
 }
 
@@ skipping 105 matching lines @@
   DCHECK(thread_checker_.CalledOnValidThread());
   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_(NULL),
-      has_been_doomed_(false) {
+      synchronous_entry_(NULL) {
   SetSynchronousEntry(synchronous_entry);
 }
 
 SimpleEntryImpl::~SimpleEntryImpl() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!synchronous_entry_) << "synchronous_entry_ = " << synchronous_entry_;
 }
 
 SimpleSynchronousEntry* SimpleEntryImpl::ReleaseSynchronousEntry() {
   DCHECK(synchronous_entry_);
   SimpleSynchronousEntry* retval = synchronous_entry_;
   synchronous_entry_ = NULL;
   return retval;
 }
 
 void SimpleEntryImpl::SetSynchronousEntry(
     SimpleSynchronousEntry* synchronous_entry) {
   DCHECK(!synchronous_entry_) << "synchronous_entry_ = " << synchronous_entry_;
   synchronous_entry_ = synchronous_entry;
   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