net: Update FileStream to use base::File instead of PlatformFile.

net/base/file_stream_context.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::Context class.
 // The general design of FileStream is as follows: file_stream.h defines
 // FileStream class which basically is just an "wrapper" not containing any
 // specific implementation details. It re-routes all its method calls to
 // the instance of FileStream::Context (FileStream holds a scoped_ptr to
 // FileStream::Context instance). Context was extracted into a different class
 // to be able to do and finish all async operations even when FileStream
 // instance is deleted. So FileStream's destructor can schedule file
 // closing to be done by Context in WorkerPool (or the TaskRunner passed to
 // constructor) and then just return (releasing Context pointer from
 // scoped_ptr) without waiting for actual closing to complete.
 // Implementation of FileStream::Context is divided in two parts: some methods
 // and members are platform-independent and some depend on the platform. This
 // header file contains the complete definition of Context class including all
 // platform-dependent parts (because of that it has a lot of #if-#else
 // branching). Implementations of all platform-independent methods are
 // located in file_stream_context.cc, and all platform-dependent methods are
 // in file_stream_context_{win,posix}.cc. This separation provides better
 // readability of Context's code. And we tried to make as much Context code
 // platform-independent as possible. So file_stream_context_{win,posix}.cc are
 // much smaller than file_stream_context.cc now.
 
 #ifndef NET_BASE_FILE_STREAM_CONTEXT_H_
 #define NET_BASE_FILE_STREAM_CONTEXT_H_
 
+#include "base/files/file.h"
 #include "base/message_loop/message_loop.h"
-#include "base/platform_file.h"
+#include "base/move.h"
 #include "base/task_runner.h"
 #include "net/base/completion_callback.h"
 #include "net/base/file_stream.h"
 #include "net/base/file_stream_metrics.h"
 #include "net/base/file_stream_whence.h"
 #include "net/base/net_log.h"
 
 #if defined(OS_POSIX)
 #include <errno.h>
 #endif
