blob: ccb9aaaf0deacd59c092df337c86b04ca8af2ba6 [file] [log] [blame]
[email protected]0afff032012-01-06 20:55:001// Copyright (c) 2012 The Chromium Authors. All rights reserved.
license.botbf09a502008-08-24 00:55:552// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
initial.commit09911bf2008-07-26 23:55:294
[email protected]5656f8a2011-11-17 16:12:585#include "content/browser/download/download_manager_impl.h"
initial.commit09911bf2008-07-26 23:55:296
[email protected]e7557f172011-08-19 23:42:017#include <iterator>
dcheng36b6aec92015-12-26 06:16:368#include <utility>
[email protected]e7557f172011-08-19 23:42:019
[email protected]eda58402011-09-21 19:32:0210#include "base/bind.h"
[email protected]2041cf342010-02-19 03:15:5911#include "base/callback.h"
[email protected]c6944272012-01-06 22:12:2812#include "base/debug/alias.h"
[email protected]503d03872011-05-06 08:36:2613#include "base/i18n/case_conversion.h"
initial.commit09911bf2008-07-26 23:55:2914#include "base/logging.h"
dchengf6c40582016-04-09 00:05:1315#include "base/memory/ptr_util.h"
svaldez6901c902015-12-10 18:57:3316#include "base/memory/weak_ptr.h"
[email protected]95f861e2013-07-18 02:07:1717#include "base/message_loop/message_loop.h"
jialiul82b8e502016-09-30 17:42:4218#include "base/metrics/histogram_macros.h"
[email protected]7286e3fc2011-07-19 22:13:2419#include "base/stl_util.h"
[email protected]10994d132013-06-11 07:16:1820#include "base/strings/stringprintf.h"
[email protected]40d11e02013-03-28 17:43:1421#include "base/strings/sys_string_conversions.h"
[email protected]d59d40c2012-08-08 18:18:3722#include "base/supports_user_data.h"
[email protected]eda58402011-09-21 19:32:0223#include "base/synchronization/lock.h"
[email protected]d2a8fb72010-01-21 05:31:4224#include "build/build_config.h"
[email protected]f8e92b5d2013-03-21 18:35:4625#include "content/browser/byte_stream.h"
anantac82dd5be2016-08-26 01:21:5326#include "content/browser/child_process_security_policy_impl.h"
[email protected]71bf3f5e2011-08-15 21:05:2227#include "content/browser/download/download_create_info.h"
[email protected]53ac00e82012-10-18 20:59:2028#include "content/browser/download/download_file_factory.h"
29#include "content/browser/download/download_item_factory.h"
[email protected]c09a8fd2011-11-21 19:54:5030#include "content/browser/download/download_item_impl.h"
[email protected]da4a5582011-10-17 19:08:0631#include "content/browser/download/download_stats.h"
[email protected]678c0362012-12-05 08:02:4432#include "content/browser/loader/resource_dispatcher_host_impl.h"
anantac82dd5be2016-08-26 01:21:5333#include "content/browser/loader/resource_request_info_impl.h"
[email protected]b3c41c0b2012-03-06 15:48:3234#include "content/browser/renderer_host/render_view_host_impl.h"
[email protected]93ddb3c2012-04-11 21:44:2935#include "content/browser/web_contents/web_contents_impl.h"
[email protected]ccb797302011-12-15 16:55:1136#include "content/public/browser/browser_context.h"
[email protected]87f3c082011-10-19 18:07:4437#include "content/public/browser/content_browser_client.h"
[email protected]bf3b08a2012-03-08 01:52:3438#include "content/public/browser/download_interrupt_reasons.h"
[email protected]1bd0ef12011-10-20 05:24:1739#include "content/public/browser/download_manager_delegate.h"
[email protected]c5a5c0842012-05-04 20:05:1440#include "content/public/browser/download_url_parameters.h"
[email protected]ad50def52011-10-19 23:17:0741#include "content/public/browser/notification_service.h"
[email protected]0d6e9bd2011-10-18 04:29:1642#include "content/public/browser/notification_types.h"
[email protected]f3b1a082011-11-18 00:34:3043#include "content/public/browser/render_process_host.h"
[email protected]94e2bbe2012-06-22 15:26:1344#include "content/public/browser/resource_context.h"
[email protected]0bfbf882011-12-22 18:19:2745#include "content/public/browser/web_contents_delegate.h"
megjabloncaf312f2017-01-12 18:47:4946#include "content/public/common/previews_state.h"
[email protected]8d68a3e02013-01-12 15:57:1047#include "content/public/common/referrer.h"
mmenkecbc2b712014-10-09 20:29:0748#include "net/base/elements_upload_data_stream.h"
[email protected]c5a5c0842012-05-04 20:05:1449#include "net/base/load_flags.h"
[email protected]2ca01e52013-10-31 22:05:1950#include "net/base/request_priority.h"
[email protected]f288ef02012-12-15 20:28:2851#include "net/base/upload_bytes_element_reader.h"
mikecirone8b85c432016-09-08 19:11:0052#include "net/log/net_log_source_type.h"
mikecironef22f9812016-10-04 03:40:1953#include "net/log/net_log_with_source.h"
[email protected]eb795632012-09-01 00:19:3154#include "net/url_request/url_request_context.h"
asanka6150c522016-03-25 21:40:5755#include "storage/browser/blob/blob_url_request_job_factory.h"
ttr31481dc54b2015-08-06 20:11:2656#include "url/origin.h"
initial.commit09911bf2008-07-26 23:55:2957
[email protected]35869622012-10-26 23:23:5558namespace content {
[email protected]a0ce3282011-08-19 20:49:5259namespace {
60
dchengf6c40582016-04-09 00:05:1361std::unique_ptr<UrlDownloader, BrowserThread::DeleteOnIOThread> BeginDownload(
62 std::unique_ptr<DownloadUrlParameters> params,
asanka3b4be122016-05-11 04:27:5763 content::ResourceContext* resource_context,
avib7348942015-12-25 20:57:1064 uint32_t download_id,
svaldez6901c902015-12-10 18:57:3365 base::WeakPtr<DownloadManagerImpl> download_manager) {
mostynbfbcdc27a2015-03-13 17:58:5266 DCHECK_CURRENTLY_ON(BrowserThread::IO);
[email protected]8d68a3e02013-01-12 15:57:1067
dchengf6c40582016-04-09 00:05:1368 std::unique_ptr<net::URLRequest> url_request =
asanka00b621f2016-02-19 18:09:2369 DownloadRequestCore::CreateRequestOnIOThread(download_id, params.get());
dchengf6c40582016-04-09 00:05:1370 std::unique_ptr<storage::BlobDataHandle> blob_data_handle =
asanka6150c522016-03-25 21:40:5771 params->GetBlobDataHandle();
72 if (blob_data_handle) {
73 storage::BlobProtocolHandler::SetRequestedBlobDataHandle(
74 url_request.get(), std::move(blob_data_handle));
75 }
[email protected]fc179dd12013-03-16 09:35:1976
asanka00b621f2016-02-19 18:09:2377 // If there's a valid renderer process associated with the request, then the
78 // request should be driven by the ResourceLoader. Pass it over to the
79 // ResourceDispatcherHostImpl which will in turn pass it along to the
80 // ResourceLoader.
asanka3b4be122016-05-11 04:27:5781 if (params->render_process_host_id() >= 0) {
anantac82dd5be2016-08-26 01:21:5382 DownloadInterruptReason reason = DownloadManagerImpl::BeginDownloadRequest(
83 std::move(url_request), params->referrer(), resource_context,
84 params->content_initiated(), params->render_process_host_id(),
85 params->render_view_host_routing_id(),
86 params->render_frame_host_routing_id(),
87 params->do_not_prompt_for_login());
asanka00b621f2016-02-19 18:09:2388
89 // If the download was accepted, the DownloadResourceHandler is now
90 // responsible for driving the request to completion.
91 if (reason == DOWNLOAD_INTERRUPT_REASON_NONE)
92 return nullptr;
93
94 // Otherwise, create an interrupted download.
dchengf6c40582016-04-09 00:05:1395 std::unique_ptr<DownloadCreateInfo> failed_created_info(
tfarina42834112016-09-22 13:38:2096 new DownloadCreateInfo(base::Time::Now(), net::NetLogWithSource(),
dchengf6c40582016-04-09 00:05:1397 base::WrapUnique(new DownloadSaveInfo)));
asanka00b621f2016-02-19 18:09:2398 failed_created_info->url_chain.push_back(params->url());
99 failed_created_info->result = reason;
dchengf6c40582016-04-09 00:05:13100 std::unique_ptr<ByteStreamReader> empty_byte_stream;
asanka00b621f2016-02-19 18:09:23101 BrowserThread::PostTask(
102 BrowserThread::UI, FROM_HERE,
103 base::Bind(&DownloadManager::StartDownload, download_manager,
104 base::Passed(&failed_created_info),
105 base::Passed(&empty_byte_stream), params->callback()));
svaldez6901c902015-12-10 18:57:33106 return nullptr;
107 }
asanka00b621f2016-02-19 18:09:23108
dchengf6c40582016-04-09 00:05:13109 return std::unique_ptr<UrlDownloader, BrowserThread::DeleteOnIOThread>(
asanka00b621f2016-02-19 18:09:23110 UrlDownloader::BeginDownload(download_manager, std::move(url_request),
111 params->referrer())
svaldez6901c902015-12-10 18:57:33112 .release());
[email protected]a0ce3282011-08-19 20:49:52113}
114
[email protected]35869622012-10-26 23:23:55115class DownloadItemFactoryImpl : public DownloadItemFactory {
[email protected]d25fda12012-06-12 17:05:03116 public:
[email protected]b3756012013-03-06 17:43:02117 DownloadItemFactoryImpl() {}
dchengc2282aa2014-10-21 12:07:58118 ~DownloadItemFactoryImpl() override {}
[email protected]d25fda12012-06-12 17:05:03119
dchengc2282aa2014-10-21 12:07:58120 DownloadItemImpl* CreatePersistedItem(
[email protected]b3756012013-03-06 17:43:02121 DownloadItemImplDelegate* delegate,
asankaeef62b02016-03-14 21:23:11122 const std::string& guid,
avib7348942015-12-25 20:57:10123 uint32_t download_id,
[email protected]b3756012013-03-06 17:43:02124 const base::FilePath& current_path,
125 const base::FilePath& target_path,
126 const std::vector<GURL>& url_chain,
127 const GURL& referrer_url,
asanka3b4be122016-05-11 04:27:57128 const GURL& site_url,
asanka038d58d2016-04-14 00:29:28129 const GURL& tab_url,
130 const GURL& tab_refererr_url,
[email protected]0e648562014-06-12 19:39:45131 const std::string& mime_type,
132 const std::string& original_mime_type,
[email protected]b3756012013-03-06 17:43:02133 const base::Time& start_time,
134 const base::Time& end_time,
[email protected]56cd5942013-08-08 23:53:21135 const std::string& etag,
136 const std::string& last_modified,
avib7348942015-12-25 20:57:10137 int64_t received_bytes,
138 int64_t total_bytes,
asanka4350f6a2016-03-15 02:40:57139 const std::string& hash,
[email protected]b3756012013-03-06 17:43:02140 DownloadItem::DownloadState state,
141 DownloadDangerType danger_type,
142 DownloadInterruptReason interrupt_reason,
143 bool opened,
tfarina42834112016-09-22 13:38:20144 const net::NetLogWithSource& net_log) override {
asanka038d58d2016-04-14 00:29:28145 return new DownloadItemImpl(
146 delegate, guid, download_id, current_path, target_path, url_chain,
asanka3b4be122016-05-11 04:27:57147 referrer_url, site_url, tab_url, tab_refererr_url, mime_type,
148 original_mime_type, start_time, end_time, etag, last_modified,
149 received_bytes, total_bytes, hash, state, danger_type, interrupt_reason,
tfarina42834112016-09-22 13:38:20150 opened, net_log);
[email protected]b3756012013-03-06 17:43:02151 }
[email protected]d25fda12012-06-12 17:05:03152
dchengc2282aa2014-10-21 12:07:58153 DownloadItemImpl* CreateActiveItem(
[email protected]b3756012013-03-06 17:43:02154 DownloadItemImplDelegate* delegate,
avib7348942015-12-25 20:57:10155 uint32_t download_id,
[email protected]b3756012013-03-06 17:43:02156 const DownloadCreateInfo& info,
tfarina42834112016-09-22 13:38:20157 const net::NetLogWithSource& net_log) override {
158 return new DownloadItemImpl(delegate, download_id, info, net_log);
[email protected]b3756012013-03-06 17:43:02159 }
[email protected]d25fda12012-06-12 17:05:03160
dchengc2282aa2014-10-21 12:07:58161 DownloadItemImpl* CreateSavePageItem(
[email protected]b3756012013-03-06 17:43:02162 DownloadItemImplDelegate* delegate,
avib7348942015-12-25 20:57:10163 uint32_t download_id,
[email protected]b3756012013-03-06 17:43:02164 const base::FilePath& path,
165 const GURL& url,
[email protected]b3756012013-03-06 17:43:02166 const std::string& mime_type,
dchengf6c40582016-04-09 00:05:13167 std::unique_ptr<DownloadRequestHandleInterface> request_handle,
tfarina42834112016-09-22 13:38:20168 const net::NetLogWithSource& net_log) override {
dcheng36b6aec92015-12-26 06:16:36169 return new DownloadItemImpl(delegate, download_id, path, url, mime_type,
tfarina42834112016-09-22 13:38:20170 std::move(request_handle), net_log);
[email protected]b3756012013-03-06 17:43:02171 }
[email protected]d25fda12012-06-12 17:05:03172};
173
[email protected]a0ce3282011-08-19 20:49:52174} // namespace
175
avicebda7922016-10-21 17:37:54176DownloadManagerImpl::DownloadManagerImpl(net::NetLog* net_log,
177 BrowserContext* browser_context)
[email protected]53ac00e82012-10-18 20:59:20178 : item_factory_(new DownloadItemFactoryImpl()),
[email protected]35869622012-10-26 23:23:55179 file_factory_(new DownloadFileFactory()),
[email protected]16798692013-04-23 18:08:38180 shutdown_needed_(true),
181 browser_context_(browser_context),
avicebda7922016-10-21 17:37:54182 delegate_(nullptr),
[email protected]eba4a4d2013-05-29 02:18:06183 net_log_(net_log),
184 weak_factory_(this) {
[email protected]16798692013-04-23 18:08:38185 DCHECK(browser_context);
initial.commit09911bf2008-07-26 23:55:29186}
187
[email protected]5656f8a2011-11-17 16:12:58188DownloadManagerImpl::~DownloadManagerImpl() {
[email protected]326a6a92010-09-10 20:21:13189 DCHECK(!shutdown_needed_);
initial.commit09911bf2008-07-26 23:55:29190}
191
[email protected]89ec81f2013-05-15 19:20:02192DownloadItemImpl* DownloadManagerImpl::CreateActiveItem(
avib7348942015-12-25 20:57:10193 uint32_t id,
194 const DownloadCreateInfo& info) {
mostynbfbcdc27a2015-03-13 17:58:52195 DCHECK_CURRENTLY_ON(BrowserThread::UI);
skyostil66bd67912016-08-12 12:33:11196 DCHECK(!base::ContainsKey(downloads_, id));
tfarina42834112016-09-22 13:38:20197 net::NetLogWithSource net_log =
198 net::NetLogWithSource::Make(net_log_, net::NetLogSourceType::DOWNLOAD);
[email protected]89ec81f2013-05-15 19:20:02199 DownloadItemImpl* download =
tfarina42834112016-09-22 13:38:20200 item_factory_->CreateActiveItem(this, id, info, net_log);
avicebda7922016-10-21 17:37:54201 downloads_[id] = base::WrapUnique(download);
asankaeef62b02016-03-14 21:23:11202 downloads_by_guid_[download->GetGuid()] = download;
[email protected]89ec81f2013-05-15 19:20:02203 return download;
[email protected]381af492013-03-28 01:56:22204}
205
[email protected]530047e2013-07-12 17:02:25206void DownloadManagerImpl::GetNextId(const DownloadIdCallback& callback) {
mostynbfbcdc27a2015-03-13 17:58:52207 DCHECK_CURRENTLY_ON(BrowserThread::UI);
[email protected]530047e2013-07-12 17:02:25208 if (delegate_) {
209 delegate_->GetNextId(callback);
210 return;
[email protected]491aaa62012-06-07 03:50:18211 }
avib7348942015-12-25 20:57:10212 static uint32_t next_id = content::DownloadItem::kInvalidId + 1;
[email protected]530047e2013-07-12 17:02:25213 callback.Run(next_id++);
[email protected]2909e342011-10-29 00:46:53214}
215
[email protected]53ac00e82012-10-18 20:59:20216void DownloadManagerImpl::DetermineDownloadTarget(
217 DownloadItemImpl* item, const DownloadTargetCallback& callback) {
218 // Note that this next call relies on
219 // DownloadItemImplDelegate::DownloadTargetCallback and
220 // DownloadManagerDelegate::DownloadTargetCallback having the same
221 // type. If the types ever diverge, gasket code will need to
222 // be written here.
223 if (!delegate_ || !delegate_->DetermineDownloadTarget(item, callback)) {
[email protected]2dec8ec2013-02-07 19:20:34224 base::FilePath target_path = item->GetForcedFilePath();
[email protected]53ac00e82012-10-18 20:59:20225 // TODO(asanka): Determine a useful path if |target_path| is empty.
226 callback.Run(target_path,
227 DownloadItem::TARGET_DISPOSITION_OVERWRITE,
[email protected]35869622012-10-26 23:23:55228 DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
[email protected]53ac00e82012-10-18 20:59:20229 target_path);
230 }
[email protected]47665442012-07-27 02:31:22231}
232
[email protected]98299622013-01-03 22:26:50233bool DownloadManagerImpl::ShouldCompleteDownload(
[email protected]18710a42a2012-10-17 19:50:43234 DownloadItemImpl* item, const base::Closure& complete_callback) {
235 if (!delegate_ ||
236 delegate_->ShouldCompleteDownload(item, complete_callback)) {
[email protected]98299622013-01-03 22:26:50237 return true;
[email protected]18710a42a2012-10-17 19:50:43238 }
239 // Otherwise, the delegate has accepted responsibility to run the
240 // callback when the download is ready for completion.
[email protected]98299622013-01-03 22:26:50241 return false;
[email protected]fc03de22011-12-06 23:28:12242}
243
[email protected]2dec8ec2013-02-07 19:20:34244bool DownloadManagerImpl::ShouldOpenFileBasedOnExtension(
245 const base::FilePath& path) {
[email protected]491aaa62012-06-07 03:50:18246 if (!delegate_)
247 return false;
248
[email protected]fc03de22011-12-06 23:28:12249 return delegate_->ShouldOpenFileBasedOnExtension(path);
250}
251
[email protected]bde0e4f2012-11-08 22:49:59252bool DownloadManagerImpl::ShouldOpenDownload(
253 DownloadItemImpl* item, const ShouldOpenDownloadCallback& callback) {
[email protected]18710a42a2012-10-17 19:50:43254 if (!delegate_)
255 return true;
256
[email protected]bde0e4f2012-11-08 22:49:59257 // Relies on DownloadItemImplDelegate::ShouldOpenDownloadCallback and
258 // DownloadManagerDelegate::DownloadOpenDelayedCallback "just happening"
259 // to have the same type :-}.
260 return delegate_->ShouldOpenDownload(item, callback);
[email protected]18710a42a2012-10-17 19:50:43261}
262
[email protected]35869622012-10-26 23:23:55263void DownloadManagerImpl::SetDelegate(DownloadManagerDelegate* delegate) {
[email protected]b441a8492012-06-06 14:55:57264 delegate_ = delegate;
265}
266
[email protected]35869622012-10-26 23:23:55267DownloadManagerDelegate* DownloadManagerImpl::GetDelegate() const {
[email protected]b488b5a52012-06-06 17:01:28268 return delegate_;
269}
270
[email protected]5656f8a2011-11-17 16:12:58271void DownloadManagerImpl::Shutdown() {
pkastingf5279482016-07-27 02:18:20272 DVLOG(20) << __func__ << "() shutdown_needed_ = " << shutdown_needed_;
[email protected]326a6a92010-09-10 20:21:13273 if (!shutdown_needed_)
274 return;
275 shutdown_needed_ = false;
initial.commit09911bf2008-07-26 23:55:29276
ericwilligers254597b2016-10-17 10:32:31277 for (auto& observer : observers_)
278 observer.ManagerGoingDown(this);
[email protected]fb4f8d902011-09-16 06:07:08279 // TODO(benjhayden): Consider clearing observers_.
[email protected]326a6a92010-09-10 20:21:13280
[email protected]fe752272013-05-29 18:57:45281 // If there are in-progress downloads, cancel them. This also goes for
282 // dangerous downloads which will remain in history if they aren't explicitly
283 // accepted or discarded. Canceling will remove the intermediate download
284 // file.
lukasza921fabfa2016-02-05 19:51:48285 for (const auto& it : downloads_) {
avicebda7922016-10-21 17:37:54286 DownloadItemImpl* download = it.second.get();
[email protected]fe752272013-05-29 18:57:45287 if (download->GetState() == DownloadItem::IN_PROGRESS)
[email protected]93af2272011-09-21 18:29:17288 download->Cancel(false);
initial.commit09911bf2008-07-26 23:55:29289 }
avicebda7922016-10-21 17:37:54290 downloads_.clear();
asankaeef62b02016-03-14 21:23:11291 downloads_by_guid_.clear();
svaldez9a07ab332016-01-12 18:29:01292 url_downloaders_.clear();
initial.commit09911bf2008-07-26 23:55:29293
[email protected]41f558fb2012-01-09 22:59:58294 // We'll have nothing more to report to the observers after this point.
295 observers_.Clear();
296
[email protected]b441a8492012-06-06 14:55:57297 if (delegate_)
298 delegate_->Shutdown();
avicebda7922016-10-21 17:37:54299 delegate_ = nullptr;
initial.commit09911bf2008-07-26 23:55:29300}
301
[email protected]530047e2013-07-12 17:02:25302void DownloadManagerImpl::StartDownload(
dchengf6c40582016-04-09 00:05:13303 std::unique_ptr<DownloadCreateInfo> info,
304 std::unique_ptr<ByteStreamReader> stream,
[email protected]530047e2013-07-12 17:02:25305 const DownloadUrlParameters::OnStartedCallback& on_started) {
mostynbfbcdc27a2015-03-13 17:58:52306 DCHECK_CURRENTLY_ON(BrowserThread::UI);
[email protected]530047e2013-07-12 17:02:25307 DCHECK(info);
asanka00b621f2016-02-19 18:09:23308 // |stream| is only non-nil if the download request was successful.
309 DCHECK((info->result == DOWNLOAD_INTERRUPT_REASON_NONE && stream.get()) ||
310 (info->result != DOWNLOAD_INTERRUPT_REASON_NONE && !stream.get()));
pkastingf5279482016-07-27 02:18:20311 DVLOG(20) << __func__
312 << "() result=" << DownloadInterruptReasonToString(info->result);
avib7348942015-12-25 20:57:10313 uint32_t download_id = info->download_id;
[email protected]530047e2013-07-12 17:02:25314 const bool new_download = (download_id == content::DownloadItem::kInvalidId);
jialiul82b8e502016-09-30 17:42:42315 if (new_download)
316 RecordDownloadConnectionSecurity(info->url(), info->url_chain);
avib7348942015-12-25 20:57:10317 base::Callback<void(uint32_t)> got_id(base::Bind(
318 &DownloadManagerImpl::StartDownloadWithId, weak_factory_.GetWeakPtr(),
319 base::Passed(&info), base::Passed(&stream), on_started, new_download));
[email protected]89ec81f2013-05-15 19:20:02320 if (new_download) {
[email protected]530047e2013-07-12 17:02:25321 GetNextId(got_id);
322 } else {
323 got_id.Run(download_id);
324 }
325}
326
327void DownloadManagerImpl::StartDownloadWithId(
dchengf6c40582016-04-09 00:05:13328 std::unique_ptr<DownloadCreateInfo> info,
329 std::unique_ptr<ByteStreamReader> stream,
[email protected]530047e2013-07-12 17:02:25330 const DownloadUrlParameters::OnStartedCallback& on_started,
331 bool new_download,
avib7348942015-12-25 20:57:10332 uint32_t id) {
mostynbfbcdc27a2015-03-13 17:58:52333 DCHECK_CURRENTLY_ON(BrowserThread::UI);
[email protected]530047e2013-07-12 17:02:25334 DCHECK_NE(content::DownloadItem::kInvalidId, id);
avicebda7922016-10-21 17:37:54335 DownloadItemImpl* download = nullptr;
[email protected]530047e2013-07-12 17:02:25336 if (new_download) {
[email protected]89ec81f2013-05-15 19:20:02337 download = CreateActiveItem(id, *info);
338 } else {
avicebda7922016-10-21 17:37:54339 auto item_iterator = downloads_.find(id);
[email protected]89ec81f2013-05-15 19:20:02340 // Trying to resume an interrupted download.
[email protected]7b3eeca42013-05-23 20:56:37341 if (item_iterator == downloads_.end() ||
[email protected]803036e02013-06-15 17:08:47342 (item_iterator->second->GetState() == DownloadItem::CANCELLED)) {
[email protected]89ec81f2013-05-15 19:20:02343 // If the download is no longer known to the DownloadManager, then it was
[email protected]7b3eeca42013-05-23 20:56:37344 // removed after it was resumed. Ignore. If the download is cancelled
345 // while resuming, then also ignore the request.
asanka64114152015-12-21 21:28:49346 info->request_handle->CancelRequest();
[email protected]530047e2013-07-12 17:02:25347 if (!on_started.is_null())
avicebda7922016-10-21 17:37:54348 on_started.Run(nullptr, DOWNLOAD_INTERRUPT_REASON_USER_CANCELED);
asanka81c2214f2016-01-13 20:05:54349 // The ByteStreamReader lives and dies on the FILE thread.
asanka00b621f2016-02-19 18:09:23350 if (info->result == DOWNLOAD_INTERRUPT_REASON_NONE)
351 BrowserThread::DeleteSoon(BrowserThread::FILE, FROM_HERE,
352 stream.release());
[email protected]530047e2013-07-12 17:02:25353 return;
[email protected]89ec81f2013-05-15 19:20:02354 }
avicebda7922016-10-21 17:37:54355 download = item_iterator->second.get();
[email protected]89ec81f2013-05-15 19:20:02356 }
357
[email protected]2dec8ec2013-02-07 19:20:34358 base::FilePath default_download_directory;
[email protected]96bfed052012-09-15 22:21:01359 if (delegate_) {
[email protected]2dec8ec2013-02-07 19:20:34360 base::FilePath website_save_directory; // Unused
361 bool skip_dir_check = false; // Unused
[email protected]96bfed052012-09-15 22:21:01362 delegate_->GetSaveDir(GetBrowserContext(), &website_save_directory,
[email protected]53ac00e82012-10-18 20:59:20363 &default_download_directory, &skip_dir_check);
[email protected]96bfed052012-09-15 22:21:01364 }
365
dchengf6c40582016-04-09 00:05:13366 std::unique_ptr<DownloadFile> download_file;
[email protected]492c0092013-08-10 13:49:48367
asanka00b621f2016-02-19 18:09:23368 if (info->result == DOWNLOAD_INTERRUPT_REASON_NONE) {
369 DCHECK(stream.get());
tfarina42834112016-09-22 13:38:20370 download_file.reset(file_factory_->CreateFile(
371 std::move(info->save_info), default_download_directory,
372 std::move(stream), download->GetNetLogWithSource(),
373 download->DestinationObserverAsWeakPtr()));
[email protected]492c0092013-08-10 13:49:48374 }
asanka4350f6a2016-03-15 02:40:57375 // It is important to leave info->save_info intact in the case of an interrupt
376 // so that the DownloadItem can salvage what it can out of a failed resumption
377 // attempt.
[email protected]492c0092013-08-10 13:49:48378
asanka00b621f2016-02-19 18:09:23379 download->Start(std::move(download_file), std::move(info->request_handle),
380 *info);
[email protected]96c3bdbaa2012-08-31 16:39:54381
[email protected]381af492013-03-28 01:56:22382 // For interrupted downloads, Start() will transition the state to
383 // IN_PROGRESS and consumers will be notified via OnDownloadUpdated().
384 // For new downloads, we notify here, rather than earlier, so that
385 // the download_file is bound to download and all the usual
386 // setters (e.g. Cancel) work.
ericwilligers254597b2016-10-17 10:32:31387 if (new_download) {
388 for (auto& observer : observers_)
389 observer.OnDownloadCreated(this, download);
390 }
[email protected]96c3bdbaa2012-08-31 16:39:54391
[email protected]530047e2013-07-12 17:02:25392 if (!on_started.is_null())
[email protected]7f3918882014-01-14 06:14:56393 on_started.Run(download, DOWNLOAD_INTERRUPT_REASON_NONE);
[email protected]287b86b2011-02-26 00:11:35394}
395
[email protected]5656f8a2011-11-17 16:12:58396void DownloadManagerImpl::CheckForHistoryFilesRemoval() {
mostynbfbcdc27a2015-03-13 17:58:52397 DCHECK_CURRENTLY_ON(BrowserThread::UI);
lukasza921fabfa2016-02-05 19:51:48398 for (const auto& it : downloads_) {
avicebda7922016-10-21 17:37:54399 DownloadItemImpl* item = it.second.get();
[email protected]3d95e542012-11-20 00:52:08400 CheckForFileRemoval(item);
[email protected]9fc114672011-06-15 08:17:48401 }
402}
403
[email protected]db1d8f72012-07-13 19:23:16404void DownloadManagerImpl::CheckForFileRemoval(DownloadItemImpl* download_item) {
mostynbfbcdc27a2015-03-13 17:58:52405 DCHECK_CURRENTLY_ON(BrowserThread::UI);
[email protected]803036e02013-06-15 17:08:47406 if ((download_item->GetState() == DownloadItem::COMPLETE) &&
[email protected]4c544cd2013-01-25 07:54:16407 !download_item->GetFileExternallyRemoved() &&
408 delegate_) {
409 delegate_->CheckForFileExistence(
410 download_item,
411 base::Bind(&DownloadManagerImpl::OnFileExistenceChecked,
[email protected]eba4a4d2013-05-29 02:18:06412 weak_factory_.GetWeakPtr(), download_item->GetId()));
[email protected]9fc114672011-06-15 08:17:48413 }
414}
415
avib7348942015-12-25 20:57:10416void DownloadManagerImpl::OnFileExistenceChecked(uint32_t download_id,
[email protected]4c544cd2013-01-25 07:54:16417 bool result) {
mostynbfbcdc27a2015-03-13 17:58:52418 DCHECK_CURRENTLY_ON(BrowserThread::UI);
[email protected]4c544cd2013-01-25 07:54:16419 if (!result) { // File does not exist.
skyostil66bd67912016-08-12 12:33:11420 if (base::ContainsKey(downloads_, download_id))
[email protected]1c63da02014-01-17 17:09:51421 downloads_[download_id]->OnDownloadedFileRemoved();
[email protected]4c544cd2013-01-25 07:54:16422 }
[email protected]9fc114672011-06-15 08:17:48423}
424
asankadb9e50ad2016-10-03 15:00:29425std::string DownloadManagerImpl::GetApplicationClientIdForFileScanning() const {
426 if (delegate_)
427 return delegate_->ApplicationClientIdForFileScanning();
428 return std::string();
429}
430
[email protected]35869622012-10-26 23:23:55431BrowserContext* DownloadManagerImpl::GetBrowserContext() const {
[email protected]5656f8a2011-11-17 16:12:58432 return browser_context_;
433}
434
[email protected]530047e2013-07-12 17:02:25435void DownloadManagerImpl::CreateSavePackageDownloadItem(
[email protected]2dec8ec2013-02-07 19:20:34436 const base::FilePath& main_file_path,
[email protected]fc03de22011-12-06 23:28:12437 const GURL& page_url,
[email protected]6474b112012-05-04 19:35:27438 const std::string& mime_type,
dchengf6c40582016-04-09 00:05:13439 std::unique_ptr<DownloadRequestHandleInterface> request_handle,
[email protected]530047e2013-07-12 17:02:25440 const DownloadItemImplCreated& item_created) {
mostynbfbcdc27a2015-03-13 17:58:52441 DCHECK_CURRENTLY_ON(BrowserThread::UI);
[email protected]530047e2013-07-12 17:02:25442 GetNextId(base::Bind(
443 &DownloadManagerImpl::CreateSavePackageDownloadItemWithId,
dcheng36b6aec92015-12-26 06:16:36444 weak_factory_.GetWeakPtr(), main_file_path, page_url, mime_type,
445 base::Passed(std::move(request_handle)), item_created));
[email protected]530047e2013-07-12 17:02:25446}
447
448void DownloadManagerImpl::CreateSavePackageDownloadItemWithId(
449 const base::FilePath& main_file_path,
450 const GURL& page_url,
451 const std::string& mime_type,
dchengf6c40582016-04-09 00:05:13452 std::unique_ptr<DownloadRequestHandleInterface> request_handle,
[email protected]530047e2013-07-12 17:02:25453 const DownloadItemImplCreated& item_created,
avib7348942015-12-25 20:57:10454 uint32_t id) {
mostynbfbcdc27a2015-03-13 17:58:52455 DCHECK_CURRENTLY_ON(BrowserThread::UI);
[email protected]530047e2013-07-12 17:02:25456 DCHECK_NE(content::DownloadItem::kInvalidId, id);
skyostil66bd67912016-08-12 12:33:11457 DCHECK(!base::ContainsKey(downloads_, id));
tfarina42834112016-09-22 13:38:20458 net::NetLogWithSource net_log =
459 net::NetLogWithSource::Make(net_log_, net::NetLogSourceType::DOWNLOAD);
[email protected]3d95e542012-11-20 00:52:08460 DownloadItemImpl* download_item = item_factory_->CreateSavePageItem(
dcheng36b6aec92015-12-26 06:16:36461 this, id, main_file_path, page_url, mime_type, std::move(request_handle),
tfarina42834112016-09-22 13:38:20462 net_log);
avicebda7922016-10-21 17:37:54463 downloads_[download_item->GetId()] = base::WrapUnique(download_item);
skyostil66bd67912016-08-12 12:33:11464 DCHECK(!base::ContainsKey(downloads_by_guid_, download_item->GetGuid()));
asankaeef62b02016-03-14 21:23:11465 downloads_by_guid_[download_item->GetGuid()] = download_item;
ericwilligers254597b2016-10-17 10:32:31466 for (auto& observer : observers_)
467 observer.OnDownloadCreated(this, download_item);
[email protected]530047e2013-07-12 17:02:25468 if (!item_created.is_null())
469 item_created.Run(download_item);
[email protected]fc03de22011-12-06 23:28:12470}
471
[email protected]df58aa82013-01-24 21:54:00472void DownloadManagerImpl::OnSavePackageSuccessfullyFinished(
473 DownloadItem* download_item) {
ericwilligers254597b2016-10-17 10:32:31474 for (auto& observer : observers_)
475 observer.OnSavePackageSuccessfullyFinished(this, download_item);
[email protected]df58aa82013-01-24 21:54:00476}
477
[email protected]8d68a3e02013-01-12 15:57:10478// Resume a download of a specific URL. We send the request to the
479// ResourceDispatcherHost, and let it send us responses like a regular
480// download.
481void DownloadManagerImpl::ResumeInterruptedDownload(
dchengf6c40582016-04-09 00:05:13482 std::unique_ptr<content::DownloadUrlParameters> params,
avib7348942015-12-25 20:57:10483 uint32_t id) {
svaldez6901c902015-12-10 18:57:33484 BrowserThread::PostTaskAndReplyWithResult(
485 BrowserThread::IO, FROM_HERE,
asanka3b4be122016-05-11 04:27:57486 base::Bind(&BeginDownload, base::Passed(&params),
487 browser_context_->GetResourceContext(), id,
svaldez6901c902015-12-10 18:57:33488 weak_factory_.GetWeakPtr()),
489 base::Bind(&DownloadManagerImpl::AddUrlDownloader,
490 weak_factory_.GetWeakPtr()));
[email protected]8d68a3e02013-01-12 15:57:10491}
492
[email protected]53ac00e82012-10-18 20:59:20493void DownloadManagerImpl::SetDownloadItemFactoryForTesting(
dchengf6c40582016-04-09 00:05:13494 std::unique_ptr<DownloadItemFactory> item_factory) {
dcheng36b6aec92015-12-26 06:16:36495 item_factory_ = std::move(item_factory);
[email protected]53ac00e82012-10-18 20:59:20496}
497
498void DownloadManagerImpl::SetDownloadFileFactoryForTesting(
dchengf6c40582016-04-09 00:05:13499 std::unique_ptr<DownloadFileFactory> file_factory) {
dcheng36b6aec92015-12-26 06:16:36500 file_factory_ = std::move(file_factory);
[email protected]53ac00e82012-10-18 20:59:20501}
502
[email protected]35869622012-10-26 23:23:55503DownloadFileFactory* DownloadManagerImpl::GetDownloadFileFactoryForTesting() {
[email protected]53ac00e82012-10-18 20:59:20504 return file_factory_.get();
505}
506
[email protected]db1d8f72012-07-13 19:23:16507void DownloadManagerImpl::DownloadRemoved(DownloadItemImpl* download) {
[email protected]237af6d2013-03-15 23:45:28508 if (!download)
[email protected]09ea72c7422012-07-02 20:35:40509 return;
510
asankaeef62b02016-03-14 21:23:11511 downloads_by_guid_.erase(download->GetGuid());
avicebda7922016-10-21 17:37:54512 downloads_.erase(download->GetId());
initial.commit09911bf2008-07-26 23:55:29513}
514
svaldez6901c902015-12-10 18:57:33515void DownloadManagerImpl::AddUrlDownloader(
dchengf6c40582016-04-09 00:05:13516 std::unique_ptr<UrlDownloader, BrowserThread::DeleteOnIOThread>
517 downloader) {
svaldez6901c902015-12-10 18:57:33518 if (downloader)
dcheng36b6aec92015-12-26 06:16:36519 url_downloaders_.push_back(std::move(downloader));
svaldez6901c902015-12-10 18:57:33520}
521
522void DownloadManagerImpl::RemoveUrlDownloader(UrlDownloader* downloader) {
523 for (auto ptr = url_downloaders_.begin(); ptr != url_downloaders_.end();
524 ++ptr) {
525 if (ptr->get() == downloader) {
526 url_downloaders_.erase(ptr);
527 return;
528 }
529 }
530}
531
anantac82dd5be2016-08-26 01:21:53532// static
533DownloadInterruptReason DownloadManagerImpl::BeginDownloadRequest(
534 std::unique_ptr<net::URLRequest> url_request,
535 const Referrer& referrer,
536 ResourceContext* resource_context,
537 bool is_content_initiated,
538 int render_process_id,
539 int render_view_route_id,
540 int render_frame_route_id,
541 bool do_not_prompt_for_login) {
542 if (ResourceDispatcherHostImpl::Get()->is_shutdown())
543 return DOWNLOAD_INTERRUPT_REASON_USER_SHUTDOWN;
544
545 // The URLRequest needs to be initialized with the referrer and other
546 // information prior to issuing it.
547 ResourceDispatcherHostImpl::Get()->InitializeURLRequest(
548 url_request.get(), referrer,
549 true, // download.
550 render_process_id, render_view_route_id, render_frame_route_id,
megjabloncaf312f2017-01-12 18:47:49551 PREVIEWS_OFF, resource_context);
anantac82dd5be2016-08-26 01:21:53552
553 // We treat a download as a main frame load, and thus update the policy URL on
554 // redirects.
555 //
556 // TODO(davidben): Is this correct? If this came from a
557 // ViewHostMsg_DownloadUrl in a frame, should it have first-party URL set
558 // appropriately?
559 url_request->set_first_party_url_policy(
560 net::URLRequest::UPDATE_FIRST_PARTY_URL_ON_REDIRECT);
561
562 const GURL& url = url_request->original_url();
563
564 // Check if the renderer is permitted to request the requested URL.
565 if (!ChildProcessSecurityPolicyImpl::GetInstance()->CanRequestURL(
566 render_process_id, url)) {
567 DVLOG(1) << "Denied unauthorized download request for "
568 << url.possibly_invalid_spec();
569 return DOWNLOAD_INTERRUPT_REASON_NETWORK_INVALID_REQUEST;
570 }
571
572 const net::URLRequestContext* request_context = url_request->context();
573 if (!request_context->job_factory()->IsHandledURL(url)) {
574 DVLOG(1) << "Download request for unsupported protocol: "
575 << url.possibly_invalid_spec();
576 return DOWNLOAD_INTERRUPT_REASON_NETWORK_INVALID_REQUEST;
577 }
578
579 // From this point forward, the |DownloadResourceHandler| is responsible for
580 // |started_callback|.
581 // TODO(ananta)
582 // Find a better way to create the DownloadResourceHandler instance.
583 std::unique_ptr<ResourceHandler> handler(
584 DownloadResourceHandler::Create(url_request.get()));
585
586 ResourceDispatcherHostImpl::Get()->BeginURLRequest(
587 std::move(url_request), std::move(handler), true, // download
588 is_content_initiated, do_not_prompt_for_login, resource_context);
589 return DOWNLOAD_INTERRUPT_REASON_NONE;
590}
591
asanka6381bd4e2017-01-05 22:08:37592int DownloadManagerImpl::RemoveDownloadsByURLAndTime(
msramekd9c162a2016-02-23 11:17:21593 const base::Callback<bool(const GURL&)>& url_filter,
asanka6381bd4e2017-01-05 22:08:37594 base::Time remove_begin,
595 base::Time remove_end) {
[email protected]237af6d2013-03-15 23:45:28596 int count = 0;
avicebda7922016-10-21 17:37:54597 auto it = downloads_.begin();
[email protected]237af6d2013-03-15 23:45:28598 while (it != downloads_.end()) {
avicebda7922016-10-21 17:37:54599 DownloadItemImpl* download = it->second.get();
[email protected]237af6d2013-03-15 23:45:28600
601 // Increment done here to protect against invalidation below.
602 ++it;
603
ttr31481dc54b2015-08-06 20:11:26604 if (download->GetState() != DownloadItem::IN_PROGRESS &&
asanka6381bd4e2017-01-05 22:08:37605 url_filter.Run(download->GetURL()) &&
606 download->GetStartTime() >= remove_begin &&
607 (remove_end.is_null() || download->GetStartTime() < remove_end)) {
[email protected]237af6d2013-03-15 23:45:28608 download->Remove();
609 count++;
initial.commit09911bf2008-07-26 23:55:29610 }
initial.commit09911bf2008-07-26 23:55:29611 }
[email protected]237af6d2013-03-15 23:45:28612 return count;
initial.commit09911bf2008-07-26 23:55:29613}
614
[email protected]0d4e30c2012-01-28 00:47:53615void DownloadManagerImpl::DownloadUrl(
dchengf6c40582016-04-09 00:05:13616 std::unique_ptr<DownloadUrlParameters> params) {
[email protected]c5a5c0842012-05-04 20:05:14617 if (params->post_id() >= 0) {
618 // Check this here so that the traceback is more useful.
619 DCHECK(params->prefer_cache());
[email protected]6065748f2013-10-29 01:07:43620 DCHECK_EQ("POST", params->method());
[email protected]c5a5c0842012-05-04 20:05:14621 }
svaldez6901c902015-12-10 18:57:33622 BrowserThread::PostTaskAndReplyWithResult(
623 BrowserThread::IO, FROM_HERE,
624 base::Bind(&BeginDownload, base::Passed(&params),
asanka3b4be122016-05-11 04:27:57625 browser_context_->GetResourceContext(),
svaldez6901c902015-12-10 18:57:33626 content::DownloadItem::kInvalidId, weak_factory_.GetWeakPtr()),
627 base::Bind(&DownloadManagerImpl::AddUrlDownloader,
628 weak_factory_.GetWeakPtr()));
initial.commit09911bf2008-07-26 23:55:29629}
630
[email protected]5656f8a2011-11-17 16:12:58631void DownloadManagerImpl::AddObserver(Observer* observer) {
initial.commit09911bf2008-07-26 23:55:29632 observers_.AddObserver(observer);
initial.commit09911bf2008-07-26 23:55:29633}
634
[email protected]5656f8a2011-11-17 16:12:58635void DownloadManagerImpl::RemoveObserver(Observer* observer) {
initial.commit09911bf2008-07-26 23:55:29636 observers_.RemoveObserver(observer);
637}
638
[email protected]3d95e542012-11-20 00:52:08639DownloadItem* DownloadManagerImpl::CreateDownloadItem(
asankaeef62b02016-03-14 21:23:11640 const std::string& guid,
avib7348942015-12-25 20:57:10641 uint32_t id,
[email protected]2dec8ec2013-02-07 19:20:34642 const base::FilePath& current_path,
643 const base::FilePath& target_path,
[email protected]876774692013-02-03 17:20:15644 const std::vector<GURL>& url_chain,
[email protected]3d95e542012-11-20 00:52:08645 const GURL& referrer_url,
asanka3b4be122016-05-11 04:27:57646 const GURL& site_url,
asanka038d58d2016-04-14 00:29:28647 const GURL& tab_url,
648 const GURL& tab_refererr_url,
[email protected]0e648562014-06-12 19:39:45649 const std::string& mime_type,
650 const std::string& original_mime_type,
[email protected]3d95e542012-11-20 00:52:08651 const base::Time& start_time,
652 const base::Time& end_time,
[email protected]56cd5942013-08-08 23:53:21653 const std::string& etag,
654 const std::string& last_modified,
avib7348942015-12-25 20:57:10655 int64_t received_bytes,
656 int64_t total_bytes,
asanka4350f6a2016-03-15 02:40:57657 const std::string& hash,
[email protected]3d95e542012-11-20 00:52:08658 DownloadItem::DownloadState state,
[email protected]876774692013-02-03 17:20:15659 DownloadDangerType danger_type,
660 DownloadInterruptReason interrupt_reason,
[email protected]3d95e542012-11-20 00:52:08661 bool opened) {
skyostil66bd67912016-08-12 12:33:11662 if (base::ContainsKey(downloads_, id)) {
[email protected]6065748f2013-10-29 01:07:43663 NOTREACHED();
avicebda7922016-10-21 17:37:54664 return nullptr;
[email protected]6065748f2013-10-29 01:07:43665 }
skyostil66bd67912016-08-12 12:33:11666 DCHECK(!base::ContainsKey(downloads_by_guid_, guid));
[email protected]3d95e542012-11-20 00:52:08667 DownloadItemImpl* item = item_factory_->CreatePersistedItem(
asanka038d58d2016-04-14 00:29:28668 this, guid, id, current_path, target_path, url_chain, referrer_url,
asanka3b4be122016-05-11 04:27:57669 site_url, tab_url, tab_refererr_url, mime_type, original_mime_type,
670 start_time, end_time, etag, last_modified, received_bytes, total_bytes,
671 hash, state, danger_type, interrupt_reason, opened,
tfarina42834112016-09-22 13:38:20672 net::NetLogWithSource::Make(net_log_, net::NetLogSourceType::DOWNLOAD));
avicebda7922016-10-21 17:37:54673 downloads_[id] = base::WrapUnique(item);
asankaeef62b02016-03-14 21:23:11674 downloads_by_guid_[guid] = item;
ericwilligers254597b2016-10-17 10:32:31675 for (auto& observer : observers_)
676 observer.OnDownloadCreated(this, item);
pkastingf5279482016-07-27 02:18:20677 DVLOG(20) << __func__ << "() download = " << item->DebugString(true);
[email protected]3d95e542012-11-20 00:52:08678 return item;
initial.commit09911bf2008-07-26 23:55:29679}
680
[email protected]5656f8a2011-11-17 16:12:58681int DownloadManagerImpl::InProgressCount() const {
[email protected]007e7412012-03-13 20:10:56682 int count = 0;
lukasza921fabfa2016-02-05 19:51:48683 for (const auto& it : downloads_) {
684 if (it.second->GetState() == DownloadItem::IN_PROGRESS)
[email protected]007e7412012-03-13 20:10:56685 ++count;
686 }
687 return count;
[email protected]5656f8a2011-11-17 16:12:58688}
689
[email protected]422a7d12013-10-21 12:10:42690int DownloadManagerImpl::NonMaliciousInProgressCount() const {
691 int count = 0;
lukasza921fabfa2016-02-05 19:51:48692 for (const auto& it : downloads_) {
693 if (it.second->GetState() == DownloadItem::IN_PROGRESS &&
694 it.second->GetDangerType() != DOWNLOAD_DANGER_TYPE_DANGEROUS_URL &&
695 it.second->GetDangerType() != DOWNLOAD_DANGER_TYPE_DANGEROUS_CONTENT &&
696 it.second->GetDangerType() != DOWNLOAD_DANGER_TYPE_DANGEROUS_HOST &&
697 it.second->GetDangerType() !=
[email protected]24eb5172013-10-27 02:03:59698 DOWNLOAD_DANGER_TYPE_POTENTIALLY_UNWANTED) {
[email protected]422a7d12013-10-21 12:10:42699 ++count;
700 }
701 }
702 return count;
703}
704
avib7348942015-12-25 20:57:10705DownloadItem* DownloadManagerImpl::GetDownload(uint32_t download_id) {
avicebda7922016-10-21 17:37:54706 return base::ContainsKey(downloads_, download_id)
707 ? downloads_[download_id].get()
708 : nullptr;
asankaeef62b02016-03-14 21:23:11709}
710
711DownloadItem* DownloadManagerImpl::GetDownloadByGuid(const std::string& guid) {
712 DCHECK(guid == base::ToUpperASCII(guid));
skyostil66bd67912016-08-12 12:33:11713 return base::ContainsKey(downloads_by_guid_, guid) ? downloads_by_guid_[guid]
714 : nullptr;
[email protected]ba7895d2012-06-22 19:02:52715}
716
[email protected]9f1f4092012-09-10 21:18:04717void DownloadManagerImpl::GetAllDownloads(DownloadVector* downloads) {
lukasza921fabfa2016-02-05 19:51:48718 for (const auto& it : downloads_) {
avicebda7922016-10-21 17:37:54719 downloads->push_back(it.second.get());
[email protected]9f1f4092012-09-10 21:18:04720 }
721}
722
[email protected]ffc0c2d2013-01-21 15:32:12723void DownloadManagerImpl::OpenDownload(DownloadItemImpl* download) {
[email protected]da4a5582011-10-17 19:08:06724 int num_unopened = 0;
lukasza921fabfa2016-02-05 19:51:48725 for (const auto& it : downloads_) {
avicebda7922016-10-21 17:37:54726 DownloadItemImpl* item = it.second.get();
[email protected]803036e02013-06-15 17:08:47727 if ((item->GetState() == DownloadItem::COMPLETE) &&
[email protected]09ea72c7422012-07-02 20:35:40728 !item->GetOpened())
[email protected]da4a5582011-10-17 19:08:06729 ++num_unopened;
730 }
[email protected]35869622012-10-26 23:23:55731 RecordOpensOutstanding(num_unopened);
[email protected]ffc0c2d2013-01-21 15:32:12732
[email protected]0baf5922013-01-30 13:55:18733 if (delegate_)
[email protected]ffc0c2d2013-01-21 15:32:12734 delegate_->OpenDownload(download);
735}
736
737void DownloadManagerImpl::ShowDownloadInShell(DownloadItemImpl* download) {
738 if (delegate_)
739 delegate_->ShowDownloadInShell(download);
[email protected]da4a5582011-10-17 19:08:06740}
[email protected]5656f8a2011-11-17 16:12:58741
[email protected]35869622012-10-26 23:23:55742} // namespace content