content/browser/download/download_manager_impl.cc

   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
  48 namespace content {
  49 namespace {
  50
  51 void 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));
  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_stream = params->GetFileStream();
 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
 136 class 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
 160 class 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 base::Time& start_time,
 173       const base::Time& end_time,
 174       const std::string& etag,
 175       const std::string& last_modified,
 176       int64 received_bytes,
 177       int64 total_bytes,
 178       DownloadItem::DownloadState state,
 179       DownloadDangerType danger_type,
 180       DownloadInterruptReason interrupt_reason,
 181       bool opened,
 182       const net::BoundNetLog& bound_net_log) OVERRIDE {
 183     return new DownloadItemImpl(
 184         delegate,
 185         download_id,
 186         current_path,
 187         target_path,
 188         url_chain,
 189         referrer_url,
 190         start_time,
 191         end_time,
 192         etag,
 193         last_modified,
 194         received_bytes,
 195         total_bytes,
 196         state,
 197         danger_type,
 198         interrupt_reason,
 199         opened,
 200         bound_net_log);
 201   }
 202
 203   virtual DownloadItemImpl* CreateActiveItem(
 204       DownloadItemImplDelegate* delegate,
 205       uint32 download_id,
 206       const DownloadCreateInfo& info,
 207       const net::BoundNetLog& bound_net_log) OVERRIDE {
 208     return new DownloadItemImpl(delegate, download_id, info, bound_net_log);
 209   }
 210
 211   virtual DownloadItemImpl* CreateSavePageItem(
 212       DownloadItemImplDelegate* delegate,
 213       uint32 download_id,
 214       const base::FilePath& path,
 215       const GURL& url,
 216       const std::string& mime_type,
 217       scoped_ptr<DownloadRequestHandleInterface> request_handle,
 218       const net::BoundNetLog& bound_net_log) OVERRIDE {
 219     return new DownloadItemImpl(delegate, download_id, path, url,
 220                                 mime_type, request_handle.Pass(),
 221                                 bound_net_log);
 222   }
 223 };
 224
 225 }  // namespace
 226
 227 DownloadManagerImpl::DownloadManagerImpl(
 228     net::NetLog* net_log,
 229     BrowserContext* browser_context)
 230     : item_factory_(new DownloadItemFactoryImpl()),
 231       file_factory_(new DownloadFileFactory()),
 232       history_size_(0),
 233       shutdown_needed_(true),
 234       browser_context_(browser_context),
 235       delegate_(NULL),
 236       net_log_(net_log),
 237       weak_factory_(this) {
 238   DCHECK(browser_context);
 239 }
 240
 241 DownloadManagerImpl::~DownloadManagerImpl() {
 242   DCHECK(!shutdown_needed_);
 243 }
 244
 245 DownloadItemImpl* DownloadManagerImpl::CreateActiveItem(
 246     uint32 id, const DownloadCreateInfo& info) {
 247   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 248   DCHECK(!ContainsKey(downloads_, id));
 249   net::BoundNetLog bound_net_log =
 250       net::BoundNetLog::Make(net_log_, net::NetLog::SOURCE_DOWNLOAD);
 251   DownloadItemImpl* download =
 252       item_factory_->CreateActiveItem(this, id, info, bound_net_log);
 253   downloads_[id] = download;
 254   return download;
 255 }
 256
 257 void DownloadManagerImpl::GetNextId(const DownloadIdCallback& callback) {
 258   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 259   if (delegate_) {
 260     delegate_->GetNextId(callback);
 261     return;
 262   }
 263   static uint32 next_id = content::DownloadItem::kInvalidId + 1;
 264   callback.Run(next_id++);
 265 }
 266
 267 void DownloadManagerImpl::DetermineDownloadTarget(
 268     DownloadItemImpl* item, const DownloadTargetCallback& callback) {
 269   // Note that this next call relies on
 270   // DownloadItemImplDelegate::DownloadTargetCallback and
 271   // DownloadManagerDelegate::DownloadTargetCallback having the same
 272   // type.  If the types ever diverge, gasket code will need to
 273   // be written here.
 274   if (!delegate_ || !delegate_->DetermineDownloadTarget(item, callback)) {
 275     base::FilePath target_path = item->GetForcedFilePath();
 276     // TODO(asanka): Determine a useful path if |target_path| is empty.
 277     callback.Run(target_path,
 278                  DownloadItem::TARGET_DISPOSITION_OVERWRITE,
 279                  DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
 280                  target_path);
 281   }
 282 }
 283
 284 bool DownloadManagerImpl::ShouldCompleteDownload(
 285     DownloadItemImpl* item, const base::Closure& complete_callback) {
 286   if (!delegate_ ||
 287       delegate_->ShouldCompleteDownload(item, complete_callback)) {
 288     return true;
 289   }
 290   // Otherwise, the delegate has accepted responsibility to run the
 291   // callback when the download is ready for completion.
 292   return false;
 293 }
 294
 295 bool DownloadManagerImpl::ShouldOpenFileBasedOnExtension(
 296     const base::FilePath& path) {
 297   if (!delegate_)
 298     return false;
 299
 300   return delegate_->ShouldOpenFileBasedOnExtension(path);
 301 }
 302
 303 bool DownloadManagerImpl::ShouldOpenDownload(
 304     DownloadItemImpl* item, const ShouldOpenDownloadCallback& callback) {
 305   if (!delegate_)
 306     return true;
 307
 308   // Relies on DownloadItemImplDelegate::ShouldOpenDownloadCallback and
 309   // DownloadManagerDelegate::DownloadOpenDelayedCallback "just happening"
 310   // to have the same type :-}.
 311   return delegate_->ShouldOpenDownload(item, callback);
 312 }
 313
 314 void DownloadManagerImpl::SetDelegate(DownloadManagerDelegate* delegate) {
 315   delegate_ = delegate;
 316 }
 317
 318 DownloadManagerDelegate* DownloadManagerImpl::GetDelegate() const {
 319   return delegate_;
 320 }
 321
 322 void DownloadManagerImpl::Shutdown() {
 323   VLOG(20) << __FUNCTION__ << "()"
 324            << " shutdown_needed_ = " << shutdown_needed_;
 325   if (!shutdown_needed_)
 326     return;
 327   shutdown_needed_ = false;
 328
 329   FOR_EACH_OBSERVER(Observer, observers_, ManagerGoingDown(this));
 330   // TODO(benjhayden): Consider clearing observers_.
 331
 332   // If there are in-progress downloads, cancel them. This also goes for
 333   // dangerous downloads which will remain in history if they aren't explicitly
 334   // accepted or discarded. Canceling will remove the intermediate download
 335   // file.
 336   for (DownloadMap::iterator it = downloads_.begin(); it != downloads_.end();
 337        ++it) {
 338     DownloadItemImpl* download = it->second;
 339     if (download->GetState() == DownloadItem::IN_PROGRESS)
 340       download->Cancel(false);
 341   }
 342   STLDeleteValues(&downloads_);
 343   downloads_.clear();
 344
 345   // We'll have nothing more to report to the observers after this point.
 346   observers_.Clear();
 347
 348   if (delegate_)
 349     delegate_->Shutdown();
 350   delegate_ = NULL;
 351 }
 352
 353 void DownloadManagerImpl::StartDownload(
 354     scoped_ptr<DownloadCreateInfo> info,
 355     scoped_ptr<ByteStreamReader> stream,
 356     const DownloadUrlParameters::OnStartedCallback& on_started) {
 357   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 358   DCHECK(info);
 359   uint32 download_id = info->download_id;
 360   const bool new_download = (download_id == content::DownloadItem::kInvalidId);
 361   base::Callback<void(uint32)> got_id(base::Bind(
 362       &DownloadManagerImpl::StartDownloadWithId,
 363       weak_factory_.GetWeakPtr(),
 364       base::Passed(info.Pass()),
 365       base::Passed(stream.Pass()),
 366       on_started,
 367       new_download));
 368   if (new_download) {
 369     GetNextId(got_id);
 370   } else {
 371     got_id.Run(download_id);
 372   }
 373 }
 374
 375 void DownloadManagerImpl::StartDownloadWithId(
 376     scoped_ptr<DownloadCreateInfo> info,
 377     scoped_ptr<ByteStreamReader> stream,
 378     const DownloadUrlParameters::OnStartedCallback& on_started,
 379     bool new_download,
 380     uint32 id) {
 381   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 382   DCHECK_NE(content::DownloadItem::kInvalidId, id);
 383   DownloadItemImpl* download = NULL;
 384   if (new_download) {
 385     download = CreateActiveItem(id, *info);
 386   } else {
 387     DownloadMap::iterator item_iterator = downloads_.find(id);
 388     // Trying to resume an interrupted download.
 389     if (item_iterator == downloads_.end() ||
 390         (item_iterator->second->GetState() == DownloadItem::CANCELLED)) {
 391       // If the download is no longer known to the DownloadManager, then it was
 392       // removed after it was resumed. Ignore. If the download is cancelled
 393       // while resuming, then also ignore the request.
 394       info->request_handle.CancelRequest();
 395       if (!on_started.is_null())
 396         on_started.Run(NULL, net::ERR_ABORTED);
 397       return;
 398     }
 399     download = item_iterator->second;
 400     DCHECK_EQ(DownloadItem::INTERRUPTED, download->GetState());
 401     download->MergeOriginInfoOnResume(*info);
 402   }
 403
 404   base::FilePath default_download_directory;
 405   if (delegate_) {
 406     base::FilePath website_save_directory;  // Unused
 407     bool skip_dir_check = false;            // Unused
 408     delegate_->GetSaveDir(GetBrowserContext(), &website_save_directory,
 409                           &default_download_directory, &skip_dir_check);
 410   }
 411
 412   // Create the download file and start the download.
 413   scoped_ptr<DownloadFile> download_file(
 414       file_factory_->CreateFile(
 415           info->save_info.Pass(), default_download_directory,
 416           info->url(), info->referrer_url,
 417           delegate_ && delegate_->GenerateFileHash(),
 418           stream.Pass(), download->GetBoundNetLog(),
 419           download->DestinationObserverAsWeakPtr()));
 420
 421   // Attach the client ID identifying the app to the AV system.
 422   if (download_file.get() && delegate_) {
 423     download_file->SetClientGuid(
 424         delegate_->ApplicationClientIdForFileScanning());
 425   }
 426
 427   scoped_ptr<DownloadRequestHandleInterface> req_handle(
 428       new DownloadRequestHandle(info->request_handle));
 429   download->Start(download_file.Pass(), req_handle.Pass());
 430
 431   // For interrupted downloads, Start() will transition the state to
 432   // IN_PROGRESS and consumers will be notified via OnDownloadUpdated().
 433   // For new downloads, we notify here, rather than earlier, so that
 434   // the download_file is bound to download and all the usual
 435   // setters (e.g. Cancel) work.
 436   if (new_download)
 437     FOR_EACH_OBSERVER(Observer, observers_, OnDownloadCreated(this, download));
 438
 439   if (!on_started.is_null())
 440     on_started.Run(download, net::OK);
 441 }
 442
 443 void DownloadManagerImpl::CheckForHistoryFilesRemoval() {
 444   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 445   for (DownloadMap::iterator it = downloads_.begin();
 446        it != downloads_.end(); ++it) {
 447     DownloadItemImpl* item = it->second;
 448     CheckForFileRemoval(item);
 449   }
 450 }
 451
 452 void DownloadManagerImpl::CheckForFileRemoval(DownloadItemImpl* download_item) {
 453   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 454   if ((download_item->GetState() == DownloadItem::COMPLETE) &&
 455       !download_item->GetFileExternallyRemoved() &&
 456       delegate_) {
 457     delegate_->CheckForFileExistence(
 458         download_item,
 459         base::Bind(&DownloadManagerImpl::OnFileExistenceChecked,
 460                    weak_factory_.GetWeakPtr(), download_item->GetId()));
 461   }
 462 }
 463
 464 void DownloadManagerImpl::OnFileExistenceChecked(uint32 download_id,
 465                                                  bool result) {
 466   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 467   if (!result) {  // File does not exist.
 468     if (ContainsKey(downloads_, download_id))
 469       downloads_[download_id]->OnDownloadedFileRemoved(true);
 470   }
 471 }
 472
 473 BrowserContext* DownloadManagerImpl::GetBrowserContext() const {
 474   return browser_context_;
 475 }
 476
 477 void DownloadManagerImpl::CreateSavePackageDownloadItem(
 478     const base::FilePath& main_file_path,
 479     const GURL& page_url,
 480     const std::string& mime_type,
 481     scoped_ptr<DownloadRequestHandleInterface> request_handle,
 482     const DownloadItemImplCreated& item_created) {
 483   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 484   GetNextId(base::Bind(
 485       &DownloadManagerImpl::CreateSavePackageDownloadItemWithId,
 486       weak_factory_.GetWeakPtr(),
 487       main_file_path,
 488       page_url,
 489       mime_type,
 490       base::Passed(request_handle.Pass()),
 491       item_created));
 492 }
 493
 494 void DownloadManagerImpl::CreateSavePackageDownloadItemWithId(
 495     const base::FilePath& main_file_path,
 496     const GURL& page_url,
 497     const std::string& mime_type,
 498     scoped_ptr<DownloadRequestHandleInterface> request_handle,
 499     const DownloadItemImplCreated& item_created,
 500     uint32 id) {
 501   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 502   DCHECK_NE(content::DownloadItem::kInvalidId, id);
 503   DCHECK(!ContainsKey(downloads_, id));
 504   net::BoundNetLog bound_net_log =
 505       net::BoundNetLog::Make(net_log_, net::NetLog::SOURCE_DOWNLOAD);
 506   DownloadItemImpl* download_item = item_factory_->CreateSavePageItem(
 507       this,
 508       id,
 509       main_file_path,
 510       page_url,
 511       mime_type,
 512       request_handle.Pass(),
 513       bound_net_log);
 514   downloads_[download_item->GetId()] = download_item;
 515   FOR_EACH_OBSERVER(Observer, observers_, OnDownloadCreated(
 516       this, download_item));
 517   if (!item_created.is_null())
 518     item_created.Run(download_item);
 519 }
 520
 521 void DownloadManagerImpl::OnSavePackageSuccessfullyFinished(
 522     DownloadItem* download_item) {
 523   FOR_EACH_OBSERVER(Observer, observers_,
 524                     OnSavePackageSuccessfullyFinished(this, download_item));
 525 }
 526
 527 // Resume a download of a specific URL. We send the request to the
 528 // ResourceDispatcherHost, and let it send us responses like a regular
 529 // download.
 530 void DownloadManagerImpl::ResumeInterruptedDownload(
 531     scoped_ptr<content::DownloadUrlParameters> params,
 532     uint32 id) {
 533   RecordDownloadSource(INITIATED_BY_RESUMPTION);
 534   BrowserThread::PostTask(
 535       BrowserThread::IO,
 536       FROM_HERE,
 537       base::Bind(&BeginDownload, base::Passed(&params), id));
 538 }
 539
 540 void DownloadManagerImpl::SetDownloadItemFactoryForTesting(
 541     scoped_ptr<DownloadItemFactory> item_factory) {
 542   item_factory_ = item_factory.Pass();
 543 }
 544
 545 void DownloadManagerImpl::SetDownloadFileFactoryForTesting(
 546     scoped_ptr<DownloadFileFactory> file_factory) {
 547   file_factory_ = file_factory.Pass();
 548 }
 549
 550 DownloadFileFactory* DownloadManagerImpl::GetDownloadFileFactoryForTesting() {
 551   return file_factory_.get();
 552 }
 553
 554 void DownloadManagerImpl::DownloadRemoved(DownloadItemImpl* download) {
 555   if (!download)
 556     return;
 557
 558   uint32 download_id = download->GetId();
 559   if (downloads_.erase(download_id) == 0)
 560     return;
 561   delete download;
 562 }
 563
 564 int DownloadManagerImpl::RemoveDownloadsBetween(base::Time remove_begin,
 565                                                 base::Time remove_end) {
 566   int count = 0;
 567   DownloadMap::const_iterator it = downloads_.begin();
 568   while (it != downloads_.end()) {
 569     DownloadItemImpl* download = it->second;
 570
 571     // Increment done here to protect against invalidation below.
 572     ++it;
 573
 574     if (download->GetStartTime() >= remove_begin &&
 575         (remove_end.is_null() || download->GetStartTime() < remove_end) &&
 576         (download->GetState() != DownloadItem::IN_PROGRESS)) {
 577       // Erases the download from downloads_.
 578       download->Remove();
 579       count++;
 580     }
 581   }
 582   return count;
 583 }
 584
 585 int DownloadManagerImpl::RemoveDownloads(base::Time remove_begin) {
 586   return RemoveDownloadsBetween(remove_begin, base::Time());
 587 }
 588
 589 int DownloadManagerImpl::RemoveAllDownloads() {
 590   // The null times make the date range unbounded.
 591   int num_deleted = RemoveDownloadsBetween(base::Time(), base::Time());
 592   RecordClearAllSize(num_deleted);
 593   return num_deleted;
 594 }
 595
 596 void DownloadManagerImpl::DownloadUrl(
 597     scoped_ptr<DownloadUrlParameters> params) {
 598   if (params->post_id() >= 0) {
 599     // Check this here so that the traceback is more useful.
 600     DCHECK(params->prefer_cache());
 601     DCHECK_EQ("POST", params->method());
 602   }
 603   BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, base::Bind(
 604       &BeginDownload, base::Passed(&params),
 605       content::DownloadItem::kInvalidId));
 606 }
 607
 608 void DownloadManagerImpl::AddObserver(Observer* observer) {
 609   observers_.AddObserver(observer);
 610 }
 611
 612 void DownloadManagerImpl::RemoveObserver(Observer* observer) {
 613   observers_.RemoveObserver(observer);
 614 }
 615
 616 DownloadItem* DownloadManagerImpl::CreateDownloadItem(
 617     uint32 id,
 618     const base::FilePath& current_path,
 619     const base::FilePath& target_path,
 620     const std::vector<GURL>& url_chain,
 621     const GURL& referrer_url,
 622     const base::Time& start_time,
 623     const base::Time& end_time,
 624     const std::string& etag,
 625     const std::string& last_modified,
 626     int64 received_bytes,
 627     int64 total_bytes,
 628     DownloadItem::DownloadState state,
 629     DownloadDangerType danger_type,
 630     DownloadInterruptReason interrupt_reason,
 631     bool opened) {
 632   if (ContainsKey(downloads_, id)) {
 633     NOTREACHED();
 634     return NULL;
 635   }
 636   DownloadItemImpl* item = item_factory_->CreatePersistedItem(
 637       this,
 638       id,
 639       current_path,
 640       target_path,
 641       url_chain,
 642       referrer_url,
 643       start_time,
 644       end_time,
 645       etag,
 646       last_modified,
 647       received_bytes,
 648       total_bytes,
 649       state,
 650       danger_type,
 651       interrupt_reason,
 652       opened,
 653       net::BoundNetLog::Make(net_log_, net::NetLog::SOURCE_DOWNLOAD));
 654   downloads_[id] = item;
 655   FOR_EACH_OBSERVER(Observer, observers_, OnDownloadCreated(this, item));
 656   VLOG(20) << __FUNCTION__ << "() download = " << item->DebugString(true);
 657   return item;
 658 }
 659
 660 int DownloadManagerImpl::InProgressCount() const {
 661   int count = 0;
 662   for (DownloadMap::const_iterator it = downloads_.begin();
 663        it != downloads_.end(); ++it) {
 664     if (it->second->GetState() == DownloadItem::IN_PROGRESS)
 665       ++count;
 666   }
 667   return count;
 668 }
 669
 670 int DownloadManagerImpl::NonMaliciousInProgressCount() const {
 671   int count = 0;
 672   for (DownloadMap::const_iterator it = downloads_.begin();
 673        it != downloads_.end(); ++it) {
 674     if (it->second->GetState() == DownloadItem::IN_PROGRESS &&
 675         it->second->GetDangerType() != DOWNLOAD_DANGER_TYPE_DANGEROUS_URL &&
 676         it->second->GetDangerType() != DOWNLOAD_DANGER_TYPE_DANGEROUS_CONTENT &&
 677         it->second->GetDangerType() != DOWNLOAD_DANGER_TYPE_DANGEROUS_HOST &&
 678         it->second->GetDangerType() !=
 679             DOWNLOAD_DANGER_TYPE_POTENTIALLY_UNWANTED) {
 680       ++count;
 681     }
 682   }
 683   return count;
 684 }
 685
 686 DownloadItem* DownloadManagerImpl::GetDownload(uint32 download_id) {
 687   return ContainsKey(downloads_, download_id) ? downloads_[download_id] : NULL;
 688 }
 689
 690 void DownloadManagerImpl::GetAllDownloads(DownloadVector* downloads) {
 691   for (DownloadMap::iterator it = downloads_.begin();
 692        it != downloads_.end(); ++it) {
 693     downloads->push_back(it->second);
 694   }
 695 }
 696
 697 void DownloadManagerImpl::OpenDownload(DownloadItemImpl* download) {
 698   int num_unopened = 0;
 699   for (DownloadMap::iterator it = downloads_.begin();
 700        it != downloads_.end(); ++it) {
 701     DownloadItemImpl* item = it->second;
 702     if ((item->GetState() == DownloadItem::COMPLETE) &&
 703         !item->GetOpened())
 704       ++num_unopened;
 705   }
 706   RecordOpensOutstanding(num_unopened);
 707
 708   if (delegate_)
 709     delegate_->OpenDownload(download);
 710 }
 711
 712 void DownloadManagerImpl::ShowDownloadInShell(DownloadItemImpl* download) {
 713   if (delegate_)
 714     delegate_->ShowDownloadInShell(download);
 715 }
 716
 717 }  // namespace content