download_manager.h revision eb525c5499e34cc9c4b825d6d9e75bb07cc06ace
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// The DownloadManager object manages the process of downloading, including 6// updates to the history system and providing the information for displaying 7// the downloads view in the Destinations tab. There is one DownloadManager per 8// active browser context in Chrome. 9// 10// Download observers: 11// Objects that are interested in notifications about new downloads, or progress 12// updates for a given download must implement one of the download observer 13// interfaces: 14// DownloadManager::Observer: 15// - allows observers, primarily views, to be notified when changes to the 16// set of all downloads (such as new downloads, or deletes) occur 17// Use AddObserver() / RemoveObserver() on the appropriate download object to 18// receive state updates. 19// 20// Download state persistence: 21// The DownloadManager uses the history service for storing persistent 22// information about the state of all downloads. The history system maintains a 23// separate table for this called 'downloads'. At the point that the 24// DownloadManager is constructed, we query the history service for the state of 25// all persisted downloads. 26 27#ifndef CONTENT_PUBLIC_BROWSER_DOWNLOAD_MANAGER_H_ 28#define CONTENT_PUBLIC_BROWSER_DOWNLOAD_MANAGER_H_ 29 30#include <string> 31#include <vector> 32 33#include "base/basictypes.h" 34#include "base/callback.h" 35#include "base/files/file_path.h" 36#include "base/gtest_prod_util.h" 37#include "base/sequenced_task_runner_helpers.h" 38#include "base/time/time.h" 39#include "content/public/browser/download_id.h" 40#include "content/public/browser/download_interrupt_reasons.h" 41#include "content/public/browser/download_item.h" 42#include "net/base/net_errors.h" 43#include "net/base/net_log.h" 44 45class GURL; 46 47namespace content { 48 49class BrowserContext; 50class ByteStreamReader; 51class DownloadManagerDelegate; 52class DownloadQuery; 53class DownloadRequestHandle; 54class DownloadUrlParameters; 55struct DownloadCreateInfo; 56struct DownloadRetrieveInfo; 57 58// Browser's download manager: manages all downloads and destination view. 59class CONTENT_EXPORT DownloadManager : public base::SupportsUserData::Data { 60 public: 61 virtual ~DownloadManager() {} 62 63 // Sets/Gets the delegate for this DownloadManager. The delegate has to live 64 // past its Shutdown method being called (by the DownloadManager). 65 virtual void SetDelegate(DownloadManagerDelegate* delegate) = 0; 66 virtual DownloadManagerDelegate* GetDelegate() const = 0; 67 68 // Shutdown the download manager. Content calls this when BrowserContext is 69 // being destructed. If the embedder needs this to be called earlier, it can 70 // call it. In that case, the delegate's Shutdown() method will only be called 71 // once. 72 virtual void Shutdown() = 0; 73 74 // Interface to implement for observers that wish to be informed of changes 75 // to the DownloadManager's collection of downloads. 76 class CONTENT_EXPORT Observer { 77 public: 78 // A DownloadItem was created. This item may be visible before the filename 79 // is determined; in this case the return value of GetTargetFileName() will 80 // be null. This method may be called an arbitrary number of times, e.g. 81 // when loading history on startup. As a result, consumers should avoid 82 // doing large amounts of work in OnDownloadCreated(). TODO(<whoever>): 83 // When we've fully specified the possible states of the DownloadItem in 84 // download_item.h, we should remove the caveat above. 85 virtual void OnDownloadCreated( 86 DownloadManager* manager, DownloadItem* item) {} 87 88 // A SavePackage has successfully finished. 89 virtual void OnSavePackageSuccessfullyFinished( 90 DownloadManager* manager, DownloadItem* item) {} 91 92 // Called when the DownloadManager is being destroyed to prevent Observers 93 // from calling back to a stale pointer. 94 virtual void ManagerGoingDown(DownloadManager* manager) {} 95 96 protected: 97 virtual ~Observer() {} 98 }; 99 100 typedef std::vector<DownloadItem*> DownloadVector; 101 102 // Add all download items to |downloads|, no matter the type or state, without 103 // clearing |downloads| first. 104 virtual void GetAllDownloads(DownloadVector* downloads) = 0; 105 106 // Called by a download source (Currently DownloadResourceHandler) 107 // to initiate the non-source portions of a download. 108 // Returns the id assigned to the download. If the DownloadCreateInfo 109 // specifies an id, that id will be used. 110 virtual DownloadItem* StartDownload( 111 scoped_ptr<DownloadCreateInfo> info, 112 scoped_ptr<ByteStreamReader> stream) = 0; 113 114 // Remove downloads after remove_begin (inclusive) and before remove_end 115 // (exclusive). You may pass in null Time values to do an unbounded delete 116 // in either direction. 117 virtual int RemoveDownloadsBetween(base::Time remove_begin, 118 base::Time remove_end) = 0; 119 120 // Remove downloads will delete all downloads that have a timestamp that is 121 // the same or more recent than |remove_begin|. The number of downloads 122 // deleted is returned back to the caller. 123 virtual int RemoveDownloads(base::Time remove_begin) = 0; 124 125 // Remove all downloads will delete all downloads. The number of downloads 126 // deleted is returned back to the caller. 127 virtual int RemoveAllDownloads() = 0; 128 129 // See DownloadUrlParameters for details about controlling the download. 130 virtual void DownloadUrl(scoped_ptr<DownloadUrlParameters> parameters) = 0; 131 132 // Allow objects to observe the download creation process. 133 virtual void AddObserver(Observer* observer) = 0; 134 135 // Remove a download observer from ourself. 136 virtual void RemoveObserver(Observer* observer) = 0; 137 138 // Called by the embedder, after creating the download manager, to let it know 139 // about downloads from previous runs of the browser. 140 virtual DownloadItem* CreateDownloadItem( 141 const base::FilePath& current_path, 142 const base::FilePath& target_path, 143 const std::vector<GURL>& url_chain, 144 const GURL& referrer_url, 145 const base::Time& start_time, 146 const base::Time& end_time, 147 int64 received_bytes, 148 int64 total_bytes, 149 DownloadItem::DownloadState state, 150 DownloadDangerType danger_type, 151 DownloadInterruptReason interrupt_reason, 152 bool opened) = 0; 153 154 // The number of in progress (including paused) downloads. 155 // Performance note: this loops over all items. If profiling finds that this 156 // is too slow, use an AllDownloadItemNotifier to count in-progress items. 157 virtual int InProgressCount() const = 0; 158 159 virtual BrowserContext* GetBrowserContext() const = 0; 160 161 // Checks whether downloaded files still exist. Updates state of downloads 162 // that refer to removed files. The check runs in the background and may 163 // finish asynchronously after this method returns. 164 virtual void CheckForHistoryFilesRemoval() = 0; 165 166 // Get the download item for |id| if present, no matter what type of download 167 // it is or state it's in. 168 virtual DownloadItem* GetDownload(int id) = 0; 169}; 170 171} // namespace content 172 173#endif // CONTENT_PUBLIC_BROWSER_DOWNLOAD_MANAGER_H_ 174