| 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/blob_url_request_job.h" | |
| 6 | |
| 7 #include <limits> | |
| 8 | |
| 9 #include "base/basictypes.h" | |
| 10 #include "base/bind.h" | |
| 11 #include "base/compiler_specific.h" | |
| 12 #include "base/files/file_util_proxy.h" | |
| 13 #include "base/format_macros.h" | |
| 14 #include "base/message_loop/message_loop.h" | |
| 15 #include "base/message_loop/message_loop_proxy.h" | |
| 16 #include "base/stl_util.h" | |
| 17 #include "base/strings/string_number_conversions.h" | |
| 18 #include "base/strings/stringprintf.h" | |
| 19 #include "net/base/io_buffer.h" | |
| 20 #include "net/base/net_errors.h" | |
| 21 #include "net/http/http_request_headers.h" | |
| 22 #include "net/http/http_response_headers.h" | |
| 23 #include "net/http/http_response_info.h" | |
| 24 #include "net/http/http_util.h" | |
| 25 #include "net/url_request/url_request.h" | |
| 26 #include "net/url_request/url_request_context.h" | |
| 27 #include "net/url_request/url_request_error_job.h" | |
| 28 #include "net/url_request/url_request_status.h" | |
| 29 #include "webkit/browser/blob/file_stream_reader.h" | |
| 30 #include "webkit/browser/fileapi/file_system_context.h" | |
| 31 #include "webkit/browser/fileapi/file_system_url.h" | |
| 32 | |
| 33 namespace webkit_blob { | |
| 34 | |
| 35 namespace { | |
| 36 | |
| 37 bool IsFileType(BlobData::Item::Type type) { | |
| 38 switch (type) { | |
| 39 case BlobData::Item::TYPE_FILE: | |
| 40 case BlobData::Item::TYPE_FILE_FILESYSTEM: | |
| 41 return true; | |
| 42 default: | |
| 43 return false; | |
| 44 } | |
| 45 } | |
| 46 | |
| 47 } // namespace | |
| 48 | |
| 49 BlobURLRequestJob::BlobURLRequestJob( | |
| 50 net::URLRequest* request, | |
| 51 net::NetworkDelegate* network_delegate, | |
| 52 BlobData* blob_data, | |
| 53 fileapi::FileSystemContext* file_system_context, | |
| 54 base::MessageLoopProxy* file_thread_proxy) | |
| 55 : net::URLRequestJob(request, network_delegate), | |
| 56 blob_data_(blob_data), | |
| 57 file_system_context_(file_system_context), | |
| 58 file_thread_proxy_(file_thread_proxy), | |
| 59 total_size_(0), | |
| 60 remaining_bytes_(0), | |
| 61 pending_get_file_info_count_(0), | |
| 62 current_item_index_(0), | |
| 63 current_item_offset_(0), | |
| 64 error_(false), | |
| 65 byte_range_set_(false), | |
| 66 weak_factory_(this) { | |
| 67 DCHECK(file_thread_proxy_.get()); | |
| 68 } | |
| 69 | |
| 70 void BlobURLRequestJob::Start() { | |
| 71 // Continue asynchronously. | |
| 72 base::MessageLoop::current()->PostTask( | |
| 73 FROM_HERE, | |
| 74 base::Bind(&BlobURLRequestJob::DidStart, weak_factory_.GetWeakPtr())); | |
| 75 } | |
| 76 | |
| 77 void BlobURLRequestJob::Kill() { | |
| 78 DeleteCurrentFileReader(); | |
| 79 | |
| 80 net::URLRequestJob::Kill(); | |
| 81 weak_factory_.InvalidateWeakPtrs(); | |
| 82 } | |
| 83 | |
| 84 bool BlobURLRequestJob::ReadRawData(net::IOBuffer* dest, | |
| 85 int dest_size, | |
| 86 int* bytes_read) { | |
| 87 DCHECK_NE(dest_size, 0); | |
| 88 DCHECK(bytes_read); | |
| 89 DCHECK_GE(remaining_bytes_, 0); | |
| 90 | |
| 91 // Bail out immediately if we encounter an error. | |
| 92 if (error_) { | |
| 93 *bytes_read = 0; | |
| 94 return true; | |
| 95 } | |
| 96 | |
| 97 if (remaining_bytes_ < dest_size) | |
| 98 dest_size = static_cast<int>(remaining_bytes_); | |
| 99 | |
| 100 // If we should copy zero bytes because |remaining_bytes_| is zero, short | |
| 101 // circuit here. | |
| 102 if (!dest_size) { | |
| 103 *bytes_read = 0; | |
| 104 return true; | |
| 105 } | |
| 106 | |
| 107 // Keep track of the buffer. | |
| 108 DCHECK(!read_buf_.get()); | |
| 109 read_buf_ = new net::DrainableIOBuffer(dest, dest_size); | |
| 110 | |
| 111 return ReadLoop(bytes_read); | |
| 112 } | |
| 113 | |
| 114 bool BlobURLRequestJob::GetMimeType(std::string* mime_type) const { | |
| 115 if (!response_info_) | |
| 116 return false; | |
| 117 | |
| 118 return response_info_->headers->GetMimeType(mime_type); | |
| 119 } | |
| 120 | |
| 121 void BlobURLRequestJob::GetResponseInfo(net::HttpResponseInfo* info) { | |
| 122 if (response_info_) | |
| 123 *info = *response_info_; | |
| 124 } | |
| 125 | |
| 126 int BlobURLRequestJob::GetResponseCode() const { | |
| 127 if (!response_info_) | |
| 128 return -1; | |
| 129 | |
| 130 return response_info_->headers->response_code(); | |
| 131 } | |
| 132 | |
| 133 void BlobURLRequestJob::SetExtraRequestHeaders( | |
| 134 const net::HttpRequestHeaders& headers) { | |
| 135 std::string range_header; | |
| 136 if (headers.GetHeader(net::HttpRequestHeaders::kRange, &range_header)) { | |
| 137 // We only care about "Range" header here. | |
| 138 std::vector<net::HttpByteRange> ranges; | |
| 139 if (net::HttpUtil::ParseRangeHeader(range_header, &ranges)) { | |
| 140 if (ranges.size() == 1) { | |
| 141 byte_range_set_ = true; | |
| 142 byte_range_ = ranges[0]; | |
| 143 } else { | |
| 144 // We don't support multiple range requests in one single URL request, | |
| 145 // because we need to do multipart encoding here. | |
| 146 // TODO(jianli): Support multipart byte range requests. | |
| 147 NotifyFailure(net::ERR_REQUEST_RANGE_NOT_SATISFIABLE); | |
| 148 } | |
| 149 } | |
| 150 } | |
| 151 } | |
| 152 | |
| 153 BlobURLRequestJob::~BlobURLRequestJob() { | |
| 154 STLDeleteValues(&index_to_reader_); | |
| 155 } | |
| 156 | |
| 157 void BlobURLRequestJob::DidStart() { | |
| 158 error_ = false; | |
| 159 | |
| 160 // We only support GET request per the spec. | |
| 161 if (request()->method() != "GET") { | |
| 162 NotifyFailure(net::ERR_METHOD_NOT_SUPPORTED); | |
| 163 return; | |
| 164 } | |
| 165 | |
| 166 // If the blob data is not present, bail out. | |
| 167 if (!blob_data_.get()) { | |
| 168 NotifyFailure(net::ERR_FILE_NOT_FOUND); | |
| 169 return; | |
| 170 } | |
| 171 | |
| 172 CountSize(); | |
| 173 } | |
| 174 | |
| 175 bool BlobURLRequestJob::AddItemLength(size_t index, int64 item_length) { | |
| 176 if (item_length > kint64max - total_size_) { | |
| 177 NotifyFailure(net::ERR_FAILED); | |
| 178 return false; | |
| 179 } | |
| 180 | |
| 181 // Cache the size and add it to the total size. | |
| 182 DCHECK_LT(index, item_length_list_.size()); | |
| 183 item_length_list_[index] = item_length; | |
| 184 total_size_ += item_length; | |
| 185 return true; | |
| 186 } | |
| 187 | |
| 188 void BlobURLRequestJob::CountSize() { | |
| 189 pending_get_file_info_count_ = 0; | |
| 190 total_size_ = 0; | |
| 191 item_length_list_.resize(blob_data_->items().size()); | |
| 192 | |
| 193 for (size_t i = 0; i < blob_data_->items().size(); ++i) { | |
| 194 const BlobData::Item& item = blob_data_->items().at(i); | |
| 195 if (IsFileType(item.type())) { | |
| 196 ++pending_get_file_info_count_; | |
| 197 GetFileStreamReader(i)->GetLength( | |
| 198 base::Bind(&BlobURLRequestJob::DidGetFileItemLength, | |
| 199 weak_factory_.GetWeakPtr(), i)); | |
| 200 continue; | |
| 201 } | |
| 202 | |
| 203 if (!AddItemLength(i, item.length())) | |
| 204 return; | |
| 205 } | |
| 206 | |
| 207 if (pending_get_file_info_count_ == 0) | |
| 208 DidCountSize(net::OK); | |
| 209 } | |
| 210 | |
| 211 void BlobURLRequestJob::DidCountSize(int error) { | |
| 212 DCHECK(!error_); | |
| 213 | |
| 214 // If an error occured, bail out. | |
| 215 if (error != net::OK) { | |
| 216 NotifyFailure(error); | |
| 217 return; | |
| 218 } | |
| 219 | |
| 220 // Apply the range requirement. | |
| 221 if (!byte_range_.ComputeBounds(total_size_)) { | |
| 222 NotifyFailure(net::ERR_REQUEST_RANGE_NOT_SATISFIABLE); | |
| 223 return; | |
| 224 } | |
| 225 | |
| 226 remaining_bytes_ = byte_range_.last_byte_position() - | |
| 227 byte_range_.first_byte_position() + 1; | |
| 228 DCHECK_GE(remaining_bytes_, 0); | |
| 229 | |
| 230 // Do the seek at the beginning of the request. | |
| 231 if (byte_range_.first_byte_position()) | |
| 232 Seek(byte_range_.first_byte_position()); | |
| 233 | |
| 234 NotifySuccess(); | |
| 235 } | |
| 236 | |
| 237 void BlobURLRequestJob::DidGetFileItemLength(size_t index, int64 result) { | |
| 238 // Do nothing if we have encountered an error. | |
| 239 if (error_) | |
| 240 return; | |
| 241 | |
| 242 if (result == net::ERR_UPLOAD_FILE_CHANGED) { | |
| 243 NotifyFailure(net::ERR_FILE_NOT_FOUND); | |
| 244 return; | |
| 245 } else if (result < 0) { | |
| 246 NotifyFailure(result); | |
| 247 return; | |
| 248 } | |
| 249 | |
| 250 DCHECK_LT(index, blob_data_->items().size()); | |
| 251 const BlobData::Item& item = blob_data_->items().at(index); | |
| 252 DCHECK(IsFileType(item.type())); | |
| 253 | |
| 254 uint64 file_length = result; | |
| 255 uint64 item_offset = item.offset(); | |
| 256 uint64 item_length = item.length(); | |
| 257 | |
| 258 if (item_offset > file_length) { | |
| 259 NotifyFailure(net::ERR_FILE_NOT_FOUND); | |
| 260 return; | |
| 261 } | |
| 262 | |
| 263 uint64 max_length = file_length - item_offset; | |
| 264 | |
| 265 // If item length is -1, we need to use the file size being resolved | |
| 266 // in the real time. | |
| 267 if (item_length == static_cast<uint64>(-1)) { | |
| 268 item_length = max_length; | |
| 269 } else if (item_length > max_length) { | |
| 270 NotifyFailure(net::ERR_FILE_NOT_FOUND); | |
| 271 return; | |
| 272 } | |
| 273 | |
| 274 if (!AddItemLength(index, item_length)) | |
| 275 return; | |
| 276 | |
| 277 if (--pending_get_file_info_count_ == 0) | |
| 278 DidCountSize(net::OK); | |
| 279 } | |
| 280 | |
| 281 void BlobURLRequestJob::Seek(int64 offset) { | |
| 282 // Skip the initial items that are not in the range. | |
| 283 for (current_item_index_ = 0; | |
| 284 current_item_index_ < blob_data_->items().size() && | |
| 285 offset >= item_length_list_[current_item_index_]; | |
| 286 ++current_item_index_) { | |
| 287 offset -= item_length_list_[current_item_index_]; | |
| 288 } | |
| 289 | |
| 290 // Set the offset that need to jump to for the first item in the range. | |
| 291 current_item_offset_ = offset; | |
| 292 | |
| 293 if (offset == 0) | |
| 294 return; | |
| 295 | |
| 296 // Adjust the offset of the first stream if it is of file type. | |
| 297 const BlobData::Item& item = blob_data_->items().at(current_item_index_); | |
| 298 if (IsFileType(item.type())) { | |
| 299 DeleteCurrentFileReader(); | |
| 300 CreateFileStreamReader(current_item_index_, offset); | |
| 301 } | |
| 302 } | |
| 303 | |
| 304 bool BlobURLRequestJob::ReadItem() { | |
| 305 // Are we done with reading all the blob data? | |
| 306 if (remaining_bytes_ == 0) | |
| 307 return true; | |
| 308 | |
| 309 // If we get to the last item but still expect something to read, bail out | |
| 310 // since something is wrong. | |
| 311 if (current_item_index_ >= blob_data_->items().size()) { | |
| 312 NotifyFailure(net::ERR_FAILED); | |
| 313 return false; | |
| 314 } | |
| 315 | |
| 316 // Compute the bytes to read for current item. | |
| 317 int bytes_to_read = ComputeBytesToRead(); | |
| 318 | |
| 319 // If nothing to read for current item, advance to next item. | |
| 320 if (bytes_to_read == 0) { | |
| 321 AdvanceItem(); | |
| 322 return ReadItem(); | |
| 323 } | |
| 324 | |
| 325 // Do the reading. | |
| 326 const BlobData::Item& item = blob_data_->items().at(current_item_index_); | |
| 327 if (item.type() == BlobData::Item::TYPE_BYTES) | |
| 328 return ReadBytesItem(item, bytes_to_read); | |
| 329 if (IsFileType(item.type())) { | |
| 330 return ReadFileItem(GetFileStreamReader(current_item_index_), | |
| 331 bytes_to_read); | |
| 332 } | |
| 333 NOTREACHED(); | |
| 334 return false; | |
| 335 } | |
| 336 | |
| 337 void BlobURLRequestJob::AdvanceItem() { | |
| 338 // Close the file if the current item is a file. | |
| 339 DeleteCurrentFileReader(); | |
| 340 | |
| 341 // Advance to the next item. | |
| 342 current_item_index_++; | |
| 343 current_item_offset_ = 0; | |
| 344 } | |
| 345 | |
| 346 void BlobURLRequestJob::AdvanceBytesRead(int result) { | |
| 347 DCHECK_GT(result, 0); | |
| 348 | |
| 349 // Do we finish reading the current item? | |
| 350 current_item_offset_ += result; | |
| 351 if (current_item_offset_ == item_length_list_[current_item_index_]) | |
| 352 AdvanceItem(); | |
| 353 | |
| 354 // Subtract the remaining bytes. | |
| 355 remaining_bytes_ -= result; | |
| 356 DCHECK_GE(remaining_bytes_, 0); | |
| 357 | |
| 358 // Adjust the read buffer. | |
| 359 read_buf_->DidConsume(result); | |
| 360 DCHECK_GE(read_buf_->BytesRemaining(), 0); | |
| 361 } | |
| 362 | |
| 363 bool BlobURLRequestJob::ReadBytesItem(const BlobData::Item& item, | |
| 364 int bytes_to_read) { | |
| 365 DCHECK_GE(read_buf_->BytesRemaining(), bytes_to_read); | |
| 366 | |
| 367 memcpy(read_buf_->data(), | |
| 368 item.bytes() + item.offset() + current_item_offset_, | |
| 369 bytes_to_read); | |
| 370 | |
| 371 AdvanceBytesRead(bytes_to_read); | |
| 372 return true; | |
| 373 } | |
| 374 | |
| 375 bool BlobURLRequestJob::ReadFileItem(FileStreamReader* reader, | |
| 376 int bytes_to_read) { | |
| 377 DCHECK_GE(read_buf_->BytesRemaining(), bytes_to_read); | |
| 378 DCHECK(reader); | |
| 379 const int result = reader->Read( | |
| 380 read_buf_.get(), | |
| 381 bytes_to_read, | |
| 382 base::Bind(&BlobURLRequestJob::DidReadFile, base::Unretained(this))); | |
| 383 if (result >= 0) { | |
| 384 // Data is immediately available. | |
| 385 if (GetStatus().is_io_pending()) | |
| 386 DidReadFile(result); | |
| 387 else | |
| 388 AdvanceBytesRead(result); | |
| 389 return true; | |
| 390 } | |
| 391 if (result == net::ERR_IO_PENDING) | |
| 392 SetStatus(net::URLRequestStatus(net::URLRequestStatus::IO_PENDING, 0)); | |
| 393 else | |
| 394 NotifyFailure(result); | |
| 395 return false; | |
| 396 } | |
| 397 | |
| 398 void BlobURLRequestJob::DidReadFile(int result) { | |
| 399 if (result <= 0) { | |
| 400 NotifyFailure(net::ERR_FAILED); | |
| 401 return; | |
| 402 } | |
| 403 SetStatus(net::URLRequestStatus()); // Clear the IO_PENDING status | |
| 404 | |
| 405 AdvanceBytesRead(result); | |
| 406 | |
| 407 // If the read buffer is completely filled, we're done. | |
| 408 if (!read_buf_->BytesRemaining()) { | |
| 409 int bytes_read = BytesReadCompleted(); | |
| 410 NotifyReadComplete(bytes_read); | |
| 411 return; | |
| 412 } | |
| 413 | |
| 414 // Otherwise, continue the reading. | |
| 415 int bytes_read = 0; | |
| 416 if (ReadLoop(&bytes_read)) | |
| 417 NotifyReadComplete(bytes_read); | |
| 418 } | |
| 419 | |
| 420 void BlobURLRequestJob::DeleteCurrentFileReader() { | |
| 421 IndexToReaderMap::iterator found = index_to_reader_.find(current_item_index_); | |
| 422 if (found != index_to_reader_.end() && found->second) { | |
| 423 delete found->second; | |
| 424 index_to_reader_.erase(found); | |
| 425 } | |
| 426 } | |
| 427 | |
| 428 int BlobURLRequestJob::BytesReadCompleted() { | |
| 429 int bytes_read = read_buf_->BytesConsumed(); | |
| 430 read_buf_ = NULL; | |
| 431 return bytes_read; | |
| 432 } | |
| 433 | |
| 434 int BlobURLRequestJob::ComputeBytesToRead() const { | |
| 435 int64 current_item_length = item_length_list_[current_item_index_]; | |
| 436 | |
| 437 int64 item_remaining = current_item_length - current_item_offset_; | |
| 438 int64 buf_remaining = read_buf_->BytesRemaining(); | |
| 439 int64 max_remaining = std::numeric_limits<int>::max(); | |
| 440 | |
| 441 int64 min = std::min(std::min(std::min(item_remaining, | |
| 442 buf_remaining), | |
| 443 remaining_bytes_), | |
| 444 max_remaining); | |
| 445 | |
| 446 return static_cast<int>(min); | |
| 447 } | |
| 448 | |
| 449 bool BlobURLRequestJob::ReadLoop(int* bytes_read) { | |
| 450 // Read until we encounter an error or could not get the data immediately. | |
| 451 while (remaining_bytes_ > 0 && read_buf_->BytesRemaining() > 0) { | |
| 452 if (!ReadItem()) | |
| 453 return false; | |
| 454 } | |
| 455 | |
| 456 *bytes_read = BytesReadCompleted(); | |
| 457 return true; | |
| 458 } | |
| 459 | |
| 460 void BlobURLRequestJob::NotifySuccess() { | |
| 461 net::HttpStatusCode status_code = net::HTTP_OK; | |
| 462 if (byte_range_set_ && byte_range_.IsValid()) | |
| 463 status_code = net::HTTP_PARTIAL_CONTENT; | |
| 464 HeadersCompleted(status_code); | |
| 465 } | |
| 466 | |
| 467 void BlobURLRequestJob::NotifyFailure(int error_code) { | |
| 468 error_ = true; | |
| 469 | |
| 470 // If we already return the headers on success, we can't change the headers | |
| 471 // now. Instead, we just error out. | |
| 472 if (response_info_) { | |
| 473 NotifyDone(net::URLRequestStatus(net::URLRequestStatus::FAILED, | |
| 474 error_code)); | |
| 475 return; | |
| 476 } | |
| 477 | |
| 478 net::HttpStatusCode status_code = net::HTTP_INTERNAL_SERVER_ERROR; | |
| 479 switch (error_code) { | |
| 480 case net::ERR_ACCESS_DENIED: | |
| 481 status_code = net::HTTP_FORBIDDEN; | |
| 482 break; | |
| 483 case net::ERR_FILE_NOT_FOUND: | |
| 484 status_code = net::HTTP_NOT_FOUND; | |
| 485 break; | |
| 486 case net::ERR_METHOD_NOT_SUPPORTED: | |
| 487 status_code = net::HTTP_METHOD_NOT_ALLOWED; | |
| 488 break; | |
| 489 case net::ERR_REQUEST_RANGE_NOT_SATISFIABLE: | |
| 490 status_code = net::HTTP_REQUESTED_RANGE_NOT_SATISFIABLE; | |
| 491 break; | |
| 492 case net::ERR_FAILED: | |
| 493 break; | |
| 494 default: | |
| 495 DCHECK(false); | |
| 496 break; | |
| 497 } | |
| 498 HeadersCompleted(status_code); | |
| 499 } | |
| 500 | |
| 501 void BlobURLRequestJob::HeadersCompleted(net::HttpStatusCode status_code) { | |
| 502 std::string status("HTTP/1.1 "); | |
| 503 status.append(base::IntToString(status_code)); | |
| 504 status.append(" "); | |
| 505 status.append(net::GetHttpReasonPhrase(status_code)); | |
| 506 status.append("\0\0", 2); | |
| 507 net::HttpResponseHeaders* headers = new net::HttpResponseHeaders(status); | |
| 508 | |
| 509 if (status_code == net::HTTP_OK || status_code == net::HTTP_PARTIAL_CONTENT) { | |
| 510 std::string content_length_header(net::HttpRequestHeaders::kContentLength); | |
| 511 content_length_header.append(": "); | |
| 512 content_length_header.append(base::Int64ToString(remaining_bytes_)); | |
| 513 headers->AddHeader(content_length_header); | |
| 514 if (status_code == net::HTTP_PARTIAL_CONTENT) { | |
| 515 DCHECK(byte_range_set_); | |
| 516 DCHECK(byte_range_.IsValid()); | |
| 517 std::string content_range_header(net::HttpResponseHeaders::kContentRange); | |
| 518 content_range_header.append(": bytes "); | |
| 519 content_range_header.append(base::StringPrintf( | |
| 520 "%" PRId64 "-%" PRId64, | |
| 521 byte_range_.first_byte_position(), byte_range_.last_byte_position())); | |
| 522 content_range_header.append("/"); | |
| 523 content_range_header.append(base::StringPrintf("%" PRId64, total_size_)); | |
| 524 headers->AddHeader(content_range_header); | |
| 525 } | |
| 526 if (!blob_data_->content_type().empty()) { | |
| 527 std::string content_type_header(net::HttpRequestHeaders::kContentType); | |
| 528 content_type_header.append(": "); | |
| 529 content_type_header.append(blob_data_->content_type()); | |
| 530 headers->AddHeader(content_type_header); | |
| 531 } | |
| 532 if (!blob_data_->content_disposition().empty()) { | |
| 533 std::string content_disposition_header("Content-Disposition: "); | |
| 534 content_disposition_header.append(blob_data_->content_disposition()); | |
| 535 headers->AddHeader(content_disposition_header); | |
| 536 } | |
| 537 } | |
| 538 | |
| 539 response_info_.reset(new net::HttpResponseInfo()); | |
| 540 response_info_->headers = headers; | |
| 541 | |
| 542 set_expected_content_size(remaining_bytes_); | |
| 543 | |
| 544 NotifyHeadersComplete(); | |
| 545 } | |
| 546 | |
| 547 FileStreamReader* BlobURLRequestJob::GetFileStreamReader(size_t index) { | |
| 548 DCHECK_LT(index, blob_data_->items().size()); | |
| 549 const BlobData::Item& item = blob_data_->items().at(index); | |
| 550 if (!IsFileType(item.type())) | |
| 551 return NULL; | |
| 552 if (index_to_reader_.find(index) == index_to_reader_.end()) | |
| 553 CreateFileStreamReader(index, 0); | |
| 554 DCHECK(index_to_reader_[index]); | |
| 555 return index_to_reader_[index]; | |
| 556 } | |
| 557 | |
| 558 void BlobURLRequestJob::CreateFileStreamReader(size_t index, | |
| 559 int64 additional_offset) { | |
| 560 DCHECK_LT(index, blob_data_->items().size()); | |
| 561 const BlobData::Item& item = blob_data_->items().at(index); | |
| 562 DCHECK(IsFileType(item.type())); | |
| 563 DCHECK_EQ(0U, index_to_reader_.count(index)); | |
| 564 | |
| 565 FileStreamReader* reader = NULL; | |
| 566 switch (item.type()) { | |
| 567 case BlobData::Item::TYPE_FILE: | |
| 568 reader = FileStreamReader::CreateForLocalFile( | |
| 569 file_thread_proxy_.get(), | |
| 570 item.path(), | |
| 571 item.offset() + additional_offset, | |
| 572 item.expected_modification_time()); | |
| 573 break; | |
| 574 case BlobData::Item::TYPE_FILE_FILESYSTEM: | |
| 575 reader = file_system_context_->CreateFileStreamReader( | |
| 576 fileapi::FileSystemURL( | |
| 577 file_system_context_->CrackURL(item.filesystem_url())), | |
| 578 item.offset() + additional_offset, | |
| 579 item.expected_modification_time()).release(); | |
| 580 break; | |
| 581 default: | |
| 582 NOTREACHED(); | |
| 583 } | |
| 584 DCHECK(reader); | |
| 585 index_to_reader_[index] = reader; | |
| 586 } | |
| 587 | |
| 588 } // namespace webkit_blob | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 442383002:
Move storage-related files from webkit/ to new top-level directory storage/ (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src