Merge r17560....

net/base/file_stream_win.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.
 
 #include "net/base/file_stream.h"
 
 #include <windows.h>
 
 #include "base/logging.h"
 #include "base/message_loop.h"
@@ skipping 32 matching lines @@
       LOG(WARNING) << "Unknown error " << err << " mapped to net::ERR_FAILED";
       return ERR_FAILED;
   }
 }
 
 // FileStream::AsyncContext ----------------------------------------------
 
 class FileStream::AsyncContext : public MessageLoopForIO::IOHandler {
  public:
   AsyncContext(FileStream* owner)
-      : owner_(owner), context_(), callback_(NULL) {
+      : owner_(owner), context_(), callback_(NULL), is_closing_(false) {
     context_.handler = this;
   }
   ~AsyncContext();
 
   void IOCompletionIsPending(CompletionCallback* callback);
 
   OVERLAPPED* overlapped() { return &context_.overlapped; }
   CompletionCallback* callback() const { return callback_; }
 
  private:
   virtual void OnIOCompleted(MessageLoopForIO::IOContext* context,
                              DWORD bytes_read, DWORD error);
 
   FileStream* owner_;
   MessageLoopForIO::IOContext context_;
   CompletionCallback* callback_;
+  bool is_closing_;
 };
 
 FileStream::AsyncContext::~AsyncContext() {
+  is_closing_ = true;
   bool waited = false;
   base::Time start = base::Time::Now();
   while (callback_) {
     waited = true;
     MessageLoopForIO::current()->WaitForIOCompletion(INFINITE, this);
   }
   if (waited) {
     // We want to see if we block the message loop for too long.
     UMA_HISTOGRAM_TIMES("AsyncIO.FileStreamClose", base::Time::Now() - start);
   }
 }
 
 void FileStream::AsyncContext::IOCompletionIsPending(
     CompletionCallback* callback) {
   DCHECK(!callback_);
   callback_ = callback;
 }
 
 void FileStream::AsyncContext::OnIOCompleted(
     MessageLoopForIO::IOContext* context, DWORD bytes_read, DWORD error) {
   DCHECK(&context_ == context);
   DCHECK(callback_);
 
+  if (is_closing_) {
+    callback_ = NULL;
+    return;
+  }
+
   int result = static_cast<int>(bytes_read);
   if (error && error != ERROR_HANDLE_EOF)
     result = MapErrorCode(error);
 
   if (bytes_read)
     IncrementOffset(&context->overlapped, bytes_read);
 
   CompletionCallback* temp = NULL;
   std::swap(temp, callback_);
   temp->Run(result);
@@ skipping 199 matching lines @@
     DWORD error = GetLastError();
     LOG(WARNING) << "SetEndOfFile failed: " << error;
     return MapErrorCode(error);
   }
 
   // Success.
   return seek_position;
 }
 
 }  // namespace net