Home | History | Annotate | Download | only in streams 
      1 // Copyright (c) 2013 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 "content/browser/streams/stream_url_request_job.h"
      6 
      7 #include "base/strings/string_number_conversions.h"
      8 #include "content/browser/streams/stream.h"
      9 #include "net/base/io_buffer.h"
     10 #include "net/base/net_errors.h"
     11 #include "net/http/http_byte_range.h"
     12 #include "net/http/http_response_headers.h"
     13 #include "net/http/http_response_info.h"
     14 #include "net/http/http_util.h"
     15 #include "net/url_request/url_request.h"
     16 
     17 namespace content {
     18 
     19 StreamURLRequestJob::StreamURLRequestJob(
     20     net::URLRequest* request,
     21     net::NetworkDelegate* network_delegate,
     22     scoped_refptr<Stream> stream)
     23     : net::URLRequestJob(request, network_delegate),
     24       weak_factory_(this),
     25       stream_(stream),
     26       headers_set_(false),
     27       pending_buffer_size_(0),
     28       total_bytes_read_(0),
     29       max_range_(0),
     30       request_failed_(false) {
     31   DCHECK(stream_.get());
     32   stream_->SetReadObserver(this);
     33 }
     34 
     35 StreamURLRequestJob::~StreamURLRequestJob() {
     36   ClearStream();
     37 }
     38 
     39 void StreamURLRequestJob::OnDataAvailable(Stream* stream) {
     40   // Clear the IO_PENDING status.
     41   SetStatus(net::URLRequestStatus());
     42   if (pending_buffer_.get()) {
     43     int bytes_read;
     44     stream_->ReadRawData(
     45         pending_buffer_.get(), pending_buffer_size_, &bytes_read);
     46 
     47     // Clear the buffers before notifying the read is complete, so that it is
     48     // safe for the observer to read.
     49     pending_buffer_ = NULL;
     50     pending_buffer_size_ = 0;
     51 
     52     total_bytes_read_ += bytes_read;
     53     NotifyReadComplete(bytes_read);
     54   }
     55 }
     56 
     57 // net::URLRequestJob methods.
     58 void StreamURLRequestJob::Start() {
     59   // Continue asynchronously.
     60   base::MessageLoop::current()->PostTask(
     61       FROM_HERE,
     62       base::Bind(&StreamURLRequestJob::DidStart, weak_factory_.GetWeakPtr()));
     63 }
     64 
     65 void StreamURLRequestJob::Kill() {
     66   net::URLRequestJob::Kill();
     67   weak_factory_.InvalidateWeakPtrs();
     68   ClearStream();
     69 }
     70 
     71 bool StreamURLRequestJob::ReadRawData(net::IOBuffer* buf,
     72                                       int buf_size,
     73                                       int* bytes_read) {
     74   if (request_failed_)
     75     return true;
     76 
     77   DCHECK(bytes_read);
     78   int to_read = buf_size;
     79   if (max_range_ && to_read) {
     80     if (to_read + total_bytes_read_ > max_range_)
     81       to_read = max_range_ - total_bytes_read_;
     82 
     83     if (to_read <= 0) {
     84       *bytes_read = 0;
     85       return true;
     86     }
     87   }
     88 
     89   switch (stream_->ReadRawData(buf, to_read, bytes_read)) {
     90     case Stream::STREAM_HAS_DATA:
     91     case Stream::STREAM_COMPLETE:
     92       total_bytes_read_ += *bytes_read;
     93       return true;
     94     case Stream::STREAM_EMPTY:
     95       pending_buffer_ = buf;
     96       pending_buffer_size_ = to_read;
     97       SetStatus(net::URLRequestStatus(net::URLRequestStatus::IO_PENDING, 0));
     98       return false;
     99   }
    100   NOTREACHED();
    101   return false;
    102 }
    103 
    104 bool StreamURLRequestJob::GetMimeType(std::string* mime_type) const {
    105   if (!response_info_)
    106     return false;
    107 
    108   // TODO(zork): Support registered MIME types if needed.
    109   return response_info_->headers->GetMimeType(mime_type);
    110 }
    111 
    112 void StreamURLRequestJob::GetResponseInfo(net::HttpResponseInfo* info) {
    113   if (response_info_)
    114     *info = *response_info_;
    115 }
    116 
    117 int StreamURLRequestJob::GetResponseCode() const {
    118   if (!response_info_)
    119     return -1;
    120 
    121   return response_info_->headers->response_code();
    122 }
    123 
    124 void StreamURLRequestJob::SetExtraRequestHeaders(
    125     const net::HttpRequestHeaders& headers) {
    126   std::string range_header;
    127   if (headers.GetHeader(net::HttpRequestHeaders::kRange, &range_header)) {
    128     std::vector<net::HttpByteRange> ranges;
    129     if (net::HttpUtil::ParseRangeHeader(range_header, &ranges)) {
    130       if (ranges.size() == 1) {
    131         // Streams don't support seeking, so a non-zero starting position
    132         // doesn't make sense.
    133         if (ranges[0].first_byte_position() == 0) {
    134           max_range_ = ranges[0].last_byte_position() + 1;
    135         } else {
    136           NotifyFailure(net::ERR_METHOD_NOT_SUPPORTED);
    137           return;
    138         }
    139       } else {
    140         NotifyFailure(net::ERR_METHOD_NOT_SUPPORTED);
    141         return;
    142       }
    143     }
    144   }
    145 }
    146 
    147 void StreamURLRequestJob::DidStart() {
    148   // We only support GET request.
    149   if (request()->method() != "GET") {
    150     NotifyFailure(net::ERR_METHOD_NOT_SUPPORTED);
    151     return;
    152   }
    153 
    154   HeadersCompleted(net::HTTP_OK);
    155 }
    156 
    157 void StreamURLRequestJob::NotifyFailure(int error_code) {
    158   request_failed_ = true;
    159 
    160   // If we already return the headers on success, we can't change the headers
    161   // now. Instead, we just error out.
    162   if (headers_set_) {
    163     NotifyDone(net::URLRequestStatus(net::URLRequestStatus::FAILED,
    164                                      error_code));
    165     return;
    166   }
    167 
    168   // TODO(zork): Share these with BlobURLRequestJob.
    169   net::HttpStatusCode status_code = net::HTTP_INTERNAL_SERVER_ERROR;
    170   std::string status_txt;
    171   switch (error_code) {
    172     case net::ERR_ACCESS_DENIED:
    173       status_code = net::HTTP_FORBIDDEN;
    174       break;
    175     case net::ERR_FILE_NOT_FOUND:
    176       status_code = net::HTTP_NOT_FOUND;
    177       break;
    178     case net::ERR_METHOD_NOT_SUPPORTED:
    179       status_code = net::HTTP_METHOD_NOT_ALLOWED;
    180       break;
    181     case net::ERR_FAILED:
    182       break;
    183     default:
    184       DCHECK(false);
    185       break;
    186   }
    187   HeadersCompleted(status_code);
    188 }
    189 
    190 void StreamURLRequestJob::HeadersCompleted(net::HttpStatusCode status_code) {
    191   std::string status("HTTP/1.1 ");
    192   status.append(base::IntToString(status_code));
    193   status.append(" ");
    194   status.append(net::GetHttpReasonPhrase(status_code));
    195   status.append("\0\0", 2);
    196   net::HttpResponseHeaders* headers = new net::HttpResponseHeaders(status);
    197 
    198   if (status_code == net::HTTP_OK) {
    199     std::string content_type_header(net::HttpRequestHeaders::kContentType);
    200     content_type_header.append(": ");
    201     content_type_header.append("plain/text");
    202     headers->AddHeader(content_type_header);
    203   }
    204 
    205   response_info_.reset(new net::HttpResponseInfo());
    206   response_info_->headers = headers;
    207 
    208   headers_set_ = true;
    209 
    210   NotifyHeadersComplete();
    211 }
    212 
    213 void StreamURLRequestJob::ClearStream() {
    214   if (stream_.get()) {
    215     stream_->RemoveReadObserver(this);
    216     stream_ = NULL;
    217   }
    218 }
    219 
    220 }  // namespace content
    221