net: Implement canceling of all async operations in FileStream.

net/base/file_stream.h

 // 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.
 
 // This file defines FileStream, a basic interface for reading and writing files
 // synchronously or asynchronously with support for seeking to an offset.
 // Note that even when used asynchronously, only one operation is supported at
 // a time.
 
 #ifndef NET_BASE_FILE_STREAM_H_
 #define NET_BASE_FILE_STREAM_H_
 
 #include "base/platform_file.h"
 #include "net/base/completion_callback.h"
 #include "net/base/file_stream_whence.h"
 #include "net/base/net_export.h"
 #include "net/base/net_log.h"
-#if defined(OS_WIN)
-#include "net/base/file_stream_win.h"
-#elif defined(OS_POSIX)
-#include "net/base/file_stream_posix.h"
-#endif
 
 class FilePath;
 
 namespace net {
 
 class IOBuffer;
 
 class NET_EXPORT FileStream {
  public:
   // Creates a |FileStream| with a new |BoundNetLog| (based on |net_log|)
   // attached.  |net_log| may be NULL if no logging is needed.
   explicit FileStream(net::NetLog* net_log);
 
   // Construct a FileStream with an existing file handle and opening flags.
   // |file| is valid file handle.
   // |flags| is a bitfield of base::PlatformFileFlags when the file handle was
   // opened.
   // |net_log| is the net log pointer to use to create a |BoundNetLog|.  May be
   // NULL if logging is not needed.
-  // The already opened file will not be automatically closed when FileStream
-  // is destructed.
+  // Note: the new FileStream object takes ownership of the PlatformFile and
+  // will close it on destruction.
   FileStream(base::PlatformFile file, int flags, net::NetLog* net_log);
 
   // If the file stream was opened with Open() or OpenSync(), the underlying
   // file will be closed automatically by the destructor, if not closed
   // manually.
   virtual ~FileStream();
 
   // Call this method to close the FileStream, which was previously opened in
   // the async mode (PLATFORM_FILE_ASYNC) asynchronously.
   //
   // Once the operation is done, |callback| will be run on the thread where
   // Close() was called, with OK (i.e. an error is not propagated just like
   // CloseSync() does not).
   //
   // It is not OK to call Close() multiple times. The behavior is not defined.
   // Note that there must never be any pending async operations.
   virtual void Close(const CompletionCallback& callback);
 
   // Call this method to close the FileStream synchronously.
   // It is OK to call CloseSync() multiple times.  Redundant calls are
   // ignored. Note that if there are any pending async operations, they'll
-  // be aborted.
+  // be aborted and actual closing of the stream will happen asynchronously
+  // (to avoid races with async operation).
   virtual void CloseSync();
 
   // Call this method to open the FileStream asynchronously.  The remaining
   // methods cannot be used unless the file is opened successfully. Returns
   // ERR_IO_PENDING if the operation is started. If the operation cannot be
   // started then an error code is returned.
   //
   // Once the operation is done, |callback| will be run on the thread where
   // Open() was called, with the result code. open_flags is a bitfield of
   // base::PlatformFileFlags.
@@ skipping 133 matching lines @@
   // Creates source dependency events between |owner_bound_net_log| and
   // |bound_net_log_|.  Each gets an event showing the dependency on the other.
   // If only one of those is valid, it gets an event showing that a change
   // of ownership happened, but without details.
   void SetBoundNetLogSource(const net::BoundNetLog& owner_bound_net_log);
 
   // Returns the underlying platform file for testing.
   base::PlatformFile GetPlatformFileForTesting();
 
  private:
-#if defined(OS_WIN)
-  FileStreamWin impl_;
-#elif defined(OS_POSIX)
-  FileStreamPosix impl_;
-#endif
+  class AsyncContext;
+
+  bool is_async() { return !!(open_flags_ & base::PLATFORM_FILE_ASYNC); }
+
+  // Context performing I/O operations. Despite its name the context is used
+  // for synchronous operations too, but it was extracted into separate class
+  // to perform asynchronous operations correctly.
+  AsyncContext* context_;
+
+  int open_flags_;
+  net::BoundNetLog bound_net_log_;
 
   DISALLOW_COPY_AND_ASSIGN(FileStream);
 };
 
 }  // namespace net
 
 #endif  // NET_BASE_FILE_STREAM_H_