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
Start()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
AddUrlHandler()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
Factory(net::URLRequest * request,net::NetworkDelegate * network_delegate,const std::string & scheme)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
NumberOutstandingRequests()74 size_t URLRequestSlowDownloadJob::NumberOutstandingRequests() {
75 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
76 return pending_requests_.Get().size();
77 }
78
79 // static
FinishPendingRequests()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
ErrorPendingRequests()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
URLRequestSlowDownloadJob(net::URLRequest * request,net::NetworkDelegate * network_delegate)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
StartAsync()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
FillBufferHelper(net::IOBuffer * buf,int buf_size,int * bytes_written)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
ReadRawData(net::IOBuffer * buf,int buf_size,int * bytes_read)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
CheckDoneStatus()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.
GetResponseInfo(net::HttpResponseInfo * info)228 void URLRequestSlowDownloadJob::GetResponseInfo(net::HttpResponseInfo* info) {
229 // Forward to private const version.
230 GetResponseInfoConst(info);
231 }
232
~URLRequestSlowDownloadJob()233 URLRequestSlowDownloadJob::~URLRequestSlowDownloadJob() {
234 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
235 pending_requests_.Get().erase(this);
236 }
237
238 // Private const version.
GetResponseInfoConst(net::HttpResponseInfo * info) const239 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
GetMimeType(std::string * mime_type) const268 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