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 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_in_use_by_worker_) {
-    NOTIMPLEMENTED() << ": Overlapping an asynchronous operation.";
-    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

[rvargas (doing something else), 2013/02/13 03:23:46]

I think this is wrong, but it is also wrong on the base CL and should be fixed
over there.

This is sort of a step in the right direction, but ReadData(old_content) must
succeed after doom, not just being able to keep writing (and reading) new
content.

[felipeg, 2013/02/13 13:47:36]

Hi Ricardo,

Sorry, why ReaData(old_content) will not succeed to read the content that was
previously stored in the file (before being deleted by the Doom call) ?
I think POSIX semantics says that as long as you have the file opened by the
process you can still read the contents even if other process deleted it.
Am I wrong ?

+  // 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() {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (synchronous_entry_in_use_by_worker_) {
     NOTIMPLEMENTED() << ": Overlapping an asynchronous operation.";
     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 {
   DCHECK(thread_checker_.CalledOnValidThread());
   return key_;
 }
 
@@ skipping 110 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_(NULL),
-      synchronous_entry_in_use_by_worker_(false),
-      has_been_doomed_(false) {
+      synchronous_entry_in_use_by_worker_(false) {
   SetSynchronousData();
 }
 
 SimpleEntryImpl::~SimpleEntryImpl() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!synchronous_entry_) << "synchronous_entry_ = " << synchronous_entry_;
 }
 
 // static
 void SimpleEntryImpl::CreationOperationComplete(
@@ skipping 39 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