OLD | NEW |
| (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 #include "webkit/browser/blob/local_file_stream_reader.h" | |
6 | |
7 #include "base/file_util.h" | |
8 #include "base/files/file_util_proxy.h" | |
9 #include "base/location.h" | |
10 #include "base/logging.h" | |
11 #include "base/task_runner.h" | |
12 #include "net/base/file_stream.h" | |
13 #include "net/base/io_buffer.h" | |
14 #include "net/base/net_errors.h" | |
15 | |
16 namespace webkit_blob { | |
17 | |
18 namespace { | |
19 | |
20 const int kOpenFlagsForRead = base::File::FLAG_OPEN | | |
21 base::File::FLAG_READ | | |
22 base::File::FLAG_ASYNC; | |
23 | |
24 } // namespace | |
25 | |
26 FileStreamReader* FileStreamReader::CreateForLocalFile( | |
27 base::TaskRunner* task_runner, | |
28 const base::FilePath& file_path, | |
29 int64 initial_offset, | |
30 const base::Time& expected_modification_time) { | |
31 return new LocalFileStreamReader(task_runner, file_path, initial_offset, | |
32 expected_modification_time); | |
33 } | |
34 | |
35 LocalFileStreamReader::~LocalFileStreamReader() { | |
36 } | |
37 | |
38 int LocalFileStreamReader::Read(net::IOBuffer* buf, int buf_len, | |
39 const net::CompletionCallback& callback) { | |
40 DCHECK(!has_pending_open_); | |
41 if (stream_impl_) | |
42 return stream_impl_->Read(buf, buf_len, callback); | |
43 return Open(base::Bind(&LocalFileStreamReader::DidOpenForRead, | |
44 weak_factory_.GetWeakPtr(), | |
45 make_scoped_refptr(buf), buf_len, callback)); | |
46 } | |
47 | |
48 int64 LocalFileStreamReader::GetLength( | |
49 const net::Int64CompletionCallback& callback) { | |
50 const bool posted = base::FileUtilProxy::GetFileInfo( | |
51 task_runner_.get(), | |
52 file_path_, | |
53 base::Bind(&LocalFileStreamReader::DidGetFileInfoForGetLength, | |
54 weak_factory_.GetWeakPtr(), | |
55 callback)); | |
56 DCHECK(posted); | |
57 return net::ERR_IO_PENDING; | |
58 } | |
59 | |
60 LocalFileStreamReader::LocalFileStreamReader( | |
61 base::TaskRunner* task_runner, | |
62 const base::FilePath& file_path, | |
63 int64 initial_offset, | |
64 const base::Time& expected_modification_time) | |
65 : task_runner_(task_runner), | |
66 file_path_(file_path), | |
67 initial_offset_(initial_offset), | |
68 expected_modification_time_(expected_modification_time), | |
69 has_pending_open_(false), | |
70 weak_factory_(this) {} | |
71 | |
72 int LocalFileStreamReader::Open(const net::CompletionCallback& callback) { | |
73 DCHECK(!has_pending_open_); | |
74 DCHECK(!stream_impl_.get()); | |
75 has_pending_open_ = true; | |
76 | |
77 // Call GetLength first to make it perform last-modified-time verification, | |
78 // and then call DidVerifyForOpen for do the rest. | |
79 return GetLength(base::Bind(&LocalFileStreamReader::DidVerifyForOpen, | |
80 weak_factory_.GetWeakPtr(), callback)); | |
81 } | |
82 | |
83 void LocalFileStreamReader::DidVerifyForOpen( | |
84 const net::CompletionCallback& callback, | |
85 int64 get_length_result) { | |
86 if (get_length_result < 0) { | |
87 callback.Run(static_cast<int>(get_length_result)); | |
88 return; | |
89 } | |
90 | |
91 stream_impl_.reset(new net::FileStream(task_runner_)); | |
92 const int result = stream_impl_->Open( | |
93 file_path_, kOpenFlagsForRead, | |
94 base::Bind(&LocalFileStreamReader::DidOpenFileStream, | |
95 weak_factory_.GetWeakPtr(), | |
96 callback)); | |
97 if (result != net::ERR_IO_PENDING) | |
98 callback.Run(result); | |
99 } | |
100 | |
101 void LocalFileStreamReader::DidOpenFileStream( | |
102 const net::CompletionCallback& callback, | |
103 int result) { | |
104 if (result != net::OK) { | |
105 callback.Run(result); | |
106 return; | |
107 } | |
108 result = stream_impl_->Seek( | |
109 base::File::FROM_BEGIN, initial_offset_, | |
110 base::Bind(&LocalFileStreamReader::DidSeekFileStream, | |
111 weak_factory_.GetWeakPtr(), | |
112 callback)); | |
113 if (result != net::ERR_IO_PENDING) { | |
114 callback.Run(result); | |
115 } | |
116 } | |
117 | |
118 void LocalFileStreamReader::DidSeekFileStream( | |
119 const net::CompletionCallback& callback, | |
120 int64 seek_result) { | |
121 if (seek_result < 0) { | |
122 callback.Run(static_cast<int>(seek_result)); | |
123 return; | |
124 } | |
125 if (seek_result != initial_offset_) { | |
126 callback.Run(net::ERR_REQUEST_RANGE_NOT_SATISFIABLE); | |
127 return; | |
128 } | |
129 callback.Run(net::OK); | |
130 } | |
131 | |
132 void LocalFileStreamReader::DidOpenForRead( | |
133 net::IOBuffer* buf, | |
134 int buf_len, | |
135 const net::CompletionCallback& callback, | |
136 int open_result) { | |
137 DCHECK(has_pending_open_); | |
138 has_pending_open_ = false; | |
139 if (open_result != net::OK) { | |
140 stream_impl_.reset(); | |
141 callback.Run(open_result); | |
142 return; | |
143 } | |
144 DCHECK(stream_impl_.get()); | |
145 const int read_result = stream_impl_->Read(buf, buf_len, callback); | |
146 if (read_result != net::ERR_IO_PENDING) | |
147 callback.Run(read_result); | |
148 } | |
149 | |
150 void LocalFileStreamReader::DidGetFileInfoForGetLength( | |
151 const net::Int64CompletionCallback& callback, | |
152 base::File::Error error, | |
153 const base::File::Info& file_info) { | |
154 if (file_info.is_directory) { | |
155 callback.Run(net::ERR_FILE_NOT_FOUND); | |
156 return; | |
157 } | |
158 if (error != base::File::FILE_OK) { | |
159 callback.Run(net::FileErrorToNetError(error)); | |
160 return; | |
161 } | |
162 if (!VerifySnapshotTime(expected_modification_time_, file_info)) { | |
163 callback.Run(net::ERR_UPLOAD_FILE_CHANGED); | |
164 return; | |
165 } | |
166 callback.Run(file_info.size); | |
167 } | |
168 | |
169 } // namespace webkit_blob | |
OLD | NEW |