Fix race condition for non-open/create operations happening after a doom.

net/disk_cache/simple/simple_entry_operation.cc

 // Copyright 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_operation.h"
 
 #include "base/logging.h"
 #include "net/base/io_buffer.h"
 #include "net/disk_cache/disk_cache.h"
 #include "net/disk_cache/simple/simple_entry_impl.h"
@@ skipping 10 matching lines @@
       type_(other.type_),
       have_index_(other.have_index_),
       index_(other.index_),
       truncate_(other.truncate_),
       optimistic_(other.optimistic_),
       alone_in_queue_(other.alone_in_queue_) {
 }
 
 SimpleEntryOperation::~SimpleEntryOperation() {}
 
-// Static.
+// static
 SimpleEntryOperation SimpleEntryOperation::OpenOperation(
     SimpleEntryImpl* entry,
     bool have_index,
     const CompletionCallback& callback,
     Entry** out_entry) {
   return SimpleEntryOperation(entry,
                               NULL,
                               callback,
                               out_entry,
                               0,
                               0,
                               TYPE_OPEN,
                               have_index,
                               0,
                               false,
                               false,
                               false);
 }
 
-// Static.
+// static
 SimpleEntryOperation SimpleEntryOperation::CreateOperation(
     SimpleEntryImpl* entry,
     bool have_index,
     const CompletionCallback& callback,
     Entry** out_entry) {
   return SimpleEntryOperation(entry,
                               NULL,
                               callback,
                               out_entry,
                               0,
                               0,
                               TYPE_CREATE,
                               have_index,
                               0,
                               false,
                               false,
                               false);
 }
 
-// Static.
+// static
 SimpleEntryOperation SimpleEntryOperation::CloseOperation(
     SimpleEntryImpl* entry) {
   return SimpleEntryOperation(entry,
                               NULL,
                               CompletionCallback(),
                               NULL,
                               0,
                               0,
                               TYPE_CLOSE,
                               false,
                               0,
                               false,
                               false,
                               false);
 }
 
-// Static.
+// static
 SimpleEntryOperation SimpleEntryOperation::ReadOperation(
     SimpleEntryImpl* entry,
     int index,
     int offset,
     int length,
     net::IOBuffer* buf,
     const CompletionCallback& callback,
     bool alone_in_queue) {
   return SimpleEntryOperation(entry,
                               buf,
                               callback,
                               NULL,
                               offset,
                               length,
                               TYPE_READ,
                               false,
                               index,
                               false,
                               false,
                               alone_in_queue);
 }
 
-// Static.
+// static
 SimpleEntryOperation SimpleEntryOperation::WriteOperation(
     SimpleEntryImpl* entry,
     int index,
     int offset,
     int length,
     net::IOBuffer* buf,
     bool truncate,
     bool optimistic,
     const CompletionCallback& callback) {
   return SimpleEntryOperation(entry,
                               buf,
                               callback,
                               NULL,
                               offset,
                               length,
                               TYPE_WRITE,
                               false,
                               index,
                               truncate,
                               optimistic,
                               false);
 }
 
+// static
+SimpleEntryOperation SimpleEntryOperation::DoomOperation(
+    SimpleEntryImpl* entry,
+    const CompletionCallback& callback) {
+  net::IOBuffer* const buf = NULL;
+  Entry** const out_entry = NULL;
+  const int offset = 0;
+  const int length = 0;
+  const bool have_index = false;
+  const int index = 0;
+  const bool truncate = false;
+  const bool optimistic = false;
+  const bool alone_in_queue = false;
+  return SimpleEntryOperation(entry,
+                              buf,
+                              callback,
+                              out_entry,
+                              offset,
+                              length,
+                              TYPE_DOOM,
+                              have_index,
+                              index,
+                              truncate,
+                              optimistic,
+                              alone_in_queue);
+}
+
 bool SimpleEntryOperation::ConflictsWith(
     const SimpleEntryOperation& other_op) const {
   if (type_ != TYPE_READ && type_ != TYPE_WRITE)
     return true;
   if (other_op.type() != TYPE_READ && other_op.type() != TYPE_WRITE)
     return true;
   if (type() == TYPE_READ && other_op.type() == TYPE_READ)
     return false;
   if (index_ != other_op.index_)
     return false;
@@ skipping 30 matching lines @@
       length_(length),
       type_(type),
       have_index_(have_index),
       index_(index),
       truncate_(truncate),
       optimistic_(optimistic),
       alone_in_queue_(alone_in_queue) {
 }
 
 }  // namespace disk_cache