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 // Do nothing if pending_buffer_ is empty, i.e. there's no ReadRawData() 43 // operation waiting for IO completion. 44 if (!pending_buffer_.get()) 45 return; 46 47 // pending_buffer_ is set to the IOBuffer instance provided to ReadRawData() 48 // by URLRequestJob. 49 50 int bytes_read; 51 switch (stream_->ReadRawData( 52 pending_buffer_.get(), pending_buffer_size_, &bytes_read)) { 53 case Stream::STREAM_HAS_DATA: 54 DCHECK_GT(bytes_read, 0); 55 break; 56 case Stream::STREAM_COMPLETE: 57 // Ensure this. Calling NotifyReadComplete call with 0 signals 58 // completion. 59 bytes_read = 0; 60 break; 61 case Stream::STREAM_EMPTY: 62 NOTREACHED(); 63 break; 64 case Stream::STREAM_ABORTED: 65 // Handle this as connection reset. 66 NotifyDone(net::URLRequestStatus(net::URLRequestStatus::FAILED, 67 net::ERR_CONNECTION_RESET)); 68 break; 69 } 70 71 // Clear the buffers before notifying the read is complete, so that it is 72 // safe for the observer to read. 73 pending_buffer_ = NULL; 74 pending_buffer_size_ = 0; 75 76 total_bytes_read_ += bytes_read; 77 NotifyReadComplete(bytes_read); 78 } 79 80 // net::URLRequestJob methods. 81 void StreamURLRequestJob::Start() { 82 // Continue asynchronously. 83 base::MessageLoop::current()->PostTask( 84 FROM_HERE, 85 base::Bind(&StreamURLRequestJob::DidStart, weak_factory_.GetWeakPtr())); 86 } 87 88 void StreamURLRequestJob::Kill() { 89 net::URLRequestJob::Kill(); 90 weak_factory_.InvalidateWeakPtrs(); 91 ClearStream(); 92 } 93 94 bool StreamURLRequestJob::ReadRawData(net::IOBuffer* buf, 95 int buf_size, 96 int* bytes_read) { 97 if (request_failed_) 98 return true; 99 100 DCHECK(buf); 101 DCHECK(bytes_read); 102 int to_read = buf_size; 103 if (max_range_ && to_read) { 104 if (to_read + total_bytes_read_ > max_range_) 105 to_read = max_range_ - total_bytes_read_; 106 107 if (to_read <= 0) { 108 *bytes_read = 0; 109 return true; 110 } 111 } 112 113 switch (stream_->ReadRawData(buf, to_read, bytes_read)) { 114 case Stream::STREAM_HAS_DATA: 115 case Stream::STREAM_COMPLETE: 116 total_bytes_read_ += *bytes_read; 117 return true; 118 case Stream::STREAM_EMPTY: 119 pending_buffer_ = buf; 120 pending_buffer_size_ = to_read; 121 SetStatus(net::URLRequestStatus(net::URLRequestStatus::IO_PENDING, 0)); 122 return false; 123 case Stream::STREAM_ABORTED: 124 // Handle this as connection reset. 125 NotifyDone(net::URLRequestStatus(net::URLRequestStatus::FAILED, 126 net::ERR_CONNECTION_RESET)); 127 return false; 128 } 129 NOTREACHED(); 130 return false; 131 } 132 133 bool StreamURLRequestJob::GetMimeType(std::string* mime_type) const { 134 if (!response_info_) 135 return false; 136 137 // TODO(zork): Support registered MIME types if needed. 138 return response_info_->headers->GetMimeType(mime_type); 139 } 140 141 void StreamURLRequestJob::GetResponseInfo(net::HttpResponseInfo* info) { 142 if (response_info_) 143 *info = *response_info_; 144 } 145 146 int StreamURLRequestJob::GetResponseCode() const { 147 if (!response_info_) 148 return -1; 149 150 return response_info_->headers->response_code(); 151 } 152 153 void StreamURLRequestJob::SetExtraRequestHeaders( 154 const net::HttpRequestHeaders& headers) { 155 std::string range_header; 156 if (headers.GetHeader(net::HttpRequestHeaders::kRange, &range_header)) { 157 std::vector<net::HttpByteRange> ranges; 158 if (net::HttpUtil::ParseRangeHeader(range_header, &ranges)) { 159 if (ranges.size() == 1) { 160 // Streams don't support seeking, so a non-zero starting position 161 // doesn't make sense. 162 if (ranges[0].first_byte_position() == 0) { 163 max_range_ = ranges[0].last_byte_position() + 1; 164 } else { 165 NotifyFailure(net::ERR_METHOD_NOT_SUPPORTED); 166 return; 167 } 168 } else { 169 NotifyFailure(net::ERR_METHOD_NOT_SUPPORTED); 170 return; 171 } 172 } 173 } 174 } 175 176 void StreamURLRequestJob::DidStart() { 177 // We only support GET request. 178 if (request()->method() != "GET") { 179 NotifyFailure(net::ERR_METHOD_NOT_SUPPORTED); 180 return; 181 } 182 183 HeadersCompleted(net::HTTP_OK); 184 } 185 186 void StreamURLRequestJob::NotifyFailure(int error_code) { 187 request_failed_ = true; 188 189 // If we already return the headers on success, we can't change the headers 190 // now. Instead, we just error out. 191 if (headers_set_) { 192 NotifyDone(net::URLRequestStatus(net::URLRequestStatus::FAILED, 193 error_code)); 194 return; 195 } 196 197 // TODO(zork): Share these with BlobURLRequestJob. 198 net::HttpStatusCode status_code = net::HTTP_INTERNAL_SERVER_ERROR; 199 switch (error_code) { 200 case net::ERR_ACCESS_DENIED: 201 status_code = net::HTTP_FORBIDDEN; 202 break; 203 case net::ERR_FILE_NOT_FOUND: 204 status_code = net::HTTP_NOT_FOUND; 205 break; 206 case net::ERR_METHOD_NOT_SUPPORTED: 207 status_code = net::HTTP_METHOD_NOT_ALLOWED; 208 break; 209 case net::ERR_FAILED: 210 break; 211 default: 212 DCHECK(false); 213 break; 214 } 215 HeadersCompleted(status_code); 216 } 217 218 void StreamURLRequestJob::HeadersCompleted(net::HttpStatusCode status_code) { 219 std::string status("HTTP/1.1 "); 220 status.append(base::IntToString(status_code)); 221 status.append(" "); 222 status.append(net::GetHttpReasonPhrase(status_code)); 223 status.append("\0\0", 2); 224 net::HttpResponseHeaders* headers = new net::HttpResponseHeaders(status); 225 226 if (status_code == net::HTTP_OK) { 227 std::string content_type_header(net::HttpRequestHeaders::kContentType); 228 content_type_header.append(": "); 229 content_type_header.append("text/plain"); 230 headers->AddHeader(content_type_header); 231 } 232 233 response_info_.reset(new net::HttpResponseInfo()); 234 response_info_->headers = headers; 235 236 headers_set_ = true; 237 238 NotifyHeadersComplete(); 239 } 240 241 void StreamURLRequestJob::ClearStream() { 242 if (stream_.get()) { 243 stream_->RemoveReadObserver(this); 244 stream_ = NULL; 245 } 246 } 247 248 } // namespace content 249
