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_manager_impl.h"
6
7#include <iterator>
8
9#include "base/bind.h"
10#include "base/callback.h"
11#include "base/debug/alias.h"
12#include "base/i18n/case_conversion.h"
13#include "base/logging.h"
14#include "base/message_loop/message_loop.h"
15#include "base/stl_util.h"
16#include "base/strings/stringprintf.h"
17#include "base/strings/sys_string_conversions.h"
18#include "base/supports_user_data.h"
19#include "base/synchronization/lock.h"
20#include "build/build_config.h"
21#include "content/browser/byte_stream.h"
22#include "content/browser/download/download_create_info.h"
23#include "content/browser/download/download_file_factory.h"
24#include "content/browser/download/download_item_factory.h"
25#include "content/browser/download/download_item_impl.h"
26#include "content/browser/download/download_stats.h"
27#include "content/browser/loader/resource_dispatcher_host_impl.h"
28#include "content/browser/renderer_host/render_view_host_impl.h"
29#include "content/browser/web_contents/web_contents_impl.h"
30#include "content/public/browser/browser_context.h"
31#include "content/public/browser/browser_thread.h"
32#include "content/public/browser/content_browser_client.h"
33#include "content/public/browser/download_interrupt_reasons.h"
34#include "content/public/browser/download_manager_delegate.h"
35#include "content/public/browser/download_url_parameters.h"
36#include "content/public/browser/notification_service.h"
37#include "content/public/browser/notification_types.h"
38#include "content/public/browser/render_process_host.h"
39#include "content/public/browser/resource_context.h"
40#include "content/public/browser/web_contents_delegate.h"
41#include "content/public/common/referrer.h"
42#include "net/base/load_flags.h"
43#include "net/base/request_priority.h"
44#include "net/base/upload_bytes_element_reader.h"
45#include "net/base/upload_data_stream.h"
46#include "net/url_request/url_request_context.h"
47
48namespace content {
49namespace {
50
51void BeginDownload(scoped_ptr<DownloadUrlParameters> params,
52                   uint32 download_id) {
53  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
54  // ResourceDispatcherHost{Base} is-not-a URLRequest::Delegate, and
55  // DownloadUrlParameters can-not include resource_dispatcher_host_impl.h, so
56  // we must down cast. RDHI is the only subclass of RDH as of 2012 May 4.
57  scoped_ptr<net::URLRequest> request(
58      params->resource_context()->GetRequestContext()->CreateRequest(
59          params->url(), net::DEFAULT_PRIORITY, NULL, NULL));
60  request->SetLoadFlags(request->load_flags() | params->load_flags());
61  request->set_method(params->method());
62  if (!params->post_body().empty()) {
63    const std::string& body = params->post_body();
64    scoped_ptr<net::UploadElementReader> reader(
65        net::UploadOwnedBytesElementReader::CreateWithString(body));
66    request->set_upload(make_scoped_ptr(
67        net::UploadDataStream::CreateWithReader(reader.Pass(), 0)));
68  }
69  if (params->post_id() >= 0) {
70    // The POST in this case does not have an actual body, and only works
71    // when retrieving data from cache. This is done because we don't want
72    // to do a re-POST without user consent, and currently don't have a good
73    // plan on how to display the UI for that.
74    DCHECK(params->prefer_cache());
75    DCHECK_EQ("POST", params->method());
76    ScopedVector<net::UploadElementReader> element_readers;
77    request->set_upload(make_scoped_ptr(
78        new net::UploadDataStream(element_readers.Pass(), params->post_id())));
79  }
80
81  // If we're not at the beginning of the file, retrieve only the remaining
82  // portion.
83  bool has_last_modified = !params->last_modified().empty();
84  bool has_etag = !params->etag().empty();
85
86  // If we've asked for a range, we want to make sure that we only
87  // get that range if our current copy of the information is good.
88  // We shouldn't be asked to continue if we don't have a verifier.
89  DCHECK(params->offset() == 0 || has_etag || has_last_modified);
90
91  if (params->offset() > 0) {
92    request->SetExtraRequestHeaderByName(
93        "Range",
94        base::StringPrintf("bytes=%" PRId64 "-", params->offset()),
95        true);
96
97    if (has_last_modified) {
98      request->SetExtraRequestHeaderByName("If-Unmodified-Since",
99                                           params->last_modified(),
100                                           true);
101    }
102    if (has_etag) {
103      request->SetExtraRequestHeaderByName("If-Match", params->etag(), true);
104    }
105  }
106
107  for (DownloadUrlParameters::RequestHeadersType::const_iterator iter
108           = params->request_headers_begin();
109       iter != params->request_headers_end();
110       ++iter) {
111    request->SetExtraRequestHeaderByName(
112        iter->first, iter->second, false /*overwrite*/);
113  }
114
115  scoped_ptr<DownloadSaveInfo> save_info(new DownloadSaveInfo());
116  save_info->file_path = params->file_path();
117  save_info->suggested_name = params->suggested_name();
118  save_info->offset = params->offset();
119  save_info->hash_state = params->hash_state();
120  save_info->prompt_for_save_location = params->prompt();
121  save_info->file = params->GetFile();
122
123  ResourceDispatcherHost::Get()->BeginDownload(
124      request.Pass(),
125      params->referrer(),
126      params->content_initiated(),
127      params->resource_context(),
128      params->render_process_host_id(),
129      params->render_view_host_routing_id(),
130      params->prefer_cache(),
131      save_info.Pass(),
132      download_id,
133      params->callback());
134}
135
136class MapValueIteratorAdapter {
137 public:
138  explicit MapValueIteratorAdapter(
139      base::hash_map<int64, DownloadItem*>::const_iterator iter)
140    : iter_(iter) {
141  }
142  ~MapValueIteratorAdapter() {}
143
144  DownloadItem* operator*() { return iter_->second; }
145
146  MapValueIteratorAdapter& operator++() {
147    ++iter_;
148    return *this;
149  }
150
151  bool operator!=(const MapValueIteratorAdapter& that) const {
152    return iter_ != that.iter_;
153  }
154
155 private:
156  base::hash_map<int64, DownloadItem*>::const_iterator iter_;
157  // Allow copy and assign.
158};
159
160class DownloadItemFactoryImpl : public DownloadItemFactory {
161 public:
162  DownloadItemFactoryImpl() {}
163  virtual ~DownloadItemFactoryImpl() {}
164
165  virtual DownloadItemImpl* CreatePersistedItem(
166      DownloadItemImplDelegate* delegate,
167      uint32 download_id,
168      const base::FilePath& current_path,
169      const base::FilePath& target_path,
170      const std::vector<GURL>& url_chain,
171      const GURL& referrer_url,
172      const std::string& mime_type,
173      const std::string& original_mime_type,
174      const base::Time& start_time,
175      const base::Time& end_time,
176      const std::string& etag,
177      const std::string& last_modified,
178      int64 received_bytes,
179      int64 total_bytes,
180      DownloadItem::DownloadState state,
181      DownloadDangerType danger_type,
182      DownloadInterruptReason interrupt_reason,
183      bool opened,
184      const net::BoundNetLog& bound_net_log) OVERRIDE {
185    return new DownloadItemImpl(
186        delegate,
187        download_id,
188        current_path,
189        target_path,
190        url_chain,
191        referrer_url,
192        mime_type,
193        original_mime_type,
194        start_time,
195        end_time,
196        etag,
197        last_modified,
198        received_bytes,
199        total_bytes,
200        state,
201        danger_type,
202        interrupt_reason,
203        opened,
204        bound_net_log);
205  }
206
207  virtual DownloadItemImpl* CreateActiveItem(
208      DownloadItemImplDelegate* delegate,
209      uint32 download_id,
210      const DownloadCreateInfo& info,
211      const net::BoundNetLog& bound_net_log) OVERRIDE {
212    return new DownloadItemImpl(delegate, download_id, info, bound_net_log);
213  }
214
215  virtual DownloadItemImpl* CreateSavePageItem(
216      DownloadItemImplDelegate* delegate,
217      uint32 download_id,
218      const base::FilePath& path,
219      const GURL& url,
220      const std::string& mime_type,
221      scoped_ptr<DownloadRequestHandleInterface> request_handle,
222      const net::BoundNetLog& bound_net_log) OVERRIDE {
223    return new DownloadItemImpl(delegate, download_id, path, url,
224                                mime_type, request_handle.Pass(),
225                                bound_net_log);
226  }
227};
228
229}  // namespace
230
231DownloadManagerImpl::DownloadManagerImpl(
232    net::NetLog* net_log,
233    BrowserContext* browser_context)
234    : item_factory_(new DownloadItemFactoryImpl()),
235      file_factory_(new DownloadFileFactory()),
236      history_size_(0),
237      shutdown_needed_(true),
238      browser_context_(browser_context),
239      delegate_(NULL),
240      net_log_(net_log),
241      weak_factory_(this) {
242  DCHECK(browser_context);
243}
244
245DownloadManagerImpl::~DownloadManagerImpl() {
246  DCHECK(!shutdown_needed_);
247}
248
249DownloadItemImpl* DownloadManagerImpl::CreateActiveItem(
250    uint32 id, const DownloadCreateInfo& info) {
251  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
252  DCHECK(!ContainsKey(downloads_, id));
253  net::BoundNetLog bound_net_log =
254      net::BoundNetLog::Make(net_log_, net::NetLog::SOURCE_DOWNLOAD);
255  DownloadItemImpl* download =
256      item_factory_->CreateActiveItem(this, id, info, bound_net_log);
257  downloads_[id] = download;
258  return download;
259}
260
261void DownloadManagerImpl::GetNextId(const DownloadIdCallback& callback) {
262  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
263  if (delegate_) {
264    delegate_->GetNextId(callback);
265    return;
266  }
267  static uint32 next_id = content::DownloadItem::kInvalidId + 1;
268  callback.Run(next_id++);
269}
270
271void DownloadManagerImpl::DetermineDownloadTarget(
272    DownloadItemImpl* item, const DownloadTargetCallback& callback) {
273  // Note that this next call relies on
274  // DownloadItemImplDelegate::DownloadTargetCallback and
275  // DownloadManagerDelegate::DownloadTargetCallback having the same
276  // type.  If the types ever diverge, gasket code will need to
277  // be written here.
278  if (!delegate_ || !delegate_->DetermineDownloadTarget(item, callback)) {
279    base::FilePath target_path = item->GetForcedFilePath();
280    // TODO(asanka): Determine a useful path if |target_path| is empty.
281    callback.Run(target_path,
282                 DownloadItem::TARGET_DISPOSITION_OVERWRITE,
283                 DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
284                 target_path);
285  }
286}
287
288bool DownloadManagerImpl::ShouldCompleteDownload(
289    DownloadItemImpl* item, const base::Closure& complete_callback) {
290  if (!delegate_ ||
291      delegate_->ShouldCompleteDownload(item, complete_callback)) {
292    return true;
293  }
294  // Otherwise, the delegate has accepted responsibility to run the
295  // callback when the download is ready for completion.
296  return false;
297}
298
299bool DownloadManagerImpl::ShouldOpenFileBasedOnExtension(
300    const base::FilePath& path) {
301  if (!delegate_)
302    return false;
303
304  return delegate_->ShouldOpenFileBasedOnExtension(path);
305}
306
307bool DownloadManagerImpl::ShouldOpenDownload(
308    DownloadItemImpl* item, const ShouldOpenDownloadCallback& callback) {
309  if (!delegate_)
310    return true;
311
312  // Relies on DownloadItemImplDelegate::ShouldOpenDownloadCallback and
313  // DownloadManagerDelegate::DownloadOpenDelayedCallback "just happening"
314  // to have the same type :-}.
315  return delegate_->ShouldOpenDownload(item, callback);
316}
317
318void DownloadManagerImpl::SetDelegate(DownloadManagerDelegate* delegate) {
319  delegate_ = delegate;
320}
321
322DownloadManagerDelegate* DownloadManagerImpl::GetDelegate() const {
323  return delegate_;
324}
325
326void DownloadManagerImpl::Shutdown() {
327  VLOG(20) << __FUNCTION__ << "()"
328           << " shutdown_needed_ = " << shutdown_needed_;
329  if (!shutdown_needed_)
330    return;
331  shutdown_needed_ = false;
332
333  FOR_EACH_OBSERVER(Observer, observers_, ManagerGoingDown(this));
334  // TODO(benjhayden): Consider clearing observers_.
335
336  // If there are in-progress downloads, cancel them. This also goes for
337  // dangerous downloads which will remain in history if they aren't explicitly
338  // accepted or discarded. Canceling will remove the intermediate download
339  // file.
340  for (DownloadMap::iterator it = downloads_.begin(); it != downloads_.end();
341       ++it) {
342    DownloadItemImpl* download = it->second;
343    if (download->GetState() == DownloadItem::IN_PROGRESS)
344      download->Cancel(false);
345  }
346  STLDeleteValues(&downloads_);
347  downloads_.clear();
348
349  // We'll have nothing more to report to the observers after this point.
350  observers_.Clear();
351
352  if (delegate_)
353    delegate_->Shutdown();
354  delegate_ = NULL;
355}
356
357void DownloadManagerImpl::StartDownload(
358    scoped_ptr<DownloadCreateInfo> info,
359    scoped_ptr<ByteStreamReader> stream,
360    const DownloadUrlParameters::OnStartedCallback& on_started) {
361  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
362  DCHECK(info);
363  uint32 download_id = info->download_id;
364  const bool new_download = (download_id == content::DownloadItem::kInvalidId);
365  base::Callback<void(uint32)> got_id(base::Bind(
366      &DownloadManagerImpl::StartDownloadWithId,
367      weak_factory_.GetWeakPtr(),
368      base::Passed(info.Pass()),
369      base::Passed(stream.Pass()),
370      on_started,
371      new_download));
372  if (new_download) {
373    GetNextId(got_id);
374  } else {
375    got_id.Run(download_id);
376  }
377}
378
379void DownloadManagerImpl::StartDownloadWithId(
380    scoped_ptr<DownloadCreateInfo> info,
381    scoped_ptr<ByteStreamReader> stream,
382    const DownloadUrlParameters::OnStartedCallback& on_started,
383    bool new_download,
384    uint32 id) {
385  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
386  DCHECK_NE(content::DownloadItem::kInvalidId, id);
387  DownloadItemImpl* download = NULL;
388  if (new_download) {
389    download = CreateActiveItem(id, *info);
390  } else {
391    DownloadMap::iterator item_iterator = downloads_.find(id);
392    // Trying to resume an interrupted download.
393    if (item_iterator == downloads_.end() ||
394        (item_iterator->second->GetState() == DownloadItem::CANCELLED)) {
395      // If the download is no longer known to the DownloadManager, then it was
396      // removed after it was resumed. Ignore. If the download is cancelled
397      // while resuming, then also ignore the request.
398      info->request_handle.CancelRequest();
399      if (!on_started.is_null())
400        on_started.Run(NULL, DOWNLOAD_INTERRUPT_REASON_USER_CANCELED);
401      return;
402    }
403    download = item_iterator->second;
404    DCHECK_EQ(DownloadItem::INTERRUPTED, download->GetState());
405    download->MergeOriginInfoOnResume(*info);
406  }
407
408  base::FilePath default_download_directory;
409  if (delegate_) {
410    base::FilePath website_save_directory;  // Unused
411    bool skip_dir_check = false;            // Unused
412    delegate_->GetSaveDir(GetBrowserContext(), &website_save_directory,
413                          &default_download_directory, &skip_dir_check);
414  }
415
416  // Create the download file and start the download.
417  scoped_ptr<DownloadFile> download_file(
418      file_factory_->CreateFile(
419          info->save_info.Pass(), default_download_directory,
420          info->url(), info->referrer_url,
421          delegate_ && delegate_->GenerateFileHash(),
422          stream.Pass(), download->GetBoundNetLog(),
423          download->DestinationObserverAsWeakPtr()));
424
425  // Attach the client ID identifying the app to the AV system.
426  if (download_file.get() && delegate_) {
427    download_file->SetClientGuid(
428        delegate_->ApplicationClientIdForFileScanning());
429  }
430
431  scoped_ptr<DownloadRequestHandleInterface> req_handle(
432      new DownloadRequestHandle(info->request_handle));
433  download->Start(download_file.Pass(), req_handle.Pass());
434
435  // For interrupted downloads, Start() will transition the state to
436  // IN_PROGRESS and consumers will be notified via OnDownloadUpdated().
437  // For new downloads, we notify here, rather than earlier, so that
438  // the download_file is bound to download and all the usual
439  // setters (e.g. Cancel) work.
440  if (new_download)
441    FOR_EACH_OBSERVER(Observer, observers_, OnDownloadCreated(this, download));
442
443  if (!on_started.is_null())
444    on_started.Run(download, DOWNLOAD_INTERRUPT_REASON_NONE);
445}
446
447void DownloadManagerImpl::CheckForHistoryFilesRemoval() {
448  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
449  for (DownloadMap::iterator it = downloads_.begin();
450       it != downloads_.end(); ++it) {
451    DownloadItemImpl* item = it->second;
452    CheckForFileRemoval(item);
453  }
454}
455
456void DownloadManagerImpl::CheckForFileRemoval(DownloadItemImpl* download_item) {
457  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
458  if ((download_item->GetState() == DownloadItem::COMPLETE) &&
459      !download_item->GetFileExternallyRemoved() &&
460      delegate_) {
461    delegate_->CheckForFileExistence(
462        download_item,
463        base::Bind(&DownloadManagerImpl::OnFileExistenceChecked,
464                   weak_factory_.GetWeakPtr(), download_item->GetId()));
465  }
466}
467
468void DownloadManagerImpl::OnFileExistenceChecked(uint32 download_id,
469                                                 bool result) {
470  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
471  if (!result) {  // File does not exist.
472    if (ContainsKey(downloads_, download_id))
473      downloads_[download_id]->OnDownloadedFileRemoved();
474  }
475}
476
477BrowserContext* DownloadManagerImpl::GetBrowserContext() const {
478  return browser_context_;
479}
480
481void DownloadManagerImpl::CreateSavePackageDownloadItem(
482    const base::FilePath& main_file_path,
483    const GURL& page_url,
484    const std::string& mime_type,
485    scoped_ptr<DownloadRequestHandleInterface> request_handle,
486    const DownloadItemImplCreated& item_created) {
487  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
488  GetNextId(base::Bind(
489      &DownloadManagerImpl::CreateSavePackageDownloadItemWithId,
490      weak_factory_.GetWeakPtr(),
491      main_file_path,
492      page_url,
493      mime_type,
494      base::Passed(request_handle.Pass()),
495      item_created));
496}
497
498void DownloadManagerImpl::CreateSavePackageDownloadItemWithId(
499    const base::FilePath& main_file_path,
500    const GURL& page_url,
501    const std::string& mime_type,
502    scoped_ptr<DownloadRequestHandleInterface> request_handle,
503    const DownloadItemImplCreated& item_created,
504    uint32 id) {
505  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
506  DCHECK_NE(content::DownloadItem::kInvalidId, id);
507  DCHECK(!ContainsKey(downloads_, id));
508  net::BoundNetLog bound_net_log =
509      net::BoundNetLog::Make(net_log_, net::NetLog::SOURCE_DOWNLOAD);
510  DownloadItemImpl* download_item = item_factory_->CreateSavePageItem(
511      this,
512      id,
513      main_file_path,
514      page_url,
515      mime_type,
516      request_handle.Pass(),
517      bound_net_log);
518  downloads_[download_item->GetId()] = download_item;
519  FOR_EACH_OBSERVER(Observer, observers_, OnDownloadCreated(
520      this, download_item));
521  if (!item_created.is_null())
522    item_created.Run(download_item);
523}
524
525void DownloadManagerImpl::OnSavePackageSuccessfullyFinished(
526    DownloadItem* download_item) {
527  FOR_EACH_OBSERVER(Observer, observers_,
528                    OnSavePackageSuccessfullyFinished(this, download_item));
529}
530
531// Resume a download of a specific URL. We send the request to the
532// ResourceDispatcherHost, and let it send us responses like a regular
533// download.
534void DownloadManagerImpl::ResumeInterruptedDownload(
535    scoped_ptr<content::DownloadUrlParameters> params,
536    uint32 id) {
537  RecordDownloadSource(INITIATED_BY_RESUMPTION);
538  BrowserThread::PostTask(
539      BrowserThread::IO,
540      FROM_HERE,
541      base::Bind(&BeginDownload, base::Passed(&params), id));
542}
543
544void DownloadManagerImpl::SetDownloadItemFactoryForTesting(
545    scoped_ptr<DownloadItemFactory> item_factory) {
546  item_factory_ = item_factory.Pass();
547}
548
549void DownloadManagerImpl::SetDownloadFileFactoryForTesting(
550    scoped_ptr<DownloadFileFactory> file_factory) {
551  file_factory_ = file_factory.Pass();
552}
553
554DownloadFileFactory* DownloadManagerImpl::GetDownloadFileFactoryForTesting() {
555  return file_factory_.get();
556}
557
558void DownloadManagerImpl::DownloadRemoved(DownloadItemImpl* download) {
559  if (!download)
560    return;
561
562  uint32 download_id = download->GetId();
563  if (downloads_.erase(download_id) == 0)
564    return;
565  delete download;
566}
567
568int DownloadManagerImpl::RemoveDownloadsBetween(base::Time remove_begin,
569                                                base::Time remove_end) {
570  int count = 0;
571  DownloadMap::const_iterator it = downloads_.begin();
572  while (it != downloads_.end()) {
573    DownloadItemImpl* download = it->second;
574
575    // Increment done here to protect against invalidation below.
576    ++it;
577
578    if (download->GetStartTime() >= remove_begin &&
579        (remove_end.is_null() || download->GetStartTime() < remove_end) &&
580        (download->GetState() != DownloadItem::IN_PROGRESS)) {
581      // Erases the download from downloads_.
582      download->Remove();
583      count++;
584    }
585  }
586  return count;
587}
588
589int DownloadManagerImpl::RemoveDownloads(base::Time remove_begin) {
590  return RemoveDownloadsBetween(remove_begin, base::Time());
591}
592
593int DownloadManagerImpl::RemoveAllDownloads() {
594  // The null times make the date range unbounded.
595  int num_deleted = RemoveDownloadsBetween(base::Time(), base::Time());
596  RecordClearAllSize(num_deleted);
597  return num_deleted;
598}
599
600void DownloadManagerImpl::DownloadUrl(
601    scoped_ptr<DownloadUrlParameters> params) {
602  if (params->post_id() >= 0) {
603    // Check this here so that the traceback is more useful.
604    DCHECK(params->prefer_cache());
605    DCHECK_EQ("POST", params->method());
606  }
607  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, base::Bind(
608      &BeginDownload, base::Passed(&params),
609      content::DownloadItem::kInvalidId));
610}
611
612void DownloadManagerImpl::AddObserver(Observer* observer) {
613  observers_.AddObserver(observer);
614}
615
616void DownloadManagerImpl::RemoveObserver(Observer* observer) {
617  observers_.RemoveObserver(observer);
618}
619
620DownloadItem* DownloadManagerImpl::CreateDownloadItem(
621    uint32 id,
622    const base::FilePath& current_path,
623    const base::FilePath& target_path,
624    const std::vector<GURL>& url_chain,
625    const GURL& referrer_url,
626    const std::string& mime_type,
627    const std::string& original_mime_type,
628    const base::Time& start_time,
629    const base::Time& end_time,
630    const std::string& etag,
631    const std::string& last_modified,
632    int64 received_bytes,
633    int64 total_bytes,
634    DownloadItem::DownloadState state,
635    DownloadDangerType danger_type,
636    DownloadInterruptReason interrupt_reason,
637    bool opened) {
638  if (ContainsKey(downloads_, id)) {
639    NOTREACHED();
640    return NULL;
641  }
642  DownloadItemImpl* item = item_factory_->CreatePersistedItem(
643      this,
644      id,
645      current_path,
646      target_path,
647      url_chain,
648      referrer_url,
649      mime_type,
650      original_mime_type,
651      start_time,
652      end_time,
653      etag,
654      last_modified,
655      received_bytes,
656      total_bytes,
657      state,
658      danger_type,
659      interrupt_reason,
660      opened,
661      net::BoundNetLog::Make(net_log_, net::NetLog::SOURCE_DOWNLOAD));
662  downloads_[id] = item;
663  FOR_EACH_OBSERVER(Observer, observers_, OnDownloadCreated(this, item));
664  VLOG(20) << __FUNCTION__ << "() download = " << item->DebugString(true);
665  return item;
666}
667
668int DownloadManagerImpl::InProgressCount() const {
669  int count = 0;
670  for (DownloadMap::const_iterator it = downloads_.begin();
671       it != downloads_.end(); ++it) {
672    if (it->second->GetState() == DownloadItem::IN_PROGRESS)
673      ++count;
674  }
675  return count;
676}
677
678int DownloadManagerImpl::NonMaliciousInProgressCount() const {
679  int count = 0;
680  for (DownloadMap::const_iterator it = downloads_.begin();
681       it != downloads_.end(); ++it) {
682    if (it->second->GetState() == DownloadItem::IN_PROGRESS &&
683        it->second->GetDangerType() != DOWNLOAD_DANGER_TYPE_DANGEROUS_URL &&
684        it->second->GetDangerType() != DOWNLOAD_DANGER_TYPE_DANGEROUS_CONTENT &&
685        it->second->GetDangerType() != DOWNLOAD_DANGER_TYPE_DANGEROUS_HOST &&
686        it->second->GetDangerType() !=
687            DOWNLOAD_DANGER_TYPE_POTENTIALLY_UNWANTED) {
688      ++count;
689    }
690  }
691  return count;
692}
693
694DownloadItem* DownloadManagerImpl::GetDownload(uint32 download_id) {
695  return ContainsKey(downloads_, download_id) ? downloads_[download_id] : NULL;
696}
697
698void DownloadManagerImpl::GetAllDownloads(DownloadVector* downloads) {
699  for (DownloadMap::iterator it = downloads_.begin();
700       it != downloads_.end(); ++it) {
701    downloads->push_back(it->second);
702  }
703}
704
705void DownloadManagerImpl::OpenDownload(DownloadItemImpl* download) {
706  int num_unopened = 0;
707  for (DownloadMap::iterator it = downloads_.begin();
708       it != downloads_.end(); ++it) {
709    DownloadItemImpl* item = it->second;
710    if ((item->GetState() == DownloadItem::COMPLETE) &&
711        !item->GetOpened())
712      ++num_unopened;
713  }
714  RecordOpensOutstanding(num_unopened);
715
716  if (delegate_)
717    delegate_->OpenDownload(download);
718}
719
720void DownloadManagerImpl::ShowDownloadInShell(DownloadItemImpl* download) {
721  if (delegate_)
722    delegate_->ShowDownloadInShell(download);
723}
724
725}  // namespace content
726