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/browser/download/download_resource_handler.h"
6
7 #include <string>
8
9 #include "base/bind.h"
10 #include "base/logging.h"
11 #include "base/message_loop/message_loop_proxy.h"
12 #include "base/metrics/histogram.h"
13 #include "base/metrics/stats_counters.h"
14 #include "base/strings/stringprintf.h"
15 #include "content/browser/byte_stream.h"
16 #include "content/browser/download/download_create_info.h"
17 #include "content/browser/download/download_interrupt_reasons_impl.h"
18 #include "content/browser/download/download_manager_impl.h"
19 #include "content/browser/download/download_request_handle.h"
20 #include "content/browser/download/download_stats.h"
21 #include "content/browser/loader/resource_dispatcher_host_impl.h"
22 #include "content/browser/loader/resource_request_info_impl.h"
23 #include "content/public/browser/browser_thread.h"
24 #include "content/public/browser/download_interrupt_reasons.h"
25 #include "content/public/browser/download_item.h"
26 #include "content/public/browser/download_manager_delegate.h"
27 #include "content/public/browser/navigation_entry.h"
28 #include "content/public/browser/power_save_blocker.h"
29 #include "content/public/browser/web_contents.h"
30 #include "content/public/common/resource_response.h"
31 #include "net/base/io_buffer.h"
32 #include "net/base/net_errors.h"
33 #include "net/http/http_response_headers.h"
34 #include "net/http/http_status_code.h"
35 #include "net/url_request/url_request_context.h"
36
37 namespace content {
38
39 struct DownloadResourceHandler::DownloadTabInfo {
40 GURL tab_url;
41 GURL tab_referrer_url;
42 };
43
44 namespace {
45
CallStartedCBOnUIThread(const DownloadUrlParameters::OnStartedCallback & started_cb,DownloadItem * item,DownloadInterruptReason interrupt_reason)46 void CallStartedCBOnUIThread(
47 const DownloadUrlParameters::OnStartedCallback& started_cb,
48 DownloadItem* item,
49 DownloadInterruptReason interrupt_reason) {
50 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
51
52 if (started_cb.is_null())
53 return;
54 started_cb.Run(item, interrupt_reason);
55 }
56
57 // Static function in order to prevent any accidental accesses to
58 // DownloadResourceHandler members from the UI thread.
StartOnUIThread(scoped_ptr<DownloadCreateInfo> info,DownloadResourceHandler::DownloadTabInfo * tab_info,scoped_ptr<ByteStreamReader> stream,const DownloadUrlParameters::OnStartedCallback & started_cb)59 static void StartOnUIThread(
60 scoped_ptr<DownloadCreateInfo> info,
61 DownloadResourceHandler::DownloadTabInfo* tab_info,
62 scoped_ptr<ByteStreamReader> stream,
63 const DownloadUrlParameters::OnStartedCallback& started_cb) {
64 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
65
66 DownloadManager* download_manager = info->request_handle.GetDownloadManager();
67 if (!download_manager) {
68 // NULL in unittests or if the page closed right after starting the
69 // download.
70 if (!started_cb.is_null())
71 started_cb.Run(NULL, DOWNLOAD_INTERRUPT_REASON_USER_CANCELED);
72
73 // |stream| gets deleted on non-FILE thread, but it's ok since
74 // we're not using stream_writer_ yet.
75
76 return;
77 }
78
79 info->tab_url = tab_info->tab_url;
80 info->tab_referrer_url = tab_info->tab_referrer_url;
81
82 download_manager->StartDownload(info.Pass(), stream.Pass(), started_cb);
83 }
84
InitializeDownloadTabInfoOnUIThread(const DownloadRequestHandle & request_handle,DownloadResourceHandler::DownloadTabInfo * tab_info)85 void InitializeDownloadTabInfoOnUIThread(
86 const DownloadRequestHandle& request_handle,
87 DownloadResourceHandler::DownloadTabInfo* tab_info) {
88 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
89
90 WebContents* web_contents = request_handle.GetWebContents();
91 if (web_contents) {
92 NavigationEntry* entry = web_contents->GetController().GetVisibleEntry();
93 if (entry) {
94 tab_info->tab_url = entry->GetURL();
95 tab_info->tab_referrer_url = entry->GetReferrer().url;
96 }
97 }
98 }
99
100 } // namespace
101
102 const int DownloadResourceHandler::kDownloadByteStreamSize = 100 * 1024;
103
DownloadResourceHandler(uint32 id,net::URLRequest * request,const DownloadUrlParameters::OnStartedCallback & started_cb,scoped_ptr<DownloadSaveInfo> save_info)104 DownloadResourceHandler::DownloadResourceHandler(
105 uint32 id,
106 net::URLRequest* request,
107 const DownloadUrlParameters::OnStartedCallback& started_cb,
108 scoped_ptr<DownloadSaveInfo> save_info)
109 : ResourceHandler(request),
110 download_id_(id),
111 started_cb_(started_cb),
112 save_info_(save_info.Pass()),
113 last_buffer_size_(0),
114 bytes_read_(0),
115 pause_count_(0),
116 was_deferred_(false),
117 on_response_started_called_(false) {
118 RecordDownloadCount(UNTHROTTLED_COUNT);
119
120 // Do UI thread initialization asap after DownloadResourceHandler creation
121 // since the tab could be navigated before StartOnUIThread gets called.
122 const ResourceRequestInfoImpl* request_info = GetRequestInfo();
123 tab_info_ = new DownloadTabInfo();
124 BrowserThread::PostTask(
125 BrowserThread::UI,
126 FROM_HERE,
127 base::Bind(&InitializeDownloadTabInfoOnUIThread,
128 DownloadRequestHandle(AsWeakPtr(),
129 request_info->GetChildID(),
130 request_info->GetRouteID(),
131 request_info->GetRequestID()),
132 tab_info_));
133 power_save_blocker_ = PowerSaveBlocker::Create(
134 PowerSaveBlocker::kPowerSaveBlockPreventAppSuspension,
135 "Download in progress");
136 }
137
OnUploadProgress(uint64 position,uint64 size)138 bool DownloadResourceHandler::OnUploadProgress(uint64 position,
139 uint64 size) {
140 return true;
141 }
142
OnRequestRedirected(const net::RedirectInfo & redirect_info,ResourceResponse * response,bool * defer)143 bool DownloadResourceHandler::OnRequestRedirected(
144 const net::RedirectInfo& redirect_info,
145 ResourceResponse* response,
146 bool* defer) {
147 return true;
148 }
149
150 // Send the download creation information to the download thread.
OnResponseStarted(ResourceResponse * response,bool * defer)151 bool DownloadResourceHandler::OnResponseStarted(
152 ResourceResponse* response,
153 bool* defer) {
154 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
155 // There can be only one (call)
156 DCHECK(!on_response_started_called_);
157 on_response_started_called_ = true;
158
159 VLOG(20) << __FUNCTION__ << "()" << DebugString();
160 download_start_time_ = base::TimeTicks::Now();
161
162 // If it's a download, we don't want to poison the cache with it.
163 request()->StopCaching();
164
165 // Lower priority as well, so downloads don't contend for resources
166 // with main frames.
167 request()->SetPriority(net::IDLE);
168
169 // If the content-length header is not present (or contains something other
170 // than numbers), the incoming content_length is -1 (unknown size).
171 // Set the content length to 0 to indicate unknown size to DownloadManager.
172 int64 content_length =
173 response->head.content_length > 0 ? response->head.content_length : 0;
174
175 const ResourceRequestInfoImpl* request_info = GetRequestInfo();
176
177 // Deleted in DownloadManager.
178 scoped_ptr<DownloadCreateInfo> info(
179 new DownloadCreateInfo(base::Time::Now(),
180 content_length,
181 request()->net_log(),
182 request_info->HasUserGesture(),
183 request_info->GetPageTransition(),
184 save_info_.Pass()));
185
186 // Create the ByteStream for sending data to the download sink.
187 scoped_ptr<ByteStreamReader> stream_reader;
188 CreateByteStream(
189 base::MessageLoopProxy::current(),
190 BrowserThread::GetMessageLoopProxyForThread(BrowserThread::FILE),
191 kDownloadByteStreamSize, &stream_writer_, &stream_reader);
192 stream_writer_->RegisterCallback(
193 base::Bind(&DownloadResourceHandler::ResumeRequest, AsWeakPtr()));
194
195 info->download_id = download_id_;
196 info->url_chain = request()->url_chain();
197 info->referrer_url = GURL(request()->referrer());
198 info->mime_type = response->head.mime_type;
199 info->remote_address = request()->GetSocketAddress().host();
200 request()->GetResponseHeaderByName("content-disposition",
201 &info->content_disposition);
202 RecordDownloadMimeType(info->mime_type);
203 RecordDownloadContentDisposition(info->content_disposition);
204
205 info->request_handle =
206 DownloadRequestHandle(AsWeakPtr(), request_info->GetChildID(),
207 request_info->GetRouteID(),
208 request_info->GetRequestID());
209
210 // Get the last modified time and etag.
211 const net::HttpResponseHeaders* headers = request()->response_headers();
212 if (headers) {
213 if (headers->HasStrongValidators()) {
214 // If we don't have strong validators as per RFC 2616 section 13.3.3, then
215 // we neither store nor use them for range requests.
216 if (!headers->EnumerateHeader(NULL, "Last-Modified",
217 &info->last_modified))
218 info->last_modified.clear();
219 if (!headers->EnumerateHeader(NULL, "ETag", &info->etag))
220 info->etag.clear();
221 }
222
223 int status = headers->response_code();
224 if (2 == status / 100 && status != net::HTTP_PARTIAL_CONTENT) {
225 // Success & not range response; if we asked for a range, we didn't
226 // get it--reset the file pointers to reflect that.
227 info->save_info->offset = 0;
228 info->save_info->hash_state = "";
229 }
230
231 if (!headers->GetMimeType(&info->original_mime_type))
232 info->original_mime_type.clear();
233 }
234
235 // Blink verifies that the requester of this download is allowed to set a
236 // suggested name for the security origin of the downlaod URL. However, this
237 // assumption doesn't hold if there were cross origin redirects. Therefore,
238 // clear the suggested_name for such requests.
239 if (info->url_chain.size() > 1 &&
240 info->url_chain.front().GetOrigin() != info->url_chain.back().GetOrigin())
241 info->save_info->suggested_name.clear();
242
243 BrowserThread::PostTask(
244 BrowserThread::UI, FROM_HERE,
245 base::Bind(&StartOnUIThread,
246 base::Passed(&info),
247 base::Owned(tab_info_),
248 base::Passed(&stream_reader),
249 // Pass to StartOnUIThread so that variable
250 // access is always on IO thread but function
251 // is called on UI thread.
252 started_cb_));
253 // Now owned by the task that was just posted.
254 tab_info_ = NULL;
255 // Guaranteed to be called in StartOnUIThread
256 started_cb_.Reset();
257
258 return true;
259 }
260
CallStartedCB(DownloadItem * item,DownloadInterruptReason interrupt_reason)261 void DownloadResourceHandler::CallStartedCB(
262 DownloadItem* item,
263 DownloadInterruptReason interrupt_reason) {
264 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
265 if (started_cb_.is_null())
266 return;
267 BrowserThread::PostTask(
268 BrowserThread::UI,
269 FROM_HERE,
270 base::Bind(
271 &CallStartedCBOnUIThread, started_cb_, item, interrupt_reason));
272 started_cb_.Reset();
273 }
274
OnWillStart(const GURL & url,bool * defer)275 bool DownloadResourceHandler::OnWillStart(const GURL& url, bool* defer) {
276 return true;
277 }
278
OnBeforeNetworkStart(const GURL & url,bool * defer)279 bool DownloadResourceHandler::OnBeforeNetworkStart(const GURL& url,
280 bool* defer) {
281 return true;
282 }
283
284 // Create a new buffer, which will be handed to the download thread for file
285 // writing and deletion.
OnWillRead(scoped_refptr<net::IOBuffer> * buf,int * buf_size,int min_size)286 bool DownloadResourceHandler::OnWillRead(scoped_refptr<net::IOBuffer>* buf,
287 int* buf_size,
288 int min_size) {
289 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
290 DCHECK(buf && buf_size);
291 DCHECK(!read_buffer_.get());
292
293 *buf_size = min_size < 0 ? kReadBufSize : min_size;
294 last_buffer_size_ = *buf_size;
295 read_buffer_ = new net::IOBuffer(*buf_size);
296 *buf = read_buffer_.get();
297 return true;
298 }
299
300 // Pass the buffer to the download file writer.
OnReadCompleted(int bytes_read,bool * defer)301 bool DownloadResourceHandler::OnReadCompleted(int bytes_read, bool* defer) {
302 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
303 DCHECK(read_buffer_.get());
304
305 base::TimeTicks now(base::TimeTicks::Now());
306 if (!last_read_time_.is_null()) {
307 double seconds_since_last_read = (now - last_read_time_).InSecondsF();
308 if (now == last_read_time_)
309 // Use 1/10 ms as a "very small number" so that we avoid
310 // divide-by-zero error and still record a very high potential bandwidth.
311 seconds_since_last_read = 0.00001;
312
313 double actual_bandwidth = (bytes_read)/seconds_since_last_read;
314 double potential_bandwidth = last_buffer_size_/seconds_since_last_read;
315 RecordBandwidth(actual_bandwidth, potential_bandwidth);
316 }
317 last_read_time_ = now;
318
319 if (!bytes_read)
320 return true;
321 bytes_read_ += bytes_read;
322 DCHECK(read_buffer_.get());
323
324 // Take the data ship it down the stream. If the stream is full, pause the
325 // request; the stream callback will resume it.
326 if (!stream_writer_->Write(read_buffer_, bytes_read)) {
327 PauseRequest();
328 *defer = was_deferred_ = true;
329 last_stream_pause_time_ = now;
330 }
331
332 read_buffer_ = NULL; // Drop our reference.
333
334 if (pause_count_ > 0)
335 *defer = was_deferred_ = true;
336
337 return true;
338 }
339
OnResponseCompleted(const net::URLRequestStatus & status,const std::string & security_info,bool * defer)340 void DownloadResourceHandler::OnResponseCompleted(
341 const net::URLRequestStatus& status,
342 const std::string& security_info,
343 bool* defer) {
344 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
345 int response_code = status.is_success() ? request()->GetResponseCode() : 0;
346 VLOG(20) << __FUNCTION__ << "()" << DebugString()
347 << " status.status() = " << status.status()
348 << " status.error() = " << status.error()
349 << " response_code = " << response_code;
350
351 net::Error error_code = net::OK;
352 if (status.status() == net::URLRequestStatus::FAILED ||
353 // Note cancels as failures too.
354 status.status() == net::URLRequestStatus::CANCELED) {
355 error_code = static_cast<net::Error>(status.error()); // Normal case.
356 // Make sure that at least the fact of failure comes through.
357 if (error_code == net::OK)
358 error_code = net::ERR_FAILED;
359 }
360
361 // ERR_CONTENT_LENGTH_MISMATCH and ERR_INCOMPLETE_CHUNKED_ENCODING are
362 // allowed since a number of servers in the wild close the connection too
363 // early by mistake. Other browsers - IE9, Firefox 11.0, and Safari 5.1.4 -
364 // treat downloads as complete in both cases, so we follow their lead.
365 if (error_code == net::ERR_CONTENT_LENGTH_MISMATCH ||
366 error_code == net::ERR_INCOMPLETE_CHUNKED_ENCODING) {
367 error_code = net::OK;
368 }
369 DownloadInterruptReason reason =
370 ConvertNetErrorToInterruptReason(
371 error_code, DOWNLOAD_INTERRUPT_FROM_NETWORK);
372
373 if (status.status() == net::URLRequestStatus::CANCELED &&
374 status.error() == net::ERR_ABORTED) {
375 // CANCELED + ERR_ABORTED == something outside of the network
376 // stack cancelled the request. There aren't that many things that
377 // could do this to a download request (whose lifetime is separated from
378 // the tab from which it came). We map this to USER_CANCELLED as the
379 // case we know about (system suspend because of laptop close) corresponds
380 // to a user action.
381 // TODO(ahendrickson) -- Find a better set of codes to use here, as
382 // CANCELED/ERR_ABORTED can occur for reasons other than user cancel.
383 if (net::IsCertStatusError(request()->ssl_info().cert_status))
384 reason = DOWNLOAD_INTERRUPT_REASON_SERVER_CERT_PROBLEM;
385 else
386 reason = DOWNLOAD_INTERRUPT_REASON_USER_CANCELED;
387 }
388
389 if (status.is_success() &&
390 reason == DOWNLOAD_INTERRUPT_REASON_NONE &&
391 request()->response_headers()) {
392 // Handle server's response codes.
393 switch(response_code) {
394 case -1: // Non-HTTP request.
395 case net::HTTP_OK:
396 case net::HTTP_CREATED:
397 case net::HTTP_ACCEPTED:
398 case net::HTTP_NON_AUTHORITATIVE_INFORMATION:
399 case net::HTTP_RESET_CONTENT:
400 case net::HTTP_PARTIAL_CONTENT:
401 // Expected successful codes.
402 break;
403 case net::HTTP_NO_CONTENT:
404 case net::HTTP_NOT_FOUND:
405 reason = DOWNLOAD_INTERRUPT_REASON_SERVER_BAD_CONTENT;
406 break;
407 case net::HTTP_PRECONDITION_FAILED:
408 // Failed our 'If-Unmodified-Since' or 'If-Match'; see
409 // download_manager_impl.cc BeginDownload()
410 reason = DOWNLOAD_INTERRUPT_REASON_SERVER_PRECONDITION;
411 break;
412 case net::HTTP_REQUESTED_RANGE_NOT_SATISFIABLE:
413 // Retry by downloading from the start automatically:
414 // If we haven't received data when we get this error, we won't.
415 reason = DOWNLOAD_INTERRUPT_REASON_SERVER_NO_RANGE;
416 break;
417 case net::HTTP_UNAUTHORIZED:
418 // Server didn't authorize this request.
419 reason = DOWNLOAD_INTERRUPT_REASON_SERVER_UNAUTHORIZED;
420 break;
421 default: // All other errors.
422 // Redirection and informational codes should have been handled earlier
423 // in the stack.
424 DCHECK_NE(3, response_code / 100);
425 DCHECK_NE(1, response_code / 100);
426 reason = DOWNLOAD_INTERRUPT_REASON_SERVER_FAILED;
427 break;
428 }
429 }
430
431 std::string accept_ranges;
432 bool has_strong_validators = false;
433 if (request()->response_headers()) {
434 request()->response_headers()->EnumerateHeader(
435 NULL, "Accept-Ranges", &accept_ranges);
436 has_strong_validators =
437 request()->response_headers()->HasStrongValidators();
438 }
439 RecordAcceptsRanges(accept_ranges, bytes_read_, has_strong_validators);
440 RecordNetworkBlockage(base::TimeTicks::Now() - download_start_time_,
441 total_pause_time_);
442
443 CallStartedCB(NULL, reason);
444
445 // Send the info down the stream. Conditional is in case we get
446 // OnResponseCompleted without OnResponseStarted.
447 if (stream_writer_)
448 stream_writer_->Close(reason);
449
450 // If the error mapped to something unknown, record it so that
451 // we can drill down.
452 if (reason == DOWNLOAD_INTERRUPT_REASON_NETWORK_FAILED) {
453 UMA_HISTOGRAM_CUSTOM_ENUMERATION("Download.MapErrorNetworkFailed",
454 std::abs(status.error()),
455 net::GetAllErrorCodesForUma());
456 }
457
458 stream_writer_.reset(); // We no longer need the stream.
459 read_buffer_ = NULL;
460 }
461
OnDataDownloaded(int bytes_downloaded)462 void DownloadResourceHandler::OnDataDownloaded(int bytes_downloaded) {
463 NOTREACHED();
464 }
465
PauseRequest()466 void DownloadResourceHandler::PauseRequest() {
467 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
468
469 ++pause_count_;
470 }
471
ResumeRequest()472 void DownloadResourceHandler::ResumeRequest() {
473 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
474 DCHECK_LT(0, pause_count_);
475
476 --pause_count_;
477
478 if (!was_deferred_)
479 return;
480 if (pause_count_ > 0)
481 return;
482
483 was_deferred_ = false;
484 if (!last_stream_pause_time_.is_null()) {
485 total_pause_time_ += (base::TimeTicks::Now() - last_stream_pause_time_);
486 last_stream_pause_time_ = base::TimeTicks();
487 }
488
489 controller()->Resume();
490 }
491
CancelRequest()492 void DownloadResourceHandler::CancelRequest() {
493 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
494
495 const ResourceRequestInfo* info = GetRequestInfo();
496 ResourceDispatcherHostImpl::Get()->CancelRequest(
497 info->GetChildID(),
498 info->GetRequestID());
499 // This object has been deleted.
500 }
501
DebugString() const502 std::string DownloadResourceHandler::DebugString() const {
503 const ResourceRequestInfo* info = GetRequestInfo();
504 return base::StringPrintf("{"
505 " url_ = " "\"%s\""
506 " info = {"
507 " child_id = " "%d"
508 " request_id = " "%d"
509 " route_id = " "%d"
510 " }"
511 " }",
512 request() ?
513 request()->url().spec().c_str() :
514 "<NULL request>",
515 info->GetChildID(),
516 info->GetRequestID(),
517 info->GetRouteID());
518 }
519
~DownloadResourceHandler()520 DownloadResourceHandler::~DownloadResourceHandler() {
521 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
522
523 // This won't do anything if the callback was called before.
524 // If it goes through, it will likely be because OnWillStart() returned
525 // false somewhere in the chain of resource handlers.
526 CallStartedCB(NULL, DOWNLOAD_INTERRUPT_REASON_NETWORK_FAILED);
527
528 // Remove output stream callback if a stream exists.
529 if (stream_writer_)
530 stream_writer_->RegisterCallback(base::Closure());
531
532 // tab_info_ must be destroyed on UI thread, since
533 // InitializeDownloadTabInfoOnUIThread might still be using it.
534 if (tab_info_)
535 BrowserThread::DeleteSoon(BrowserThread::UI, FROM_HERE, tab_info_);
536
537 UMA_HISTOGRAM_TIMES("SB2.DownloadDuration",
538 base::TimeTicks::Now() - download_start_time_);
539 }
540
541 } // namespace content
542