OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "storage/browser/fileapi/file_system_url_request_job.h" | 5 #include "storage/browser/fileapi/file_system_url_request_job.h" |
6 | 6 |
7 #include <vector> | 7 #include <vector> |
8 | 8 |
9 #include "base/bind.h" | 9 #include "base/bind.h" |
10 #include "base/compiler_specific.h" | 10 #include "base/compiler_specific.h" |
(...skipping 44 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
55 FileSystemURLRequestJob::FileSystemURLRequestJob( | 55 FileSystemURLRequestJob::FileSystemURLRequestJob( |
56 URLRequest* request, | 56 URLRequest* request, |
57 NetworkDelegate* network_delegate, | 57 NetworkDelegate* network_delegate, |
58 const std::string& storage_domain, | 58 const std::string& storage_domain, |
59 FileSystemContext* file_system_context) | 59 FileSystemContext* file_system_context) |
60 : URLRequestJob(request, network_delegate), | 60 : URLRequestJob(request, network_delegate), |
61 storage_domain_(storage_domain), | 61 storage_domain_(storage_domain), |
62 file_system_context_(file_system_context), | 62 file_system_context_(file_system_context), |
63 is_directory_(false), | 63 is_directory_(false), |
64 remaining_bytes_(0), | 64 remaining_bytes_(0), |
| 65 range_parse_result_(net::OK), |
65 weak_factory_(this) {} | 66 weak_factory_(this) {} |
66 | 67 |
67 FileSystemURLRequestJob::~FileSystemURLRequestJob() {} | 68 FileSystemURLRequestJob::~FileSystemURLRequestJob() {} |
68 | 69 |
69 void FileSystemURLRequestJob::Start() { | 70 void FileSystemURLRequestJob::Start() { |
70 base::MessageLoop::current()->PostTask( | 71 base::MessageLoop::current()->PostTask( |
71 FROM_HERE, | 72 FROM_HERE, |
72 base::Bind(&FileSystemURLRequestJob::StartAsync, | 73 base::Bind(&FileSystemURLRequestJob::StartAsync, |
73 weak_factory_.GetWeakPtr())); | 74 weak_factory_.GetWeakPtr())); |
74 } | 75 } |
75 | 76 |
76 void FileSystemURLRequestJob::Kill() { | 77 void FileSystemURLRequestJob::Kill() { |
77 reader_.reset(); | 78 reader_.reset(); |
78 URLRequestJob::Kill(); | 79 URLRequestJob::Kill(); |
79 weak_factory_.InvalidateWeakPtrs(); | 80 weak_factory_.InvalidateWeakPtrs(); |
80 } | 81 } |
81 | 82 |
82 bool FileSystemURLRequestJob::ReadRawData(net::IOBuffer* dest, | 83 int FileSystemURLRequestJob::ReadRawData(net::IOBuffer* dest, int dest_size) { |
83 int dest_size, | |
84 int* bytes_read) { | |
85 DCHECK_NE(dest_size, 0); | 84 DCHECK_NE(dest_size, 0); |
86 DCHECK(bytes_read); | |
87 DCHECK_GE(remaining_bytes_, 0); | 85 DCHECK_GE(remaining_bytes_, 0); |
88 | 86 |
89 if (reader_.get() == NULL) | 87 if (reader_.get() == NULL) |
90 return false; | 88 return net::ERR_FAILED; |
91 | 89 |
92 if (remaining_bytes_ < dest_size) | 90 if (remaining_bytes_ < dest_size) |
93 dest_size = static_cast<int>(remaining_bytes_); | 91 dest_size = remaining_bytes_; |
94 | 92 |
95 if (!dest_size) { | 93 if (!dest_size) |
96 *bytes_read = 0; | 94 return 0; |
97 return true; | |
98 } | |
99 | 95 |
100 const int rv = reader_->Read(dest, dest_size, | 96 const int rv = reader_->Read(dest, dest_size, |
101 base::Bind(&FileSystemURLRequestJob::DidRead, | 97 base::Bind(&FileSystemURLRequestJob::DidRead, |
102 weak_factory_.GetWeakPtr())); | 98 weak_factory_.GetWeakPtr())); |
103 if (rv >= 0) { | 99 if (rv >= 0) { |
104 // Data is immediately available. | |
105 *bytes_read = rv; | |
106 remaining_bytes_ -= rv; | 100 remaining_bytes_ -= rv; |
107 DCHECK_GE(remaining_bytes_, 0); | 101 DCHECK_GE(remaining_bytes_, 0); |
108 return true; | |
109 } | 102 } |
110 if (rv == net::ERR_IO_PENDING) | 103 |
111 SetStatus(URLRequestStatus(URLRequestStatus::IO_PENDING, 0)); | 104 return rv; |
112 else | |
113 NotifyFailed(rv); | |
114 return false; | |
115 } | 105 } |
116 | 106 |
117 bool FileSystemURLRequestJob::GetMimeType(std::string* mime_type) const { | 107 bool FileSystemURLRequestJob::GetMimeType(std::string* mime_type) const { |
118 DCHECK(request_); | 108 DCHECK(request_); |
119 DCHECK(url_.is_valid()); | 109 DCHECK(url_.is_valid()); |
120 base::FilePath::StringType extension = url_.path().Extension(); | 110 base::FilePath::StringType extension = url_.path().Extension(); |
121 if (!extension.empty()) | 111 if (!extension.empty()) |
122 extension = extension.substr(1); | 112 extension = extension.substr(1); |
123 return net::GetWellKnownMimeTypeFromExtension(extension, mime_type); | 113 return net::GetWellKnownMimeTypeFromExtension(extension, mime_type); |
124 } | 114 } |
125 | 115 |
126 void FileSystemURLRequestJob::SetExtraRequestHeaders( | 116 void FileSystemURLRequestJob::SetExtraRequestHeaders( |
127 const net::HttpRequestHeaders& headers) { | 117 const net::HttpRequestHeaders& headers) { |
128 std::string range_header; | 118 std::string range_header; |
| 119 // Currently this job only cares about the Range header. Note that validation |
| 120 // is deferred to DidGetMetaData(), because NotifyStartError is not legal to |
| 121 // call since the job has not started. |
129 if (headers.GetHeader(net::HttpRequestHeaders::kRange, &range_header)) { | 122 if (headers.GetHeader(net::HttpRequestHeaders::kRange, &range_header)) { |
130 std::vector<net::HttpByteRange> ranges; | 123 std::vector<net::HttpByteRange> ranges; |
| 124 |
131 if (net::HttpUtil::ParseRangeHeader(range_header, &ranges)) { | 125 if (net::HttpUtil::ParseRangeHeader(range_header, &ranges)) { |
132 if (ranges.size() == 1) { | 126 if (ranges.size() == 1) { |
133 byte_range_ = ranges[0]; | 127 byte_range_ = ranges[0]; |
134 } else { | 128 } else { |
135 // We don't support multiple range requests in one single URL request. | 129 // We don't support multiple range requests in one single URL request. |
136 // TODO(adamk): decide whether we want to support multiple range | 130 // TODO(adamk): decide whether we want to support multiple range |
137 // requests. | 131 // requests. |
138 NotifyFailed(net::ERR_REQUEST_RANGE_NOT_SATISFIABLE); | 132 range_parse_result_ = net::ERR_REQUEST_RANGE_NOT_SATISFIABLE; |
139 } | 133 } |
140 } | 134 } |
141 } | 135 } |
142 } | 136 } |
143 | 137 |
144 void FileSystemURLRequestJob::GetResponseInfo(net::HttpResponseInfo* info) { | 138 void FileSystemURLRequestJob::GetResponseInfo(net::HttpResponseInfo* info) { |
145 if (response_info_) | 139 if (response_info_) |
146 *info = *response_info_; | 140 *info = *response_info_; |
147 } | 141 } |
148 | 142 |
(...skipping 11 matching lines...) Expand all Loading... |
160 if (!url_.is_valid()) { | 154 if (!url_.is_valid()) { |
161 file_system_context_->AttemptAutoMountForURLRequest( | 155 file_system_context_->AttemptAutoMountForURLRequest( |
162 request_, | 156 request_, |
163 storage_domain_, | 157 storage_domain_, |
164 base::Bind(&FileSystemURLRequestJob::DidAttemptAutoMount, | 158 base::Bind(&FileSystemURLRequestJob::DidAttemptAutoMount, |
165 weak_factory_.GetWeakPtr())); | 159 weak_factory_.GetWeakPtr())); |
166 return; | 160 return; |
167 } | 161 } |
168 if (!file_system_context_->CanServeURLRequest(url_)) { | 162 if (!file_system_context_->CanServeURLRequest(url_)) { |
169 // In incognito mode the API is not usable and there should be no data. | 163 // In incognito mode the API is not usable and there should be no data. |
170 NotifyFailed(net::ERR_FILE_NOT_FOUND); | 164 NotifyStartError(URLRequestStatus::FromError(net::ERR_FILE_NOT_FOUND)); |
171 return; | 165 return; |
172 } | 166 } |
173 file_system_context_->operation_runner()->GetMetadata( | 167 file_system_context_->operation_runner()->GetMetadata( |
174 url_, FileSystemOperation::GET_METADATA_FIELD_IS_DIRECTORY | | 168 url_, FileSystemOperation::GET_METADATA_FIELD_IS_DIRECTORY | |
175 FileSystemOperation::GET_METADATA_FIELD_SIZE, | 169 FileSystemOperation::GET_METADATA_FIELD_SIZE, |
176 base::Bind(&FileSystemURLRequestJob::DidGetMetadata, | 170 base::Bind(&FileSystemURLRequestJob::DidGetMetadata, |
177 weak_factory_.GetWeakPtr())); | 171 weak_factory_.GetWeakPtr())); |
178 } | 172 } |
179 | 173 |
180 void FileSystemURLRequestJob::DidAttemptAutoMount(base::File::Error result) { | 174 void FileSystemURLRequestJob::DidAttemptAutoMount(base::File::Error result) { |
181 if (result >= 0 && | 175 if (result >= 0 && |
182 file_system_context_->CrackURL(request_->url()).is_valid()) { | 176 file_system_context_->CrackURL(request_->url()).is_valid()) { |
183 StartAsync(); | 177 StartAsync(); |
184 } else { | 178 } else { |
185 NotifyFailed(net::ERR_FILE_NOT_FOUND); | 179 NotifyStartError(URLRequestStatus::FromError(net::ERR_FILE_NOT_FOUND)); |
186 } | 180 } |
187 } | 181 } |
188 | 182 |
189 void FileSystemURLRequestJob::DidGetMetadata( | 183 void FileSystemURLRequestJob::DidGetMetadata( |
190 base::File::Error error_code, | 184 base::File::Error error_code, |
191 const base::File::Info& file_info) { | 185 const base::File::Info& file_info) { |
192 if (error_code != base::File::FILE_OK) { | 186 if (error_code != base::File::FILE_OK) { |
193 NotifyFailed(error_code == base::File::FILE_ERROR_INVALID_URL | 187 NotifyStartError(URLRequestStatus::FromError( |
194 ? net::ERR_INVALID_URL | 188 error_code == base::File::FILE_ERROR_INVALID_URL |
195 : net::ERR_FILE_NOT_FOUND); | 189 ? net::ERR_INVALID_URL |
| 190 : net::ERR_FILE_NOT_FOUND)); |
196 return; | 191 return; |
197 } | 192 } |
198 | 193 |
199 // We may have been orphaned... | 194 // We may have been orphaned... |
200 if (!request_) | 195 if (!request_) |
201 return; | 196 return; |
202 | 197 |
203 is_directory_ = file_info.is_directory; | 198 is_directory_ = file_info.is_directory; |
204 | 199 |
205 if (!byte_range_.ComputeBounds(file_info.size)) { | 200 if (range_parse_result_ != net::OK) { |
206 NotifyFailed(net::ERR_REQUEST_RANGE_NOT_SATISFIABLE); | 201 NotifyStartError(URLRequestStatus::FromError(range_parse_result_)); |
207 return; | 202 return; |
208 } | 203 } |
209 | 204 |
| 205 if (!byte_range_.ComputeBounds(file_info.size)) { |
| 206 NotifyStartError( |
| 207 URLRequestStatus::FromError(net::ERR_REQUEST_RANGE_NOT_SATISFIABLE)); |
| 208 return; |
| 209 } |
| 210 |
210 if (is_directory_) { | 211 if (is_directory_) { |
211 NotifyHeadersComplete(); | 212 NotifyHeadersComplete(); |
212 return; | 213 return; |
213 } | 214 } |
214 | 215 |
215 remaining_bytes_ = byte_range_.last_byte_position() - | 216 remaining_bytes_ = byte_range_.last_byte_position() - |
216 byte_range_.first_byte_position() + 1; | 217 byte_range_.first_byte_position() + 1; |
217 DCHECK_GE(remaining_bytes_, 0); | 218 DCHECK_GE(remaining_bytes_, 0); |
218 | 219 |
219 DCHECK(!reader_.get()); | 220 DCHECK(!reader_.get()); |
220 reader_ = file_system_context_->CreateFileStreamReader( | 221 reader_ = file_system_context_->CreateFileStreamReader( |
221 url_, byte_range_.first_byte_position(), remaining_bytes_, base::Time()); | 222 url_, byte_range_.first_byte_position(), remaining_bytes_, base::Time()); |
222 | 223 |
223 set_expected_content_size(remaining_bytes_); | 224 set_expected_content_size(remaining_bytes_); |
224 response_info_.reset(new net::HttpResponseInfo()); | 225 response_info_.reset(new net::HttpResponseInfo()); |
225 response_info_->headers = CreateHttpResponseHeaders(); | 226 response_info_->headers = CreateHttpResponseHeaders(); |
226 NotifyHeadersComplete(); | 227 NotifyHeadersComplete(); |
227 } | 228 } |
228 | 229 |
229 void FileSystemURLRequestJob::DidRead(int result) { | 230 void FileSystemURLRequestJob::DidRead(int result) { |
230 if (result > 0) | 231 if (result >= 0) { |
231 SetStatus(URLRequestStatus()); // Clear the IO_PENDING status | 232 remaining_bytes_ -= result; |
232 else if (result == 0) | 233 DCHECK_GE(remaining_bytes_, 0); |
233 NotifyDone(URLRequestStatus()); | 234 } |
234 else | |
235 NotifyFailed(result); | |
236 | 235 |
237 remaining_bytes_ -= result; | 236 ReadRawDataComplete(result); |
238 DCHECK_GE(remaining_bytes_, 0); | |
239 | |
240 NotifyReadComplete(result); | |
241 } | 237 } |
242 | 238 |
243 bool FileSystemURLRequestJob::IsRedirectResponse(GURL* location, | 239 bool FileSystemURLRequestJob::IsRedirectResponse(GURL* location, |
244 int* http_status_code) { | 240 int* http_status_code) { |
245 if (is_directory_) { | 241 if (is_directory_) { |
246 // This happens when we discovered the file is a directory, so needs a | 242 // This happens when we discovered the file is a directory, so needs a |
247 // slash at the end of the path. | 243 // slash at the end of the path. |
248 std::string new_path = request_->url().path(); | 244 std::string new_path = request_->url().path(); |
249 new_path.push_back('/'); | 245 new_path.push_back('/'); |
250 GURL::Replacements replacements; | 246 GURL::Replacements replacements; |
251 replacements.SetPathStr(new_path); | 247 replacements.SetPathStr(new_path); |
252 *location = request_->url().ReplaceComponents(replacements); | 248 *location = request_->url().ReplaceComponents(replacements); |
253 *http_status_code = 301; // simulate a permanent redirect | 249 *http_status_code = 301; // simulate a permanent redirect |
254 return true; | 250 return true; |
255 } | 251 } |
256 | 252 |
257 return false; | 253 return false; |
258 } | 254 } |
259 | 255 |
260 void FileSystemURLRequestJob::NotifyFailed(int rv) { | |
261 NotifyDone(URLRequestStatus(URLRequestStatus::FAILED, rv)); | |
262 } | |
263 | |
264 } // namespace storage | 256 } // namespace storage |
OLD | NEW |