Avoiding IO completion callback during the closing

net/base/file_stream_posix.cc

 // Copyright (c) 2008 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.
 
 // For 64-bit file access (off_t = off64_t, lseek64, etc).
 #define _FILE_OFFSET_BITS 64
 
 #include "net/base/file_stream.h"
 
 #include <sys/types.h>
@@ skipping 182 matching lines @@
 
   // This is used to synchronize between the AsyncContext destructor (which runs
   // on the IO thread and OnBackgroundIOCompleted() which runs on the WorkerPool
   // thread.
   base::WaitableEvent background_io_completed_;
 
   // These variables are only valid when background_io_completed is signaled.
   int result_;
   CancelableCallbackTask* message_loop_task_;
 
+  bool is_closing_;
+
   DISALLOW_COPY_AND_ASSIGN(AsyncContext);
 };
 
 FileStream::AsyncContext::AsyncContext()
     : message_loop_(MessageLoopForIO::current()),
       callback_(NULL),
       background_io_completed_callback_(
           this, &AsyncContext::OnBackgroundIOCompleted),
       background_io_completed_(true, false),
-      message_loop_task_(NULL) {}
+      message_loop_task_(NULL),
+      is_closing_(false) {}
 
 FileStream::AsyncContext::~AsyncContext() {
+  is_closing_ = true;
   if (callback_) {
     // If |callback_| is non-NULL, that implies either the worker thread is
     // still running the IO task, or the completion callback is queued up on the
     // MessageLoopForIO, but AsyncContext() got deleted before then.
     const bool need_to_wait = !background_io_completed_.IsSignaled();
     base::Time start = base::Time::Now();
     RunAsynchronousCallback();
     if (need_to_wait) {
       // We want to see if we block the message loop for too long.
       UMA_HISTOGRAM_TIMES("AsyncIO.FileStreamClose", base::Time::Now() - start);
@@ skipping 39 matching lines @@
   // Wait() here ensures that all modifications from the WorkerPool thread are
   // now visible.
   background_io_completed_.Wait();
 
   // Either we're in the MessageLoop's task, in which case Cancel() doesn't do
   // anything, or we're in ~AsyncContext(), in which case this prevents the call
   // from happening again.  Must do it here after calling Wait().
   message_loop_task_->Cancel();
   message_loop_task_ = NULL;
 
+  if (is_closing_) {
+    callback_ = NULL;
+    return;
+  }
+
   DCHECK(callback_);
   CompletionCallback* temp = NULL;
   std::swap(temp, callback_);
   background_io_completed_.Reset();
   temp->Run(result_);
 }
 
 // FileStream ------------------------------------------------------------
 
 FileStream::FileStream() : file_(base::kInvalidPlatformFileValue) {
@@ skipping 153 matching lines @@
   int64 seek_position = Seek(FROM_BEGIN, bytes);
   if (seek_position != bytes)
     return ERR_UNEXPECTED;
 
   // And truncate the file.
   int result = ftruncate(file_, bytes);
   return result == 0 ? seek_position : MapErrorCode(errno);
 }
 
 }  // namespace net