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