net: Implement canceling of all async operations in FileStream.

net/base/file_stream_unittest.cc

 // Copyright (c) 2012 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 "base/bind.h"
 #include "base/callback.h"
 #include "base/file_util.h"
 #include "base/message_loop.h"
@@ skipping 304 matching lines @@
   if (rv < 0) {
     EXPECT_EQ(ERR_IO_PENDING, rv);
     // The callback should not be called if the request is cancelled.
     MessageLoop::current()->RunAllPending();
     EXPECT_FALSE(callback.have_result());
   } else {
     EXPECT_EQ(std::string(kTestData, rv), std::string(buf->data(), rv));
   }
 }
 
-// Similar to AsyncRead_EarlyDelete but using a given file handler rather than
-// calling FileStream::Open, to ensure that deleting a stream with in-flight
-// operation without auto-closing feature is also ok.
-TEST_F(FileStreamTest, AsyncRead_EarlyDelete_NoAutoClose) {
+// Similar to AsyncRead_EarlyDelete but calls CloseAndCancelAsync() instead,
+// to ensure that it works as expected while an async read is in flight.
+TEST_F(FileStreamTest, AsyncRead_CloseAndCancelAsync) {
   int64 file_size;
   bool ok = file_util::GetFileSize(temp_file_path(), &file_size);
   EXPECT_TRUE(ok);
 
-  bool created = false;
+  scoped_ptr<FileStream> stream(new FileStream(NULL));
   int flags = base::PLATFORM_FILE_OPEN |
               base::PLATFORM_FILE_READ |
               base::PLATFORM_FILE_ASYNC;
-  base::PlatformFileError error_code = base::PLATFORM_FILE_ERROR_FAILED;
-  base::PlatformFile file = base::CreatePlatformFile(
-      temp_file_path(), flags, &created, &error_code);
-  EXPECT_EQ(base::PLATFORM_FILE_OK, error_code);
+  TestCompletionCallback callback;
+  int rv = stream->Open(temp_file_path(), flags, callback.callback());
+  EXPECT_EQ(ERR_IO_PENDING, rv);
+  EXPECT_EQ(OK, callback.WaitForResult());
 
-  scoped_ptr<FileStream> stream(new FileStream(file, flags, NULL));
   int64 total_bytes_avail = stream->Available();
   EXPECT_EQ(file_size, total_bytes_avail);
 
-  TestCompletionCallback callback;
   scoped_refptr<IOBufferWithSize> buf = new IOBufferWithSize(4);
-  int rv = stream->Read(buf, buf->size(), callback.callback());
-  stream.reset();  // Delete instead of closing it.
+  rv = stream->Read(buf, buf->size(), callback.callback());
+  stream->CloseAndCancelAsync();
   if (rv < 0) {
     EXPECT_EQ(ERR_IO_PENDING, rv);
-    // The callback should not be called if the request is cancelled.
+    // The callback should not be called if the request is canceled.
     MessageLoop::current()->RunAllPending();
     EXPECT_FALSE(callback.have_result());
   } else {
     EXPECT_EQ(std::string(kTestData, rv), std::string(buf->data(), rv));
   }
-
-  base::PlatformFileInfo info;
-  // The file should still be open.
-  EXPECT_TRUE(base::GetPlatformFileInfo(file, &info));
-  // Clean up.
-  EXPECT_TRUE(base::ClosePlatformFile(file));
 }
 
 TEST_F(FileStreamTest, BasicRead_FromOffset) {
   int64 file_size;
   bool ok = file_util::GetFileSize(temp_file_path(), &file_size);
   EXPECT_TRUE(ok);
 
   FileStream stream(NULL);
   int flags = base::PLATFORM_FILE_OPEN |
               base::PLATFORM_FILE_READ;
@@ skipping 838 matching lines @@
   int flags = base::PLATFORM_FILE_OPEN |
       base::PLATFORM_FILE_WRITE |
       base::PLATFORM_FILE_ASYNC;
   TestCompletionCallback open_callback;
   int rv = stream.Open(temp_file_path(), flags, open_callback.callback());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // Close the stream without waiting for the completion. Should be safe.
   stream.CloseSync();
   // open_callback won't be called.
+  MessageLoop::current()->RunAllPending();
   EXPECT_FALSE(open_callback.have_result());
 }
 
 TEST_F(FileStreamTest, AsyncOpenAndDelete) {
   scoped_ptr<FileStream> stream(new FileStream(NULL));
   int flags = base::PLATFORM_FILE_OPEN |
       base::PLATFORM_FILE_WRITE |
       base::PLATFORM_FILE_ASYNC;
   TestCompletionCallback open_callback;
   int rv = stream->Open(temp_file_path(), flags, open_callback.callback());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // Delete the stream without waiting for the open operation to be
   // complete. Should be safe.
   stream.reset();
   // open_callback won't be called.
+  MessageLoop::current()->RunAllPending();
+  EXPECT_FALSE(open_callback.have_result());
+}
+
+TEST_F(FileStreamTest, AsyncOpenAndCancelAsync) {
+  scoped_ptr<FileStream> stream(new FileStream(NULL));
+  int flags = base::PLATFORM_FILE_OPEN |
+      base::PLATFORM_FILE_WRITE |
+      base::PLATFORM_FILE_ASYNC;
+  TestCompletionCallback open_callback;
+  int rv = stream->Open(temp_file_path(), flags, open_callback.callback());
+  EXPECT_EQ(ERR_IO_PENDING, rv);
+
+  // Close and cancel without waiting for the open operation to be
+  // complete. Should be safe.
+  stream->CloseAndCancelAsync();
+  // open_callback won't be called.
+  MessageLoop::current()->RunAllPending();
   EXPECT_FALSE(open_callback.have_result());
 }
 
 TEST_F(FileStreamTest, AsyncCloseAndDelete) {
   scoped_ptr<FileStream> stream(new FileStream(NULL));
   int flags = base::PLATFORM_FILE_OPEN |
       base::PLATFORM_FILE_WRITE |
       base::PLATFORM_FILE_ASYNC;
   TestCompletionCallback open_callback;
   int rv = stream->Open(temp_file_path(), flags, open_callback.callback());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(OK, open_callback.WaitForResult());
   EXPECT_TRUE(stream->IsOpen());
 
   TestCompletionCallback close_callback;
   stream->Close(close_callback.callback());
 
   // Delete the stream without waiting for the close operation to be
   // complete. Should be safe.
   stream.reset();
   // close_callback won't be called.
+  MessageLoop::current()->RunAllPending();
   EXPECT_FALSE(close_callback.have_result());
 }
 
 }  // namespace
 
 }  // namespace net