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 "content/test/net/url_request_slow_download_job.h" 6 7 #include "base/bind.h" 8 #include "base/compiler_specific.h" 9 #include "base/logging.h" 10 #include "base/message_loop/message_loop.h" 11 #include "base/strings/string_util.h" 12 #include "base/strings/stringprintf.h" 13 #include "content/public/browser/browser_thread.h" 14 #include "net/base/io_buffer.h" 15 #include "net/base/net_errors.h" 16 #include "net/http/http_response_headers.h" 17 #include "net/url_request/url_request.h" 18 #include "net/url_request/url_request_filter.h" 19 #include "url/gurl.h" 20 21 namespace content { 22 23 const char URLRequestSlowDownloadJob::kUnknownSizeUrl[] = 24 "http://url.handled.by.slow.download/download-unknown-size"; 25 const char URLRequestSlowDownloadJob::kKnownSizeUrl[] = 26 "http://url.handled.by.slow.download/download-known-size"; 27 const char URLRequestSlowDownloadJob::kFinishDownloadUrl[] = 28 "http://url.handled.by.slow.download/download-finish"; 29 const char URLRequestSlowDownloadJob::kErrorDownloadUrl[] = 30 "http://url.handled.by.slow.download/download-error"; 31 32 const int URLRequestSlowDownloadJob::kFirstDownloadSize = 1024 * 35; 33 const int URLRequestSlowDownloadJob::kSecondDownloadSize = 1024 * 10; 34 35 // static 36 base::LazyInstance<URLRequestSlowDownloadJob::SlowJobsSet>::Leaky 37 URLRequestSlowDownloadJob::pending_requests_ = LAZY_INSTANCE_INITIALIZER; 38 39 void URLRequestSlowDownloadJob::Start() { 40 base::MessageLoop::current()->PostTask( 41 FROM_HERE, 42 base::Bind(&URLRequestSlowDownloadJob::StartAsync, 43 weak_factory_.GetWeakPtr())); 44 } 45 46 // static 47 void URLRequestSlowDownloadJob::AddUrlHandler() { 48 net::URLRequestFilter* filter = net::URLRequestFilter::GetInstance(); 49 filter->AddUrlHandler(GURL(kUnknownSizeUrl), 50 &URLRequestSlowDownloadJob::Factory); 51 filter->AddUrlHandler(GURL(kKnownSizeUrl), 52 &URLRequestSlowDownloadJob::Factory); 53 filter->AddUrlHandler(GURL(kFinishDownloadUrl), 54 &URLRequestSlowDownloadJob::Factory); 55 filter->AddUrlHandler(GURL(kErrorDownloadUrl), 56 &URLRequestSlowDownloadJob::Factory); 57 } 58 59 // static 60 net::URLRequestJob* URLRequestSlowDownloadJob::Factory( 61 net::URLRequest* request, 62 net::NetworkDelegate* network_delegate, 63 const std::string& scheme) { 64 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); 65 URLRequestSlowDownloadJob* job = new URLRequestSlowDownloadJob( 66 request, network_delegate); 67 if (request->url().spec() != kFinishDownloadUrl && 68 request->url().spec() != kErrorDownloadUrl) 69 pending_requests_.Get().insert(job); 70 return job; 71 } 72 73 // static 74 size_t URLRequestSlowDownloadJob::NumberOutstandingRequests() { 75 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); 76 return pending_requests_.Get().size(); 77 } 78 79 // static 80 void URLRequestSlowDownloadJob::FinishPendingRequests() { 81 typedef std::set<URLRequestSlowDownloadJob*> JobList; 82 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); 83 for (JobList::iterator it = pending_requests_.Get().begin(); it != 84 pending_requests_.Get().end(); ++it) { 85 (*it)->set_should_finish_download(); 86 } 87 } 88 89 void URLRequestSlowDownloadJob::ErrorPendingRequests() { 90 typedef std::set<URLRequestSlowDownloadJob*> JobList; 91 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); 92 for (JobList::iterator it = pending_requests_.Get().begin(); it != 93 pending_requests_.Get().end(); ++it) { 94 (*it)->set_should_error_download(); 95 } 96 } 97 98 URLRequestSlowDownloadJob::URLRequestSlowDownloadJob( 99 net::URLRequest* request, net::NetworkDelegate* network_delegate) 100 : net::URLRequestJob(request, network_delegate), 101 bytes_already_sent_(0), 102 should_error_download_(false), 103 should_finish_download_(false), 104 buffer_size_(0), 105 weak_factory_(this) { 106 } 107 108 void URLRequestSlowDownloadJob::StartAsync() { 109 if (LowerCaseEqualsASCII(kFinishDownloadUrl, request_->url().spec().c_str())) 110 URLRequestSlowDownloadJob::FinishPendingRequests(); 111 if (LowerCaseEqualsASCII(kErrorDownloadUrl, request_->url().spec().c_str())) 112 URLRequestSlowDownloadJob::ErrorPendingRequests(); 113 114 NotifyHeadersComplete(); 115 } 116 117 // ReadRawData and CheckDoneStatus together implement a state 118 // machine. ReadRawData may be called arbitrarily by the network stack. 119 // It responds by: 120 // * If there are bytes remaining in the first chunk, they are 121 // returned. 122 // [No bytes remaining in first chunk. ] 123 // * If should_finish_download_ is not set, it returns IO_PENDING, 124 // and starts calling CheckDoneStatus on a regular timer. 125 // [should_finish_download_ set.] 126 // * If there are bytes remaining in the second chunk, they are filled. 127 // * Otherwise, return *bytes_read = 0 to indicate end of request. 128 // CheckDoneStatus is called on a regular basis, in the specific 129 // case where we have transmitted all of the first chunk and none of the 130 // second. If should_finish_download_ becomes set, it will "complete" 131 // the ReadRawData call that spawned off the CheckDoneStatus() repeated call. 132 // 133 // FillBufferHelper is a helper function that does the actual work of figuring 134 // out where in the state machine we are and how we should fill the buffer. 135 // It returns an enum indicating the state of the read. 136 URLRequestSlowDownloadJob::ReadStatus 137 URLRequestSlowDownloadJob::FillBufferHelper( 138 net::IOBuffer* buf, int buf_size, int* bytes_written) { 139 if (bytes_already_sent_ < kFirstDownloadSize) { 140 int bytes_to_write = std::min(kFirstDownloadSize - bytes_already_sent_, 141 buf_size); 142 for (int i = 0; i < bytes_to_write; ++i) { 143 buf->data()[i] = '*'; 144 } 145 *bytes_written = bytes_to_write; 146 bytes_already_sent_ += bytes_to_write; 147 return BUFFER_FILLED; 148 } 149 150 if (!should_finish_download_) 151 return REQUEST_BLOCKED; 152 153 if (bytes_already_sent_ < kFirstDownloadSize + kSecondDownloadSize) { 154 int bytes_to_write = 155 std::min(kFirstDownloadSize + kSecondDownloadSize - bytes_already_sent_, 156 buf_size); 157 for (int i = 0; i < bytes_to_write; ++i) { 158 buf->data()[i] = '*'; 159 } 160 *bytes_written = bytes_to_write; 161 bytes_already_sent_ += bytes_to_write; 162 return BUFFER_FILLED; 163 } 164 165 return REQUEST_COMPLETE; 166 } 167 168 bool URLRequestSlowDownloadJob::ReadRawData(net::IOBuffer* buf, int buf_size, 169 int* bytes_read) { 170 if (LowerCaseEqualsASCII(kFinishDownloadUrl, 171 request_->url().spec().c_str()) || 172 LowerCaseEqualsASCII(kErrorDownloadUrl, 173 request_->url().spec().c_str())) { 174 VLOG(10) << __FUNCTION__ << " called w/ kFinish/ErrorDownloadUrl."; 175 *bytes_read = 0; 176 return true; 177 } 178 179 VLOG(10) << __FUNCTION__ << " called at position " 180 << bytes_already_sent_ << " in the stream."; 181 ReadStatus status = FillBufferHelper(buf, buf_size, bytes_read); 182 switch (status) { 183 case BUFFER_FILLED: 184 return true; 185 case REQUEST_BLOCKED: 186 buffer_ = buf; 187 buffer_size_ = buf_size; 188 SetStatus(net::URLRequestStatus(net::URLRequestStatus::IO_PENDING, 0)); 189 base::MessageLoop::current()->PostDelayedTask( 190 FROM_HERE, 191 base::Bind(&URLRequestSlowDownloadJob::CheckDoneStatus, 192 weak_factory_.GetWeakPtr()), 193 base::TimeDelta::FromMilliseconds(100)); 194 return false; 195 case REQUEST_COMPLETE: 196 *bytes_read = 0; 197 return true; 198 } 199 NOTREACHED(); 200 return true; 201 } 202 203 void URLRequestSlowDownloadJob::CheckDoneStatus() { 204 if (should_finish_download_) { 205 VLOG(10) << __FUNCTION__ << " called w/ should_finish_download_ set."; 206 DCHECK(NULL != buffer_.get()); 207 int bytes_written = 0; 208 ReadStatus status = 209 FillBufferHelper(buffer_.get(), buffer_size_, &bytes_written); 210 DCHECK_EQ(BUFFER_FILLED, status); 211 buffer_ = NULL; // Release the reference. 212 SetStatus(net::URLRequestStatus()); 213 NotifyReadComplete(bytes_written); 214 } else if (should_error_download_) { 215 VLOG(10) << __FUNCTION__ << " called w/ should_finish_ownload_ set."; 216 NotifyDone(net::URLRequestStatus( 217 net::URLRequestStatus::FAILED, net::ERR_CONNECTION_RESET)); 218 } else { 219 base::MessageLoop::current()->PostDelayedTask( 220 FROM_HERE, 221 base::Bind(&URLRequestSlowDownloadJob::CheckDoneStatus, 222 weak_factory_.GetWeakPtr()), 223 base::TimeDelta::FromMilliseconds(100)); 224 } 225 } 226 227 // Public virtual version. 228 void URLRequestSlowDownloadJob::GetResponseInfo(net::HttpResponseInfo* info) { 229 // Forward to private const version. 230 GetResponseInfoConst(info); 231 } 232 233 URLRequestSlowDownloadJob::~URLRequestSlowDownloadJob() { 234 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); 235 pending_requests_.Get().erase(this); 236 } 237 238 // Private const version. 239 void URLRequestSlowDownloadJob::GetResponseInfoConst( 240 net::HttpResponseInfo* info) const { 241 // Send back mock headers. 242 std::string raw_headers; 243 if (LowerCaseEqualsASCII(kFinishDownloadUrl, 244 request_->url().spec().c_str()) || 245 LowerCaseEqualsASCII(kErrorDownloadUrl, 246 request_->url().spec().c_str())) { 247 raw_headers.append( 248 "HTTP/1.1 200 OK\n" 249 "Content-type: text/plain\n"); 250 } else { 251 raw_headers.append( 252 "HTTP/1.1 200 OK\n" 253 "Content-type: application/octet-stream\n" 254 "Cache-Control: max-age=0\n"); 255 256 if (LowerCaseEqualsASCII(kKnownSizeUrl, request_->url().spec().c_str())) { 257 raw_headers.append(base::StringPrintf( 258 "Content-Length: %d\n", 259 kFirstDownloadSize + kSecondDownloadSize)); 260 } 261 } 262 263 // ParseRawHeaders expects \0 to end each header line. 264 ReplaceSubstringsAfterOffset(&raw_headers, 0, "\n", std::string("\0", 1)); 265 info->headers = new net::HttpResponseHeaders(raw_headers); 266 } 267 268 bool URLRequestSlowDownloadJob::GetMimeType(std::string* mime_type) const { 269 net::HttpResponseInfo info; 270 GetResponseInfoConst(&info); 271 return info.headers.get() && info.headers->GetMimeType(mime_type); 272 } 273 274 } // namespace content 275
