src/webkit/browser/blob/blob_url_request_job.cc

   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