download_manager.h revision 90dce4d38c5ff5333bea97d859d4e484e27edf0c
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.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 // Offthread target for cancelling a particular download. Will be a no-op 115 // if the download has already been cancelled. 116 virtual void CancelDownload(int32 download_id) = 0; 117 118 // Remove downloads after remove_begin (inclusive) and before remove_end 119 // (exclusive). You may pass in null Time values to do an unbounded delete 120 // in either direction. 121 virtual int RemoveDownloadsBetween(base::Time remove_begin, 122 base::Time remove_end) = 0; 123 124 // Remove downloads will delete all downloads that have a timestamp that is 125 // the same or more recent than |remove_begin|. The number of downloads 126 // deleted is returned back to the caller. 127 virtual int RemoveDownloads(base::Time remove_begin) = 0; 128 129 // Remove all downloads will delete all downloads. The number of downloads 130 // deleted is returned back to the caller. 131 virtual int RemoveAllDownloads() = 0; 132 133 // See DownloadUrlParameters for details about controlling the download. 134 virtual void DownloadUrl(scoped_ptr<DownloadUrlParameters> parameters) = 0; 135 136 // Allow objects to observe the download creation process. 137 virtual void AddObserver(Observer* observer) = 0; 138 139 // Remove a download observer from ourself. 140 virtual void RemoveObserver(Observer* observer) = 0; 141 142 // Called by the embedder, after creating the download manager, to let it know 143 // about downloads from previous runs of the browser. 144 virtual DownloadItem* CreateDownloadItem( 145 const base::FilePath& current_path, 146 const base::FilePath& target_path, 147 const std::vector<GURL>& url_chain, 148 const GURL& referrer_url, 149 const base::Time& start_time, 150 const base::Time& end_time, 151 int64 received_bytes, 152 int64 total_bytes, 153 DownloadItem::DownloadState state, 154 DownloadDangerType danger_type, 155 DownloadInterruptReason interrupt_reason, 156 bool opened) = 0; 157 158 // The number of in progress (including paused) downloads. 159 // Performance note: this loops over all items. If profiling finds that this 160 // is too slow, use an AllDownloadItemNotifier to count in-progress items. 161 virtual int InProgressCount() const = 0; 162 163 virtual BrowserContext* GetBrowserContext() const = 0; 164 165 // Checks whether downloaded files still exist. Updates state of downloads 166 // that refer to removed files. The check runs in the background and may 167 // finish asynchronously after this method returns. 168 virtual void CheckForHistoryFilesRemoval() = 0; 169 170 // Get the download item for |id| if present, no matter what type of download 171 // it is or state it's in. 172 virtual DownloadItem* GetDownload(int id) = 0; 173}; 174 175} // namespace content 176 177#endif // CONTENT_PUBLIC_BROWSER_DOWNLOAD_MANAGER_H_ 178