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 95 matching lines @@
     EXPECT_EQ(OK, rv);
     EXPECT_TRUE(stream.IsOpen());
     file = stream.GetPlatformFileForTesting();
   }
   EXPECT_NE(base::kInvalidPlatformFileValue, file);
   base::PlatformFileInfo info;
   // The file should be closed.
   EXPECT_FALSE(base::GetPlatformFileInfo(file, &info));
 }
 
-TEST_F(FileStreamTest, FileHandleLeftOpen) {
+TEST_F(FileStreamTest, FileHandleNotLeftOpen) {
   bool created = false;
   ASSERT_EQ(kTestDataSize,
       file_util::WriteFile(temp_file_path(), kTestData, kTestDataSize));
   int flags = base::PLATFORM_FILE_OPEN_ALWAYS | base::PLATFORM_FILE_READ;
   base::PlatformFile file = base::CreatePlatformFile(
       temp_file_path(), flags, &created, NULL);
 
   {
     // Seek to the beginning of the file and read.
     FileStream read_stream(file, flags, NULL);
     EXPECT_TRUE(read_stream.IsOpen());
   }
 
   EXPECT_NE(base::kInvalidPlatformFileValue, file);
   base::PlatformFileInfo info;
-  // The file should still be open.
-  EXPECT_TRUE(base::GetPlatformFileInfo(file, &info));
-  // Clean up.
-  EXPECT_TRUE(base::ClosePlatformFile(file));
+  // The file should be closed.
+  EXPECT_FALSE(base::GetPlatformFileInfo(file, &info));
+  EXPECT_FALSE(base::ClosePlatformFile(file));
 }
 
 // Test the use of FileStream with a file handle provided at construction.
 TEST_F(FileStreamTest, UseFileHandle) {
   bool created = false;
 
   // 1. Test reading with a file handle.
   ASSERT_EQ(kTestDataSize,
       file_util::WriteFile(temp_file_path(), kTestData, kTestDataSize));
   int flags = base::PLATFORM_FILE_OPEN_ALWAYS | base::PLATFORM_FILE_READ;
@@ skipping 167 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) {
-  int64 file_size;
-  bool ok = file_util::GetFileSize(temp_file_path(), &file_size);
-  EXPECT_TRUE(ok);
-
-  bool created = false;
-  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);
-
-  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.
-  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));
-  }
-
-  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;
   int rv = stream.OpenSync(temp_file_path(), flags);
   EXPECT_EQ(OK, rv);
@@ skipping 836 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, 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