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
|
// 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.
#ifndef CONTENT_PUBLIC_BROWSER_DOWNLOAD_MANAGER_DELEGATE_H_
#define CONTENT_PUBLIC_BROWSER_DOWNLOAD_MANAGER_DELEGATE_H_
#pragma once
#include "base/basictypes.h"
#include "base/callback.h"
#include "base/file_path.h"
#include "base/logging.h"
#include "base/time.h"
#include "content/common/content_export.h"
#include "content/public/browser/save_page_type.h"
namespace content {
class DownloadId;
class DownloadItem;
class WebContents;
// Called by SavePackage when it creates a DownloadItem.
typedef base::Callback<void(DownloadItem*)>
SavePackageDownloadCreatedCallback;
// Will be called asynchronously with the results of the ChooseSavePath
// operation. If the delegate wants notification of the download item created
// in response to this operation, the SavePackageDownloadCreatedCallback will be
// non-null.
typedef base::Callback<void(const FilePath&,
content::SavePageType,
const SavePackageDownloadCreatedCallback&)>
SavePackagePathPickedCallback;
// Browser's download manager: manages all downloads and destination view.
class CONTENT_EXPORT DownloadManagerDelegate {
public:
virtual ~DownloadManagerDelegate();
// Lets the delegate know that the download manager is shutting down.
virtual void Shutdown() {}
// Returns a new DownloadId.
virtual DownloadId GetNextId();
// Notifies the delegate that a download is starting. The delegate can return
// false to delay the start of the download, in which case it should call
// DownloadManager::RestartDownload when it's ready.
virtual bool ShouldStartDownload(int32 download_id);
// Asks the user for the path for a download. The delegate calls
// DownloadManager::FileSelected or DownloadManager::FileSelectionCanceled to
// give the answer.
virtual void ChooseDownloadPath(WebContents* web_contents,
const FilePath& suggested_path,
int32 download_id) {}
// Allows the embedder to set an intermediate name for the download until it's
// complete. If the embedder doesn't want this return the suggested path.
virtual FilePath GetIntermediatePath(const FilePath& suggested_path);
// Called when the download system wants to alert a WebContents that a
// download has started, but the TabConetnts has gone away. This lets an
// delegate return an alternative WebContents. The delegate can return NULL.
virtual WebContents* GetAlternativeWebContentsToNotifyForDownload();
// Tests if a file type should be opened automatically.
virtual bool ShouldOpenFileBasedOnExtension(const FilePath& path);
// Allows the delegate to override completion of the download. If this
// function returns false, the download completion is delayed and the
// delegate is responsible for making sure that
// DownloadItem::MaybeCompleteDownload is called at some point in the
// future. Note that at that point this function will be called again,
// and is responsible for returning true when it really is ok for the
// download to complete.
virtual bool ShouldCompleteDownload(DownloadItem* item);
// Allows the delegate to override opening the download. If this function
// returns false, the delegate needs to call
// DownloadItem::DelayedDownloadOpened when it's done with the item,
// and is responsible for opening it. This function is called
// after the final rename, but before the download state is set to COMPLETED.
virtual bool ShouldOpenDownload(DownloadItem* item);
// Returns true if we need to generate a binary hash for downloads.
virtual bool GenerateFileHash();
// Notifies the delegate that a new download item is created. The
// DownloadManager waits for the delegate to add information about this
// download to its persistent store. When the delegate is done, it calls
// DownloadManager::OnDownloadItemAddedToPersistentStore.
virtual void AddItemToPersistentStore(DownloadItem* item) {}
// Notifies the delegate that information about the given download has change,
// so that it can update its persistent store.
// Does not update |url|, |start_time|, |total_bytes|; uses |db_handle| only
// to select the row in the database table to update.
virtual void UpdateItemInPersistentStore(DownloadItem* item) {}
// Notifies the delegate that path for the download item has changed, so that
// it can update its persistent store.
virtual void UpdatePathForItemInPersistentStore(
DownloadItem* item,
const FilePath& new_path) {}
// Notifies the delegate that it should remove the download item from its
// persistent store.
virtual void RemoveItemFromPersistentStore(DownloadItem* item) {}
// Notifies the delegate to remove downloads from the given time range.
virtual void RemoveItemsFromPersistentStoreBetween(
base::Time remove_begin,
base::Time remove_end) {}
// Retrieve the directories to save html pages and downloads to.
virtual void GetSaveDir(WebContents* web_contents,
FilePath* website_save_dir,
FilePath* download_save_dir) {}
// Asks the user for the path to save a page. The delegate calls the callback
// to give the answer.
virtual void ChooseSavePath(WebContents* web_contents,
const FilePath& suggested_path,
const FilePath::StringType& default_extension,
bool can_save_as_complete,
const SavePackagePathPickedCallback& callback) {
}
};
} // namespace content
#endif // CONTENT_PUBLIC_BROWSER_DOWNLOAD_MANAGER_DELEGATE_H_
|
