Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(62)

Side by Side Diff: net/base/file_stream_context.h

Issue 992733002: Remove //net (except for Android test stuff) and sdch (Closed) Base URL: git@github.com:domokit/mojo.git@master
Patch Set: Created 5 years, 9 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« no previous file with comments | « net/base/file_stream.cc ('k') | net/base/file_stream_context.cc » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
(Empty)
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 // This file defines FileStream::Context class.
6 // The general design of FileStream is as follows: file_stream.h defines
7 // FileStream class which basically is just an "wrapper" not containing any
8 // specific implementation details. It re-routes all its method calls to
9 // the instance of FileStream::Context (FileStream holds a scoped_ptr to
10 // FileStream::Context instance). Context was extracted into a different class
11 // to be able to do and finish all async operations even when FileStream
12 // instance is deleted. So FileStream's destructor can schedule file
13 // closing to be done by Context in WorkerPool (or the TaskRunner passed to
14 // constructor) and then just return (releasing Context pointer from
15 // scoped_ptr) without waiting for actual closing to complete.
16 // Implementation of FileStream::Context is divided in two parts: some methods
17 // and members are platform-independent and some depend on the platform. This
18 // header file contains the complete definition of Context class including all
19 // platform-dependent parts (because of that it has a lot of #if-#else
20 // branching). Implementations of all platform-independent methods are
21 // located in file_stream_context.cc, and all platform-dependent methods are
22 // in file_stream_context_{win,posix}.cc. This separation provides better
23 // readability of Context's code. And we tried to make as much Context code
24 // platform-independent as possible. So file_stream_context_{win,posix}.cc are
25 // much smaller than file_stream_context.cc now.
26
27 #ifndef NET_BASE_FILE_STREAM_CONTEXT_H_
28 #define NET_BASE_FILE_STREAM_CONTEXT_H_
29
30 #include "base/files/file.h"
31 #include "base/memory/weak_ptr.h"
32 #include "base/message_loop/message_loop.h"
33 #include "base/move.h"
34 #include "base/task_runner.h"
35 #include "net/base/completion_callback.h"
36 #include "net/base/file_stream.h"
37
38 #if defined(OS_POSIX)
39 #include <errno.h>
40 #endif
41
42 namespace base {
43 class FilePath;
44 }
45
46 namespace net {
47
48 class IOBuffer;
49
50 #if defined(OS_WIN)
51 class FileStream::Context : public base::MessageLoopForIO::IOHandler {
52 #elif defined(OS_POSIX)
53 class FileStream::Context {
54 #endif
55 public:
56 ////////////////////////////////////////////////////////////////////////////
57 // Platform-dependent methods implemented in
58 // file_stream_context_{win,posix}.cc.
59 ////////////////////////////////////////////////////////////////////////////
60
61 explicit Context(const scoped_refptr<base::TaskRunner>& task_runner);
62 Context(base::File file, const scoped_refptr<base::TaskRunner>& task_runner);
63 #if defined(OS_WIN)
64 virtual ~Context();
65 #elif defined(OS_POSIX)
66 ~Context();
67 #endif
68
69 int Read(IOBuffer* buf,
70 int buf_len,
71 const CompletionCallback& callback);
72
73 int Write(IOBuffer* buf,
74 int buf_len,
75 const CompletionCallback& callback);
76
77 const base::File& file() const { return file_; }
78 bool async_in_progress() const { return async_in_progress_; }
79
80 ////////////////////////////////////////////////////////////////////////////
81 // Platform-independent methods implemented in file_stream_context.cc.
82 ////////////////////////////////////////////////////////////////////////////
83
84 // Destroys the context. It can be deleted in the method or deletion can be
85 // deferred if some asynchronous operation is now in progress or if file is
86 // not closed yet.
87 void Orphan();
88
89 void Open(const base::FilePath& path,
90 int open_flags,
91 const CompletionCallback& callback);
92
93 void Close(const CompletionCallback& callback);
94
95 void Seek(base::File::Whence whence,
96 int64 offset,
97 const Int64CompletionCallback& callback);
98
99 void Flush(const CompletionCallback& callback);
100
101 private:
102 struct IOResult {
103 IOResult();
104 IOResult(int64 result, logging::SystemErrorCode os_error);
105 static IOResult FromOSError(logging::SystemErrorCode os_error);
106
107 int64 result;
108 logging::SystemErrorCode os_error; // Set only when result < 0.
109 };
110
111 struct OpenResult {
112 MOVE_ONLY_TYPE_FOR_CPP_03(OpenResult, RValue)
113 public:
114 OpenResult();
115 OpenResult(base::File file, IOResult error_code);
116 // C++03 move emulation of this type.
117 OpenResult(RValue other);
118 OpenResult& operator=(RValue other);
119
120 base::File file;
121 IOResult error_code;
122 };
123
124 ////////////////////////////////////////////////////////////////////////////
125 // Platform-independent methods implemented in file_stream_context.cc.
126 ////////////////////////////////////////////////////////////////////////////
127
128 OpenResult OpenFileImpl(const base::FilePath& path, int open_flags);
129
130 IOResult CloseFileImpl();
131
132 IOResult FlushFileImpl();
133
134 void OnOpenCompleted(const CompletionCallback& callback,
135 OpenResult open_result);
136
137 void CloseAndDelete();
138
139 Int64CompletionCallback IntToInt64(const CompletionCallback& callback);
140
141 // Called when Open() or Seek() completes. |result| contains the result or a
142 // network error code.
143 void OnAsyncCompleted(const Int64CompletionCallback& callback,
144 const IOResult& result);
145
146 ////////////////////////////////////////////////////////////////////////////
147 // Platform-dependent methods implemented in
148 // file_stream_context_{win,posix}.cc.
149 ////////////////////////////////////////////////////////////////////////////
150
151 // Adjusts the position from where the data is read.
152 IOResult SeekFileImpl(base::File::Whence whence, int64 offset);
153
154 void OnFileOpened();
155
156 #if defined(OS_WIN)
157 void IOCompletionIsPending(const CompletionCallback& callback, IOBuffer* buf);
158
159 // Implementation of MessageLoopForIO::IOHandler.
160 virtual void OnIOCompleted(base::MessageLoopForIO::IOContext* context,
161 DWORD bytes_read,
162 DWORD error) override;
163
164 // Invokes the user callback.
165 void InvokeUserCallback();
166
167 // Deletes an orphaned context.
168 void DeleteOrphanedContext();
169
170 // The ReadFile call on Windows can execute synchonously at times.
171 // http://support.microsoft.com/kb/156932. This ends up blocking the calling
172 // thread which is undesirable. To avoid this we execute the ReadFile call
173 // on a worker thread.
174 // The |context| parameter is a pointer to the current Context instance. It
175 // is safe to pass this as is to the pool as the Context instance should
176 // remain valid until the pending Read operation completes.
177 // The |file| parameter is the handle to the file being read.
178 // The |buf| parameter is the buffer where we want the ReadFile to read the
179 // data into.
180 // The |buf_len| parameter contains the number of bytes to be read.
181 // The |overlapped| parameter is a pointer to the OVERLAPPED structure being
182 // used.
183 // The |origin_thread_loop| is a MessageLoopProxy instance used to post tasks
184 // back to the originating thread.
185 static void ReadAsync(
186 FileStream::Context* context,
187 HANDLE file,
188 scoped_refptr<net::IOBuffer> buf,
189 int buf_len,
190 OVERLAPPED* overlapped,
191 scoped_refptr<base::MessageLoopProxy> origin_thread_loop);
192
193 // This callback executes on the main calling thread. It informs the caller
194 // about the result of the ReadFile call.
195 // The |read_file_ret| parameter contains the return value of the ReadFile
196 // call.
197 // The |bytes_read| contains the number of bytes read from the file, if
198 // ReadFile succeeds.
199 // The |os_error| parameter contains the value of the last error returned by
200 // the ReadFile API.
201 void ReadAsyncResult(BOOL read_file_ret, DWORD bytes_read, DWORD os_error);
202
203 #elif defined(OS_POSIX)
204 // ReadFileImpl() is a simple wrapper around read() that handles EINTR
205 // signals and calls RecordAndMapError() to map errno to net error codes.
206 IOResult ReadFileImpl(scoped_refptr<IOBuffer> buf, int buf_len);
207
208 // WriteFileImpl() is a simple wrapper around write() that handles EINTR
209 // signals and calls MapSystemError() to map errno to net error codes.
210 // It tries to write to completion.
211 IOResult WriteFileImpl(scoped_refptr<IOBuffer> buf, int buf_len);
212 #endif
213
214 base::File file_;
215 bool async_in_progress_;
216 bool orphaned_;
217 scoped_refptr<base::TaskRunner> task_runner_;
218
219 #if defined(OS_WIN)
220 base::MessageLoopForIO::IOContext io_context_;
221 CompletionCallback callback_;
222 scoped_refptr<IOBuffer> in_flight_buf_;
223 // This flag is set to true when we receive a Read request which is queued to
224 // the thread pool.
225 bool async_read_initiated_;
226 // This flag is set to true when we receive a notification ReadAsyncResult()
227 // on the calling thread which indicates that the asynchronous Read
228 // operation is complete.
229 bool async_read_completed_;
230 // This flag is set to true when we receive an IO completion notification for
231 // an asynchonously initiated Read operaton. OnIOComplete().
232 bool io_complete_for_read_received_;
233 // Tracks the result of the IO completion operation. Set in OnIOComplete.
234 int result_;
235 #endif
236
237 DISALLOW_COPY_AND_ASSIGN(Context);
238 };
239
240 } // namespace net
241
242 #endif // NET_BASE_FILE_STREAM_CONTEXT_H_
OLDNEW
« no previous file with comments | « net/base/file_stream.cc ('k') | net/base/file_stream_context.cc » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698