@@ skipping 12 matching lines @@
 class FileStream::Context {
 #endif
  public:
   ////////////////////////////////////////////////////////////////////////////
   // Platform-dependent methods implemented in
   // file_stream_context_{win,posix}.cc.
   ////////////////////////////////////////////////////////////////////////////
 
   Context(const BoundNetLog& bound_net_log,
           const scoped_refptr<base::TaskRunner>& task_runner);
-  Context(base::PlatformFile file,
+  Context(base::File file,
           const BoundNetLog& bound_net_log,
-          int open_flags,
+          const scoped_refptr<base::TaskRunner>& task_runner);
+
+  // This is a deprecated constructor intended only to support callers that
+  // provide a PlatformFile. Such callers are to be updated to provide a File.
+  Context(base::File file,
+          int flags,
+          const BoundNetLog& bound_net_log,
           const scoped_refptr<base::TaskRunner>& task_runner);
 #if defined(OS_WIN)
   virtual ~Context();
 #elif defined(OS_POSIX)
   ~Context();
 #endif
 
   int64 GetFileSize() const;
 
   int ReadAsync(IOBuffer* buf,
                 int buf_len,
                 const CompletionCallback& callback);
   int ReadSync(char* buf, int buf_len);
 
   int WriteAsync(IOBuffer* buf,
                  int buf_len,
                  const CompletionCallback& callback);
   int WriteSync(const char* buf, int buf_len);
 
   int Truncate(int64 bytes);
 
   ////////////////////////////////////////////////////////////////////////////
   // Inline methods.
   ////////////////////////////////////////////////////////////////////////////
 
   void set_record_uma(bool value) { record_uma_ = value; }
-  base::PlatformFile file() const { return file_; }
+  const base::File& file() const { return file_; }
   bool async_in_progress() const { return async_in_progress_; }
+  bool async() const { return async_in_progress_ || async_ || file_.async(); }
 
   ////////////////////////////////////////////////////////////////////////////
   // Platform-independent methods implemented in file_stream_context.cc.
   ////////////////////////////////////////////////////////////////////////////
 
   // Destroys the context. It can be deleted in the method or deletion can be
   // deferred if some asynchronous operation is now in progress or if file is
   // not closed yet.
   void Orphan();
 
@@ skipping 21 matching lines @@
 
   struct IOResult {
     IOResult();
     IOResult(int64 result, int os_error);
     static IOResult FromOSError(int64 os_error);
 
     int64 result;
     int os_error;  // Set only when result < 0.
   };
 
-  struct OpenResult {
+  class OpenResult {

[willchan no longer on Chromium, 2014/03/18 20:36:56]

I chatted with jyasskin (c++ committee member and ex-readability reviewer) and
he thinks stylistically we should keep this as a struct, even if you added the
move emulation here. I tend to agree. WDYT about switching this back to a
struct?

[rvargas (doing something else), 2014/03/19 01:03:18]

I guess it looks weird in any case. I mean, having a struct with private and
public sections (and operators) really feels like going against the "use a
struct for trivial cases... everything else is a class". On the other hand,
having a class with the members declared as public goes against the "everything
private, declare accessors".

Just so that it's clear to me, what is your concern about making it a class?

[rvargas (doing something else), 2014/03/19 19:01:48]

Tentatively back to struct

[willchan no longer on Chromium, 2014/03/19 22:36:35]

It's just a minor preference. The reason is that these public member functions
are purely there for move support, and our idiomatic use of struct is to
indicate that it's just a encapsulation of a bunch of data, rather than
associated functionality.

+    MOVE_ONLY_TYPE_FOR_CPP_03(OpenResult, RValue)
+   public:
     OpenResult();
-    OpenResult(base::PlatformFile file, IOResult error_code);
-    base::PlatformFile file;
+    OpenResult(base::File file, IOResult error_code);
+    // C++03 move emulation of this type.
+    OpenResult(RValue other);
+    OpenResult& operator=(RValue other);
+
+    base::File file;
     IOResult error_code;
   };
 
   // Log the error from |result| to |bound_net_log_|.
   void RecordError(const IOResult& result, FileErrorSource source) const;
 
   void BeginOpenEvent(const base::FilePath& path);
 
   OpenResult OpenFileImpl(const base::FilePath& path, int open_flags);
 
+  IOResult CloseFileImpl();
+
   void ProcessOpenError(const IOResult& result);
   void OnOpenCompleted(const CompletionCallback& callback,
                        OpenResult open_result);
 
   void CloseAndDelete();
   void OnCloseCompleted();
 
   Int64CompletionCallback IntToInt64(const CompletionCallback& callback);
 
   // Called when asynchronous Seek() is completed.
@@ skipping 26 matching lines @@
   // Platform-dependent methods implemented in
   // file_stream_context_{win,posix}.cc.
   ////////////////////////////////////////////////////////////////////////////
 
   // Adjusts the position from where the data is read.
   IOResult SeekFileImpl(Whence whence, int64 offset);
 
   // Flushes all data written to the stream.
   IOResult FlushFileImpl();
 
-  // Closes the file.
-  IOResult CloseFileImpl();
-
 #if defined(OS_WIN)
   void IOCompletionIsPending(const CompletionCallback& callback, IOBuffer* buf);
 
   // Implementation of MessageLoopForIO::IOHandler.
   virtual void OnIOCompleted(base::MessageLoopForIO::IOContext* context,
                              DWORD bytes_read,
                              DWORD error) OVERRIDE;
 #elif defined(OS_POSIX)
   // ReadFileImpl() is a simple wrapper around read() that handles EINTR
   // signals and calls RecordAndMapError() to map errno to net error codes.
   IOResult ReadFileImpl(scoped_refptr<IOBuffer> buf, int buf_len);
 
   // WriteFileImpl() is a simple wrapper around write() that handles EINTR
   // signals and calls MapSystemError() to map errno to net error codes.
   // It tries to write to completion.
   IOResult WriteFileImpl(scoped_refptr<IOBuffer> buf, int buf_len);
 #endif
 
-  base::PlatformFile file_;
+  base::File file_;
   bool record_uma_;
   bool async_in_progress_;
   bool orphaned_;
+  bool async_;  // To be removed when flags are removed from the constructor.
   BoundNetLog bound_net_log_;
   scoped_refptr<base::TaskRunner> task_runner_;
 
 #if defined(OS_WIN)
   base::MessageLoopForIO::IOContext io_context_;
   CompletionCallback callback_;
   scoped_refptr<IOBuffer> in_flight_buf_;
   FileErrorSource error_source_;
 #endif
 
   DISALLOW_COPY_AND_ASSIGN(Context);
 };
 
 }  // namespace net
 
 #endif  // NET_BASE_FILE_STREAM_CONTEXT_H_